@vascend/talos 0.1.0

package/dist/tui/theme.js

@@ -0,0 +1,383 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Sistema temi a token, parita' con Pi: ogni tema definisce tutti i token di
+// colore; i valori sono hex (#rrggbb), indice palette 256 (0-255), riferimento
+// a una var, o "" per il default del terminale. Default brand = argento/grafite.
+export const THEME_TOKENS = [
+    "accent",
+    "border",
+    "borderAccent",
+    "borderMuted",
+    "success",
+    "error",
+    "warning",
+    "muted",
+    "dim",
+    "text",
+    "thinkingText",
+    "selectedBg",
+    "userMessageBg",
+    "userMessageText",
+    "attachmentRef",
+    "customMessageBg",
+    "customMessageText",
+    "customMessageLabel",
+    "toolPendingBg",
+    "toolSuccessBg",
+    "toolErrorBg",
+    "toolTitle",
+    "toolOutput",
+    "mdHeading",
+    "mdLink",
+    "mdLinkUrl",
+    "mdCode",
+    "mdCodeBlock",
+    "mdCodeBlockBorder",
+    "mdQuote",
+    "mdQuoteBorder",
+    "mdHr",
+    "mdListBullet",
+    "toolDiffAdded",
+    "toolDiffAddedBg",
+    "toolDiffRemoved",
+    "toolDiffRemovedBg",
+    "toolDiffContext",
+    "toolDiffContextBg",
+    "toolDiffHeaderBg",
+    "toolDiffBorder",
+    "syntaxComment",
+    "syntaxKeyword",
+    "syntaxFunction",
+    "syntaxVariable",
+    "syntaxString",
+    "syntaxNumber",
+    "syntaxType",
+    "syntaxOperator",
+    "syntaxPunctuation",
+    "thinkingOff",
+    "thinkingMinimal",
+    "thinkingLow",
+    "thinkingMedium",
+    "thinkingHigh",
+    "thinkingXhigh",
+    "bashMode",
+];
+const RESET = "\x1b[0m";
+// Palette brand Vascend: argento chiaro, argento scuro (grafite), accenti.
+// Gerarchia a 3 livelli del testo (per leggibilita' e raggruppamento):
+//   SILVER (accent/heading) > MUTED_SILVER (secondario) > DIM_SILVER (terziario)
+// I toni "freddi" (bias blu-acciaio) restano coerenti col brand argento-gelido.
+const SILVER = "#d2d6dc";
+const DARK_SILVER = "#828b96"; // secondario: schiarito per leggibilita' (era #686f7a)
+const DIM_SILVER = "#5a626c"; // terziario: chiaramente sotto il secondario, cool
+const BORDER_SILVER = "#565d68"; // bordi: piu' definiti del terziario
+const GRAPHITE = "#3d4346";
+const CHAT_TEXT = "#e8ebef";
+const VASCEND_DARK_COLORS = {
+    accent: "lime",
+    border: "silver",
+    borderAccent: "lime",
+    borderMuted: "borderSilver",
+    success: "#8fc79a",
+    error: "#e09a9a",
+    warning: "#e0cc8c",
+    muted: "darkSilver",
+    dim: "dimSilver",
+    text: CHAT_TEXT,
+    thinkingText: "darkSilver",
+    selectedBg: "#30445e",
+    userMessageBg: "#252c19",
+    userMessageText: CHAT_TEXT,
+    attachmentRef: "#28aacc",
+    customMessageBg: "#12151b",
+    customMessageText: CHAT_TEXT,
+    customMessageLabel: "silver",
+    toolPendingBg: "#14161c",
+    toolSuccessBg: "#121a14",
+    toolErrorBg: "#1c1314",
+    toolTitle: "silver",
+    toolOutput: CHAT_TEXT,
+    mdHeading: SILVER,
+    mdLink: "silver",
+    mdLinkUrl: "darkSilver",
+    mdCode: "#c8cdd4",
+    mdCodeBlock: CHAT_TEXT,
+    mdCodeBlockBorder: "darkSilver",
+    mdQuote: "darkSilver",
+    mdQuoteBorder: "darkSilver",
+    mdHr: "darkSilver",
+    mdListBullet: "silver",
+    toolDiffAdded: "#7fb98a",
+    toolDiffAddedBg: "#102117",
+    toolDiffRemoved: "#d98c8c",
+    toolDiffRemovedBg: "#251314",
+    toolDiffContext: "darkSilver",
+    toolDiffContextBg: "#0d1015",
+    toolDiffHeaderBg: "#151923",
+    toolDiffBorder: "#4d5561",
+    // Ruoli cromatici della notazione Danilov (oltre alla syntax del codice).
+    // Distinti ma tutti dentro il brand argento-gelido (bias blu-acciaio):
+    //   keyword  = parole-chiave di sezione INDICE/DEFINIZIONI/RELAZIONI/OUTPUT (silver pieno)
+    //   function = il marcatore @tag (acciaio-azzurro chiaro)
+    //   type     = id tra [..] e id stanza T01 (ciano-acciaio)
+    //   string   = il valore/contenuto dopo i due punti (salvia fredda)
+    //   number   = maschere bit 0x.. e numeri (ottone tenue)
+    //   operator = frecce/relazioni src->tgt (blu freddo)
+    //   punct    = parentesi, due punti, separatori (dim)
+    syntaxComment: "darkSilver",
+    syntaxKeyword: SILVER,
+    syntaxFunction: "#a9c2d9",
+    syntaxVariable: CHAT_TEXT,
+    syntaxString: "#a7bdaa",
+    syntaxNumber: "#c8bd9c",
+    syntaxType: "#86b2c6",
+    syntaxOperator: "#7f96b4",
+    syntaxPunctuation: "#6b7480",
+    thinkingOff: "darkSilver",
+    thinkingMinimal: "silver",
+    thinkingLow: "#9aa3ad",
+    thinkingMedium: "#b9c0c8",
+    thinkingHigh: SILVER,
+    thinkingXhigh: "#e8ebef",
+    bashMode: "#c2b89f",
+};
+const VASCEND_LIGHT_COLORS = {
+    ...VASCEND_DARK_COLORS,
+    accent: "graphite",
+    border: "graphite",
+    borderAccent: GRAPHITE,
+    borderMuted: "#9aa1a8",
+    muted: "#6b727a",
+    dim: "#707780",
+    success: "#2e7146",
+    error: "#a33340",
+    warning: "#806117",
+    text: "#1c2024",
+    thinkingText: "#6b727a",
+    selectedBg: "#cbdcef",
+    userMessageBg: "#e5edf7",
+    userMessageText: "#1c2024",
+    attachmentRef: "#006d8f",
+    customMessageBg: "#eef0f2",
+    customMessageText: "#1c2024",
+    customMessageLabel: "graphite",
+    toolPendingBg: "#ecedf0",
+    toolSuccessBg: "#e7f0e9",
+    toolErrorBg: "#f3e7e8",
+    toolTitle: "graphite",
+    toolOutput: "#1c2024",
+    mdHeading: GRAPHITE,
+    mdLink: "graphite",
+    mdCode: "#2a2f33",
+    mdCodeBlock: "#1c2024",
+    toolDiffContext: "#6b727a",
+    toolDiffAdded: "#27643b",
+    toolDiffRemoved: "#963e45",
+    toolDiffAddedBg: "#e4f2e7",
+    toolDiffRemovedBg: "#f5e2e3",
+    toolDiffContextBg: "#f4f5f7",
+    toolDiffHeaderBg: "#e8ebef",
+    toolDiffBorder: "#a9b0b8",
+    syntaxKeyword: GRAPHITE,
+    syntaxFunction: "#3f6280",
+    syntaxString: "#4e6b54",
+    syntaxNumber: "#7a6c45",
+    syntaxType: "#2f6378",
+    syntaxOperator: "#445877",
+    syntaxPunctuation: "#8b9299",
+};
+// Accento lime del marchio, IDENTICO ai token di Horizon (styles.css: --lime,
+// --lime-scuro, --su-lime; gli stessi della landing e del gestionale).
+const LIME = "#d3e65d";
+const LIME_SCURO = "#c2d64e";
+const SU_LIME = "#101010";
+const COMMON_VARS = {
+    silver: SILVER,
+    darkSilver: DARK_SILVER,
+    dimSilver: DIM_SILVER,
+    borderSilver: BORDER_SILVER,
+    graphite: GRAPHITE,
+    lime: LIME,
+    limeScuro: LIME_SCURO,
+    suLime: SU_LIME,
+};
+export const VASCEND_DARK = {
+    name: "vascend-dark",
+    mode: "dark",
+    vars: COMMON_VARS,
+    colors: VASCEND_DARK_COLORS,
+};
+export const VASCEND_LIGHT = {
+    name: "vascend-light",
+    mode: "light",
+    vars: COMMON_VARS,
+    colors: VASCEND_LIGHT_COLORS,
+};
+// Tema "vascend-lime": la base scura in vetro/argento con l'accento lime del
+// marchio, usato come lo usa Horizon — per l'azione, non per lo stato: se
+// finisce su dieci elementi non ne indica piu' nessuno. Quindi lime SOLO su
+// accento/heading/link/selezione; testo, gerarchie e semantica (success/error/
+// warning) restano quelli del tema scuro.
+const VASCEND_LIME_COLORS = {
+    ...VASCEND_DARK_COLORS,
+    accent: "lime",
+    borderAccent: LIME,
+    customMessageLabel: "lime",
+    mdHeading: LIME,
+    mdLink: "lime",
+    mdListBullet: "lime",
+    // Selezione con velo lime scuro: si vede DOVE sei senza gridare.
+    selectedBg: "#3b4420",
+    // La scala del reasoning culmina nel lime (l'intensita' massima e' l'azione).
+    thinkingXhigh: LIME,
+    // Le keyword della notazione restano argento; il marcatore @tag prende una
+    // punta di lime spento per legare la sintassi al tema senza saturarla.
+    syntaxFunction: "#b9c77f",
+};
+export const VASCEND_LIME = {
+    name: "vascend-lime",
+    mode: "dark",
+    vars: COMMON_VARS,
+    colors: VASCEND_LIME_COLORS,
+};
+export const BUILTIN_THEMES = [VASCEND_DARK, VASCEND_LIGHT, VASCEND_LIME];
+function hexToRgb(hex) {
+    const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+    if (!m || !m[1])
+        return null;
+    const n = parseInt(m[1], 16);
+    return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
+}
+// Risolve un valore di colore (hex / indice 256 / var / "") in un prefisso ANSI.
+// `background` true -> codici di sfondo (48), altrimenti foreground (38).
+export function ansiFor(spec, value, background = false) {
+    if (typeof value === "number") {
+        return Number.isInteger(value) && value >= 0 && value <= 255
+            ? `\x1b[${background ? 48 : 38};5;${value}m`
+            : "";
+    }
+    const raw = value.trim();
+    if (raw === "")
+        return "";
+    if (raw.startsWith("#")) {
+        const rgb = hexToRgb(raw);
+        return rgb ? `\x1b[${background ? 48 : 38};2;${rgb[0]};${rgb[1]};${rgb[2]}m` : "";
+    }
+    // riferimento a una var (eventualmente annidato una volta)
+    const ref = spec.vars[raw];
+    if (ref !== undefined)
+        return ansiFor(spec, ref, background);
+    return "";
+}
+export function tokenAnsi(spec, token, background = false) {
+    return ansiFor(spec, spec.colors[token], background);
+}
+// Pittore di token pronto all'uso: avvolge una stringa col colore del token.
+export function painter(spec) {
+    return (token, s, background = false) => {
+        const code = tokenAnsi(spec, token, background);
+        return code ? `${code}${s}${RESET}` : s;
+    };
+}
+function isThemeSpec(raw) {
+    return typeof raw === "object" && raw !== null;
+}
+function coerceColorMap(raw, base) {
+    if (typeof raw !== "object" || raw === null)
+        return { ...base };
+    const map = raw;
+    const out = { ...base };
+    for (const token of THEME_TOKENS) {
+        const v = map[token];
+        if (typeof v === "string" || typeof v === "number")
+            out[token] = v;
+    }
+    return out;
+}
+// Carica un tema da file JSON; i token mancanti ereditano dal tema base
+// (vascend-dark) cosi' i custom non devono dichiarare tutti i 51 token.
+export function parseThemeFile(path) {
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        if (!isThemeSpec(raw))
+            return null;
+        const name = typeof raw.name === "string" && raw.name ? raw.name : path.replace(/.*[\\/]/, "").replace(/\.json$/i, "");
+        const mode = raw.mode === "light" ? "light" : "dark";
+        const baseColors = mode === "light" ? VASCEND_LIGHT_COLORS : VASCEND_DARK_COLORS;
+        const vars = typeof raw.vars === "object" && raw.vars !== null
+            ? { ...COMMON_VARS, ...raw.vars }
+            : COMMON_VARS;
+        return { name, mode, vars, colors: coerceColorMap(raw.colors, baseColors) };
+    }
+    catch {
+        return null;
+    }
+}
+function themeDirs(cwd, projectTrusted) {
+    const dirs = [join(homedir(), ".talos", "themes")];
+    if (projectTrusted)
+        dirs.push(join(cwd, ".talos", "themes"));
+    return dirs;
+}
+// Tutti i temi disponibili: builtin + custom dalle dir (custom con stesso nome
+// sovrascrive il builtin). Ritorna anche i path per l'hot reload.
+export function loadThemes(cwd, env, projectTrusted = true, extraDirs = []) {
+    const byName = new Map();
+    for (const t of BUILTIN_THEMES)
+        byName.set(t.name, t);
+    const paths = {};
+    for (const dir of [...themeDirs(cwd, projectTrusted), ...extraDirs]) {
+        if (!existsSync(dir))
+            continue;
+        if (dir.toLowerCase().endsWith(".json")) {
+            const spec = parseThemeFile(dir);
+            if (spec) {
+                byName.set(spec.name, spec);
+                paths[spec.name] = dir;
+            }
+            continue;
+        }
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const file of entries) {
+            if (!file.toLowerCase().endsWith(".json"))
+                continue;
+            const full = join(dir, file);
+            const spec = parseThemeFile(full);
+            if (spec) {
+                byName.set(spec.name, spec);
+                paths[spec.name] = full;
+            }
+        }
+    }
+    return { themes: [...byName.values()], paths };
+}
+export function findTheme(themes, name) {
+    return themes.find((t) => t.name === name);
+}
+// Auto-detect del background del terminale: COLORFGBG (es. "15;0" -> bg scuro),
+// poi euristiche su variabili note. Default: dark (coerente col brand).
+export function detectTerminalMode(env) {
+    const fgbg = env["COLORFGBG"];
+    if (fgbg) {
+        const parts = fgbg.split(";");
+        const bg = Number(parts[parts.length - 1]);
+        if (Number.isInteger(bg))
+            return bg <= 6 || bg === 0 ? "dark" : "light";
+    }
+    const theme = (env["TERM_BACKGROUND"] || env["APPLE_INTERFACE_STYLE"] || "").toLowerCase();
+    if (theme.includes("light"))
+        return "light";
+    if (theme.includes("dark"))
+        return "dark";
+    return "dark";
+}
+export function defaultThemeName(env) {
+    return detectTerminalMode(env) === "light" ? "vascend-light" : "vascend-dark";
+}

package/dist/tui/tool-style.d.ts

@@ -0,0 +1,7 @@
+export type ToolCategory = "read" | "write" | "shell" | "search" | "web" | "danilov" | "kingdom" | "ask" | "image" | "misc";
+export declare function toolCategory(name: string): ToolCategory;
+export declare function paintToolName(name: string, label: string): string;
+export declare function paintCategoryName(category: ToolCategory, label: string): string;
+export declare function pulseGlyph(name: string, frame: number): string;
+export declare function pulseToolName(name: string, label: string, frame: number): string;
+export declare function pulseDot(name: string, frame: number): string;

package/dist/tui/tool-style.js

@@ -0,0 +1,119 @@
+// Stile visivo dei NOMI dei tool in chat: ogni categoria di tool ha un colore
+// distinto (cosi' a colpo d'occhio si capisce se l'agente legge, scrive, esegue
+// comandi, cerca, ...) e un'animazione "pulse" abbinata mostrata sul tool in
+// corso nella status-line (il colore respira tra una tinta tenue e quella piena
+// al ritmo dei frame dello spinner).
+//
+// Truecolor (38;2;r;g;b). Niente dipendenze: solo escape ANSI.
+const RESET = "\x1b[0m";
+// Mappa nome-tool -> categoria. I nomi non elencati ricadono in "misc".
+const CATEGORY = {
+    read_file: "read",
+    list_dir: "read",
+    bash_output: "read",
+    output_page: "read",
+    recall: "read",
+    write_file: "write",
+    edit_file: "write",
+    bash: "shell",
+    bash_bg: "shell",
+    reload_extensions: "shell",
+    grep: "search",
+    glob: "search",
+    tool_search: "search",
+    skill_search: "search",
+    skill_load: "search",
+    tool_invoke: "search",
+    web_fetch: "web",
+    vascend_plan: "danilov",
+    vascend_mark: "danilov",
+    vascend_note: "danilov",
+    vascend_skill: "danilov",
+    vascend_addtasks: "danilov",
+    kingdoms_warm: "kingdom",
+    kingdom_send: "kingdom",
+    kingdom_inbox: "kingdom",
+    kingdom_wait: "kingdom",
+    ask_user: "ask",
+    wait: "ask",
+    image_generate: "image",
+};
+export function toolCategory(name) {
+    return CATEGORY[name] ?? "misc";
+}
+// Colore PIENO di ogni categoria (tinta a cui punta il pulse), come tripla RGB.
+// Scelti dentro un range vivido ma coerente con la TUI scura.
+const CATEGORY_RGB = {
+    read: [122, 178, 198], // ciano-acciaio (ispezione)
+    write: [143, 199, 154], // verde salvia (mutazione)
+    shell: [200, 184, 159], // ottone (esecuzione)
+    search: [186, 162, 217], // viola tenue (ricerca)
+    web: [128, 170, 220], // azzurro (rete)
+    danilov: [210, 214, 220], // argento brand (metodo)
+    kingdom: [224, 196, 130], // oro (regno/vassalli)
+    ask: [224, 204, 140], // giallo (attesa utente)
+    image: [222, 150, 180], // rosa (immagini)
+    misc: [150, 160, 174], // argento freddo
+};
+// Glyph "battito" associato alla categoria del tool in corso: cambia col frame
+// per dare il senso di movimento abbinato al nome.
+const CATEGORY_PULSE = {
+    read: ["◌", "◎", "●", "◎"],
+    write: ["✎", "✐", "✏", "✐"],
+    shell: ["▹", "▸", "▶", "▸"],
+    search: ["·", "∴", "⁘", "∴"],
+    web: ["◜", "◝", "◞", "◟"],
+    danilov: ["✶", "✸", "✺", "✦"],
+    kingdom: ["♢", "♦", "♦", "♢"],
+    ask: ["?", "?", "?", "?"],
+    image: ["◍", "◐", "◑", "◒"],
+    misc: ["✶", "✸", "✺", "✦"],
+};
+function fg(rgb) {
+    return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+}
+// Colore STATICO del nome del tool nel log (scrollback), per categoria.
+export function paintToolName(name, label) {
+    return `${fg(CATEGORY_RGB[toolCategory(name)])}${label}${RESET}`;
+}
+export function paintCategoryName(category, label) {
+    return `${fg(CATEGORY_RGB[category])}${label}${RESET}`;
+}
+// Onda triangolare 0..1..0 in funzione del frame: e' la "respirazione" del
+// pulse (il colore sale alla tinta piena e ridiscende a una versione attenuata).
+function wave(frame, period) {
+    const p = period <= 0 ? 1 : period;
+    const x = ((frame % p) + p) % p;
+    const half = p / 2;
+    return x <= half ? x / half : (p - x) / half;
+}
+// Interpola tra una versione SCURA (attenuata) e quella PIENA del colore della
+// categoria al livello t in [0,1]. t=0 -> ~40% di luminosita', t=1 -> pieno.
+function pulseRgb(rgb, t) {
+    const lo = 0.42; // pavimento di luminosita' del battito
+    const k = lo + (1 - lo) * (t < 0 ? 0 : t > 1 ? 1 : t);
+    return [Math.round(rgb[0] * k), Math.round(rgb[1] * k), Math.round(rgb[2] * k)];
+}
+// Glyph animato del tool in corso (per la status-line), gia' colorato col pulse.
+export function pulseGlyph(name, frame) {
+    const cat = toolCategory(name);
+    const seq = CATEGORY_PULSE[cat];
+    const glyph = seq[frame % seq.length] ?? seq[0];
+    const rgb = pulseRgb(CATEGORY_RGB[cat], wave(frame, 8));
+    return `${fg(rgb)}${glyph}${RESET}`;
+}
+// Nome del tool animato (per la status-line): il colore "respira" al ritmo dei
+// frame, restando nella tinta della categoria.
+export function pulseToolName(name, label, frame) {
+    const rgb = pulseRgb(CATEGORY_RGB[toolCategory(name)], wave(frame, 8));
+    return `${fg(rgb)}${label}${RESET}`;
+}
+// Puntino ● animato per la riga del tool IN CORSO nello scrollback (chat): lo
+// stesso bullet ● che apre la riga "● Nome(arg)", ma colorato col pulse della
+// categoria cosi' "respira" finche' il tool e' in esecuzione. A tool finito si
+// torna al bullet statico (theme.accent) scritto da repl. Period piu' lungo (12)
+// per un battito piu' lento e leggibile nello scrollback.
+export function pulseDot(name, frame) {
+    const rgb = pulseRgb(CATEGORY_RGB[toolCategory(name)], wave(frame, 12));
+    return `${fg(rgb)}●${RESET}`;
+}

package/dist/tui/update-prompt.d.ts

@@ -0,0 +1,14 @@
+import type { Readable, Writable } from "node:stream";
+import type { CliArgs } from "../core/cli-args.js";
+import { type TalosUpdate } from "../core/update-check.js";
+import { type UpdateResult } from "../core/self-update.js";
+export type UpdateChoice = "skip" | "update" | "cancel";
+export declare function updatePromptText(update: TalosUpdate): string;
+export declare function promptForUpdate(update: TalosUpdate, input?: Readable, output?: Writable): Promise<UpdateChoice>;
+export declare function handleTalosUpdate(update: TalosUpdate, hooks: {
+    readonly prompt: (update: TalosUpdate) => Promise<UpdateChoice>;
+    readonly install: (update: TalosUpdate) => Promise<UpdateResult>;
+    readonly restart: () => Promise<number>;
+    readonly write: (text: string) => void;
+}): Promise<number | null>;
+export declare function offerStartupUpdate(args: CliArgs, env: NodeJS.ProcessEnv): Promise<number | null>;

package/dist/tui/update-prompt.js

@@ -0,0 +1,104 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { stdin, stdout } from "node:process";
+import { TALOS_VERSION } from "../core/version.js";
+import { checkForTalosUpdate, shouldCheckForUpdate, TALOS_RELEASES_URL } from "../core/update-check.js";
+import { installTalosUpdate, TALOS_INSTALL_ROOT } from "../core/self-update.js";
+import { initializeLanguage } from "./language-preference.js";
+import { tr } from "./i18n.js";
+export function updatePromptText(update) {
+    return `\n  ${tr("Aggiornamento disponibile per Talos", "Talos update available")}\n\n`
+        + `  ${update.currentVersion} → ${update.version}\n\n`
+        + `  1. ${tr("Salta per ora", "Skip for now")}\n`
+        + `  2. ${tr("Aggiorna subito", "Update now")}\n\n`;
+}
+export function promptForUpdate(update, input = stdin, output = stdout) {
+    output.write(updatePromptText(update));
+    const rl = createInterface({ input, output });
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (choice) => {
+            if (settled)
+                return;
+            settled = true;
+            rl.close();
+            resolve(choice);
+        };
+        rl.on("SIGINT", () => { output.write("\n"); finish("cancel"); });
+        rl.on("close", () => finish("cancel"));
+        const ask = () => {
+            rl.question(`  ${tr("Scegli", "Choose")} [1/2] (1): `, answer => {
+                const value = answer.trim();
+                if (!value || value === "1")
+                    finish("skip");
+                else if (value === "2")
+                    finish("update");
+                else {
+                    output.write(`  ${tr("Inserisci 1 o 2.", "Enter 1 or 2.")}\n`);
+                    ask();
+                }
+            });
+        };
+        ask();
+    });
+}
+function failureMessage(reason) {
+    switch (reason) {
+        case "modified": return tr("Il repository di Talos contiene modifiche locali. Salvale prima di aggiornare.", "The Talos repository has local changes. Save them before updating.");
+        case "diverged": return tr("Il repository di Talos ha una cronologia divergente dalla release. Aggiornalo manualmente.", "The Talos repository has diverged from this release. Update it manually.");
+        case "unsupported": return tr("Installazione non riconosciuta. Aggiorna Talos con il gestore usato per installarlo.", "Installation not recognized. Update Talos with the package manager used to install it.");
+        case "install": return tr("Installazione non completata. Riprova l'aggiornamento con il gestore usato per installare Talos, poi riavvia talos.", "Installation did not complete. Retry the update with the package manager used to install Talos, then restart talos.");
+        case "version": return tr("La release non contiene il pacchetto Talos della versione richiesta.", "The release does not contain the requested Talos package version.");
+        case "download": return tr("Aggiornamento non riuscito. Verifica la connessione e l'accesso GitHub e riprova.", "Update failed. Check your connection and GitHub access, then try again.");
+        case "build": return tr("Release scaricata, ma installazione non completata. Nel repository di Talos esegui bun install --frozen-lockfile e bun run install:cli, poi riavvia talos.", "Release downloaded, but installation did not complete. In the Talos repository run bun install --frozen-lockfile and bun run install:cli, then restart talos.");
+    }
+}
+export async function handleTalosUpdate(update, hooks) {
+    const choice = await hooks.prompt(update);
+    if (choice === "cancel")
+        return 130;
+    if (choice === "skip")
+        return null;
+    hooks.write(`\n  ${tr("Aggiornamento di Talos a {version}…", "Updating Talos to {version}…", { version: update.version })}\n`);
+    const result = await hooks.install(update);
+    if (!result.ok) {
+        hooks.write(`\n  ${failureMessage(result.reason)}\n  ${TALOS_RELEASES_URL}\n\n`);
+        // Once sources have changed, do not start a session with partially built code.
+        return result.changed ? 1 : null;
+    }
+    hooks.write(`\n  ${tr("Talos aggiornato a {version}. Riavvio…", "Talos updated to {version}. Restarting…", { version: update.version })}\n\n`);
+    return hooks.restart();
+}
+function restartTalos(env) {
+    return new Promise(resolve => {
+        const child = spawn(process.execPath, process.argv.slice(1), {
+            cwd: process.cwd(), env: { ...env, TALOS_NO_UPDATE_CHECK: "1" }, stdio: "inherit", shell: false,
+        });
+        // The foreground child owns the terminal and receives its Ctrl+C directly.
+        const ignore = () => { };
+        process.on("SIGINT", ignore);
+        const finish = (code) => { process.off("SIGINT", ignore); resolve(code); };
+        child.on("error", () => {
+            stdout.write(`  ${tr("Riavvia talos per usare la nuova versione.", "Restart talos to use the new version.")}\n`);
+            finish(1);
+        });
+        child.on("close", (code, signal) => finish(code ?? (signal === "SIGINT" ? 130 : 1)));
+    });
+}
+export async function offerStartupUpdate(args, env) {
+    if (!shouldCheckForUpdate(args, env, Boolean(stdin.isTTY), Boolean(stdout.isTTY)))
+        return null;
+    const update = await checkForTalosUpdate({ currentVersion: TALOS_VERSION, env, cwd: process.cwd(),
+        source: existsSync(join(TALOS_INSTALL_ROOT, ".git")) ? "github" : "npm" });
+    if (!update)
+        return null;
+    initializeLanguage(env);
+    return handleTalosUpdate(update, {
+        prompt: promptForUpdate,
+        install: update => installTalosUpdate(update, { env }),
+        restart: () => restartTalos(env),
+        write: text => { stdout.write(text); },
+    });
+}

package/dist/tui/usage-footer.d.ts

@@ -0,0 +1,9 @@
+import type { PlanLimits } from "../core/types.js";
+import type { TuiTheme } from "./branding.js";
+import { type SessionUsageState } from "./session-usage.js";
+import { type StatusData, type StatusOptions } from "./status-line.js";
+export declare const SESSION_USAGE_EXPLANATION = "I token cumulati sono la somma delle chiamate della sessione, inclusi input ripetuti e cache: non sono il contesto di una singola richiesta. Talos seleziona informazioni rilevanti e gestisce la cronologia con recupero e compattazione secondo la configurazione. Questo non annulla i consumi registrati dal provider. \u2265 indica un totale parziale: il consumo noto \u00E8 almeno quello mostrato. Il contesto indicato \u00E8 una stima locale, non una misura esatta del payload inviato.";
+type UsageState = Pick<SessionUsageState, "limits" | "incomplete" | "missing" | "unsaved">;
+export declare function subscriptionDetails(providerId: string, limits: PlanLimits | undefined, t: TuiTheme, now?: number): string[];
+export declare function buildUsageFooter(d: StatusData, t: TuiTheme, state: UsageState, providerId: string, opts?: StatusOptions, now?: number): readonly string[];
+export {};