@vascend/talos 0.1.5 → 0.1.6

package/dist/tools/program.js

@@ -64,11 +64,12 @@ const BRIDGE_DENYLIST = new Set([
 // ---------------------------------------------------------------------------
 const KERNEL_SOURCE = `"use strict";
 const util = require("node:util");
+const { AsyncLocalStorage } = require("node:async_hooks");
+const executionScope = new AsyncLocalStorage();
 let buf = "";
 let seq = 0;
 const pending = new Map();
 const state = {};
-let inputData = {};
 
 function send(msg) { process.stdout.write(JSON.stringify(msg) + "\\n"); }
 
@@ -80,10 +81,12 @@ function render(value) {
 }
 
 function callTool(name, args, structured = false) {
+  const scope = executionScope.getStore();
+  if (!scope?.active) return Promise.reject(new Error("programma gia' concluso"));
   return new Promise((resolve, reject) => {
     seq += 1;
     pending.set(seq, { resolve, reject, structured });
-    send({ t: "call", seq, name, args: args === undefined ? {} : args });
+    send({ t: "call", id: scope.id, seq, name, args: args === undefined ? {} : args });
   });
 }
 
@@ -92,7 +95,7 @@ function callTool(name, args, structured = false) {
 const tools = new Proxy({}, {
   get(_t, prop) {
     if (typeof prop !== "string" || prop === "then" || prop === "toJSON") return undefined;
-    if (prop === "$data") return inputData;
+    if (prop === "$data") return executionScope.getStore()?.data ?? {};
     if (prop === "$result") return (name, args) => callTool(name, args, true);
     return (args) => callTool(prop, args);
   },
@@ -100,24 +103,31 @@ const tools = new Proxy({}, {
 
 const fakeConsole = {};
 for (const level of ["log", "info", "warn", "error", "debug", "trace"]) {
-  fakeConsole[level] = (...parts) => send({
-    t: "log",
-    line: parts.map((p) => (typeof p === "string" ? p : render(p))).join(" "),
-  });
+  fakeConsole[level] = (...parts) => {
+    const scope = executionScope.getStore();
+    if (scope?.active) send({
+      t: "log", id: scope.id,
+      line: parts.map((p) => (typeof p === "string" ? p : render(p))).join(" "),
+    });
+  };
 }
 
 async function execute(msg) {
-  inputData = msg.data ?? {};
-  const AsyncFunction = (async () => {}).constructor;
-  try {
-    // require/process oscurati: e' un invito a passare dai tool (che portano i
-    // permessi), non un confine di sicurezza — il confine e' la conferma utente.
-    const fn = new AsyncFunction("tools", "state", "console", "require", "process", msg.code);
-    const value = await fn(tools, state, fakeConsole, undefined, undefined);
-    send({ t: "done", id: msg.id, value: render(value) });
-  } catch (err) {
-    send({ t: "done", id: msg.id, error: err instanceof Error ? (err.stack || err.message) : String(err) });
-  }
+  const scope = { id: msg.id, data: msg.data ?? {}, active: true };
+  return executionScope.run(scope, async () => {
+    const AsyncFunction = (async () => {}).constructor;
+    try {
+      // require/process oscurati: e' un invito a passare dai tool (che portano i
+      // permessi), non un confine di sicurezza — il confine e' la conferma utente.
+      const fn = new AsyncFunction("tools", "state", "console", "require", "process", msg.code);
+      const value = await fn(tools, state, fakeConsole, undefined, undefined);
+      send({ t: "done", id: msg.id, value: render(value) });
+    } catch (err) {
+      send({ t: "done", id: msg.id, error: err instanceof Error ? (err.stack || err.message) : String(err) });
+    } finally {
+      scope.active = false;
+    }
+  });
 }
 
 process.stdin.setEncoding("utf8");
@@ -255,7 +265,7 @@ class ProgramKernel {
     }
     async onMessage(msg) {
         const cur = this.current;
-        if (!cur)
+        if (!cur || Number(msg["id"]) !== cur.id)
             return;
         if (msg["t"] === "log") {
             this.appendLog(cur, String(msg["line"] ?? ""));
@@ -307,8 +317,11 @@ class ProgramKernel {
             cur.logsTruncatedLines += 1;
             return;
         }
-        cur.logs.push(line);
-        cur.logChars += line.length + 1;
+        const remaining = Math.max(0, MAX_LOG_CHARS - cur.logChars - 1);
+        cur.logs.push(line.slice(0, remaining));
+        cur.logChars += Math.min(line.length, remaining) + 1;
+        if (line.length > remaining)
+            cur.logsTruncatedLines += 1;
     }
     send(msg) {
         try {

package/dist/tools/team-tools.js

@@ -257,7 +257,7 @@ export const teamWaitTool = {
         const combacia = (m) => (!from || addressKey(m.from) === from) && (!contains || m.text.toLowerCase().includes(contains));
         const canale = bus(ctx);
         for (;;) {
-            if (ctx.signal.aborted)
+            if (ctx.signal.aborted || ctx.waitInterrupted?.())
                 return "attesa interrotta";
             const msgs = canale.inbox(id, me, combacia);
             if (msgs.length)
@@ -323,20 +323,25 @@ export const teamReportTool = {
         const richiesti = Number(input["timeout_s"]);
         const secondi = Number.isFinite(richiesti) ? Math.min(WAIT_MAX_S, Math.max(1, richiesti)) : WAIT_DEFAULT_S;
         const deadline = Date.now() + secondi * 1000;
+        // Keep the original target even if a newer team appears during the wait.
+        const selected = () => teamById(team.sessionId, team.id) ?? team;
         while (Date.now() < deadline) {
-            if (ctx.signal.aborted)
-                return reportResult("attesa interrotta; il lavoro del team non viene cancellato", currentTeam(ctx) ?? team);
-            const current = requested ? teamById(ctx.sessionId ?? "", requested) : currentTeam(ctx);
+            if (ctx.signal.aborted || ctx.waitInterrupted?.())
+                return reportResult("attesa interrotta; il lavoro del team non viene cancellato", selected());
+            const current = selected();
             if (current?.done)
                 return finished(current);
             try {
                 await sleep(Math.min(250, Math.max(1, deadline - Date.now())), ctx.signal);
             }
             catch {
-                return reportResult("attesa interrotta; il lavoro del team non viene cancellato", currentTeam(ctx) ?? team);
+                return reportResult("attesa interrotta; il lavoro del team non viene cancellato", selected());
             }
         }
-        return reportResult(`non hanno ancora finito dopo ${secondi}s: ${pendingMembers(currentTeam(ctx) ?? team).join(", ")}. Richiama team_report piu' tardi.`, currentTeam(ctx) ?? team);
+        const current = selected();
+        if (current.done)
+            return finished(current);
+        return reportResult(`non hanno ancora finito dopo ${secondi}s: ${pendingMembers(current).join(", ")}. Richiama team_report piu' tardi.`, current);
     },
 };
 export const teamTools = [

package/dist/tui/account-entry.js

@@ -3,7 +3,8 @@ import { stdin, stdout } from "node:process";
 import { tr } from "./i18n.js";
 import { initializeLanguage, onboardingLanguage } from "./language-preference.js";
 import { leggiOnboarding, salvaOnboarding, serveTermini, TESTI, consensoAffermativo, TERMINI_VERSIONE, LINK_TERMINI, LINK_PRIVACY } from "./onboarding.js";
-import { decisioneCancello, tokenVascend, statoSessione, valutaLicenzaLocale, rimuoviTokenVascend, salvaTokenVascend, rinnovaProvaOffline } from "./vascend-login.js";
+import { decisioneCancello, statoSessione, valutaLicenzaLocale, rimuoviTokenVascend, rinnovaProvaOffline } from "./vascend-login.js";
+import { rimuoviSessione, salvaSessione, tokenAgente } from "./vascend-id.js";
 import { startWebLogin, waitForWebLogin, WebLoginError } from "./web-login.js";
 import { showWebLoginScreen } from "./web-login-screen.js";
 import { CliCancelled } from "../core/cli-cancelled.js";
@@ -14,12 +15,16 @@ export async function enterAccount(env, theme) {
     // requires a verified session and current account permissions.
     if (env["TALOS_NO_LOGIN"] === "1")
         return "";
-    const saved = tokenVascend(env);
-    const session = saved ? await statoSessione(env, saved) : null;
+    // Token per l'agente dalla sessione Vascend ID, rinnovato se serve. Il vecchio
+    // token del backend agentico non vale piu': chi lo aveva rifa' l'accesso.
+    const esito = await tokenAgente(env);
+    const saved = esito.token;
+    const session = saved ? await statoSessione(env, saved)
+        : esito.errore === "rete" ? { stato: "irraggiungibile" } : null;
     if (!stdin.isTTY || !stdout.isTTY || env["TALOS_HOST_PROFILE"]?.toLowerCase() === "horizon")
         return "";
     const offline = session?.stato === "irraggiungibile" ? valutaLicenzaLocale(env) : null;
-    const decision = decisioneCancello(saved, session, offline);
+    const decision = decisioneCancello(saved || (esito.errore === "rete" ? "offline" : ""), session, offline);
     let tier = decision.tier;
     let token = saved;
     const note = () => tr("Account connesso", "Account connected") +
@@ -38,18 +43,18 @@ export async function enterAccount(env, theme) {
     const write = (text) => { stdout.write(`  ${text}\n`); };
     try {
         if (decision.azione === "login") {
-            if (saved)
-                rimuoviTokenVascend(env);
+            rimuoviSessione(env);
+            rimuoviTokenVascend(env);
             stdout.write(`\n  ${tr("Preparazione dell'accesso a Talos...", "Preparing Talos sign-in...")}`);
             const grant = await startWebLogin(env, language, {}, abort.signal)
                 .finally(() => { stdout.write(env.TERM === "dumb" ? "\n" : "\r\x1b[2K"); });
             const finish = showWebLoginScreen(grant, abort, { env, theme });
             try {
-                const account = await waitForWebLogin(env, grant, {}, abort.signal);
-                if (!salvaTokenVascend(env, account.token))
+                const account = await waitForWebLogin(env, grant, language, {}, abort.signal);
+                if (!salvaSessione(env, account))
                     throw new Error(TESTI[language].tokenNonSalvabile);
                 token = account.token;
-                tier = account.tier;
+                tier = undefined;
                 finish(true);
                 write(TESTI[language].benvenuto(account.email));
             }

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

@@ -0,0 +1,2 @@
+/** Translate display labels without changing saved IDs or team addresses. */
+export declare function agentLabel(actor: string): string;

package/dist/tui/agent-label.js

@@ -0,0 +1,5 @@
+import { tr } from "./i18n.js";
+/** Translate display labels without changing saved IDs or team addresses. */
+export function agentLabel(actor) {
+    return ["main", "orchestratore", "orchestrator"].includes(actor) ? tr("principale", "main") : actor;
+}

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

@@ -1,21 +1,31 @@
-import type { AgentSessions } from "./agent-sessions.js";
+import type { AgentSession, AgentSessions } from "./agent-sessions.js";
 import type { QueueStyle } from "./queue-screen.js";
 import type { ScreenKey, TerminalScreen } from "./terminal-screen.js";
 export declare function sessionDuration(ms: number): string;
 export declare class AgentSessionsScreen implements TerminalScreen {
     private readonly store;
     private readonly style;
+    private readonly onDelete?;
     private selected;
     private active;
     private offset;
     private pageSize;
     private maxOffset;
     private follow;
+    private readonly transcript;
     focused: boolean;
-    constructor(store: AgentSessions, style?: QueueStyle);
+    private deleteConfirmation?;
+    constructor(store: AgentSessions, style?: QueueStyle, onDelete?: ((session: AgentSession) => {
+        ok: boolean;
+        error?: string;
+    }) | undefined);
+    private deleteSelected;
+    get session(): AgentSession;
+    conversation(width: number, height: number): readonly string[];
     get selectedId(): string;
     get activeId(): string;
     get available(): boolean;
+    returnToMain(): void;
     sync(): void;
     private select;
     key(_text: string, key: ScreenKey): "close" | void;

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

@@ -1,6 +1,8 @@
 import { tr } from "./i18n.js";
 import { PLAIN_QUEUE_STYLE } from "./queue-screen.js";
-import { fitLine, oneLine, terminalWidth, wrapText } from "./terminal-text.js";
+import { fitLine, oneLine, terminalWidth } from "./terminal-text.js";
+import { SessionTranscriptLayout } from "./session-transcript-layout.js";
+import { agentLabel } from "./agent-label.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`;
@@ -17,32 +19,69 @@ function metrics(session) {
 export class AgentSessionsScreen {
     store;
     style;
+    onDelete;
     selected = "main";
     active = "main";
     offset = 0;
     pageSize = 1;
     maxOffset = 0;
     follow = true;
+    transcript = new SessionTranscriptLayout();
     focused = false;
-    constructor(store, style = PLAIN_QUEUE_STYLE) {
+    deleteConfirmation;
+    constructor(store, style = PLAIN_QUEUE_STYLE, onDelete) {
         this.store = store;
         this.style = style;
+        this.onDelete = onDelete;
+    }
+    deleteSelected() {
+        const session = this.store.get(this.selectedId);
+        if (!session || session.id === "main" || !this.onDelete)
+            return;
+        if (session.running && (this.deleteConfirmation?.id !== session.id || this.deleteConfirmation.until < Date.now())) {
+            this.deleteConfirmation = { id: session.id, until: Date.now() + 3000 };
+            return;
+        }
+        this.deleteConfirmation = undefined;
+        const result = this.onDelete(session);
+        if (result.ok) {
+            this.store.delete(session.id);
+            this.sync();
+        }
+        else
+            this.store.notify(session.id, result.error ?? tr("Eliminazione non riuscita", "Deletion failed"));
+    }
+    get session() { return this.store.get(this.activeId); }
+    conversation(width, height) {
+        const session = this.session;
+        const lines = this.store.conversations.layout(session.id, width)
+            ?? this.transcript.lines(session.id, [session.goal, ...session.transcript], Math.max(2, width - 2));
+        this.pageSize = Math.max(1, height);
+        this.maxOffset = Math.max(0, lines.length - this.pageSize);
+        this.offset = this.follow ? this.maxOffset : Math.min(this.offset, this.maxOffset);
+        return lines.slice(this.offset, this.offset + this.pageSize);
     }
     get selectedId() { this.sync(); return this.selected; }
     get activeId() { this.sync(); return this.active; }
     get available() { return this.store.hasAgents; }
+    returnToMain() {
+        this.active = "main";
+        this.selected = "main";
+        this.focused = false;
+        this.follow = true;
+        this.offset = 0;
+    }
     sync() {
-        if (!this.store.get(this.active)?.live) {
-            this.active = "main";
-            this.selected = "main";
-            this.focused = false;
-            this.follow = true;
-            this.offset = 0;
-        }
+        this.transcript.retain(new Set(this.store.list().map(s => s.id)));
+        if (!this.store.get(this.active)?.live)
+            this.returnToMain();
         if (!this.store.get(this.selected)?.live)
             this.selected = this.active;
         if (!this.available)
             this.focused = false;
+        if (this.deleteConfirmation && (!this.focused || this.deleteConfirmation.id !== this.selected || this.deleteConfirmation.until < Date.now())) {
+            this.deleteConfirmation = undefined;
+        }
     }
     select(delta) {
         this.sync();
@@ -53,6 +92,11 @@ export class AgentSessionsScreen {
     }
     key(_text, key) {
         this.sync();
+        if (key.name === "delete" && this.focused) {
+            this.deleteSelected();
+            return;
+        }
+        this.deleteConfirmation = undefined;
         if (key.name === "up" || key.name === "down")
             this.select(key.name === "up" ? -1 : 1);
         else if (key.name === "return" || key.name === "enter") {
@@ -88,14 +132,17 @@ export class AgentSessionsScreen {
         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 deletion = this.onDelete && this.selected !== "main"
+            ? this.deleteConfirmation ? tr("[Canc: conferma stop ed elimina]", "[Del: confirm stop and delete]")
+                : tr("[Canc: elimina sessione]", "[Del: delete session]") : "";
         const help = this.focused
-            ? tr("↑↓ seleziona · Invio apri · main: sessione principale", "↑↓ select · Enter open · main: primary session")
+            ? `${deletion ? deletion + " · " : ""}${tr("↑↓ seleziona · Invio apri", "↑↓ select · Enter open")}`
             : 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 name = `  ${indicator} ${s.id === this.active ? "*" : " "} ${oneLine(agentLabel(s.actor))}`;
             const tail = `  ${metrics(s)}`;
             const room = Math.max(1, width - 1 - terminalWidth(tail));
             const activity = s.activity ? `  ${oneLine(s.activity)}` : "";
@@ -110,16 +157,15 @@ export class AgentSessionsScreen {
         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 heading = this.style.heading(fitLine(` ${tr("Sessione", "Session")} · ${oneLine(agentLabel(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 help = this.style.muted(fitLine(tr("↑↓ seleziona · Invio apri · seleziona principale 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);
+        const blocks = [session.goal, usage, ...session.transcript].filter(Boolean);
+        const lines = this.transcript.lines(session.id, blocks.length ? blocks : [tr("In attesa di attività…", "Waiting for activity…")], w);
         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);

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

@@ -1,6 +1,13 @@
+import type { ContextLedger } from "../core/context-ledger.js";
+import { WorkerTranscripts } from "./worker-transcripts.js";
 import type { AgentEvent } from "../core/types.js";
 import type { SessionUsageRecord } from "../core/session-usage.js";
 export interface AgentSession {
+    readonly kingdomId?: string;
+    readonly context?: ContextLedger;
+    readonly compacting?: boolean;
+    readonly compactingAt?: number;
+    readonly notice?: string;
     readonly id: string;
     readonly actor: string;
     readonly goal: string;
@@ -16,10 +23,14 @@ export interface AgentSession {
     readonly transcript: readonly string[];
 }
 export declare class AgentSessions {
+    readonly conversations: WorkerTranscripts;
     private sessions;
     private actors;
     private seenUsage;
+    private deleted;
     private listeners;
+    private messageListeners;
+    onMessage(listener: (id: string, messageId: string) => void): () => void;
     subscribe(listener: () => void): () => void;
     private changed;
     reset(): void;
@@ -31,6 +42,9 @@ export declare class AgentSessions {
     get(id: string, now?: number): AgentSession | undefined;
     get hasAgents(): boolean;
     private snapshot;
+    /** Remove only the live UI session, never files or persisted team reports. */
+    delete(id: string): boolean;
+    notify(id: string, notice: string): void;
     begin(goal: string, at?: number): void;
     finish(at?: number): void;
     private stop;

package/dist/tui/agent-sessions.js

@@ -1,4 +1,6 @@
+import { WorkerTranscripts } from "./worker-transcripts.js";
 import { tr } from "./i18n.js";
+import { runtimeError } from "./runtime-error.js";
 import { oneLine, plainText } from "./terminal-text.js";
 const EMPTY = { input: 0, output: 0 };
 const MAIN = "main";
@@ -14,10 +16,17 @@ function fresh(id, actor, goal = "") {
 // 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 {
+    conversations = new WorkerTranscripts();
     sessions = new Map([[MAIN, fresh(MAIN, MAIN)]]);
     actors = new Map();
     seenUsage = new Set();
+    deleted = new Set();
     listeners = new Set();
+    messageListeners = new Set();
+    onMessage(listener) {
+        this.messageListeners.add(listener);
+        return () => { this.messageListeners.delete(listener); };
+    }
     subscribe(listener) {
         this.listeners.add(listener);
         return () => { this.listeners.delete(listener); };
@@ -25,9 +34,11 @@ export class AgentSessions {
     changed() { for (const listener of this.listeners)
         listener(); }
     reset() {
+        this.conversations.reset();
         this.sessions = new Map([[MAIN, fresh(MAIN, MAIN)]]);
         this.actors.clear();
         this.seenUsage.clear();
+        this.deleted.clear();
         this.changed();
     }
     restoreMain(history) {
@@ -49,11 +60,31 @@ export class AgentSessions {
     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,
+        return { kingdomId: s.kingdomId, context: s.context, compacting: s.compacting, compactingAt: s.compactingAt, notice: s.notice, 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 };
     }
+    /** Remove only the live UI session, never files or persisted team reports. */
+    delete(id) {
+        if (id === MAIN || !this.sessions.has(id))
+            return false;
+        this.deleted.add(id);
+        this.sessions.delete(id);
+        this.conversations.delete(id);
+        for (const [actor, sessionId] of this.actors)
+            if (sessionId === id)
+                this.actors.delete(actor);
+        this.changed();
+        return true;
+    }
+    notify(id, notice) {
+        const session = this.sessions.get(id);
+        if (session) {
+            this.sessions.set(id, { ...session, notice });
+            this.changed();
+        }
+    }
     begin(goal, at = Date.now()) {
         const s = this.sessions.get(MAIN);
         this.sessions.set(MAIN, { ...s, goal, startedAt: s.startedAt ?? at, running: true,
@@ -86,24 +117,34 @@ export class AgentSessions {
     }
     record(event, at = Date.now(), actor = "Talos") {
         if (event.type === "kingdom" && event.phase === "session") {
+            if (this.deleted.has(event.sessionId))
+                return;
+            if (event.state === "despawned")
+                this.conversations.delete(event.sessionId);
             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") });
+                        kingdomId: event.kingdomId, startedAt: event.at, running: true, activity: tr("Avvio", "Starting") });
                 }
                 this.actors.set(event.slug, event.sessionId);
+                const session = this.sessions.get(event.sessionId);
+                this.sessions.set(event.sessionId, { ...session, live: true, running: true, startedAt: session.startedAt ?? event.at });
             }
             else
-                this.stop(event.sessionId, event.at, true);
+                this.stop(event.sessionId, event.at, event.state === "despawned");
             // 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)))
+            for (const s of completed.slice(0, Math.max(0, completed.length - 32))) {
                 this.sessions.delete(s.id);
+                this.conversations.delete(s.id);
+            }
             this.changed();
             return;
         }
         let id = actor === "Talos" ? MAIN : this.actors.get(actor);
         if (event.type === "usage") {
+            if (this.deleted.has(event.record.sessionId))
+                return;
             id = this.sessions.has(event.record.sessionId) ? event.record.sessionId
                 : event.record.actor ? this.actors.get(event.record.actor) : id;
         }
@@ -131,9 +172,21 @@ export class AgentSessions {
             s = { ...s, fallback: event.usage ? add(s.fallback, tokens(event.usage)) : s.fallback,
                 usageKnown: s.usageKnown || !!event.usage };
         }
+        else if (event.type === "context_window")
+            s = { ...s, context: event.ledger };
+        else if (event.type === "compacting")
+            s = { ...s, compacting: true, compactingAt: at };
+        else if (event.type === "compaction_end")
+            s = { ...s, compacting: false };
+        else if (event.type === "compacted")
+            s = { ...s, compacting: false,
+                context: s.context ? { ...s.context, tokens: event.tokensAfter, fraction: event.tokensAfter / s.context.window, pressure: event.tokensAfter / s.context.compactAt } : undefined };
         else if (event.type === "status")
             s = { ...s, activity: oneLine(event.label) };
         else if (event.type === "turn_start")
+            s = { ...s, running: true, live: true,
+                startedAt: s.startedAt ?? at, notice: undefined, activity: tr("Elaborazione", "Thinking") };
+        else if (event.type === "reasoning")
             s = { ...s, activity: tr("Elaborazione", "Thinking") };
         else if (event.type === "text")
             s = { ...this.log(s, event.delta, true), activity: tr("Risposta in corso", "Writing") };
@@ -148,9 +201,9 @@ export class AgentSessions {
         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) };
+            s = { ...this.log(s, runtimeError(event.message)), activity: oneLine(runtimeError(event.message)) };
         else if (event.type === "done")
-            s = { ...s, activity: tr("Concluso", "Finished") };
+            s = { ...s, compacting: false, 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 };
@@ -169,6 +222,14 @@ export class AgentSessions {
         }
         else
             return;
+        if (id !== MAIN && s.live) {
+            this.conversations.record(id, event);
+            if (event.type === "user_message") {
+                s = { ...s, notice: tr("Messaggio preso in carico", "Message received") };
+                for (const listener of this.messageListeners)
+                    listener(id, event.id);
+            }
+        }
         this.sessions.set(id, s);
         this.changed();
     }