@vascend/talos 0.1.0

package/dist/tui/selector.js

@@ -0,0 +1,299 @@
+import * as readline from "node:readline";
+import { stdin, stdout } from "node:process";
+import { PassThrough } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import { tr } from "./i18n.js";
+import { SelectorMouseInput, selectorMouseIndex } from "./selector-mouse.js";
+import { fitLine, oneLine, padLine, plainText, terminalWidth, wrapText } from "./terminal-text.js";
+import { renderQuestionChoices } from "./question.js";
+export function pickerPageSize(rows, fullHeight = false) {
+    const available = Math.max(1, Math.floor(rows) - 6);
+    return Math.min(available, fullHeight ? 26 : 7);
+}
+function searchable(text) {
+    return plainText(text).normalize("NFD").replace(/\p{Mark}/gu, "").toLowerCase();
+}
+export function filterOptions(options, query) {
+    const terms = searchable(query).split(/\s+/).filter(Boolean);
+    if (!terms.length)
+        return options;
+    return options.filter(option => {
+        const hay = searchable(`${option.label} ${option.detail} ${option.group ?? ""} ${option.hint ?? ""}`);
+        return terms.every(term => hay.includes(term));
+    });
+}
+function isCurrent(option, current, currentKey) {
+    if (currentKey !== undefined)
+        return (option.key ?? String(option.value)) === currentKey;
+    return current !== undefined && option.value === current;
+}
+function selectorWidth(columns, wide) {
+    return Math.max(1, Math.min(wide ? 120 : 96, columns - 2));
+}
+function detailLines(opts, option, width) {
+    if (!option)
+        return [];
+    return [
+        ...wrapText(opts.title, width, true),
+        ...(opts.hint ? wrapText(opts.hint, width, true) : []),
+        ...wrapText(`${option.label}${option.hint ? ` ${option.hint}` : ""}`, width),
+        ...(option.group ? wrapText(option.group, width) : []),
+        ...wrapText(option.detail, width, true),
+    ];
+}
+export function renderSelector(opts) {
+    const t = opts.theme;
+    const width = selectorWidth(opts.columns, opts.wide);
+    const page = Math.max(1, opts.pageSize);
+    const index = Math.max(0, Math.min(opts.index, opts.options.length - 1));
+    const selected = opts.options[index];
+    const row = (text) => " " + fitLine(text, width);
+    const title = fitLine(oneLine(opts.title), opts.query === undefined ? width : Math.max(4, Math.floor(width * 0.45)));
+    const searchWidth = Math.max(1, width - terminalWidth(title) - 3);
+    // Una sola riga per titolo e ricerca; mostra la coda della query durante la digitazione.
+    const query = Array.from(oneLine(opts.query ?? ""));
+    while (query.length && terminalWidth(query.join("")) > searchWidth - 2)
+        query.shift();
+    const search = opts.query === undefined ? "" : t.muted(" / ") +
+        (opts.query ? t.silver(query.join("")) : t.muted(fitLine(tr("Cerca", "Search"), searchWidth - 1))) + t.accent("▏");
+    const lines = [row(t.bold(title) + search)];
+    let range;
+    if (opts.details && selected) {
+        const all = detailLines(opts, selected, width - 2);
+        const offset = Math.max(0, Math.min(opts.detailOffset ?? 0, all.length - page));
+        for (const [i, line] of all.slice(offset, offset + page).entries()) {
+            lines.push(row(" " + (offset + i === 0 ? t.bold(line) : t.silver(line))));
+        }
+        range = `${offset + 1}–${Math.min(all.length, offset + page)}/${all.length}`;
+    }
+    else {
+        const start = Math.max(0, Math.min(index - Math.floor(page / 2), opts.options.length - page));
+        const visible = opts.options.slice(start, start + page);
+        const maxLabel = Math.max(0, ...opts.options.map(option => terminalWidth(oneLine(option.label))));
+        const contentWidth = Math.max(1, width - 4);
+        const labelWidth = width < 38 ? contentWidth : Math.min(maxLabel, Math.max(10, Math.floor(contentWidth * 0.48)));
+        const detailWidth = Math.max(0, contentWidth - labelWidth - 2);
+        for (const [offset, option] of visible.entries()) {
+            const active = start + offset === index;
+            const current = isCurrent(option, opts.current, opts.currentKey);
+            const mark = `${active ? "›" : " "}${current ? "●" : " "} `;
+            const label = padLine(oneLine(option.label), labelWidth);
+            const detail = detailWidth > 2 && (!opts.selectedDetailsOnly || active)
+                ? "  " + fitLine(oneLine(option.detail), detailWidth) : "";
+            if (active) {
+                // Colore uniforme, con un indicatore testuale visibile anche senza colori.
+                lines.push(row(t.selected(padLine(plainText(mark + label + detail), width))));
+            }
+            else {
+                lines.push(row((current ? t.accent(mark) : t.muted(mark)) + t.silver(label) + t.muted(detail)));
+            }
+        }
+        if (!visible.length)
+            lines.push(row(t.muted(tr(" Nessun risultato. Modifica la ricerca.", " No results. Change your search."))));
+        range = opts.options.length ? `${start + 1}–${start + visible.length}/${opts.options.length}` : "0";
+        if (opts.totalCount !== undefined && opts.totalCount !== opts.options.length)
+            range += ` ${tr("di", "of")} ${opts.totalCount}`;
+        // Categoria e sintassi soltanto per la voce a fuoco, non ripetute nella lista.
+        if (opts.hint || (selected && (selected.group || selected.hint))) {
+            const meta = [opts.hint, selected?.group, selected?.hint ? `${selected.label} ${selected.hint}` : ""].filter(Boolean).join(" · ");
+            lines.push(row(t.muted(" " + meta)));
+        }
+    }
+    const shortcut = opts.details ? tr("↑↓ scorri · Tab elenco · Invio · Esc", "↑↓ scroll · Tab list · Enter · Esc")
+        : opts.mouse ? tr("↑↓ / click · Invio apri · Tab dettagli · Esc", "↑↓ / click · Enter open · Tab details · Esc")
+            : tr("↑↓ · Invio scegli · Tab dettagli · Esc", "↑↓ · Enter select · Tab details · Esc");
+    const short = opts.details ? tr("Tab elenco · Invio · Esc", "Tab list · Enter · Esc") : tr("↑↓ · Invio · Tab · Esc", "↑↓ · Enter · Tab · Esc");
+    const hintWidth = width - terminalWidth(range) - 2;
+    const hint = fitLine(terminalWidth(shortcut) <= hintWidth ? shortcut : short, hintWidth);
+    lines.push(row(t.muted(hint + " ".repeat(Math.max(1, width - terminalWidth(hint) - terminalWidth(range))) + range)));
+    return lines;
+}
+export async function selectOption(opts) {
+    if (!stdin.isTTY || !stdout.isTTY || typeof stdin.setRawMode !== "function") {
+        opts.ctl.write(opts.theme.bold(`\n ${opts.title}\n`));
+        if (opts.hint)
+            opts.ctl.write(` ${opts.hint}\n`);
+        for (const option of opts.options) {
+            const mark = isCurrent(option, opts.current, opts.currentKey) ? "●" : " ";
+            opts.ctl.write(` ${mark} ${option.label}${option.hint ? ` ${option.hint}` : ""} · ${option.detail}\n`);
+        }
+        return null;
+    }
+    // Decode mouse reports before readline can turn fragments into search text.
+    const keys = new PassThrough();
+    readline.emitKeypressEvents(keys);
+    let query = "";
+    let filtered = opts.options;
+    let index = Math.max(0, filtered.findIndex(option => isCurrent(option, opts.current, opts.currentKey)));
+    let details = false;
+    let detailOffset = 0;
+    let questionOffset = 0;
+    let questionView;
+    let renderedRows = 0;
+    const wasRaw = stdin.isRaw;
+    const wasPaused = stdin.isPaused();
+    const pageSize = () => pickerPageSize(stdout.rows || 24, opts.fullHeight);
+    const detailMax = () => Math.max(0, detailLines(opts, filtered[index], selectorWidth(opts.terminalColumns(), opts.wide) - 2).length - pageSize());
+    const applyFilter = () => {
+        const previous = filtered[index];
+        filtered = filterOptions(opts.options, query);
+        index = Math.max(0, previous ? filtered.indexOf(previous) : 0);
+        details = false;
+        detailOffset = 0;
+    };
+    const draw = () => {
+        if (opts.question) {
+            questionView = renderQuestionChoices({ title: opts.title, options: filtered, index, offset: questionOffset,
+                columns: opts.terminalColumns(), rows: Math.max(5, (stdout.rows || 24) - 1), theme: opts.theme });
+            questionOffset = questionView.offset;
+            opts.ctl.setOverlay(questionView.lines);
+            return;
+        }
+        detailOffset = Math.min(detailOffset, detailMax());
+        const lines = renderSelector({ ...opts, options: filtered, index,
+            pageSize: pageSize(), columns: opts.terminalColumns(), query: opts.filterable ? query : undefined,
+            totalCount: opts.options.length, details, detailOffset,
+        });
+        renderedRows = lines.length;
+        opts.ctl.setOverlay(lines);
+        if (opts.mouse)
+            stdout.write("\x1b[?1000h\x1b[?1006h");
+    };
+    return new Promise(resolve => {
+        let settled = false;
+        const cleanup = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            stdin.off("data", onData);
+            decoder.dispose();
+            keys.off("keypress", onKeypress);
+            keys.destroy();
+            if (opts.mouse)
+                stdout.write("\x1b[?1000l\x1b[?1006l");
+            stdout.off("resize", draw);
+            stdin.setRawMode(Boolean(wasRaw));
+            if (wasPaused)
+                stdin.pause();
+            opts.ctl.setOverlay(null);
+            opts.ctl.resume();
+            resolve(value);
+        };
+        const decoder = new SelectorMouseInput((data) => { if (!settled)
+            keys.write(data); }, (event) => {
+            if (!opts.mouse || !event.press || settled)
+                return;
+            if (event.button === 64 || event.button === 65) {
+                onKeypress("", { name: event.button === 64 ? "up" : "down" });
+                return;
+            }
+            if (event.button !== 0 || details || opts.question)
+                return;
+            const hit = selectorMouseIndex({ y: event.y, x: event.x, rows: stdout.rows || 24,
+                columns: selectorWidth(opts.terminalColumns(), opts.wide), renderedRows,
+                count: filtered.length, index, pageSize: pageSize() });
+            if (hit === null)
+                return;
+            // A click focuses and reveals the description; clicking the focused row opens it.
+            if (index === hit)
+                cleanup(filtered[hit] ?? null);
+            else {
+                index = hit;
+                draw();
+            }
+        });
+        const utf8 = new StringDecoder("utf8");
+        const onData = (data) => decoder.push(typeof data === "string" ? data : utf8.write(data));
+        const onKeypress = (chunk, key) => {
+            if (key.name === "return") {
+                cleanup(filtered[index] ?? null);
+                return;
+            }
+            if (key.ctrl && key.name === "c") {
+                cleanup(null);
+                return;
+            }
+            if (key.name === "escape") {
+                if (details) {
+                    details = false;
+                    draw();
+                }
+                else
+                    cleanup(null);
+                return;
+            }
+            if (opts.question && questionView) {
+                const page = questionView.pageSize;
+                if (key.name === "pageup")
+                    questionOffset = Math.max(0, questionOffset - page);
+                else if (key.name === "pagedown")
+                    questionOffset = Math.min(questionView.maxOffset, questionOffset + page);
+                else if (key.name === "home") {
+                    index = 0;
+                    questionOffset = 0;
+                }
+                else if (key.name === "end") {
+                    index = Math.max(0, filtered.length - 1);
+                    questionOffset = questionView.maxOffset;
+                }
+                else if (key.name === "up" || key.name === "down" || key.name === "tab") {
+                    const delta = key.name === "up" || key.shift ? -1 : 1;
+                    const next = Math.max(0, Math.min(filtered.length - 1, index + delta));
+                    if (next === index && delta < 0)
+                        questionOffset = Math.max(0, questionOffset - 1);
+                    else {
+                        index = next;
+                        const range = questionView.ranges[index];
+                        if (range && (range.start < questionOffset || range.end > questionOffset + page))
+                            questionOffset = range.start;
+                    }
+                }
+                else
+                    return;
+                draw();
+                return;
+            }
+            if (key.name === "tab" && filtered.length) {
+                details = !details;
+                detailOffset = 0;
+                draw();
+                return;
+            }
+            const moves = { down: 1, up: -1, pagedown: pageSize(), pageup: -pageSize() };
+            const name = key.ctrl && key.name === "n" ? "down" : key.ctrl && key.name === "p" ? "up" : key.name ?? "";
+            const delta = moves[name];
+            if (delta !== undefined || name === "home" || name === "end") {
+                const max = details ? detailMax() : Math.max(0, filtered.length - 1);
+                const pos = details ? detailOffset : index;
+                const next = name === "home" ? 0 : name === "end" ? max : Math.max(0, Math.min(max, pos + (delta ?? 0)));
+                if (details)
+                    detailOffset = next;
+                else
+                    index = next;
+                draw();
+                return;
+            }
+            if (opts.filterable) {
+                if (key.name === "backspace")
+                    query = Array.from(query).slice(0, -1).join("");
+                else if (key.ctrl && key.name === "u")
+                    query = "";
+                else if (!key.ctrl && !key.meta && typeof chunk === "string" && chunk && !/[\x00-\x1f\x7f-\x9f]/.test(chunk))
+                    query += chunk;
+                else
+                    return;
+                applyFilter();
+                draw();
+            }
+            else if (key.name === "q")
+                cleanup(null);
+        };
+        opts.ctl.pause();
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+        keys.on("keypress", onKeypress);
+        stdout.on("resize", draw);
+        draw();
+    });
+}

package/dist/tui/session-replay.d.ts

@@ -0,0 +1,10 @@
+import type { Session } from "../core/session.js";
+import type { Message } from "../core/types.js";
+import { type TuiTheme } from "./branding.js";
+export declare function sessionConversation(session: Session): readonly Message[];
+export declare function replaySession(session: Session, control: {
+    write(text: string): void;
+    writeConversation?(text: string): void;
+    replayConversation?(renderer: (columns: number) => string): void;
+}, theme: TuiTheme, columns: number): void;
+export declare function resumeReplay(session: Session, theme: TuiTheme, columns: number): string;

package/dist/tui/session-replay.js

@@ -0,0 +1,78 @@
+import { renderAssistantSegment, renderUserMessage } from "./branding.js";
+import { commandSource, highlightCommand } from "./command-transcript.js";
+import { plainText, wrapText } from "./terminal-text.js";
+import { tr } from "./i18n.js";
+// The model's history() is compacted; the visible conversation uses the
+// original nodes on the selected branch, including archived messages.
+export function sessionConversation(session) {
+    return session.nodeChain().map(node => node.message);
+}
+export function replaySession(session, control, theme, columns) {
+    if (control.replayConversation)
+        control.replayConversation(width => resumeReplay(session, theme, width));
+    else
+        (control.writeConversation ?? control.write).call(control, resumeReplay(session, theme, columns));
+}
+export function resumeReplay(session, theme, columns) {
+    const messages = sessionConversation(session);
+    const width = Math.max(2, columns - 5);
+    const out = [];
+    const calls = new Map();
+    const heading = (text, style = theme.dim) => {
+        out.push("\n" + wrapText(plainText(text), width, true).map(row => "  " + style(row)).join("\n") + "\n");
+    };
+    const literal = (text, style = theme.dim) => {
+        out.push(wrapText(plainText(text), width, true).map(row => "    " + style(row)).join("\n") + "\n");
+    };
+    const attachment = (part) => {
+        const source = part.source && !part.source.startsWith("data:") ? ` · ${part.source}` : "";
+        literal(`[${tr("immagine", "image")} · ${part.mime}${source}]`);
+    };
+    heading(tr("ripresa sessione {name}({id}) · {count} messaggi", "Resumed session {name}({id}) · {count} messages", {
+        name: session.name ? `"${session.name}" ` : "", id: session.id, count: messages.length,
+    }), theme.bold);
+    for (const message of messages) {
+        let text = "";
+        const flushText = () => {
+            if (!text.trim()) {
+                text = "";
+                return;
+            }
+            if (message.role === "user")
+                out.push(renderUserMessage(text, theme, columns));
+            else if (message.role === "assistant")
+                out.push(renderAssistantSegment(text, theme, columns));
+            else {
+                heading(message.role === "system" ? tr("Sistema", "System") : tr("Strumento", "Tool"));
+                literal(text);
+            }
+            text = "";
+        };
+        for (const part of message.content) {
+            if (part.type === "text") {
+                text += (text ? "\n\n" : "") + part.text;
+                continue;
+            }
+            flushText();
+            if (part.type === "tool_call") {
+                calls.set(part.id, part);
+                heading(`${tr("Strumento", "Tool")} · ${part.name}`, theme.accent);
+                const source = commandSource(part);
+                literal(source ?? JSON.stringify(part.input, null, 2), source === undefined ? theme.dim : row => highlightCommand(row, theme));
+            }
+            else if (part.type === "tool_result") {
+                const name = calls.get(part.callId)?.name ?? part.callId;
+                heading(`${part.isError ? tr("Errore", "Error") : tr("Risultato", "Result")} · ${name}`, part.isError ? theme.red : theme.dim);
+                literal(part.output || tr("(nessun output)", "(no output)"), part.isError ? theme.red : theme.dim);
+                for (const media of part.media ?? [])
+                    attachment(media);
+            }
+            else if (part.type === "image") {
+                attachment(part);
+            }
+        }
+        flushText();
+    }
+    heading(tr("contesto ripreso: continua pure da qui", "Context restored: continue from here"));
+    return out.join("");
+}

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

@@ -0,0 +1,22 @@
+import type { AgentEvent, PlanLimits, Usage } from "../core/types.js";
+import type { CostTracker } from "./cost-tracker.js";
+import { ContextMeter } from "./context-meter.js";
+export declare const isSubscription: (providerId: string) => boolean;
+export declare class SessionUsageState {
+    readonly cost: CostTracker;
+    readonly context: ContextMeter;
+    last?: Usage;
+    readonly limits: Map<string, PlanLimits>;
+    missing: number;
+    incomplete: boolean;
+    unsaved: boolean;
+    private readonly seen;
+    private directory;
+    private sessionId;
+    constructor(cost: CostTracker);
+    restore(directory: string, sessionId: string, oldestAssistantAt?: number): void;
+    private add;
+    observe(event: Extract<AgentEvent, {
+        type: "usage";
+    }>): void;
+}

package/dist/tui/session-usage.js

@@ -0,0 +1,55 @@
+import { readSessionUsage, saveSessionUsage } from "../core/session-usage.js";
+import { ContextMeter } from "./context-meter.js";
+export const isSubscription = (providerId) => providerId === "chatgpt" || providerId === "claude-code";
+export class SessionUsageState {
+    cost;
+    context = new ContextMeter();
+    last;
+    limits = new Map();
+    missing = 0;
+    incomplete = false;
+    unsaved = false;
+    seen = new Set();
+    directory = "";
+    sessionId = "";
+    constructor(cost) {
+        this.cost = cost;
+    }
+    restore(directory, sessionId, oldestAssistantAt) {
+        this.context.reset();
+        this.directory = directory;
+        this.sessionId = sessionId;
+        this.cost.reset();
+        this.seen.clear();
+        this.last = undefined;
+        this.missing = 0;
+        this.unsaved = false;
+        const saved = readSessionUsage(directory, sessionId);
+        this.incomplete = saved.incomplete || (oldestAssistantAt !== undefined &&
+            (!saved.records.length || oldestAssistantAt < Math.min(...saved.records.map(r => r.at))));
+        for (const record of saved.records)
+            this.add(record);
+    }
+    add(record) {
+        if (this.seen.has(record.id))
+            return;
+        this.seen.add(record.id);
+        if (record.usage) {
+            this.last = record.usage;
+            this.cost.record(record.model, record.usage, isSubscription(record.providerId));
+        }
+        else
+            this.missing++;
+        const previous = this.limits.get(record.providerId);
+        if (record.limits && (!previous || record.limits.capturedAt >= previous.capturedAt))
+            this.limits.set(record.providerId, record.limits);
+    }
+    observe(event) {
+        if (this.seen.has(event.record.id))
+            return;
+        const own = event.record.sessionId === this.sessionId;
+        const saved = own ? event.persisted : saveSessionUsage(this.directory, this.sessionId, event.record);
+        this.unsaved ||= !saved;
+        this.add(event.record);
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { ToolCallPart } from "../core/types.js";
+import type { TuiTheme } from "./branding.js";
+export declare function loadedSkill(call: ToolCallPart): string | undefined;
+export declare function skillHeader(state: "running" | "ok" | "error", theme: TuiTheme, columns: number): string;
+export declare function skillPreview(name: string, theme: TuiTheme, columns: number, state?: "running" | "ok" | "error"): string[];

package/dist/tui/skill-transcript.js

@@ -0,0 +1,31 @@
+import { fitLine, plainText } from "./terminal-text.js";
+import { tr } from "./i18n.js";
+export function loadedSkill(call) {
+    if (call.name === "skill_load" && typeof call.input["name"] === "string")
+        return call.input["name"];
+    if (call.name === "vascend_skill" && call.input["load"] === true && Array.isArray(call.input["skills"])) {
+        return call.input["skills"].filter((name) => typeof name === "string").join(", ") || undefined;
+    }
+    if (call.name === "read_file" && typeof call.input["path"] === "string") {
+        const path = call.input["path"].replaceAll("\\", "/");
+        return /(?:^|\/)SKILL\.md$/i.test(path) ? path.split("/").at(-2) || "SKILL.md" : undefined;
+    }
+    if (call.name === "bash" && typeof call.input["command"] === "string") {
+        // Recognize a single declared file read, never a script or command chain.
+        const read = /^\s*(?:cat|type|Get-Content)(?:\s+-(?:LiteralPath|Path)|\s+-Encoding\s+(?:UTF8|UTF-8))?\s+(?:-(?:LiteralPath|Path)\s+)?(?:"([^"]+)"|'([^']+)'|([^\s;&|<>]+))\s*$/i.exec(call.input["command"]);
+        const path = (read?.[1] ?? read?.[2] ?? read?.[3])?.replaceAll("\\", "/");
+        if (path && /(?:^|\/)SKILL\.md$/i.test(path))
+            return path.split("/").at(-2) || "SKILL.md";
+    }
+    return undefined;
+}
+export function skillHeader(state, theme, columns) {
+    const label = state === "running" ? tr("Esplorazione", "Exploring")
+        : state === "error" ? tr("Errore", "Error") : tr("Esplorato", "Explored");
+    return fitLine(theme.dim("  • ") + (state === "error" ? theme.red : theme.bold)(label), Math.max(1, columns - 1));
+}
+export function skillPreview(name, theme, columns, state = "running") {
+    return [skillHeader(state, theme, columns),
+        fitLine(theme.dim("    └ ") + (theme.markdownLink ?? theme.accent)(tr("Lettura", "Read"))
+            + theme.dim(` SKILL.md (${plainText(name).replace(/\s+/g, " ")} skill)`), Math.max(1, columns - 1))];
+}

package/dist/tui/startup.d.ts

@@ -0,0 +1,5 @@
+import type { TuiTheme } from "./branding.js";
+import type { StatusData } from "./status-line.js";
+export declare function permissionLabel(mode?: string): string;
+export declare function buildTerminalStartup(d: StatusData, t: TuiTheme): readonly string[];
+export declare function buildStartupRuntime(d: StatusData, t: TuiTheme): string;

package/dist/tui/startup.js

@@ -0,0 +1,61 @@
+import { TALOS_VERSION } from "../core/version.js";
+import { tr } from "./i18n.js";
+import { fitLine, oneLine, padLine, terminalWidth, wrapText } from "./terminal-text.js";
+function modelLabel(d, t, width) {
+    const model = oneLine(d.model).split("/").pop() || oneLine(d.model);
+    const suffix = [d.effort ? t.muted(oneLine(d.effort)) : "", d.fast ? t.accent("fast") : ""].filter(Boolean).join(" ");
+    const budget = Math.max(1, width - terminalWidth(suffix) - (suffix ? 1 : 0));
+    return fitLine(t.silver(fitLine(model, budget)) + (suffix ? " " + suffix : ""), width);
+}
+export function permissionLabel(mode = "normal") {
+    const labels = { normal: tr("Conferma azioni", "Ask before actions"), acceptEdits: tr("Modifiche automatiche", "Automatic edits"), auto: tr("Senza conferme", "No confirmations") };
+    return labels[mode] ?? labels["normal"];
+}
+// The native renderer refreshes this header when the settings change.
+export function buildTerminalStartup(d, t) {
+    const width = Math.max(2, d.width - 2);
+    const preferred = Math.max(46, terminalWidth(oneLine(d.cwd)) + 11, terminalWidth(modelLabel(d, t, 200)) + 26, terminalWidth(oneLine(d.sessionLabel ?? "")) + 11);
+    const inner = Math.max(2, Math.min(68, preferred, width - 4));
+    const permission = permissionLabel(d.permissions);
+    const permissionPaint = d.permissions === "auto" ? t.yellow : t.muted;
+    const title = t.muted(">_ ") + t.bold(t.silver("Vascend Talos")) + t.muted(` (v${TALOS_VERSION})`);
+    const body = [fitLine(title, inner), ""];
+    const labelWidth = Math.max(11, tr("permessi:", "permissions:").length + 1);
+    const stacked = inner < 40;
+    const field = (label, value, paint) => {
+        if (stacked) {
+            body.push(t.muted(label));
+            body.push(...wrapText(oneLine(value), Math.max(2, inner - 2), true).map(line => "  " + paint(line)));
+        }
+        else {
+            const rows = wrapText(oneLine(value), inner - labelWidth, true);
+            body.push(...rows.map((line, i) => (i === 0 ? t.muted(label.padEnd(labelWidth)) : " ".repeat(labelWidth)) + paint(line)));
+        }
+    };
+    if (stacked) {
+        body.push(t.muted(tr("modello:", "model:")), "  " + modelLabel(d, t, inner - 2));
+    }
+    else {
+        let model = modelLabel(d, t, inner - labelWidth);
+        const shortcut = tr("  /model cambia", "  /model change");
+        if (terminalWidth(model) + shortcut.length <= inner - labelWidth)
+            model += t.accent(shortcut);
+        body.push(t.muted(tr("modello:", "model:").padEnd(labelWidth)) + model);
+    }
+    field(tr("cartella:", "directory:"), d.cwd, t.silver);
+    field(tr("permessi:", "permissions:"), permission, permissionPaint);
+    if (d.sessionLabel)
+        field("chat:", d.sessionLabel, t.silver);
+    if (width < 12)
+        return body.map(line => fitLine(line, width));
+    const edge = (left, right) => " " + t.frame(left + "─".repeat(inner + 2) + right);
+    return [edge("╭", "╮"), ...body.map(line => " " + t.frame("│ ") + padLine(line, inner) + t.frame(" │")), edge("╰", "╯")];
+}
+export function buildStartupRuntime(d, t) {
+    const width = Math.max(1, d.width - 3);
+    let line = modelLabel(d, t, width);
+    const remaining = width - terminalWidth(line) - 3;
+    if (remaining >= 8)
+        line += t.dim(" · ") + t.muted(fitLine(oneLine(d.cwd), remaining));
+    return fitLine("  " + line, Math.max(1, d.width - 1));
+}

package/dist/tui/status-line-loader.d.ts

@@ -0,0 +1,8 @@
+import type { SegmentRender } from "./status-line.js";
+export interface StatusExt {
+    readonly render?: SegmentRender;
+    readonly custom?: Readonly<Record<string, SegmentRender>>;
+    readonly path?: string;
+}
+export declare function statusLineFiles(cwd: string, projectTrusted: boolean): string[];
+export declare function loadStatusExt(cwd: string, projectTrusted: boolean): Promise<StatusExt>;

package/dist/tui/status-line-loader.js

@@ -0,0 +1,33 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+// File candidati (progetto prima, poi globale). Solo i fidati: il file di
+// progetto richiede project trust.
+export function statusLineFiles(cwd, projectTrusted) {
+    const names = ["status-line.js", "status-line.mjs", "status-line.cjs", "status-line.ts"];
+    const out = [];
+    if (projectTrusted)
+        for (const n of names)
+            out.push(join(cwd, ".talos", n));
+    for (const n of names)
+        out.push(join(homedir(), ".talos", n));
+    return out;
+}
+export async function loadStatusExt(cwd, projectTrusted) {
+    const file = statusLineFiles(cwd, projectTrusted).find((p) => existsSync(p));
+    if (!file)
+        return {};
+    try {
+        // Cache-bust per il reload a caldo (ogni import rilegge il file).
+        const url = pathToFileURL(resolve(file)).href + `?t=${Date.now()}`;
+        const mod = (await import(url));
+        const render = typeof mod.default === "function" ? mod.default : undefined;
+        const custom = mod.segments && typeof mod.segments === "object" ? mod.segments : undefined;
+        return { render, custom, path: file };
+    }
+    catch (err) {
+        process.stderr.write(`[status-line] errore caricando ${file}: ${err.message}\n`);
+        return { path: file };
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { TuiTheme } from "./branding.js";
+import type { ContextArchiveBlock } from "./context-meter.js";
+import { type CostSnapshot } from "./cost-tracker.js";
+export interface StatusData {
+    readonly model: string;
+    readonly provider?: string;
+    readonly cwd: string;
+    readonly effort?: string;
+    readonly fast?: boolean;
+    readonly vibeMode?: string;
+    readonly permissions?: string;
+    readonly sessionLabel?: string;
+    readonly contextTokens?: number;
+    readonly contextWindow?: number;
+    readonly contextArchive?: readonly ContextArchiveBlock[];
+    readonly regno?: {
+        readonly done: number;
+        readonly total: number;
+        readonly castles: number;
+    } | null;
+    readonly cost?: CostSnapshot | null;
+    readonly bg?: {
+        readonly running: number;
+        readonly total: number;
+    } | null;
+    readonly width: number;
+}
+export type SegmentRender = (d: StatusData, theme: TuiTheme) => string | null;
+export interface StatusOptions {
+    readonly order?: readonly string[];
+    readonly custom?: Readonly<Record<string, SegmentRender>>;
+    readonly render?: (d: StatusData, theme: TuiTheme) => string | null;
+}
+export declare const DEFAULT_ORDER: readonly string[];
+export declare const BUILTIN_SEGMENTS: Readonly<Record<string, SegmentRender>>;
+export declare function buildStatusLine(d: StatusData, theme: TuiTheme, opts?: StatusOptions): string;
+export declare function buildTerminalHeader(d: StatusData, theme: TuiTheme): readonly string[];
+export declare function buildTerminalWelcome(width: number, theme: TuiTheme): string;