@vascend/talos 0.1.4 → 0.1.6

package/dist/tui/agent-sessions.js

@@ -0,0 +1,236 @@
+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";
+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 {
+    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); };
+    }
+    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) {
+        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 { 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,
+            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 (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),
+                        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, 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))) {
+                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;
+        }
+        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 === "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") };
+        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, runtimeError(event.message)), activity: oneLine(runtimeError(event.message)) };
+        else if (event.type === "done")
+            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 };
+            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;
+        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();
+    }
+}

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

@@ -5,6 +5,32 @@ import { type QueuedPrompt } from "./prompt-queue.js";
 import type { QueuePersistence } from "./prompt-queue-store.js";
 import { type QueueStyle } from "./queue-screen.js";
 export interface BottomInputHandlers {
+    readonly bindSessionInbox?: (session: import("./agent-sessions.js").AgentSession, inbox: import("../core/user-inbox.js").UserInbox) => {
+        ok: boolean;
+        error?: string;
+    };
+    readonly wakeSession?: (session: import("./agent-sessions.js").AgentSession) => {
+        ok: boolean;
+        error?: string;
+    };
+    readonly onSessionSubmit?: (session: import("./agent-sessions.js").AgentSession, text: string, parts: readonly ContentPart[], immediate: boolean) => {
+        ok: boolean;
+        error?: string;
+    };
+    readonly onSessionStop?: (session: import("./agent-sessions.js").AgentSession) => {
+        ok: boolean;
+        error?: string;
+    };
+    readonly onSessionDelete?: (session: import("./agent-sessions.js").AgentSession) => {
+        ok: boolean;
+        error?: string;
+    };
+    readonly onSessionBackground?: (session: import("./agent-sessions.js").AgentSession) => {
+        ok: boolean;
+        error?: string;
+    };
+    readonly sessionFooter?: (session: import("./agent-sessions.js").AgentSession, width: number) => readonly string[];
+    readonly sessionBelowInput?: (session: import("./agent-sessions.js").AgentSession, width: number) => readonly string[];
     readonly nativeScroll?: boolean;
     readonly review?: ReviewStore;
     readonly createReviewScreen?: (section?: string) => TerminalScreen;
@@ -18,11 +44,15 @@ export interface BottomInputHandlers {
     readonly attachmentStyle?: (s: string) => string;
     readonly footerLines: () => readonly string[];
     readonly belowInputLines?: () => readonly string[];
+    readonly currentModel?: () => string;
+    readonly limitWarningStyle?: (s: string) => string;
+    readonly warningLines?: () => readonly string[];
     readonly completion: (buffer: string) => string | null;
     readonly hint: (buffer: string) => string;
     readonly statusStyle?: (s: string) => string;
     readonly boxStyle?: (s: string) => string;
     readonly onSubmit: (line: string, signal: AbortSignal, fromQueue?: boolean, queued?: QueuedPrompt) => Promise<void>;
+    readonly onCommandDuringRun?: (line: string, signal: AbortSignal) => Promise<void>;
     readonly prepareQueuedInput?: (text: string) => readonly ContentPart[];
     readonly queuePersistence?: () => QueuePersistence;
     readonly restoreQueuedInput?: (entry: QueuedPrompt) => QueuedPrompt;
@@ -51,7 +81,9 @@ export declare class BottomInput {
     private readonly h;
     private buffer;
     private cursor;
-    private readonly history;
+    private history;
+    private composerSession;
+    private readonly sessionDrafts;
     private histIdx;
     private draft;
     private active;
@@ -59,9 +91,13 @@ export declare class BottomInput {
     private ctrlCConfirmation;
     private ctrlCTimer?;
     private running;
+    private commandPending;
     private readonly questions;
     private runAbort?;
     private queue;
+    private readonly workerQueues;
+    private get composerQueue();
+    private ensureWorkerQueue;
     private queueEditor;
     private readonly log;
     private readonly logIds;
@@ -84,8 +120,15 @@ export declare class BottomInput {
     private kingdomBoard;
     private overlay;
     private screen;
+    private readonly agentSessions?;
+    private sessionsUnsubscribe?;
+    private messagesUnsubscribe?;
+    private sessionsTimer?;
     private modal;
     private statusLabel;
+    private sessionLimitNotice;
+    private compactionStartedAt;
+    private compactionPreviousStatus;
     private statusTool;
     private roomStatus;
     private roomTimer?;
@@ -95,6 +138,7 @@ export declare class BottomInput {
     private tokensOut;
     private frame;
     private spinnerTimer?;
+    private readonly namingNotice;
     private lastLayout?;
     private liveStartRow;
     private paintedRows;
@@ -120,7 +164,7 @@ export declare class BottomInput {
     private createQueue;
     restoreQueue(): void;
     get review(): ReviewStore | undefined;
-    get userInbox(): import("../sdk.js").UserInbox;
+    get userInbox(): import("../core/user-inbox.js").UserInbox;
     acceptQueuedMessage(id: string): string | undefined;
     pauseQueuedMessages(): void;
     showQueue(): void;
@@ -129,6 +173,10 @@ export declare class BottomInput {
     private finishQueueEdit;
     showReview(section?: string): void;
     private get screenVisible();
+    private get workerVisible();
+    private syncSessionComposer;
+    showAgents(): void;
+    private sessionArrow;
     static supported(): boolean;
     start(): Promise<void>;
     write(text: string): void;
@@ -140,8 +188,13 @@ 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;
+    submitExternal(line: string, immediate?: boolean): boolean;
+    requestStop(): boolean;
     setStatusTool(name: string | null): void;
     setRoomStatus(label: string | null, state?: "running" | "done" | "failed"): void;
     private reportFailure;
@@ -160,6 +213,7 @@ export declare class BottomInput {
     private trimLog;
     private renderedLog;
     private touchLog;
+    cyclePermissionMode(): void;
     pause(): void;
     resume(): void;
     setKingdomVassals(data: ReadonlyArray<{
@@ -207,6 +261,7 @@ export declare class BottomInput {
     private submit;
     private dispatch;
     private startNextQueued;
+    private runLiveCommand;
     private runLine;
     private quit;
 }