@vascend/talos 0.1.5 → 0.1.6

package/dist/tui/review-store.d.ts

@@ -35,6 +35,7 @@ export declare class ReviewStore {
     private retainedChars;
     private callIndex;
     private actorText;
+    private rawActors;
     private sequence;
     private run;
     private _revision;

package/dist/tui/review-store.js

@@ -1,5 +1,8 @@
 import { oneLine } from "./terminal-text.js";
 import { AgentSessions } from "./agent-sessions.js";
+import { agentLabel } from "./agent-label.js";
+import { tr } from "./i18n.js";
+import { runtimeError } from "./runtime-error.js";
 const LABELS = {
     read_file: "Lettura", list_dir: "Cartella", grep: "Ricerca", glob: "Ricerca file",
     write_file: "Scrittura", edit_file: "Modifica", bash: "Comando", bash_bg: "Comando in background",
@@ -9,7 +12,9 @@ const LABELS = {
     vascend_addrooms: "Nuove attività", vascend_status: "Lista attività",
     kingdom_send: "Messaggio al team", kingdom_inbox: "Messaggi del team", kingdom_wait: "Attesa collaboratori",
 };
-export function reviewTitle(name) { return LABELS[name] ?? name; }
+export function reviewTitle(name) {
+    return name === "bash_output" ? tr("Processo in background", "Background process") : LABELS[name] ?? name;
+}
 function textSize(value, seen = new Set()) {
     if (typeof value === "string")
         return value.length;
@@ -34,6 +39,7 @@ export class ReviewStore {
     retainedChars = 0;
     callIndex = new Map();
     actorText = new Map();
+    rawActors = new Set();
     sequence = 0;
     run = 0;
     _revision = 0;
@@ -48,7 +54,17 @@ export class ReviewStore {
     get revision() { return this._revision; }
     get evicted() { return this._evicted; }
     get running() { return this._running || [...this.items.values()].some(e => e.state === "running"); }
-    get label() { return !this._running && this.running ? "Collaboratori in esecuzione" : this._label; }
+    get label() {
+        if (!this._running && this.running)
+            return tr("Collaboratori in esecuzione", "Workers running");
+        switch (this._label) {
+            case "Pronto": return tr("Pronto", "Ready");
+            case "Avvio": return tr("Avvio", "Starting");
+            case "Interrotto": return tr("Interrotto", "Interrupted");
+            case "In attesa del prossimo messaggio": return tr("In attesa del prossimo messaggio", "Waiting for the next message");
+            default: return this._label;
+        }
+    }
     get goal() { return this._goal; }
     entries() { return [...this.items.values()]; }
     get(id) { return this.items.get(id); }
@@ -77,6 +93,7 @@ export class ReviewStore {
         this.retainedChars = 0;
         this.callIndex.clear();
         this.actorText.clear();
+        this.rawActors.clear();
         this.sequence = 0;
         this.run = 0;
         this._evicted = 0;
@@ -106,6 +123,10 @@ export class ReviewStore {
             this.put({ ...entry, change });
     }
     record(event, at = Date.now(), actor = "Talos") {
+        // Host summaries must not overwrite full raw tool output or duplicate messages.
+        if (event.type === "kingdom" && (event.phase === "tool" || event.phase === "say" || event.phase === "inbox")
+            && this.rawActors.has(event.slug))
+            return;
         this.sessions.record(event, at, actor);
         switch (event.type) {
             case "status":
@@ -152,7 +173,7 @@ export class ReviewStore {
                 break;
             }
             case "error":
-                this.notice("Errore", event.message, "error", at, actor);
+                this.notice(tr("Errore", "Error"), runtimeError(event.message), "error", at, actor);
                 break;
             case "compacted":
                 this.notice("Contesto riassunto", `Stima locale: ${event.tokensBefore} → ${event.tokensAfter} token.\n${event.anchors?.join("\n") ?? ""}`, "info", at);
@@ -169,6 +190,7 @@ export class ReviewStore {
         }
     }
     recordActor(actor, event) {
+        this.rawActors.add(actor);
         if (event.type === "status" || event.type === "text")
             this.sessions.record(event, Date.now(), actor);
         if (event.type === "status") {
@@ -193,12 +215,11 @@ export class ReviewStore {
         if (event.type === "turn_start" || event.type === "done" || event.type === "error") {
             this.record({ type: "kingdom", phase: "vassal", slug: actor,
                 state: event.type === "turn_start" ? "active" : event.type === "done" ? "done" : "error",
-                ...(event.type === "error" ? { label: event.message } : {}) });
+                ...(event.type === "error" ? { label: runtimeError(event.message) } : {}) });
         }
         if (event.type === "done" || event.type === "error")
             this.finishActor(actor);
-        if (event.type !== "turn_start")
-            this.record(event, Date.now(), actor);
+        this.record(event, Date.now(), actor);
     }
     recordKingdom(e, at) {
         if (e.phase === "start") {
@@ -249,7 +270,7 @@ export class ReviewStore {
         }
         else if (e.phase === "say" || e.phase === "note" || e.phase === "notice" || e.phase === "message" || e.phase === "inbox") {
             const actor = "slug" in e ? e.slug : "from" in e ? e.from : "Talos";
-            this.notice(e.phase === "message" ? `${actor} → ${e.to}` : e.phase === "inbox" ? `Messaggio ${e.state === "read" ? "letto" : "in coda"}` : "Aggiornamento", e.text, "info", at, actor);
+            this.notice(e.phase === "message" ? `${agentLabel(actor)} → ${agentLabel(e.to)}` : e.phase === "inbox" ? `Messaggio ${e.state === "read" ? "letto" : "in coda"}` : "Aggiornamento", e.text, "info", at, actor);
         }
         else if (e.phase === "task") {
             const id = `task:${this.run}:${e.slug}:${e.workstreamId}:${e.taskRef}`;

package/dist/tui/review-team.js

@@ -1,3 +1,4 @@
+import { agentLabel } from "./agent-label.js";
 // Proiezione del registro: una riga stabile per agente, non una per evento.
 export function teamEntries(store) {
     const groups = new Map();
@@ -19,9 +20,9 @@ export function teamEntries(store) {
         const waiting = state === "running" && status && /attes|conferm|permess|domand/i.test(status.target)
             && (status.startedAt ?? 0) >= (latest.endedAt ?? latest.startedAt ?? 0);
         const activity = (waiting ? status.target : "") || current || (state !== "running" ? lifecycle?.output : "") || `${latest.title}: ${latest.target}`;
-        return { id: `agent:${actor}`, actor, kind: "team", title: actor,
-            state, target: `${actor} · ${state === "running" ? "in corso" : state === "ok" ? "concluso" : state === "error" ? "errore" : state === "stopped" ? "interrotto" : lifecycle?.output?.startsWith("In coda") ? "in coda" : "stato non disponibile"} · ${activity}`,
-            output: `Incarico: ${goal}\nRuolo: ${lifecycle?.role ?? "non disponibile"}\nRisponde a: ${lifecycle?.parent ?? "orchestratore"}\nAttività: ${activity}\n${active.length} tool attivi · ${files.size} file · ${problems.length} problemi\nEventi disponibili: ${entries.length}`,
+        return { id: `agent:${actor}`, actor, kind: "team", title: agentLabel(actor),
+            state, target: `${agentLabel(actor)} · ${state === "running" ? "in corso" : state === "ok" ? "concluso" : state === "error" ? "errore" : state === "stopped" ? "interrotto" : lifecycle?.output?.startsWith("In coda") ? "in coda" : "stato non disponibile"} · ${activity}`,
+            output: `Incarico: ${goal}\nRuolo: ${lifecycle?.role ?? "non disponibile"}\nRisponde a: ${agentLabel(lifecycle?.parent ?? "main")}\nAttività: ${activity}\n${active.length} tool attivi · ${files.size} file · ${problems.length} problemi\nEventi disponibili: ${entries.length}`,
             startedAt: lifecycle?.startedAt, endedAt: lifecycle?.endedAt };
     });
 }

package/dist/tui/runtime-error.d.ts

@@ -0,0 +1,2 @@
+export declare function isUserInterruption(message: string): boolean;
+export declare function runtimeError(message: string): string;

package/dist/tui/runtime-error.js

@@ -0,0 +1,26 @@
+import { tr } from "./i18n.js";
+export function isUserInterruption(message) {
+    return /^(?:interrotto|interrupted|richiesta interrotta|request interrupted|the operation was aborted\.?|this operation was aborted\.?)$/i.test(message.trim());
+}
+// Localize Talos-owned runtime diagnostics at the display boundary, including
+// events from existing sessions. Unknown provider errors retain their details.
+export function runtimeError(message) {
+    switch (message) {
+        case "interrotto": return tr("interrotto", "Interrupted");
+        case "Il contesto supera la finestra del modello anche dopo la compattazione. La sessione resta recuperabile.": return tr("Il contesto supera la finestra del modello anche dopo la compattazione. La sessione resta recuperabile.", "The context exceeds the model window even after compaction. The session can still be recovered.");
+        case "Il provider ha interrotto il turno senza fornire dettagli.": return tr("Il provider ha interrotto il turno senza fornire dettagli.", "The provider interrupted the turn without providing details.");
+        case "Il provider ha terminato con tool_use senza fornire una tool call valida. Il task non e' stato completato; riprova mantenendo questa sessione.": return tr("Il provider ha terminato con tool_use senza fornire una tool call valida. Il task non e' stato completato; riprova mantenendo questa sessione.", "The provider ended with tool_use without a valid tool call. The task was not completed; retry in this session.");
+        case "Il provider ha chiuso il turno senza una risposta finale. Il task non e' stato dichiarato completato; riprova mantenendo questa sessione.": return tr("Il provider ha chiuso il turno senza una risposta finale. Il task non e' stato dichiarato completato; riprova mantenendo questa sessione.", "The provider ended the turn without a final response. The task was not marked complete; retry in this session.");
+        case "La delega richiesta non e' stata autorizzata; il task non viene dichiarato completato.": return tr("La delega richiesta non e' stata autorizzata; il task non viene dichiarato completato.", "The requested delegation was not authorized; the task is not marked complete.");
+    }
+    const turns = /^pausa al tetto di (\d+) turni per questo giro \(TALOS_MAX_TURNS per alzarlo\); la validazione del piano riprende le attivita rimaste$/.exec(message);
+    if (turns)
+        return tr("Pausa al limite di {count} turni per questo giro (TALOS_MAX_TURNS per alzarlo); la validazione del piano riprende le attività rimaste.", "Paused at the limit of {count} turns for this run (increase TALOS_MAX_TURNS to raise it); plan validation resumes the remaining tasks.", { count: turns[1] });
+    const output = /^Risposta incompleta: raggiunto il limite di output dopo (\d+) continuazion[ei]\. Il task non e' stato marcato completato; riprendi dalla stessa sessione\.$/.exec(message);
+    if (output)
+        return tr("Risposta incompleta: limite di output raggiunto. Continuazioni eseguite: {count}. Il task non è stato marcato completato; riprendi dalla stessa sessione.", "Incomplete response: output limit reached. Continuations used: {count}. The task was not marked complete; resume in the same session.", { count: output[1] });
+    const tasks = /^Task incompleto: restano (.+)\. Il turno e' stato fermato senza dichiarare un falso completamento; riprendilo nella stessa sessione\.$/.exec(message);
+    if (tasks)
+        return tr("Task incompleto: restano {tasks}. Il turno è stato fermato senza dichiarare un falso completamento; riprendilo nella stessa sessione.", "Incomplete task: {tasks} remain. The turn stopped without claiming completion; resume in the same session.", { tasks: tasks[1] });
+    return message;
+}

package/dist/tui/selector-mouse.d.ts

@@ -22,5 +22,6 @@ export declare function selectorMouseIndex(o: {
     count: number;
     index: number;
     pageSize: number;
+    headerRows?: number;
 }): number | null;
 export {};

package/dist/tui/selector-mouse.js

@@ -57,7 +57,7 @@ export class SelectorMouseInput {
 }
 export function selectorMouseIndex(o) {
     const top = o.rows - Math.min(o.renderedRows, o.rows - 1) + 1;
-    const row = o.y - top - 1; // title occupies the first overlay row
+    const row = o.y - top - (o.headerRows ?? 1);
     if (o.x < 1 || o.x > o.columns + 1 || row < 0 || row >= Math.min(o.count, o.pageSize))
         return null;
     const start = Math.max(0, Math.min(o.index - Math.floor(o.pageSize / 2), o.count - o.pageSize));

package/dist/tui/selector.d.ts

@@ -7,6 +7,11 @@ export interface SelectOption<T> {
     readonly hint?: string;
     readonly value: T;
     readonly age?: string;
+    readonly modelInfo?: {
+        readonly context?: number;
+        readonly reasoning?: boolean;
+        readonly cost: Readonly<Record<string, number>>;
+    };
 }
 interface SelectorControl {
     pause(): void;
@@ -15,11 +20,13 @@ interface SelectorControl {
     setOverlay(lines: string[] | null): void;
 }
 interface SelectorOptions<T> {
+    readonly signal?: AbortSignal;
     readonly title: string;
     readonly hint?: string;
     readonly options: readonly SelectOption<T>[];
     readonly current?: T;
     readonly currentKey?: string;
+    readonly onCycleMode?: () => SelectOption<T> | undefined;
     readonly theme: TuiTheme;
     readonly wide?: boolean;
     readonly question?: boolean;

package/dist/tui/selector.js

@@ -115,6 +115,8 @@ export function renderSelector(opts) {
     return lines;
 }
 export async function selectOption(opts) {
+    if (opts.signal?.aborted)
+        return null;
     if (!stdin.isTTY || !stdout.isTTY || typeof stdin.setRawMode !== "function") {
         opts.ctl.write(opts.theme.bold(`\n ${opts.title}\n`));
         if (opts.hint)
@@ -172,6 +174,7 @@ export async function selectOption(opts) {
             if (settled)
                 return;
             settled = true;
+            opts.signal?.removeEventListener("abort", abort);
             stdin.off("data", onData);
             decoder.dispose();
             keys.off("keypress", onKeypress);
@@ -197,7 +200,8 @@ export async function selectOption(opts) {
             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,
+                columns: opts.modelList ? Math.max(1, opts.terminalColumns() - 2) : selectorWidth(opts.terminalColumns(), opts.wide), renderedRows,
+                headerRows: opts.modelList ? 4 : 1,
                 count: filtered.length, index, pageSize: pageSize() });
             if (hit === null)
                 return;
@@ -212,6 +216,14 @@ export async function selectOption(opts) {
         const utf8 = new StringDecoder("utf8");
         const onData = (data) => decoder.push(typeof data === "string" ? data : utf8.write(data));
         const onKeypress = (chunk, key) => {
+            if (key.shift && key.name === "tab" && opts.onCycleMode) {
+                const selected = opts.onCycleMode();
+                if (selected)
+                    cleanup(selected);
+                else
+                    draw();
+                return;
+            }
             if (key.name === "return") {
                 cleanup(filtered[index] ?? null);
                 return;
@@ -295,12 +307,17 @@ export async function selectOption(opts) {
             else if (key.name === "q")
                 cleanup(null);
         };
+        const abort = () => cleanup(null);
         opts.ctl.pause();
         stdin.setRawMode(true);
         stdin.resume();
         stdin.on("data", onData);
         keys.on("keypress", onKeypress);
         stdout.on("resize", draw);
-        draw();
+        opts.signal?.addEventListener("abort", abort, { once: true });
+        if (opts.signal?.aborted)
+            abort();
+        else
+            draw();
     });
 }

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

@@ -0,0 +1,26 @@
+import type { UserInbox } from "../core/user-inbox.js";
+import type { ContentPart } from "../core/types.js";
+import type { AgentSession } from "./agent-sessions.js";
+import type { TuiTheme } from "./branding.js";
+import { buildUsageFooter } from "./usage-footer.js";
+export declare function workerFooter(session: AgentSession, width: number, theme: TuiTheme, usage?: Parameters<typeof buildUsageFooter>[2], providerId?: (model: string) => string): readonly string[];
+export declare function deleteWorker(session: AgentSession): {
+    ok: boolean;
+    error?: string;
+};
+export declare function stopWorker(session: AgentSession): {
+    ok: boolean;
+    error?: string;
+};
+export declare function bindWorkerInbox(session: AgentSession, inbox: UserInbox): {
+    ok: boolean;
+    error?: string;
+};
+export declare function wakeWorker(session: AgentSession): {
+    ok: boolean;
+    error?: string;
+};
+export declare function sendWorker(session: AgentSession, text: string, parts: readonly ContentPart[], immediate: boolean): {
+    ok: boolean;
+    error?: string;
+};

package/dist/tui/session-controls.js

@@ -0,0 +1,65 @@
+import { kingdomLive } from "../vascend/kingdom-live.js";
+import { compactContextTokens } from "./context-bar.js";
+import { buildUsageFooter } from "./usage-footer.js";
+import { tr } from "./i18n.js";
+import { fitLine } from "./terminal-text.js";
+import { ContextMeter } from "./context-meter.js";
+const meters = new WeakMap();
+export function workerFooter(session, width, theme, usage = { limits: new Map(), incomplete: false, missing: 0, unsaved: false }, providerId = model => model.split("/")[0] ?? "") {
+    const source = kingdomLive.contextSource(session.kingdomId ?? "", session.actor);
+    let reading;
+    if (source) {
+        let entry = meters.get(source.session);
+        if (!entry) {
+            entry = { meter: new ContextMeter() };
+            meters.set(source.session, entry);
+        }
+        const input = { ...source, env: source.env ?? process.env };
+        if (session.context && entry.observed !== session.context) {
+            entry.meter.observe(input, session.context);
+            entry.observed = session.context;
+        }
+        reading = entry.meter.read(input);
+    }
+    const ctx = reading ?? session.context;
+    const model = source?.config.model ?? session.context?.model ?? session.actor;
+    const footer = buildUsageFooter({ model, cwd: source?.config.cwd ?? "", width,
+        effort: source?.config.effort, fast: source?.config.fast,
+        contextTokens: ctx?.tokens, contextWindow: ctx?.window, contextArchive: reading?.archived,
+    }, theme, usage, providerId(model), { order: [] });
+    return [...footer,
+        fitLine(theme.muted(`  ${tr("Consumo cumulativo", "Cumulative usage")}: ${session.usageMissing ? "≥" : ""}${session.usageKnown
+            ? compactContextTokens(session.inputTokens + session.outputTokens) : "—"} token`), width - 1)];
+}
+// Release works for both active and idle workers; persisted history is kept.
+export function deleteWorker(session) {
+    if (session.id === "main")
+        return { ok: false, error: tr("La sessione principale non si elimina", "Cannot delete the main session") };
+    if (session.kingdomId)
+        kingdomLive.release(session.kingdomId, session.actor);
+    return { ok: true };
+}
+export function stopWorker(session) {
+    if (!session.kingdomId)
+        return { ok: false, error: tr("Collaboratore non attivo", "Worker inactive") };
+    return kingdomLive.stop(session.kingdomId, session.actor);
+}
+export function bindWorkerInbox(session, inbox) {
+    return kingdomLive.bindInbox(session.kingdomId ?? "", session.actor, inbox);
+}
+export function wakeWorker(session) {
+    return kingdomLive.wake(session.kingdomId ?? "", session.actor);
+}
+// Session-scoped commands cannot silently fall through to the main session.
+// Global display/preferences commands are still handled by the host explicitly.
+export function sendWorker(session, text, parts, immediate) {
+    if (!session.kingdomId)
+        return { ok: false, error: tr("Collaboratore non attivo", "Worker inactive") };
+    const compact = /^\/compact(?:\s+([\s\S]*))?\s*$/.exec(text.trim());
+    if (compact)
+        return kingdomLive.compact(session.kingdomId, session.actor, compact[1]);
+    if (text.trimStart().startsWith("/"))
+        return { ok: false,
+            error: tr("Comando non disponibile per questa sessione", "Command unavailable for this session") };
+    return kingdomLive.deliver(session.kingdomId, session.actor, text, undefined, parts, immediate);
+}

package/dist/tui/session-naming-notice.js

@@ -1,3 +1,4 @@
+import { shimmerText } from "./compaction-status.js";
 // A short, non-scrolling transition from the first prompt to its saved title.
 export class SessionNamingNotice {
     refresh;
@@ -41,9 +42,10 @@ export class SessionNamingNotice {
             return [];
         if (!this.pending && elapsed >= 900)
             return [this.title];
-        const frame = Math.floor(elapsed / 100) % 9;
-        return Array.from({ length: 3 }, (_, row) => Array.from({ length: 3 }, (_, col) => row * 3 + col === frame ? "\u25cf" : "\u00b7").join(" ")
-            + (row === 1 ? "  Renaming" : ""));
+        // Una sola riga stabile: lo shimmer cambia soltanto luminosita', senza
+        // griglia 3x3, cubi o glyph che saltano tra un frame e l'altro.
+        const frame = Math.floor(elapsed / 100);
+        return [shimmerText("Renaming", frame)];
     }
     line(now = Date.now()) { return this.lines(now).join("\n"); }
     clear() {

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

@@ -7,4 +7,5 @@ export declare function replaySession(session: Session, control: {
     writeConversation?(text: string): void;
     replayConversation?(renderer: (columns: number) => string): void;
 }, theme: TuiTheme, columns: number): void;
+export declare function visibleUserText(text: string): string;
 export declare function resumeReplay(session: Session, theme: TuiTheme, columns: number): string;

package/dist/tui/session-replay.js

@@ -1,7 +1,11 @@
 import { renderAssistantSegment, renderUserMessage } from "./branding.js";
-import { commandSource, highlightCommand } from "./command-transcript.js";
-import { plainText, wrapText } from "./terminal-text.js";
+import { commandOutput, commandPreview, commandResultState, commandSource } from "./command-transcript.js";
 import { tr } from "./i18n.js";
+import { livePreview, liveResultSummary, backgroundResultSummary } from "./live-output.js";
+import { mcpName, mcpOutput, mcpPreview } from "./mcp-transcript.js";
+import { loadedSkill, skillPreview } from "./skill-transcript.js";
+import { fitLine, terminalWidth } from "./terminal-text.js";
+import { toolArg, toolLabel } from "./tool-presentation.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) {
@@ -13,25 +17,51 @@ export function replaySession(session, control, theme, columns) {
     else
         (control.writeConversation ?? control.write).call(control, resumeReplay(session, theme, columns));
 }
+function attachmentLabel(part) {
+    const source = part.source && !part.source.startsWith("data:") ? ` · ${part.source}` : "";
+    return `[${tr("immagine", "image")} · ${part.mime}${source}]`;
+}
+function genericToolHeader(call, theme, columns) {
+    const label = toolLabel(call.name);
+    const arg = livePreview(toolArg(call), columns - terminalWidth(label) - 9);
+    return fitLine(" " + theme.muted("◇ " + label) + " " + theme.dim(arg), Math.max(1, columns - 1));
+}
+export function visibleUserText(text) {
+    // Talos persists the exact request sent to the model. With the Vascend
+    // workflow that request contains an internal GOAL/MODE envelope, while the
+    // live chat shows only what the user typed. Resume must preserve that same
+    // presentation without changing the stored model history.
+    if (!text.includes("[VASCEND_GOAL]"))
+        return text;
+    const markers = [...text.matchAll(/(?:^|\r?\n)INPUT_UTENTE\r?\n/g)];
+    const marker = markers.at(-1);
+    if (marker?.index === undefined)
+        return text;
+    return text.slice(marker.index + marker[0].length).trim();
+}
+// A resumed session uses the same compact blocks as a live turn. No resume
+// banner or restored-context footer is inserted into the conversation.
 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}]`);
+    const backgroundPolls = new Map();
+    const results = new Map();
+    for (const message of messages) {
+        for (const part of message.content)
+            if (part.type === "tool_result" && !results.has(part.callId))
+                results.set(part.callId, part);
+    }
+    const attachment = (part, role) => {
+        const caption = attachmentLabel(part);
+        if (role === "user")
+            out.push(renderUserMessage(caption, theme, columns));
+        else
+            out.push(fitLine(theme.dark("  │ ") + theme.dark("⎿ ") + theme.dim(caption), Math.max(1, columns - 1)) + "\n");
     };
-    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) {
+        if (message.role === "system")
+            continue;
         let text = "";
         const flushText = () => {
             if (!text.trim()) {
@@ -39,13 +69,9 @@ export function resumeReplay(session, theme, columns) {
                 return;
             }
             if (message.role === "user")
-                out.push(renderUserMessage(text, theme, columns));
+                out.push(renderUserMessage(visibleUserText(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) {
@@ -54,25 +80,68 @@ export function resumeReplay(session, theme, columns) {
                 continue;
             }
             flushText();
+            if (part.type === "image") {
+                attachment(part, message.role);
+                continue;
+            }
             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));
+                if (part.name === "bash_output")
+                    continue;
+                if (part.name === "vascend_mark")
+                    continue;
+                const result = results.get(part.id);
+                const skill = loadedSkill(part);
+                if (skill) {
+                    out.push("\n" + skillPreview(skill, theme, columns, result?.isError ? "error" : result ? "ok" : "running").join("\n") + "\n");
+                    continue;
+                }
+                if (mcpName(part.name)) {
+                    out.push("\n" + mcpPreview(part, theme, columns, result?.isError ? "error" : result ? "ok" : "stopped").join("\n") + "\n");
+                    continue;
+                }
+                const source = part.name === "bash" ? commandSource(part) : undefined;
+                if (source !== undefined) {
+                    out.push("\n" + commandPreview(source, theme, columns, result ? commandResultState(result.output, result.isError) : "stopped").lines.join("\n") + "\n");
+                    continue;
+                }
+                out.push("\n" + genericToolHeader(part, theme, columns) + "\n");
+                continue;
             }
-            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);
+            if (part.type === "tool_result") {
+                const call = calls.get(part.callId);
+                if (call?.name === "bash_output") {
+                    const id = String(call.input["id"] ?? call.id);
+                    const snapshot = JSON.stringify([part.isError ?? false, part.output, part.media]);
+                    if (backgroundPolls.get(id) === snapshot)
+                        continue;
+                    backgroundPolls.set(id, snapshot);
+                    out.push("\n" + fitLine(" " + (part.isError ? theme.red("× ") : theme.muted("◇ "))
+                        + theme.muted(toolLabel("bash_output")), Math.max(1, columns - 1)) + "\n");
+                }
+                if (call?.name === "vascend_mark")
+                    continue;
+                const skill = call && loadedSkill(call);
+                if (skill) {
+                    if (part.isError)
+                        out.push(commandOutput(part.output, theme, columns, true).join("\n") + "\n");
+                }
+                else if (call && mcpName(call.name)) {
+                    out.push(mcpOutput(part.output, part.isError, theme, columns).join("\n") + "\n");
+                }
+                else if (call?.name === "bash" && commandSource(call) !== undefined) {
+                    out.push(commandOutput(part.output, theme, columns, Boolean(part.isError)).join("\n") + "\n");
+                }
+                else {
+                    const summary = call?.name === "bash_output" ? backgroundResultSummary(part.output, columns) : liveResultSummary(part.output, null, columns);
+                    out.push(fitLine(theme.dark(" └ ") + (part.isError ? theme.red("× ") : "")
+                        + (part.isError ? theme.red(summary) : theme.dim(summary)), Math.max(1, columns - 1)) + "\n");
+                }
                 for (const media of part.media ?? [])
-                    attachment(media);
-            }
-            else if (part.type === "image") {
-                attachment(part);
+                    attachment(media, "tool");
             }
         }
         flushText();
     }
-    heading(tr("contesto ripreso: continua pure da qui", "Context restored: continue from here"));
     return out.join("");
 }

package/dist/tui/session-transcript-layout.d.ts

@@ -0,0 +1,9 @@
+type Wrap = (text: string, width: number, wordWrap: boolean) => readonly string[];
+export declare class SessionTranscriptLayout {
+    private readonly wrap;
+    private readonly sessions;
+    constructor(wrap?: Wrap);
+    retain(ids: ReadonlySet<string>): void;
+    lines(id: string, values: readonly string[], width: number): readonly string[];
+}
+export {};

package/dist/tui/session-transcript-layout.js

@@ -0,0 +1,41 @@
+import { wrapText } from "./terminal-text.js";
+// Reflow only changed blocks (usually the streaming tail), not the complete
+// worker transcript on every token, timer tick or selection change. This is a
+// bounded rendering cache; the session store remains the source of truth.
+export class SessionTranscriptLayout {
+    wrap;
+    sessions = new Map();
+    constructor(wrap = wrapText) {
+        this.wrap = wrap;
+    }
+    retain(ids) {
+        for (const id of this.sessions.keys())
+            if (!ids.has(id))
+                this.sessions.delete(id);
+    }
+    lines(id, values, width) {
+        const blocks = values.filter(Boolean);
+        const cached = this.sessions.get(id);
+        const previous = cached?.width === width ? cached : undefined;
+        if (previous && blocks.length === previous.blocks.length && blocks.every((text, i) => text === previous.blocks[i])) {
+            this.sessions.delete(id);
+            this.sessions.set(id, previous);
+            return previous.lines;
+        }
+        const wrapped = new Map();
+        const lines = [];
+        for (const text of blocks) {
+            const rows = wrapped.get(text) ?? previous?.wrapped.get(text) ?? this.wrap(text, width, true);
+            wrapped.set(text, rows);
+            if (lines.length)
+                lines.push("");
+            for (const row of rows)
+                lines.push(row);
+        }
+        this.sessions.delete(id);
+        this.sessions.set(id, { width, blocks, wrapped, lines });
+        if (this.sessions.size > 8)
+            this.sessions.delete(this.sessions.keys().next().value);
+        return lines;
+    }
+}