@vascend/talos 0.1.4 → 0.1.5

package/dist/tui/agent-sessions-screen.js

@@ -0,0 +1,132 @@
+import { tr } from "./i18n.js";
+import { PLAIN_QUEUE_STYLE } from "./queue-screen.js";
+import { fitLine, oneLine, terminalWidth, wrapText } from "./terminal-text.js";
+export function sessionDuration(ms) {
+    const seconds = Math.floor(Math.max(0, ms) / 1000);
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+function tokenCount(n) {
+    return n < 1000 ? String(n) : n < 1_000_000 ? `${(n / 1000).toFixed(1)}k` : `${(n / 1_000_000).toFixed(1)}m`;
+}
+function metrics(session) {
+    const total = session.inputTokens + session.outputTokens;
+    return `${sessionDuration(session.elapsedMs)} · ${session.usageMissing ? "≥" : ""}${session.usageKnown ? tokenCount(total) : "—"} tokens`;
+}
+// One selector is shared by the chat strip and the worker viewport. Moving the
+// cursor never switches the viewed session until Enter confirms the selection.
+export class AgentSessionsScreen {
+    store;
+    style;
+    selected = "main";
+    active = "main";
+    offset = 0;
+    pageSize = 1;
+    maxOffset = 0;
+    follow = true;
+    focused = false;
+    constructor(store, style = PLAIN_QUEUE_STYLE) {
+        this.store = store;
+        this.style = style;
+    }
+    get selectedId() { this.sync(); return this.selected; }
+    get activeId() { this.sync(); return this.active; }
+    get available() { return this.store.hasAgents; }
+    sync() {
+        if (!this.store.get(this.active)?.live) {
+            this.active = "main";
+            this.selected = "main";
+            this.focused = false;
+            this.follow = true;
+            this.offset = 0;
+        }
+        if (!this.store.get(this.selected)?.live)
+            this.selected = this.active;
+        if (!this.available)
+            this.focused = false;
+    }
+    select(delta) {
+        this.sync();
+        const sessions = this.store.list();
+        const index = sessions.findIndex(s => s.id === this.selected);
+        this.selected = sessions[Math.max(0, Math.min(sessions.length - 1, index + delta))].id;
+        this.focused = true;
+    }
+    key(_text, key) {
+        this.sync();
+        if (key.name === "up" || key.name === "down")
+            this.select(key.name === "up" ? -1 : 1);
+        else if (key.name === "return" || key.name === "enter") {
+            this.active = this.selected;
+            this.follow = true;
+            this.offset = 0;
+            if (this.active === "main") {
+                this.focused = false;
+                return "close";
+            }
+        }
+        else if (key.name === "pageup" || key.name === "pagedown") {
+            this.scroll(key.name === "pageup" ? -this.pageSize : this.pageSize);
+        }
+        else if (key.name === "end") {
+            this.follow = true;
+            this.offset = this.maxOffset;
+        }
+        else if (key.name === "home") {
+            this.follow = false;
+            this.offset = 0;
+        }
+    }
+    scroll(delta) {
+        this.offset = Math.max(0, Math.min(this.maxOffset, this.offset + delta));
+        this.follow = this.offset === this.maxOffset;
+    }
+    preview(width, maxRows = 5) {
+        this.sync();
+        if (!this.available)
+            return [];
+        const sessions = this.store.list();
+        const capacity = Math.max(1, maxRows - 1);
+        const index = Math.max(0, sessions.findIndex(s => s.id === this.selected));
+        const start = Math.max(0, Math.min(index - Math.floor(capacity / 2), sessions.length - capacity));
+        const help = this.focused
+            ? tr("↑↓ seleziona · Invio apri · main: sessione principale", "↑↓ select · Enter open · main: primary session")
+            : tr("↓ sessioni · Alt+A seleziona", "↓ sessions · Alt+A select");
+        const range = sessions.length > capacity ? ` [${start + 1}–${Math.min(sessions.length, start + capacity)}/${sessions.length}]` : "";
+        const rows = [this.style.muted(fitLine(`  ${help}${range}`, width - 1))];
+        for (const s of sessions.slice(start, start + capacity)) {
+            const indicator = this.focused && s.id === this.selected ? ">" : " ";
+            const name = `  ${indicator} ${s.id === this.active ? "*" : " "} ${oneLine(s.actor)}`;
+            const tail = `  ${metrics(s)}`;
+            const room = Math.max(1, width - 1 - terminalWidth(tail));
+            const activity = s.activity ? `  ${oneLine(s.activity)}` : "";
+            const label = fitLine(name + activity, room);
+            const row = width < 36 ? fitLine(`${name} ${metrics(s)}`, width - 1)
+                : label + " ".repeat(Math.max(0, room - terminalWidth(label))) + tail;
+            rows.push(s.id === this.selected && this.focused ? this.style.selected(row) : (this.style.text ?? this.style.muted)(row));
+        }
+        return rows;
+    }
+    render(width, height) {
+        this.sync();
+        const h = Math.max(1, height), w = Math.max(1, width - 2);
+        const session = this.store.get(this.active);
+        const heading = this.style.heading(fitLine(` ${tr("Sessione", "Session")} · ${oneLine(session.actor)} · ${metrics(session)}`, width - 1));
+        const list = this.preview(width, Math.min(6, Math.max(2, Math.floor(h / 3))));
+        const help = this.style.muted(fitLine(tr("↑↓ seleziona · Invio apri · seleziona main per tornare · PgSu/PgGiù output", "↑↓ select · Enter open · select main to return · PgUp/PgDn output"), width - 1));
+        const head = [heading, ...list, ""];
+        const usage = session.usageKnown
+            ? `Input: ${tokenCount(session.inputTokens)} · Output: ${tokenCount(session.outputTokens)}`
+            : tr("Token non ancora comunicati dal provider.", "Tokens not yet reported by the provider.");
+        const text = [session.goal, usage, ...session.transcript].filter(Boolean).join("\n\n")
+            || tr("In attesa di attività…", "Waiting for activity…");
+        const lines = wrapText(text, w, true);
+        this.pageSize = Math.max(1, h - head.length - 1);
+        this.maxOffset = Math.max(0, lines.length - this.pageSize);
+        this.offset = this.follow ? this.maxOffset : Math.min(this.offset, this.maxOffset);
+        const body = lines.slice(this.offset, this.offset + this.pageSize).map(line => " " + line);
+        const rows = [...head, ...body];
+        while (rows.length < h - 1)
+            rows.push("");
+        return [...rows.slice(0, Math.max(0, h - 1)), help].map(row => fitLine(row, width - 1));
+    }
+}

package/dist/tui/agent-sessions.d.ts

@@ -0,0 +1,39 @@
+import type { AgentEvent } from "../core/types.js";
+import type { SessionUsageRecord } from "../core/session-usage.js";
+export interface AgentSession {
+    readonly id: string;
+    readonly actor: string;
+    readonly goal: string;
+    readonly activity: string;
+    readonly live: boolean;
+    readonly running: boolean;
+    readonly startedAt?: number;
+    readonly elapsedMs: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly usageKnown: boolean;
+    readonly usageMissing: boolean;
+    readonly transcript: readonly string[];
+}
+export declare class AgentSessions {
+    private sessions;
+    private actors;
+    private seenUsage;
+    private listeners;
+    subscribe(listener: () => void): () => void;
+    private changed;
+    reset(): void;
+    restoreMain(history: {
+        records: readonly SessionUsageRecord[];
+        incomplete: boolean;
+    }): void;
+    list(now?: number): readonly AgentSession[];
+    get(id: string, now?: number): AgentSession | undefined;
+    get hasAgents(): boolean;
+    private snapshot;
+    begin(goal: string, at?: number): void;
+    finish(at?: number): void;
+    private stop;
+    private log;
+    record(event: AgentEvent, at?: number, actor?: string): void;
+}

package/dist/tui/agent-sessions.js

@@ -0,0 +1,175 @@
+import { tr } from "./i18n.js";
+import { oneLine, plainText } from "./terminal-text.js";
+const EMPTY = { input: 0, output: 0 };
+const MAIN = "main";
+const MAX_TEXT = 64_000;
+const count = (n) => Number.isFinite(n) && n >= 0 ? n : 0;
+const tokens = (u) => ({ input: count(u.inputTokens) + count(u.cacheReadTokens) + count(u.cacheWriteTokens), output: count(u.outputTokens) });
+const add = (a, b) => ({ input: a.input + b.input, output: a.output + b.output });
+function fresh(id, actor, goal = "") {
+    return { id, actor, goal, activity: "", live: true, running: false, elapsedMs: 0,
+        ledger: EMPTY, fallback: EMPTY, ledgerSeen: false, usageKnown: false, usageMissing: false,
+        streaming: "", transcript: [] };
+}
+// Session IDs come from the worker lifecycle, not from a tool call or a label.
+// A finished response does not imply that its worker has been despawned.
+export class AgentSessions {
+    sessions = new Map([[MAIN, fresh(MAIN, MAIN)]]);
+    actors = new Map();
+    seenUsage = new Set();
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    changed() { for (const listener of this.listeners)
+        listener(); }
+    reset() {
+        this.sessions = new Map([[MAIN, fresh(MAIN, MAIN)]]);
+        this.actors.clear();
+        this.seenUsage.clear();
+        this.changed();
+    }
+    restoreMain(history) {
+        for (const record of history.records) {
+            if (!record.actor)
+                this.record({ type: "usage", record, persisted: true });
+        }
+        if (history.incomplete)
+            this.sessions.set(MAIN, { ...this.sessions.get(MAIN), usageMissing: true });
+        this.changed();
+    }
+    list(now = Date.now()) {
+        return [...this.sessions.values()].filter(s => s.live).map(s => this.snapshot(s, now));
+    }
+    get(id, now = Date.now()) {
+        const s = this.sessions.get(id);
+        return s ? this.snapshot(s, now) : undefined;
+    }
+    get hasAgents() { return [...this.sessions.values()].some(s => s.id !== MAIN && s.live); }
+    snapshot(s, now) {
+        const usage = s.ledgerSeen ? s.ledger : s.fallback;
+        return { id: s.id, actor: s.actor, goal: s.goal, activity: s.activity, live: s.live, running: s.running,
+            startedAt: s.startedAt, elapsedMs: s.elapsedMs + (s.startedAt === undefined ? 0 : Math.max(0, now - s.startedAt)),
+            inputTokens: usage.input, outputTokens: usage.output, usageKnown: s.usageKnown, usageMissing: s.usageMissing,
+            transcript: s.streaming ? [...s.transcript, s.streaming] : s.transcript };
+    }
+    begin(goal, at = Date.now()) {
+        const s = this.sessions.get(MAIN);
+        this.sessions.set(MAIN, { ...s, goal, startedAt: s.startedAt ?? at, running: true,
+            activity: tr("Avvio", "Starting") });
+        this.changed();
+    }
+    finish(at = Date.now()) {
+        this.stop(MAIN, at, false);
+        this.changed();
+    }
+    stop(id, at, despawn) {
+        const s = this.sessions.get(id);
+        if (!s)
+            return;
+        this.sessions.set(id, { ...s, live: !despawn, running: false, startedAt: undefined,
+            elapsedMs: s.elapsedMs + (s.startedAt === undefined ? 0 : Math.max(0, at - s.startedAt)),
+            activity: tr("Concluso", "Finished") });
+    }
+    log(s, text, stream = false) {
+        if (s.id === MAIN)
+            return s;
+        const clean = plainText(text).slice(0, 12_000);
+        if (stream)
+            return { ...s, streaming: (s.streaming + clean).slice(-12_000) };
+        const transcript = [...s.transcript, ...(s.streaming ? [s.streaming] : []), clean];
+        let size = transcript.reduce((total, item) => total + item.length, 0);
+        while (transcript.length > 100 || size > MAX_TEXT)
+            size -= transcript.shift().length;
+        return { ...s, streaming: "", transcript };
+    }
+    record(event, at = Date.now(), actor = "Talos") {
+        if (event.type === "kingdom" && event.phase === "session") {
+            if (event.state === "spawned") {
+                if (!this.sessions.has(event.sessionId)) {
+                    this.sessions.set(event.sessionId, { ...fresh(event.sessionId, event.slug, event.goal),
+                        startedAt: event.at, running: true, activity: tr("Avvio", "Starting") });
+                }
+                this.actors.set(event.slug, event.sessionId);
+            }
+            else
+                this.stop(event.sessionId, event.at, true);
+            // Retain a small completed history, without dropping any live worker.
+            const completed = [...this.sessions.values()].filter(s => !s.live);
+            for (const s of completed.slice(0, Math.max(0, completed.length - 32)))
+                this.sessions.delete(s.id);
+            this.changed();
+            return;
+        }
+        let id = actor === "Talos" ? MAIN : this.actors.get(actor);
+        if (event.type === "usage") {
+            id = this.sessions.has(event.record.sessionId) ? event.record.sessionId
+                : event.record.actor ? this.actors.get(event.record.actor) : id;
+        }
+        else if (event.type === "kingdom") {
+            if ("slug" in event)
+                id = this.actors.get(event.slug);
+            else if (event.phase === "message")
+                id = this.actors.get(event.from);
+            else
+                return;
+        }
+        if (!id)
+            return;
+        let s = this.sessions.get(id);
+        if (!s)
+            return;
+        if (event.type === "usage") {
+            if (this.seenUsage.has(event.record.id))
+                return;
+            this.seenUsage.add(event.record.id);
+            s = { ...s, ledgerSeen: s.ledgerSeen || !!event.record.usage, ledger: event.record.usage ? add(s.ledger, tokens(event.record.usage)) : s.ledger,
+                usageKnown: s.usageKnown || !!event.record.usage, usageMissing: s.usageMissing || !event.record.usage };
+        }
+        else if (event.type === "turn_end") {
+            s = { ...s, fallback: event.usage ? add(s.fallback, tokens(event.usage)) : s.fallback,
+                usageKnown: s.usageKnown || !!event.usage };
+        }
+        else if (event.type === "status")
+            s = { ...s, activity: oneLine(event.label) };
+        else if (event.type === "turn_start")
+            s = { ...s, activity: tr("Elaborazione", "Thinking") };
+        else if (event.type === "text")
+            s = { ...this.log(s, event.delta, true), activity: tr("Risposta in corso", "Writing") };
+        else if (event.type === "tool_call") {
+            const args = event.call.input;
+            const target = String(args["path"] ?? args["command"] ?? args["pattern"] ?? args["query"] ?? "");
+            const activity = `${event.call.name} ${oneLine(target)}`.trim();
+            s = { ...this.log(s, `${event.call.name}\n${target}`), activity };
+        }
+        else if (event.type === "tool_result")
+            s = this.log(s, event.result.output);
+        else if (event.type === "user_message")
+            s = this.log(s, event.text);
+        else if (event.type === "error")
+            s = { ...this.log(s, event.message), activity: oneLine(event.message) };
+        else if (event.type === "done")
+            s = { ...s, activity: tr("Concluso", "Finished") };
+        else if (event.type === "kingdom") {
+            if (event.phase === "usage")
+                s = { ...s, fallback: { input: count(event.inputTokens), output: count(event.outputTokens) }, usageKnown: true };
+            else if (event.phase === "tool") {
+                const activity = `${event.tool} ${oneLine(event.command ?? event.args ?? "")}`.trim();
+                s = event.state === "start" ? { ...this.log(s, `${event.tool}\n${event.command ?? event.args ?? ""}`), activity }
+                    : this.log(s, event.output ?? event.state);
+            }
+            else if (event.phase === "vassal")
+                s = { ...s,
+                    activity: oneLine(event.label ?? (event.state === "done" ? tr("Concluso", "Finished") : tr("Elaborazione", "Thinking"))) };
+            else if (event.phase === "say" || event.phase === "note" || event.phase === "inbox" || event.phase === "message")
+                s = this.log(s, event.text);
+            else
+                return;
+        }
+        else
+            return;
+        this.sessions.set(id, s);
+        this.changed();
+    }
+}

package/dist/tui/bottom-input.d.ts

@@ -18,6 +18,7 @@ export interface BottomInputHandlers {
     readonly attachmentStyle?: (s: string) => string;
     readonly footerLines: () => readonly string[];
     readonly belowInputLines?: () => readonly string[];
+    readonly warningLines?: () => readonly string[];
     readonly completion: (buffer: string) => string | null;
     readonly hint: (buffer: string) => string;
     readonly statusStyle?: (s: string) => string;
@@ -84,8 +85,12 @@ export declare class BottomInput {
     private kingdomBoard;
     private overlay;
     private screen;
+    private readonly agentSessions?;
+    private sessionsUnsubscribe?;
+    private sessionsTimer?;
     private modal;
     private statusLabel;
+    private compactionStartedAt;
     private statusTool;
     private roomStatus;
     private roomTimer?;
@@ -95,6 +100,7 @@ export declare class BottomInput {
     private tokensOut;
     private frame;
     private spinnerTimer?;
+    private readonly namingNotice;
     private lastLayout?;
     private liveStartRow;
     private paintedRows;
@@ -129,6 +135,8 @@ export declare class BottomInput {
     private finishQueueEdit;
     showReview(section?: string): void;
     private get screenVisible();
+    showAgents(): void;
+    private sessionArrow;
     static supported(): boolean;
     start(): Promise<void>;
     write(text: string): void;
@@ -140,6 +148,9 @@ export declare class BottomInput {
     setLogLine(index: number, text: string): void;
     setTokens(newInput: number, cache: number, outTok: number): void;
     setStatus(label: string | null): void;
+    setCompacting(active: boolean): void;
+    showSessionNaming(title: string): void;
+    setSessionNaming(phase: "start" | "end", title: string): void;
     getLogLine(index: number): string | undefined;
     isBusy(): boolean;
     setStatusTool(name: string | null): void;

package/dist/tui/bottom-input.js

@@ -1,12 +1,13 @@
 import { tr } from "./i18n.js";
 import { stdin, stdout } from "node:process";
-import { pulseGlyph, pulseToolName } from "./tool-style.js";
 import { fitLine, plainText, terminalWidth, wrapText } from "./terminal-text.js";
 import { PromptQueue } from "./prompt-queue.js";
 import { QueueScreen, queuePreview } from "./queue-screen.js";
 import { createAttachmentHighlighter } from "./attachment-highlight.js";
 import { NativeScrollback } from "./native-scrollback.js";
 import { QueuedQuestions } from "./queued-questions.js";
+import { AgentSessionsScreen } from "./agent-sessions-screen.js";
+import { SessionNamingNotice } from "./session-naming-notice.js";
 const SYNC_ON = "\x1b[?2026h";
 const SYNC_OFF = "\x1b[?2026l";
 const ALT_ON = "\x1b[?1049h";
@@ -87,10 +88,14 @@ export class BottomInput {
     kingdomBoard = null;
     overlay = null;
     screen = null;
+    agentSessions;
+    sessionsUnsubscribe;
+    sessionsTimer;
     // Domanda a risposta libera (tool ask_user): quando attiva, l'editing va alla
     // risposta e Invio/Esc risolvono la promise invece di inviare un prompt.
     modal = null;
     statusLabel = null;
+    compactionStartedAt = null;
     // Nome GREZZO del tool attualmente in corso (es. "read_file"): pilota colore e
     // glyph animati nella status-line (pulse abbinato alla categoria). null quando
     // l'attivita' non e' un singolo tool (es. "elaboro", ondata mista).
@@ -107,6 +112,8 @@ export class BottomInput {
     tokensOut = 0;
     frame = 0;
     spinnerTimer;
+    namingNotice = new SessionNamingNotice(() => { if (this.active)
+        this.render(); });
     lastLayout;
     liveStartRow = 1;
     paintedRows = [];
@@ -138,6 +145,8 @@ export class BottomInput {
         this.h = h;
         this.nativeScroll = h.nativeScroll !== false;
         this.queue = this.createQueue();
+        if (h.review)
+            this.agentSessions = new AgentSessionsScreen(h.review.sessions, h.queueStyle);
     }
     createQueue() {
         return new PromptQueue(this.h.prepareQueuedInput, () => this.render(), this.h.queuePersistence?.(), this.h.restoreQueuedInput);
@@ -232,6 +241,18 @@ export class BottomInput {
         this.render();
     }
     get screenVisible() { return this.screen !== null && !this.modal && !this.overlay; }
+    showAgents() {
+        if (!this.agentSessions?.available || this.modal || this.overlay || this.queueEditor || this.queue.held)
+            return;
+        this.agentSessions.focused = true;
+        this.scrollOffset = 0;
+        this.render();
+    }
+    sessionArrow(name) {
+        return !!this.agentSessions?.available && !this.modal && !this.overlay && !this.queueEditor
+            && !this.questions.focused && this.scrollOffset === 0
+            && (this.agentSessions.focused || (!this.buffer && name === "down"));
+    }
     static supported() {
         return Boolean(stdout.isTTY && stdin.isTTY && typeof stdin.setRawMode === "function");
     }
@@ -239,6 +260,12 @@ export class BottomInput {
         if (!BottomInput.supported())
             return Promise.resolve();
         this.active = true;
+        this.sessionsUnsubscribe = this.h.review?.sessions.subscribe(() => this.refresh());
+        this.sessionsTimer = setInterval(() => {
+            if (this.agentSessions?.available || this.screen === this.agentSessions)
+                this.refresh();
+        }, 500);
+        this.sessionsTimer.unref();
         this.alternateScreen = !this.nativeScroll;
         stdout.write(this.nativeScroll ? "\x1b[2J\x1b[H" + NATIVE_SCROLL_MODE + PASTE_ON
             : ALT_ON + "\x1b[2J\x1b[H" + NATIVE_SELECTION_MODE + PASTE_ON);
@@ -300,6 +327,7 @@ export class BottomInput {
     }
     // Forget the previous session's display and editor state before any replay.
     clearConversation() {
+        this.namingNotice.clear();
         this.questions.clear();
         this.inputGeneration++;
         this.buffer = "";
@@ -391,6 +419,8 @@ export class BottomInput {
             this.render();
     }
     setStatus(label) {
+        if (label === null)
+            this.compactionStartedAt = null;
         this.statusLabel = label;
         if (label !== null) {
             if (!this.spinnerTimer)
@@ -403,6 +433,19 @@ export class BottomInput {
         if (this.active)
             this.render();
     }
+    setCompacting(active) {
+        this.compactionStartedAt = active ? this.compactionStartedAt ?? Date.now() : null;
+        this.setStatus(this.statusLabel ?? (active ? "Compacting context" : null));
+    }
+    showSessionNaming(title) {
+        this.namingNotice.show(title);
+    }
+    setSessionNaming(phase, title) {
+        if (phase === "start")
+            this.namingNotice.start();
+        else
+            this.namingNotice.finish(title);
+    }
     getLogLine(index) { return this.log[index]; }
     // Stato leggibile dall'host per evitare una seconda telemetria statica mentre
     // la riga animata del run sta gia' mostrando token, tempo e coda.
@@ -775,6 +818,9 @@ export class BottomInput {
     render(force = false) {
         if (!this.active || this.resizeTimer || (this.paused && !this.overlay))
             return;
+        this.agentSessions?.sync();
+        if (this.agentSessions && this.screen === this.agentSessions && this.agentSessions.activeId === "main")
+            this.screen = null;
         if (this.scrollRenderTimer) {
             clearTimeout(this.scrollRenderTimer);
             this.scrollRenderTimer = undefined;
@@ -790,8 +836,10 @@ export class BottomInput {
             force = true;
         }
         if (this.screenVisible) {
-            const content = this.screen.render(W, H);
-            const rows = Array.from({ length: H }, (_, i) => fitLine(content[i] ?? "", Math.max(1, W - 1)));
+            const warnings = (this.h.warningLines?.() ?? []).slice(0, Math.max(0, H - 3));
+            const bodyHeight = H - warnings.length;
+            const content = this.screen.render(W, bodyHeight);
+            const rows = Array.from({ length: H }, (_, i) => fitLine((i < bodyHeight ? content[i] : warnings[i - bodyHeight]) ?? "", Math.max(1, W - 1)));
             this.paint(rows, W, H, 1, 1, force, true);
             return;
         }
@@ -809,9 +857,14 @@ export class BottomInput {
         }
         const lay = this.liveContent();
         this.lastLayout = lay;
+        if (this.overlay && lay.lines.length >= H - 1) {
+            const frame = Array.from({ length: H }, (_, i) => fitLine(lay.lines[i] ?? "", W - 1));
+            this.paint(frame, W, H, Math.min(H, lay.cursorRow + 1), lay.cursorCol, force, true);
+            return;
+        }
         if (this.nativeScroll && !alternate) {
             this.renderedLog();
-            const output = this.nativeOutput.render(this.renderedEntries, lay, W, H, false, this.h.startupLines?.() ?? this.h.headerLines?.() ?? []);
+            const output = this.nativeOutput.render(this.renderedEntries, lay, W, H, false, this.h.startupLines?.() ?? this.h.headerLines?.() ?? [], chunk => { stdout.write(chunk); });
             if (output)
                 stdout.write(output);
             this.lastPaintAt = Date.now();
@@ -894,6 +947,8 @@ export class BottomInput {
         const lines = [];
         if (this.statusLabel !== null)
             lines.push(this.statusLine());
+        if (this.compactionStartedAt !== null)
+            lines.push(fitLine("    Making room to continue…", cols - 1));
         if (this.statusLabel === null && this.roomStatus?.state === "failed") {
             const notice = this.roomSegment().replace(/\s+/g, " ").trim();
             lines.push(...wrapText(notice, Math.max(8, cols - 3)).slice(0, 3).map(line => `  ${line}`));
@@ -902,6 +957,9 @@ export class BottomInput {
         // La riga live descrive gia' il team; la board completa si consulta a parte.
         if (this.kingdomBoard && this.statusLabel === null)
             lines.push(fitLine(this.kingdomBoard[0] ?? "", cols - 1));
+        if (!this.modal && !this.queueEditor && !this.questions.focused) {
+            lines.push(...(this.agentSessions?.preview(cols, Math.min(5, Math.max(2, this.rows() - 12))) ?? []));
+        }
         for (const f of this.h.footerLines())
             lines.push(f);
         if (!this.modal && !this.queueEditor)
@@ -960,9 +1018,14 @@ export class BottomInput {
             lines.push(fitLine(this.h.statusStyle?.(notice) ?? notice, cols - 1));
         }
         if (!this.modal) {
+            for (const naming of this.namingNotice.lines()) {
+                lines.push(fitLine("  " + (this.h.statusStyle?.(naming) ?? naming), cols - 1));
+            }
             for (const row of this.h.belowInputLines?.() ?? [])
                 lines.push(fitLine(row, cols - 1));
         }
+        for (const row of this.h.warningLines?.() ?? [])
+            lines.push(fitLine(row, cols - 1));
         const action = this.ctrlCConfirmation?.action;
         const warning = action === "stop" ? tr("fermare il lavoro e mettere in pausa la coda", "stop work and pause the queue") : action === "clear" ? tr("svuotare la bozza", "clear the draft") : tr("uscire", "exit");
         const hint = action
@@ -998,14 +1061,19 @@ export class BottomInput {
         return style(`${glyph} ${label}`);
     }
     statusLine() {
+        if (this.compactionStartedAt !== null) {
+            const seconds = Math.floor((Date.now() - this.compactionStartedAt) / 1000);
+            return fitLine(`  ${SPINNER[this.frame % SPINNER.length]} Compacting context (${seconds}s · esc to interrupt)`, this.cols() - 1);
+        }
         const elapsed = Math.round((Date.now() - this.startedAt) / 1000);
         const style = this.h.statusStyle ?? ((s) => s);
         const label = this.statusLabel ?? tr("Elaborazione", "Working");
-        const glyph = this.statusTool ? pulseGlyph(this.statusTool, this.frame) : SPINNER[this.frame % SPINNER.length];
-        const name = this.statusTool ? pulseToolName(this.statusTool, label, this.frame) : style(label);
-        const meta = [elapsed >= 1 ? fmtElapsed(elapsed) : "", this.h.runningHint?.() ?? "", this.roomSegment()].filter(Boolean);
-        const right = style(this.cols() >= 64 && (!this.queue.length || this.modal || this.queueEditor)
-            ? tr("Alt+S subito · Esc ferma", "Alt+S send now · Esc stop") : tr("Esc ferma", "Esc stop"));
+        const glyph = style(SPINNER[this.frame % SPINNER.length]);
+        const name = style(label);
+        const meta = [this.h.runningHint?.() ?? "", this.roomSegment()].filter(Boolean);
+        const shortcut = this.cols() >= 100 && (!this.queue.length || this.modal || this.queueEditor)
+            ? tr("Alt+S subito · Esc ferma", "Alt+S send now · Esc stop") : tr("Esc ferma", "Esc stop");
+        const right = style(`${fmtElapsed(elapsed).padStart(7)} · ${shortcut}`);
         const budget = Math.max(0, this.cols() - terminalWidth(right) - 5);
         let left = `  ${glyph} ${name}`;
         for (const segment of meta) {
@@ -1188,7 +1256,7 @@ export class BottomInput {
         }
         // Freccia su/giu' NUDA: disambigua scroll(touchpad) vs pressione (timer).
         if ((name === "up" || name === "down") && !ctrl && !meta && !shift && !this.screenVisible
-            && !this.questions.focused && (!this.nativeScroll || this.scrollOffset > 0)) {
+            && !this.questions.focused && !this.sessionArrow(name) && (!this.nativeScroll || this.scrollOffset > 0)) {
             this.onArrow(name);
             return;
         }
@@ -1268,6 +1336,25 @@ export class BottomInput {
             this.showQueue();
             return;
         }
+        if (k.meta && k.name === "a") {
+            this.showAgents();
+            return;
+        }
+        if (!k.ctrl && !k.meta && !k.shift && this.sessionArrow(k.name ?? "") && (k.name === "up" || k.name === "down")) {
+            this.agentSessions.key(s, k);
+            this.render();
+            return;
+        }
+        if (this.agentSessions?.focused && !this.modal && !this.overlay && !this.queueEditor) {
+            if (k.name === "return" || k.name === "enter") {
+                this.agentSessions.key(s, k);
+                if (this.agentSessions.activeId !== "main")
+                    this.screen = this.agentSessions;
+                this.render();
+                return;
+            }
+            this.agentSessions.focused = false;
+        }
         if (k.meta && k.name === "t" && !this.modal && !this.overlay && !this.queueEditor) {
             if (this.queue.sendToTeam())
                 this.startNextQueued();
@@ -1692,6 +1779,10 @@ export class BottomInput {
             this.showQueue();
             return;
         }
+        if (/^\/(?:agents|agenti)\s*$/i.test(line.trim())) {
+            this.showAgents();
+            return;
+        }
         const review = /^\/(?:review|revisione)(?:\s+(\S+))?\s*$/i.exec(line.trim());
         if (review && this.h.createReviewScreen) {
             this.showReview(review[1]);
@@ -1768,6 +1859,10 @@ export class BottomInput {
         if (!this.active)
             return;
         this.active = false;
+        this.namingNotice.clear();
+        this.sessionsUnsubscribe?.();
+        if (this.sessionsTimer)
+            clearInterval(this.sessionsTimer);
         this.questions.clear();
         this.clearPendingEscape();
         this.cancelCtrlC();
@@ -1802,6 +1897,7 @@ export class BottomInput {
         if (this.nativeScroll)
             stdout.write(this.nativeOutput.release());
         stdout.write(PASTE_OFF + NATIVE_SCROLL_MODE + "\x1b[?25h");
+        this.nativeOutput.dispose();
         if (typeof stdin.setRawMode === "function")
             stdin.setRawMode(false);
         this.h.onQuit();