@vascend/talos 0.1.4 → 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

@@ -0,0 +1,35 @@
+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;
+    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;
+    scroll(delta: number): void;
+    preview(width: number, maxRows?: number): readonly string[];
+    render(width: number, height: number): readonly string[];
+}

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

@@ -0,0 +1,178 @@
+import { tr } from "./i18n.js";
+import { PLAIN_QUEUE_STYLE } from "./queue-screen.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`;
+}
+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;
+    onDelete;
+    selected = "main";
+    active = "main";
+    offset = 0;
+    pageSize = 1;
+    maxOffset = 0;
+    follow = true;
+    transcript = new SessionTranscriptLayout();
+    focused = false;
+    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() {
+        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();
+        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 === "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") {
+            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 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
+            ? `${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(agentLabel(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(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 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 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);
+        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,53 @@
+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;
+    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 {
+    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;
+    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;
+    /** 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;
+    private log;
+    record(event: AgentEvent, at?: number, actor?: string): void;
+}