@vascend/talos 0.1.4 → 0.1.6

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

@@ -1,4 +1,5 @@
 import type { AgentEvent, Message, ToolCallPart } from "../core/types.js";
+import { AgentSessions } from "./agent-sessions.js";
 export type ReviewState = "running" | "ok" | "error" | "stopped" | "info";
 export type ReviewKind = "tool" | "file" | "team" | "notice";
 export interface ReviewChange {
@@ -27,9 +28,14 @@ export declare function reviewTitle(name: string): string;
 export declare function callTarget(call: ToolCallPart): string;
 export declare class ReviewStore {
     private readonly capacity;
+    private readonly maxChars;
+    readonly sessions: AgentSessions;
     private items;
+    private sizes;
+    private retainedChars;
     private callIndex;
     private actorText;
+    private rawActors;
     private sequence;
     private run;
     private _revision;
@@ -37,7 +43,7 @@ export declare class ReviewStore {
     private _running;
     private _label;
     private _goal;
-    constructor(capacity?: number);
+    constructor(capacity?: number, maxChars?: number);
     get revision(): number;
     get evicted(): number;
     get running(): boolean;
@@ -57,4 +63,5 @@ export declare class ReviewStore {
     private callId;
     private notice;
     private put;
+    private remove;
 }

package/dist/tui/review-store.js

@@ -1,4 +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",
@@ -8,7 +12,17 @@ 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;
+    if (!value || typeof value !== "object" || seen.has(value))
+        return 0;
+    seen.add(value);
+    return Object.values(value).reduce((size, child) => size + textSize(child, seen), 0);
+}
 export function callTarget(call) {
     const i = call.input;
     return oneLine(String(i["path"] ?? i["command"] ?? i["pattern"] ?? i["query"] ??
@@ -18,9 +32,14 @@ export function callTarget(call) {
 // della chat viene compattato. Nessuna lettura del filesystem dal renderer.
 export class ReviewStore {
     capacity;
+    maxChars;
+    sessions = new AgentSessions();
     items = new Map();
+    sizes = new Map();
+    retainedChars = 0;
     callIndex = new Map();
     actorText = new Map();
+    rawActors = new Set();
     sequence = 0;
     run = 0;
     _revision = 0;
@@ -28,17 +47,29 @@ export class ReviewStore {
     _running = false;
     _label = "Pronto";
     _goal = "";
-    constructor(capacity = 2000) {
+    constructor(capacity = 2000, maxChars = 8_000_000) {
         this.capacity = capacity;
+        this.maxChars = maxChars;
     }
     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); }
     begin(goal) {
+        this.sessions.begin(goal);
         this.run += 1;
         this._running = true;
         this._label = "Avvio";
@@ -46,6 +77,7 @@ export class ReviewStore {
         this._revision += 1;
     }
     finish(interrupted = false) {
+        this.sessions.finish();
         for (const entry of this.items.values()) {
             if (entry.state === "running" && entry.actor === "Talos")
                 this.put({ ...entry, state: "stopped", endedAt: Date.now() });
@@ -55,9 +87,13 @@ export class ReviewStore {
         this._revision += 1;
     }
     reset(history = []) {
+        this.sessions.reset();
         this.items.clear();
+        this.sizes.clear();
+        this.retainedChars = 0;
         this.callIndex.clear();
         this.actorText.clear();
+        this.rawActors.clear();
         this.sequence = 0;
         this.run = 0;
         this._evicted = 0;
@@ -87,6 +123,11 @@ 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":
                 this._label = oneLine(event.label);
@@ -132,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);
@@ -149,6 +190,9 @@ 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") {
             this.put({ id: `status:${this.run}:${actor}`, kind: "notice", actor, title: "Stato",
                 target: oneLine(event.label), output: event.label, state: "info", startedAt: Date.now() });
@@ -166,17 +210,16 @@ export class ReviewStore {
             if (text?.trim())
                 this.notice("Aggiornamento", text, "info", Date.now(), actor);
             this.actorText.delete(actor);
-            this.items.delete(`stream:${this.run}:${actor}`);
+            this.remove(`stream:${this.run}:${actor}`);
         }
         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") {
@@ -227,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}`;
@@ -254,17 +297,27 @@ export class ReviewStore {
         this.put({ id: `notice:${++this.sequence}`, kind: "notice", title, target: oneLine(output).slice(0, 200), actor, state, output, startedAt: at });
     }
     put(entry) {
+        const size = textSize(entry);
+        this.retainedChars += size - (this.sizes.get(entry.id) ?? 0);
+        this.sizes.set(entry.id, size);
         this.items.set(entry.id, entry);
-        if (this.items.size > this.capacity) {
+        while (this.items.size > this.capacity || this.retainedChars > this.maxChars) {
             const oldest = [...this.items.values()].find(e => e.state !== "running");
             if (oldest) {
-                this.items.delete(oldest.id);
+                this.remove(oldest.id);
                 for (const [key, id] of this.callIndex)
                     if (id === oldest.id)
                         this.callIndex.delete(key);
                 this._evicted += 1;
             }
+            else
+                break;
         }
         this._revision += 1;
     }
+    remove(id) {
+        this.retainedChars -= this.sizes.get(id) ?? 0;
+        this.sizes.delete(id);
+        this.items.delete(id);
+    }
 }

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/scrollback-archive.d.ts

@@ -0,0 +1,16 @@
+import type { ScrollbackLine } from "./native-scrollback.js";
+export declare class ScrollbackArchive implements Iterable<ScrollbackLine> {
+    private readonly maxChars;
+    private rows;
+    private chars;
+    private directory?;
+    private fd?;
+    private bytes;
+    constructor(maxChars?: number);
+    get retainedChars(): number;
+    push(line: ScrollbackLine): void;
+    private write;
+    private spill;
+    [Symbol.iterator](): Iterator<ScrollbackLine>;
+    clear(): void;
+}

package/dist/tui/scrollback-archive.js

@@ -0,0 +1,90 @@
+import { closeSync, mkdtempSync, openSync, readSync, rmdirSync, unlinkSync, writeSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+// This extra copy is used for resize, not model context. Spill old rows to
+// disk instead of retaining another complete transcript in the JavaScript heap.
+export class ScrollbackArchive {
+    maxChars;
+    rows = [];
+    chars = 0;
+    directory;
+    fd;
+    bytes = 0;
+    constructor(maxChars = 1_000_000) {
+        this.maxChars = maxChars;
+    }
+    get retainedChars() { return this.chars; }
+    push(line) {
+        if (this.rows.length >= 5000 || this.chars + line.text.length > this.maxChars)
+            this.spill();
+        if (line.text.length > this.maxChars)
+            this.write(line);
+        else {
+            this.rows.push(line);
+            this.chars += line.text.length;
+        }
+    }
+    write(line) {
+        if (this.fd === undefined) {
+            this.directory = mkdtempSync(join(tmpdir(), "talos-scrollback-"));
+            this.fd = openSync(join(this.directory, "rows.jsonl"), "w+", 0o600);
+        }
+        const data = Buffer.from(JSON.stringify(line) + "\n");
+        let offset = 0;
+        while (offset < data.length) {
+            const written = writeSync(this.fd, data, offset, data.length - offset, this.bytes);
+            if (!written)
+                throw new Error("Unable to write terminal scrollback");
+            offset += written;
+            this.bytes += written;
+        }
+    }
+    spill() {
+        for (const row of this.rows)
+            this.write(row);
+        this.rows = [];
+        this.chars = 0;
+    }
+    *[Symbol.iterator]() {
+        if (this.fd !== undefined) {
+            const buffer = Buffer.allocUnsafe(64 * 1024);
+            const decoder = new StringDecoder("utf8");
+            let position = 0;
+            let pending = "";
+            while (position < this.bytes) {
+                const size = readSync(this.fd, buffer, 0, Math.min(buffer.length, this.bytes - position), position);
+                if (!size)
+                    throw new Error("Unable to read terminal scrollback");
+                position += size;
+                pending += decoder.write(buffer.subarray(0, size));
+                let start = 0;
+                let end;
+                while ((end = pending.indexOf("\n", start)) >= 0) {
+                    yield JSON.parse(pending.slice(start, end));
+                    start = end + 1;
+                }
+                pending = pending.slice(start);
+            }
+        }
+        yield* this.rows;
+    }
+    clear() {
+        this.rows = [];
+        this.chars = 0;
+        this.bytes = 0;
+        if (this.fd !== undefined) {
+            closeSync(this.fd);
+            this.fd = undefined;
+        }
+        if (this.directory) {
+            const directory = this.directory;
+            this.directory = undefined;
+            try {
+                unlinkSync(join(directory, "rows.jsonl"));
+                rmdirSync(directory);
+            }
+            catch { /* A scanner may hold the disposable cache open on Windows. */ }
+        }
+    }
+}

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

@@ -6,6 +6,12 @@ export interface SelectOption<T> {
     readonly group?: string;
     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;
@@ -14,16 +20,20 @@ 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;
     readonly selectedDetailsOnly?: boolean;
     readonly mouse?: boolean;
+    readonly sessionList?: boolean;
+    readonly modelList?: boolean;
 }
 export interface SelectorRenderOptions<T> extends SelectorOptions<T> {
     readonly index: number;
@@ -33,6 +43,7 @@ export interface SelectorRenderOptions<T> extends SelectorOptions<T> {
     readonly totalCount?: number;
     readonly details?: boolean;
     readonly detailOffset?: number;
+    readonly rows?: number;
 }
 export declare function pickerPageSize(rows: number, fullHeight?: boolean): number;
 export declare function filterOptions<T extends {

package/dist/tui/selector.js

@@ -6,6 +6,8 @@ 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";
+import { renderSessionPicker } from "./session-picker.js";
+import { renderModelPicker } from "./model-picker.js";
 export function pickerPageSize(rows, fullHeight = false) {
     const available = Math.max(1, Math.floor(rows) - 6);
     return Math.min(available, fullHeight ? 26 : 7);
@@ -42,6 +44,10 @@ function detailLines(opts, option, width) {
     ];
 }
 export function renderSelector(opts) {
+    if (opts.modelList && !opts.details)
+        return renderModelPicker(opts);
+    if (opts.sessionList && !opts.details)
+        return renderSessionPicker(opts);
     const t = opts.theme;
     const width = selectorWidth(opts.columns, opts.wide);
     const page = Math.max(1, opts.pageSize);
@@ -109,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)
@@ -132,7 +140,8 @@ export async function selectOption(opts) {
     let renderedRows = 0;
     const wasRaw = stdin.isRaw;
     const wasPaused = stdin.isPaused();
-    const pageSize = () => pickerPageSize(stdout.rows || 24, opts.fullHeight);
+    const pageSize = () => opts.modelList ? Math.max(1, (stdout.rows || 24) - 13)
+        : opts.sessionList ? Math.max(1, (stdout.rows || 24) - 8) : 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];
@@ -152,7 +161,7 @@ export async function selectOption(opts) {
         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,
+            totalCount: opts.options.length, details, detailOffset, rows: stdout.rows || 24,
         });
         renderedRows = lines.length;
         opts.ctl.setOverlay(lines);
@@ -165,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);
@@ -190,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;
@@ -205,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;
@@ -288,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.d.ts

@@ -0,0 +1,14 @@
+export declare class SessionNamingNotice {
+    private readonly refresh;
+    private title;
+    private startedAt;
+    private pending;
+    private timer?;
+    constructor(refresh: () => void);
+    show(title: string): void;
+    start(): void;
+    finish(title: string): void;
+    lines(now?: number): readonly string[];
+    line(now?: number): string;
+    clear(): void;
+}