@vascend/talos 0.1.0

package/dist/tui/command-transcript.js

@@ -0,0 +1,90 @@
+import { fitLine, plainText, terminalWidth, wrapText } from "./terminal-text.js";
+import { tr } from "./i18n.js";
+const PREVIEW_ROWS = 2;
+// Execution wrappers are unwrapped only from their declared arguments. Never
+// parse or evaluate generated JavaScript to guess which commands it will run.
+export function commandSource(call) {
+    if (call.name === "bash" && typeof call.input["command"] === "string")
+        return call.input["command"];
+    if (call.name === "run_program" && typeof call.input["code"] === "string")
+        return call.input["code"];
+    if (call.name === "execute" && call.input["mode"] === "program" && typeof call.input["code"] === "string")
+        return call.input["code"];
+    const name = call.name === "execute" && call.input["mode"] === "call" ? call.input["tool"]
+        : call.name === "tool_invoke" ? call.input["name"] : undefined;
+    const args = call.input["args"];
+    if ((name === "bash" || name === "run_program") && args && typeof args === "object" && !Array.isArray(args)) {
+        return commandSource({ name, input: args });
+    }
+    return undefined;
+}
+// Small display lexer, shared by shell and program previews. Theme syntax
+// tokens keep both light and dark palettes readable, without dependencies.
+export function highlightCommand(source, t) {
+    return plainText(source).split(/('(?:[^']|'')*'|"(?:\\.|[^"\\])*"|`[^`]*`|#[^\n]*|\$[\w:]+|--?[\w-]+|\b\d+(?:\.\d+)?\b|[|;&=<>]+|\b[\w]+(?:-[\w]+)+\b|\b(?:await|return|const|let|import|from|async|function|git|rg|bun|node|python|npm|npx|cd|cat|echo)\b)/g)
+        .map(token => {
+        if (/^["'`]/.test(token))
+            return t.danValue(token);
+        if (token.startsWith("#"))
+            return t.dim(token);
+        if (/^\$/.test(token))
+            return t.danId(token);
+        if (/^--?|^[|;&=<>]+$/.test(token))
+            return t.danArrow(token);
+        if (/^\d/.test(token))
+            return t.danNum(token);
+        if (/^[\w]+(?:-[\w]+)+$/.test(token) || /^(?:await|return|const|let|import|from|async|function|git|rg|bun|node|python|npm|npx|cd|cat|echo)$/.test(token))
+            return t.danTag(token);
+        return token;
+    }).join("");
+}
+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);
+}
+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));
+}
+function moreRows(count, t, width) {
+    const full = tr("… +{count} righe · Ctrl+R dettagli", "… +{count} lines · Ctrl+R details", { count });
+    const text = terminalWidth(full) <= width ? full : `… +${count} · Ctrl+R`;
+    return t.dim(terminalWidth(text) <= width ? text : "… Ctrl+R");
+}
+export function commandPreview(source, t, columns, state = "running") {
+    const width = Math.max(2, columns - 1);
+    const prefix = columns < 40 ? "    " : "    │ ";
+    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 };
+}
+export function commandOutput(output, t, columns, isError = false) {
+    const width = Math.max(2, columns - 1);
+    const prefix = columns < 40 ? "    " : "    │ ";
+    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;
+            return t.dim(gutter) + (isError ? t.red(row) : t.dim(row));
+        }), ...(more ? [t.dim(prefix) + moreRows(more, t, bodyWidth)] : [])].map(row => fitLine(row, width));
+}
+export function commandResultState(output, isError) {
+    if (isError)
+        return "error";
+    return /^comando in background \[/i.test(plainText(output).trimStart()) ? "background" : "ok";
+}

package/dist/tui/commands.d.ts

@@ -0,0 +1,20 @@
+export type CommandCategory = "sessione" | "modello" | "vibe" | "vascend" | "attivita" | "interfaccia" | "sistema";
+export interface BuiltinCommand {
+    readonly name: string;
+    readonly hint: string;
+    readonly desc: string;
+    readonly category: CommandCategory;
+    readonly aliases?: readonly string[];
+}
+export declare const CATEGORY_LABELS: Readonly<Record<CommandCategory, string>>;
+export declare const CATEGORY_ORDER: readonly CommandCategory[];
+export declare const BUILTIN_COMMANDS: readonly BuiltinCommand[];
+export declare function builtinNames(): readonly string[];
+export declare function visibleBuiltinNames(): readonly string[];
+export declare function commandsByCategory(): ReadonlyArray<{
+    category: CommandCategory;
+    label: string;
+    commands: readonly BuiltinCommand[];
+}>;
+export declare function levenshtein(a: string, b: string): number;
+export declare function suggestCommands(input: string, candidates: readonly string[], max?: number): readonly string[];

package/dist/tui/commands.js

@@ -0,0 +1,131 @@
+import { tr } from "./i18n.js";
+// Etichette leggibili delle categorie (per le intestazioni dell'help).
+export const CATEGORY_LABELS = {
+    get sessione() { return tr("sessione", "session"); },
+    get modello() { return tr("modello e provider", "model and provider"); },
+    get vibe() { return tr("vibecoding e contesto", "workflow and context"); },
+    get vascend() { return tr("metodo Vascend", "Vascend workflow"); },
+    get attivita() { return tr("lista delle attività", "task list"); },
+    get interfaccia() { return tr("interfaccia", "interface"); },
+    get sistema() { return tr("sistema", "system"); },
+};
+// Ordine di presentazione delle categorie nell'help.
+export const CATEGORY_ORDER = [
+    "sessione",
+    "interfaccia",
+    "modello",
+    "vibe",
+    "vascend",
+    "attivita",
+    "sistema",
+];
+// Comandi slash builtin (per autocomplete, help navigabile, suggerimenti).
+export const BUILTIN_COMMANDS = [
+    { 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"] },
+    { name: "rename", hint: "<titolo>", get desc() { return tr("Dai un nome alla chat corrente", "Name the current chat"); }, category: "sessione" },
+    { name: "commands", hint: "", get desc() { return tr("Cerca e apri tutti i comandi", "Search and open all commands"); }, category: "sistema", aliases: ["cmd"] },
+    { name: "model", hint: "[prov/modello]", get desc() { return tr("Scegli o imposta il modello", "Choose or set the model"); }, category: "modello" },
+    { name: "models", hint: "", get desc() { return tr("Esplora i modelli disponibili", "Browse available models"); }, category: "modello" },
+    { name: "provider", hint: "", get desc() { return tr("Gestisci i provider configurati", "Manage configured providers"); }, category: "modello", aliases: ["providers"] },
+    { name: "login", hint: "", get desc() { return tr("Gestisci accessi e abbonamenti", "Manage sign-ins and subscriptions"); }, category: "modello" },
+    { name: "usage", hint: "", get desc() { return tr("Token della sessione, quote dell'abbonamento e reset", "Session tokens, subscription limits and resets"); }, category: "modello", aliases: ["tokens"] },
+    { name: "effort", hint: "[default|none|minimal|low|medium|high|xhigh|max]", get desc() { return tr("Scegli l'effort disponibile per il modello corrente", "Choose a supported effort for the current model"); }, category: "modello" },
+    { name: "fast", hint: "[on|off|status]", get desc() { return tr("Gestisci la modalità veloce e il relativo indicatore", "Manage fast mode and its indicator"); }, category: "modello" },
+    { name: "vibe", hint: "[auto|modalita]", get desc() { return tr("Scegli il profilo di lavoro", "Choose a work profile"); }, category: "vibe", aliases: ["profile"] },
+    { name: "context", hint: "[pin|unpin|reset|close]", get desc() { return tr("Gestisci contesto e informazioni da conservare", "Manage context and pinned information"); }, category: "vibe", aliases: ["ctx"] },
+    { name: "arch", hint: "[depth|close]", get desc() { return tr("Esplora moduli e dipendenze del progetto", "Explore project modules and dependencies"); }, category: "vibe", aliases: ["architettura"] },
+    { name: "theme", hint: "[nome]", get desc() { return tr("Personalizza l'aspetto del terminale", "Customize terminal appearance"); }, category: "interfaccia", aliases: ["themes"] },
+    { 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: "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: "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"] },
+    { name: "bg", hint: "[id|kill <id>]", get desc() { return tr("task shell in background (Ctrl+B); mostra output o termina", "Background shell tasks (Ctrl+B); view output or stop a task"); }, category: "sistema" },
+    { name: "reload", hint: "", get desc() { return tr("ricarica le estensioni da .talos/extensions a caldo", "Reload extensions from .talos/extensions"); }, category: "sistema", aliases: ["reload-ext"] },
+    { name: "extensions", hint: "[on|off <id> | set <id> <chiave> <valore>]", get desc() { return tr("lista e gestione estensioni (abilita/disabilita, impostazioni)", "List and manage extensions and settings"); }, category: "sistema", aliases: ["ext"] },
+    { name: "expand", hint: "[all]", get desc() { return tr("Apri i dettagli delle ultime operazioni", "Expand recent operation details"); }, category: "interfaccia" },
+    { name: "img", hint: "<path>", get desc() { return tr("Allega un'immagine · Ctrl+V per incollare", "Attach an image; Ctrl+V to paste"); }, category: "interfaccia" },
+    { name: "config", hint: "[details|close]", get desc() { return tr("Personalizza le impostazioni", "Customize settings"); }, category: "sistema" },
+    { name: "cwd", hint: "[path]", get desc() { return tr("mostra il progetto; un cambio sicuro richiede riavvio con talos -C", "Show the project; safely switch with talos -C after restarting"); }, category: "sistema", aliases: ["cd"] },
+    { name: "tree", hint: "[id|close]", get desc() { return tr("albero sessione collassabile; con id sposta la testa; /tree close lo nasconde", "Browse the session tree; use an ID to move the head, or /tree close to hide it"); }, category: "sessione" },
+    { 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: "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"] },
+];
+// Tutti i nomi+alias dei comandi builtin (per il matching del dispatch).
+export function builtinNames() {
+    return BUILTIN_COMMANDS.flatMap((c) => [c.name, ...(c.aliases ?? [])]);
+}
+// I vecchi comandi restano accettati, ma non compaiono nei suggerimenti.
+export function visibleBuiltinNames() {
+    const legacy = new Set(["regno", "castello", "castelli", "kingdoms", "warm"]);
+    return builtinNames().filter((name) => !legacy.has(name));
+}
+// Raggruppa i comandi builtin per categoria, nell'ordine di CATEGORY_ORDER.
+export function commandsByCategory() {
+    return CATEGORY_ORDER.map((category) => ({
+        category,
+        label: CATEGORY_LABELS[category],
+        commands: BUILTIN_COMMANDS.filter((c) => c.category === category),
+    })).filter((g) => g.commands.length > 0);
+}
+// Distanza di Levenshtein (edit distance) fra due stringhe. Iterativa, O(n*m),
+// usata per suggerire il comando piu' vicino su input sconosciuto.
+export function levenshtein(a, b) {
+    if (a === b)
+        return 0;
+    if (!a.length)
+        return b.length;
+    if (!b.length)
+        return a.length;
+    let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    let curr = new Array(b.length + 1);
+    for (let i = 1; i <= a.length; i++) {
+        curr[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            curr[j] = Math.min((curr[j - 1] ?? 0) + 1, // inserzione
+            (prev[j] ?? 0) + 1, // cancellazione
+            (prev[j - 1] ?? 0) + cost);
+        }
+        [prev, curr] = [curr, prev];
+    }
+    return prev[b.length] ?? 0;
+}
+// Suggerisce i comandi piu' vicini a `input` fra i `candidates` noti. Ritorna
+// fino a `max` nomi entro una soglia di distanza proporzionale alla lunghezza
+// (cosi' "modl" -> "model", ma input totalmente diverso non suggerisce nulla).
+export function suggestCommands(input, candidates, max = 3) {
+    const needle = input.trim().toLowerCase();
+    if (!needle)
+        return [];
+    // Soglia: meta' della lunghezza (min 2, max 4). Tollerante ma non casuale.
+    const threshold = Math.min(4, Math.max(2, Math.ceil(needle.length / 2)));
+    const scored = candidates
+        .map((name) => {
+        const lower = name.toLowerCase();
+        // I prefissi sono match forti (distanza 0) anche se piu' lunghi.
+        if (lower.startsWith(needle) || needle.startsWith(lower))
+            return { name, dist: 0 };
+        return { name, dist: levenshtein(needle, lower) };
+    })
+        .filter((s) => s.dist <= threshold)
+        .sort((a, b) => a.dist - b.dist || a.name.length - b.name.length);
+    // Dedup preservando l'ordine.
+    const seen = new Set();
+    const out = [];
+    for (const s of scored) {
+        if (seen.has(s.name))
+            continue;
+        seen.add(s.name);
+        out.push(s.name);
+        if (out.length >= max)
+            break;
+    }
+    return out;
+}

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

@@ -0,0 +1,4 @@
+import type { TuiTheme } from "./branding.js";
+import type { ContextArchiveBlock } from "./context-meter.js";
+export declare function compactContextTokens(tokens: number, short?: boolean): string;
+export declare function buildContextBar(tokens: number, window: number, archive: readonly ContextArchiveBlock[], width: number, t: TuiTheme, warning?: string): string;

package/dist/tui/context-bar.js

@@ -0,0 +1,74 @@
+import { tr } from "./i18n.js";
+import { fitLine, terminalWidth } from "./terminal-text.js";
+const percentage = (ratio) => {
+    const n = ratio * 100;
+    return `${n > 0 && n < 10 ? n.toFixed(1) : Math.round(n)}%`;
+};
+export function compactContextTokens(tokens, short = false) {
+    const n = Math.max(0, Math.round(tokens));
+    if (n >= 999_950)
+        return `${Number((n / 1_000_000).toFixed(short ? 1 : 2))}M`;
+    if (n >= 1000)
+        return `${Number((n / 1000).toFixed(short ? 0 : 1))}k`;
+    return String(n);
+}
+function archiveBar(blocks, cells, total, t) {
+    if (!cells || !blocks.length)
+        return "";
+    // I blocchi seguono l'ordine della conversazione; il colore dipende dalla
+    // posizione temporale, non dal numero di frame o dalla data dell'archiviazione.
+    const oldest = blocks[0].at, newest = blocks[blocks.length - 1].at;
+    const colored = t.dark("x") !== "x";
+    let index = 0, end = blocks[0].tokens, result = "";
+    for (let cell = 0; cell < cells; cell++) {
+        const token = (cell + 0.5) / cells * total;
+        while (index < blocks.length - 1 && token > end)
+            end += blocks[++index].tokens;
+        const recency = newest > oldest ? (blocks[index].at - oldest) / (newest - oldest)
+            : blocks.length > 1 ? index / (blocks.length - 1) : 0.65;
+        const gray = Math.round(72 + 120 * Math.max(0, Math.min(1, recency)));
+        result += colored ? `\x1b[38;2;${gray};${gray};${gray}m▰\x1b[0m` : "▰";
+    }
+    return result;
+}
+export function buildContextBar(tokens, window, archive, width, t, warning = "") {
+    const blocks = archive.filter(block => Number.isFinite(block.tokens) && block.tokens > 0);
+    const archived = blocks.reduce((sum, block) => sum + block.tokens, 0);
+    const activeRatio = tokens / window, archiveRatio = archived / window;
+    // L'archivio puo' crescere oltre una finestra. Cambia la scala grafica,
+    // dichiarata con ×N; entrambe le percentuali restano rapportate al modello.
+    const scale = Math.max(1, Math.ceil((archived + tokens) / window));
+    const scaleLabel = scale > 1 ? `×${scale}` : "";
+    const pressure = activeRatio >= 0.9 ? t.red : activeRatio >= 0.7 ? t.yellow : t.accent;
+    const short = width < 55;
+    let label = t.muted(`${width >= 72 ? tr("Contesto~", "Context~") : "Ctx~"}${scaleLabel} `);
+    const counts = (activeLabel, archiveLabel, separator) => pressure(`${activeLabel}${compactContextTokens(tokens, short)} ${percentage(activeRatio)}`)
+        + t.dark(separator) + t.muted(`${archiveLabel}${compactContextTokens(archived, short)} ${percentage(archiveRatio)}`);
+    let values = counts(short ? tr("att ", "act ") : tr("attivo ", "active "), short ? "arc " : "arch. ", " · ");
+    if (terminalWidth(label + values + warning) > width)
+        label = t.muted(`~${scaleLabel} `);
+    if (terminalWidth(label + values + warning) > width)
+        values = counts("a", "r", " ");
+    const capacity = t.dark(` / ${compactContextTokens(window)}`);
+    if (width >= 64 && terminalWidth(label + values + capacity + warning) + 13 <= width)
+        values += capacity;
+    // Una barra breve lascia leggibili i due conteggi e non domina il footer.
+    const cells = Math.min(14, Math.max(0, width - terminalWidth(label + values + warning) - 1));
+    let grayCells = Math.round(archiveRatio / scale * cells);
+    let liveCells = Math.round(activeRatio / scale * cells);
+    if (cells >= 2) {
+        if (archived > 0)
+            grayCells = Math.max(1, grayCells);
+        if (tokens > 0)
+            liveCells = Math.max(1, liveCells);
+    }
+    if (grayCells + liveCells > cells) {
+        if (grayCells > liveCells)
+            grayCells = Math.max(0, cells - liveCells);
+        else
+            liveCells = Math.max(0, cells - grayCells);
+    }
+    const bar = archiveBar(blocks, grayCells, archived, t) + t.accent("▰".repeat(liveCells))
+        + t.dim("▱".repeat(Math.max(0, cells - grayCells - liveCells)));
+    return fitLine(label + (cells ? bar + " " : "") + values + warning, width);
+}

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

@@ -0,0 +1,25 @@
+import type { Harness } from "../core/bootstrap.js";
+import { type ContextLedger } from "../core/context-ledger.js";
+type ContextSource = Pick<Harness, "config" | "env" | "session" | "tools">;
+export interface ContextArchiveBlock {
+    readonly tokens: number;
+    readonly at: number;
+}
+export interface ContextReading {
+    readonly tokens: number;
+    readonly window: number;
+    readonly archived: readonly ContextArchiveBlock[];
+    readonly nodes: number;
+    readonly workingTarget?: number;
+    readonly checkpointAt?: number;
+}
+export declare class ContextMeter {
+    private cache?;
+    private observed?;
+    reset(): void;
+    observe(source: ContextSource, ledger: ContextLedger): void;
+    read(source: ContextSource): ContextReading;
+    private baseline;
+}
+export declare function contextDetails(reading: ContextReading): readonly string[];
+export {};

package/dist/tui/context-meter.js

@@ -0,0 +1,81 @@
+import { buildContextLedger } from "../core/context-ledger.js";
+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";
+// 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
+// aggiorna la stima solo quando cambia la cronologia, non a ogni tasto.
+export class ContextMeter {
+    cache;
+    observed;
+    reset() { this.cache = undefined; this.observed = undefined; }
+    observe(source, ledger) {
+        if (ledger.model !== source.config.model)
+            return;
+        this.cache = undefined;
+        const baseline = this.baseline(source);
+        this.observed = { session: source.session, model: ledger.model, system: source.config.system,
+            window: ledger.window, offset: ledger.tokens - baseline.tokens };
+    }
+    read(source) {
+        const base = this.baseline(source);
+        const last = this.observed;
+        if (!last || last.session !== source.session || last.model !== source.config.model
+            || last.system !== source.config.system || last.window !== base.window)
+            return base;
+        return { ...base, tokens: Math.max(0, base.tokens + last.offset) };
+    }
+    baseline(source) {
+        const { session, config, tools, env } = source;
+        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 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;
+        if (cached && cached.session === session && cached.history === history && cached.defs === defs
+            && cached.key === key && cached.system === config.system)
+            return cached.reading;
+        const store = scaledPolicy.enabled && config.sessionDir ? ToolOutputStore.open(config.sessionDir, config.roomStoreId ?? session.id) : null;
+        let messages = applyMediaEviction(history, planMediaEviction({ messages: history, policy: mediaPolicy }));
+        const demotion = planToolResultDemotion({ messages, policy: scaledPolicy, archivedId: id => store?.byCallId(id)?.id ?? null });
+        messages = applyToolResultDemotion(messages, demotion);
+        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()) {
+            // 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);
+            if (tokens > 0)
+                archived.push({ tokens, at: node.ts });
+        }
+        const reading = { tokens: ledger.tokens, window: ledger.window, archived, nodes: session.tree().length,
+            ...(config.compaction.enabled ? { workingTarget: limits.active,
+                ...(config.compaction.perRoom && contextPolicy(env).roomCompaction !== "never" ? { checkpointAt: limits.checkpoint } : {}),
+            } : {}),
+        };
+        this.cache = { session, history, defs, key, system: config.system, reading };
+        return reading;
+    }
+}
+export function contextDetails(reading) {
+    const archived = reading.archived.reduce((sum, block) => sum + block.tokens, 0);
+    const fmt = (tokens) => `~${Math.round(tokens).toLocaleString("it-IT")} token (${(100 * tokens / reading.window).toFixed(1)}%)`;
+    return [
+        `Attivo: ${fmt(reading.tokens)} · finestra ${reading.window.toLocaleString("it-IT")}`,
+        `Archiviato originale: ${fmt(archived)}`,
+        ...(reading.workingTarget ? [`Budget operativo: ~${Math.round(reading.workingTarget).toLocaleString("it-IT")} token attivi`
+                + (reading.checkpointAt ? ` · checkpoint da ~${Math.round(reading.checkpointAt).toLocaleString("it-IT")}` : "")
+                + ". Soglie di compattazione, non limiti rigidi del singolo messaggio."] : []),
+        "Lime: contesto inviato al modello, inclusi riassunti e riferimenti. Grigio: materiale originale conservato fuori dalla finestra viva.",
+        "Blocchi grigi da scuro (più vecchio) a chiaro (più recente). Le due percentuali sono riferite alla finestra del modello.",
+        "Se archivio + attivo superano una finestra, ×N indica la scala della barra; le percentuali mantengono la stessa base.",
+    ];
+}

package/dist/tui/cost-binding.d.ts

@@ -0,0 +1,8 @@
+import { CostTracker, type CostEstimate } from "./cost-tracker.js";
+type Env = Record<string, string | undefined>;
+interface RegistryLike {
+    estimateCost(modelId: string, inputTokens: number, outputTokens: number): CostEstimate;
+}
+type LoadRegistry = (env: Env) => Promise<RegistryLike | null>;
+export declare function createCostTracker(env: Env, load?: LoadRegistry): CostTracker;
+export {};

package/dist/tui/cost-binding.js

@@ -0,0 +1,43 @@
+// Aggancio tra il CostTracker (UI status line) e il model-registry (pricing).
+// Il registry e' un modulo peer (src/providers/model-registry.ts) consegnato da
+// un altro vassallo; per essere resilienti all'ordine di merge lo carichiamo in
+// modo LAZY/dinamico. Se non e' (ancora) disponibile, la stima ritorna
+// known=false e la UI mostra solo i token, mai un crash.
+import { CostTracker } from "./cost-tracker.js";
+// Specifier del modulo peer, costruito a runtime cosi' l'assenza pre-merge non
+// blocca la risoluzione statica del type-checker.
+const REGISTRY_MODULE = "../providers/model-registry.js";
+// Caricatore di default: import dinamico del model-registry peer. Tollera
+// l'assenza del modulo (pre-merge) e differenze di firma minori.
+const defaultLoad = async (env) => {
+    try {
+        const mod = (await import(REGISTRY_MODULE));
+        if (typeof mod.loadModelRegistry !== "function")
+            return null;
+        return await mod.loadModelRegistry(env, {});
+    }
+    catch {
+        return null;
+    }
+};
+// Crea un CostTracker la cui funzione di stima delega al registry caricato in
+// modo lazy. Finche' il registry non e' pronto, le stime sono known=false.
+// L'inizializzazione (fire-and-forget) popola il riferimento appena pronto.
+export function createCostTracker(env, load = defaultLoad) {
+    let registry = null;
+    const unknown = { inputCost: 0, outputCost: 0, totalCost: 0, known: false };
+    const estimate = (modelId, inputTokens, outputTokens) => {
+        if (!registry)
+            return unknown;
+        try {
+            return registry.estimateCost(modelId, inputTokens, outputTokens);
+        }
+        catch {
+            return unknown;
+        }
+    };
+    // Carica il registry in background; i turni registrati PRIMA che sia pronto
+    // resteranno senza costo (known=false), ma i successivi avranno il pricing.
+    void load(env).then((r) => { registry = r; }).catch(() => { registry = null; });
+    return new CostTracker(estimate);
+}

package/dist/tui/cost-tracker.d.ts

@@ -0,0 +1,49 @@
+export interface TurnUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+    readonly costUsd?: number;
+}
+export declare function promptTokens(usage: TurnUsage): number;
+export declare function formatTokenCount(value: number): string;
+export interface CostEstimate {
+    readonly inputCost: number;
+    readonly outputCost: number;
+    readonly totalCost: number;
+    readonly known: boolean;
+}
+export type EstimateCostFn = (modelId: string, inputTokens: number, outputTokens: number) => CostEstimate;
+export interface ModelUsage {
+    readonly modelId: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly cost: number;
+    readonly priced: boolean;
+    readonly turns: number;
+}
+export interface CostSnapshot {
+    readonly totalCost: number;
+    readonly totalInputTokens: number;
+    readonly totalOutputTokens: number;
+    readonly totalCacheReadTokens: number;
+    readonly totalCacheWriteTokens: number;
+    readonly totalPromptTokens: number;
+    readonly totalProviderTokens: number;
+    readonly totalTurns: number;
+    readonly current?: ModelUsage;
+    readonly perModel: readonly ModelUsage[];
+    readonly anyPriced: boolean;
+}
+export declare class CostTracker {
+    private readonly byModel;
+    private readonly estimate;
+    constructor(estimate: EstimateCostFn);
+    record(modelId: string, usage: TurnUsage, subscription?: boolean): void;
+    snapshot(currentModel?: string): CostSnapshot;
+    reset(): void;
+    isEmpty(): boolean;
+}
+export declare function formatCost(usd: number): string;