@vascend/talos 0.1.3 → 0.1.5

package/dist/tui/repl.js

@@ -9,6 +9,9 @@ import { createUserInbox, pendingText } from "../core/user-inbox.js";
 import { renderDiff } from "./diff.js";
 import { renderMarkdown, wrapPlain } from "./markdown.js";
 import { SessionUsageState } from "./session-usage.js";
+import { readSessionUsage } from "../core/session-usage.js";
+import { storageHealth } from "../core/storage-health.js";
+import { storageWarning } from "./storage-warning.js";
 import { ContextMeter, contextDetails } from "./context-meter.js";
 import { buildUsageFooter, subscriptionDetails, SESSION_USAGE_EXPLANATION } from "./usage-footer.js";
 import { copyText, lastAssistantText } from "./clipboard-text.js";
@@ -76,6 +79,7 @@ import { VascendPlanStore } from "../vascend/plan-store.js";
 import { reviewOptions, shouldReview, buildRoomMetricsDigest, buildReviewerPrompt } from "../vascend/reviewer.js";
 import { Session, listSessions, sessionFilePath } from "../core/session.js";
 import { sessionTitle } from "../core/session-title.js";
+import { nameSession } from "../core/session-naming.js";
 import { ToolRegistry } from "../tools/registry.js";
 import { saveGlobalSettings } from "../core/settings.js";
 import { autoApproves, nextPermMode, permModeLabel } from "./perm-mode.js";
@@ -324,6 +328,7 @@ export async function startRepl(deps) {
     stats.restore(harness.config.sessionDir, harness.session.id, harness.session.tree().find(n => n.message.role === "assistant")?.ts);
     const review = new ReviewStore();
     review.reset(sessionConversation(harness.session));
+    review.sessions.restoreMain(readSessionUsage(harness.config.sessionDir, harness.session.id));
     const reviewContext = () => {
         const cost = costTracker.snapshot(harness.config.model);
         const tasks = vascend.state().kingdom.castles.flatMap(c => c.tasks);
@@ -447,6 +452,7 @@ export async function startRepl(deps) {
     const resetSessionUi = (ctl) => {
         ctl.clearConversation?.();
         review.reset(sessionConversation(harness.session));
+        review.sessions.restoreMain(readSessionUsage(harness.config.sessionDir, harness.session.id));
         imageRegistry.clear();
         pasteRegistry.reset();
         ctl.restoreQueue?.();
@@ -671,6 +677,7 @@ export async function startRepl(deps) {
                 const providerId = harness.providers.resolve(harness.config.model)?.provider.id ?? "";
                 return buildUsageFooter(statusData(), theme, stats, providerId, statusOpts()).slice(0, 1);
             },
+            warningLines: () => storageWarning(storageHealth.snapshot(harness.config.sessionDir), terminalColumns(), theme.yellow),
             completion,
             hint: slashHint,
             statusStyle: (s) => theme.dark(s),
@@ -782,7 +789,13 @@ export async function startRepl(deps) {
             input.write(`\n  ${mark} background ${t.id} ` +
                 theme.dim(`[${t.status}${t.exitCode != null ? ` · uscita ${t.exitCode}` : ""}] ${truncate(t.command, 50)} · /bg ${t.id} per l'output\n`));
         });
-        await input.start();
+        const unsubscribeStorage = storageHealth.subscribe(() => input.refresh());
+        try {
+            await input.start();
+        }
+        finally {
+            unsubscribeStorage();
+        }
         return;
     }
     // Fallback (non-TTY o TALOS_CLASSIC_INPUT=1): loop readline classico inline.
@@ -790,6 +803,13 @@ export async function startRepl(deps) {
     if (harness.session.head)
         replaySession(harness.session, { write: text => stdout.write(text) }, theme, terminalColumns());
     const rl = readline.createInterface({ input: stdin, output: stdout });
+    const reportStorage = () => {
+        const rows = storageWarning(storageHealth.snapshot(harness.config.sessionDir), terminalColumns(), theme.yellow);
+        if (rows.length)
+            stdout.write("\n" + rows.join("\n") + "\n");
+    };
+    const unsubscribeStorage = storageHealth.subscribe(reportStorage);
+    reportStorage();
     const ctl = {
         review,
         pause: () => rl.pause(),
@@ -848,6 +868,7 @@ export async function startRepl(deps) {
         void lineQueue.enqueue(raw);
     });
     rl.on("close", () => {
+        unsubscribeStorage();
         lineQueue.close();
         harness.dispose?.();
         void harness.host.emit("session_shutdown", {});
@@ -1057,7 +1078,7 @@ async function drive(deps, input, ctl, theme, terminalColumns, stats, signal, ge
         const turnInput = imageParts && imageParts.length
             ? [{ type: "text", text: input }, ...imageParts]
             : input;
-        await runTurn({ ...deps.harness.deps(confirm), ask, spawnKingdom, inbox }, turnInput, wrappedSink, signal);
+        await runTurn({ ...deps.harness.deps(confirm), env: { ...env, TALOS_AUTO_TITLE: "1" }, ask, spawnKingdom, inbox }, turnInput, wrappedSink, signal);
         if (turnFailed || signal.aborted)
             return;
         // REVISORE di team: per i task complessi (molte stanze) con stanze fatte e
@@ -1404,7 +1425,7 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                     ctl.write(preview.lines.join("\n") + "\n");
                     commandCards.set(event.call.id, { index: ctl.logLength() - preview.lines.length,
                         firstRow: preview.firstRow, columns, end: ctl.logLength(), header: preview.lines[0] });
-                    ctl.setStatus(tr("esegue comando terminale", "running terminal command"));
+                    ctl.setStatus(tr("Esecuzione comando", "Running command"));
                     ctl.setStatusTool?.(event.call.name);
                     break;
                 }
@@ -1474,6 +1495,9 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 ctl.setStatus(tr("elaboro", "working"));
                 stopDot(); // ferma l'animazione del bullet: il tool e' finito
                 const call = calls.get(event.result.callId);
+                const before = preContent.get(event.result.callId);
+                calls.delete(event.result.callId);
+                preContent.delete(event.result.callId);
                 const toolCard = toolCards.get(event.result.callId);
                 toolCards.delete(event.result.callId);
                 if (event.parentId) {
@@ -1548,7 +1572,7 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                     break;
                 }
                 if (call && !event.result.isError && call.name === "write_file") {
-                    ctl.review?.change(call.id, { before: call.input["append"] === true ? "" : preContent.get(call.id),
+                    ctl.review?.change(call.id, { before: call.input["append"] === true ? "" : before,
                         after: String(call.input["content"] ?? ""), scope: call.input["append"] === true ? "append" : "file" });
                 }
                 // Token per stanza/castello (solo con vascend attivo). Snapshot a
@@ -1593,13 +1617,24 @@ export function makeSink(theme, terminalColumns, cwd, env, ctl, plan) {
                 }
                 // Keep the change preview alongside its operation.
                 if (call && !event.result.isError) {
-                    const diff = diffForCall(call, preContent.get(event.result.callId), event.result.output, theme, terminalColumns());
+                    const diff = diffForCall(call, before, event.result.output, theme, terminalColumns());
                     if (diff) {
                         ctl.write(previewDiff(diff, theme, terminalColumns() - 1));
                     }
                 }
                 break;
             }
+            case "session_naming":
+                ctl.setSessionNaming?.(event.phase, event.title);
+                break;
+            case "compacting":
+                stopDot();
+                flushText();
+                ctl.setCompacting?.(true);
+                break;
+            case "compaction_end":
+                ctl.setCompacting?.(false);
+                break;
             case "compacted":
                 stopDot();
                 flushText();
@@ -2061,6 +2096,7 @@ function sessionOptions(list) {
         label: sessionTitle(s.name ?? "") || s.preview || s.id,
         detail: `${fmtAge(s.updatedAt)} · ${s.messages} msg · ${s.id}`,
         value: s.id,
+        age: fmtAge(s.updatedAt),
     }));
 }
 // Riprende una sessione: la carica nell'harness (le closure vedono il nuovo
@@ -2318,8 +2354,45 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
             return null;
         }
         case "rename": {
-            const title = args.trim();
-            if (!title || title.length > 120) {
+            let title = args.trim();
+            if (!title) {
+                const choice = await selectOption({
+                    title: tr("Rinomina chat", "Rename chat"),
+                    question: true,
+                    options: [
+                        { key: "generate", label: tr("Rigenera dall'ultimo prompt", "Regenerate from the latest prompt"),
+                            detail: tr("Usa il modello selezionato per scegliere il titolo.", "Use the selected model to choose the title."), value: "generate" },
+                        { key: "manual", label: tr("Imposta manualmente", "Set manually"),
+                            detail: tr("Scrivi il nuovo nome della chat.", "Type the new chat name."), value: "manual" },
+                    ],
+                    ctl, theme, terminalColumns,
+                });
+                if (!choice || signal.aborted)
+                    return null;
+                if (choice.value === "manual") {
+                    const entered = await ctl.promptInput(tr("Nome della chat (Invio conferma · Esc annulla)", "Chat name (Enter confirms · Esc cancels)"));
+                    if (!entered?.trim() || signal.aborted)
+                        return null;
+                    title = entered.trim();
+                }
+            }
+            if (!title) {
+                const last = [...harness.session.history()].reverse().find(message => message.role === "user");
+                const prompt = last?.content.filter(part => part.type === "text").map(part => part.text).join(" ") || "";
+                if (!prompt) {
+                    notifyStatus(ctl, "Invia prima un messaggio per generare il titolo.");
+                    return null;
+                }
+                await nameSession(harness.deps(async () => false), prompt, event => {
+                    if (event.type === "usage")
+                        stats.observe?.(event);
+                    if (event.type === "session_naming")
+                        ctl.setSessionNaming?.(event.phase, event.title);
+                }, signal, true);
+                ctl.refresh?.();
+                return null;
+            }
+            if (title.length > 120) {
                 ctl.write(theme.dim("\n  Usa /rename Titolo della chat (da 1 a 120 caratteri).\n"));
                 return null;
             }
@@ -3007,44 +3080,52 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
         case "vascend-compact":
         case "compact": {
             const hasModel = Boolean(harness.providers.resolve(harness.config.model));
+            let feedback = "Checkpoint salvato; nessun modello configurato per compattare.";
+            let failed = false;
             // 1) Compattazione LLM del contesto della sessione.
             if (hasModel) {
                 const meter = stats.context ?? new ContextMeter();
                 const before = meter.read(harness).tokens;
-                ctl.write(theme.dim(`\n  compatto ~${formatTokenCount(before)} token attivi; preservo richiesta, attivita aperte e lavoro recente...\n`));
                 const controller = new AbortController();
                 const onSigint = () => controller.abort();
+                if (signal.aborted)
+                    controller.abort();
+                signal.addEventListener("abort", onSigint, { once: true });
                 process.once("SIGINT", onSigint);
                 try {
                     const done = await compactNow(harness.deps(async () => false), controller.signal, (e) => {
                         if (e.type === "usage")
                             stats.observe?.(e);
+                        if (e.type === "compacting")
+                            ctl.setCompacting?.(true);
+                        if (e.type === "compaction_end")
+                            ctl.setCompacting?.(false);
                     }, args || undefined);
                     if (done) {
                         const after = meter.read(harness);
-                        const archived = after.archived.reduce((sum, block) => sum + block.tokens, 0);
-                        ctl.write(theme.green(`  attivo ~${formatTokenCount(before)} → ~${formatTokenCount(after.tokens)} token · archivio originale ~${formatTokenCount(archived)}\n`));
+                        feedback = `Contesto compattato: ~${formatTokenCount(before)} -> ~${formatTokenCount(after.tokens)} token`;
+                    }
+                    else {
+                        feedback = controller.signal.aborted
+                            ? "Compattazione interrotta; contesto conservato."
+                            : "Nessuna compattazione necessaria; contesto conservato.";
                     }
-                    if (!done)
-                        ctl.write(theme.dim(controller.signal.aborted
-                            ? "  compattazione interrotta; contesto conservato.\n"
-                            : "  nessuna compattazione applicata; contesto conservato.\n"));
                 }
                 catch (err) {
-                    ctl.write(theme.red(`  errore compattazione: ${err.message}\n`));
+                    feedback = `Compattazione non riuscita: ${err.message}`;
+                    failed = true;
                 }
                 finally {
                     process.removeListener("SIGINT", onSigint);
+                    signal.removeEventListener("abort", onSigint);
+                    ctl.setCompacting?.(false);
+                    ctl.setStatus(null);
                 }
             }
-            else {
-                ctl.write(theme.dim("\n  nessun modello configurato: salvo solo il checkpoint Vascend.\n"));
-            }
             // 2) Checkpoint Vascend/Danilov sullo stato (gia' compattato) della sessione.
             vascend.loadPlan(harness.config.sessionDir, harness.config.planStoreId ?? harness.config.roomStoreId ?? harness.session.id);
-            const checkpoint = vascend.compact(harness.session.history());
-            ctl.write(theme.green("  ✓ checkpoint Vascend salvato in .vascend-compact.md\n"));
-            ctl.write(theme.dim(`    piano e contesto pronti per la ripresa (${checkpoint.text.split("\n").length} righe)\n`));
+            vascend.compact(harness.session.history());
+            notifyStatus(ctl, feedback, failed);
             return null;
         }
         case "tree": {
@@ -3200,9 +3281,11 @@ async function handleSlashCommand(line, deps, ctl, theme, terminalColumns, theme
                 return null;
             }
             const selected = await selectOption({
-                title: tr("Chat salvate", "Saved chats"),
+                title: "Resume a previous session",
                 hint: tr("Scrivi per cercare · Invio apre · Esc torna alla chat corrente", "Type to search · Enter open · Esc return to the current chat"),
                 filterable: true,
+                sessionList: true,
+                fullHeight: true,
                 options: sessionOptions(list).map((option) => ({ ...option,
                     detail: option.detail + (option.value === harness.session.id ? " · " + tr("corrente", "current") : ""),
                 })),
@@ -3805,7 +3888,9 @@ async function pickModel(harness, ctl, theme, terminalColumns) {
     }
     const current = canonicalModel(harness.config.model);
     const selected = await selectOption({
-        title: "Modelli",
+        title: tr("Modelli", "Models"),
+        modelList: true,
+        fullHeight: true,
         options,
         currentKey: current?.fullModel,
         ctl,
@@ -3862,7 +3947,8 @@ function modelOptions(providers, dynamic) {
             const detail = dynById.get(model)?.detail;
             out.push({
                 key: full,
-                label: `${spec.label}  ${model}`,
+                label: model,
+                group: spec.label,
                 detail: `${authSummary(spec.id, authProviders)}${detail ? ` · ${detail}` : ""}`,
                 value: { providerId: spec.id, modelId: model, fullModel: full },
             });

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,7 +28,11 @@ 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 sequence;
@@ -37,7 +42,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 +62,5 @@ export declare class ReviewStore {
     private callId;
     private notice;
     private put;
+    private remove;
 }

package/dist/tui/review-store.js

@@ -1,4 +1,5 @@
 import { oneLine } from "./terminal-text.js";
+import { AgentSessions } from "./agent-sessions.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",
@@ -9,6 +10,14 @@ const LABELS = {
     kingdom_send: "Messaggio al team", kingdom_inbox: "Messaggi del team", kingdom_wait: "Attesa collaboratori",
 };
 export function reviewTitle(name) { return 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,7 +27,11 @@ 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();
     sequence = 0;
@@ -28,8 +41,9 @@ 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; }
@@ -39,6 +53,7 @@ export class ReviewStore {
     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 +61,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,7 +71,10 @@ 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.sequence = 0;
@@ -87,6 +106,7 @@ export class ReviewStore {
             this.put({ ...entry, change });
     }
     record(event, at = Date.now(), actor = "Talos") {
+        this.sessions.record(event, at, actor);
         switch (event.type) {
             case "status":
                 this._label = oneLine(event.label);
@@ -149,6 +169,8 @@ export class ReviewStore {
         }
     }
     recordActor(actor, event) {
+        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,7 +188,7 @@ 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,
@@ -254,17 +276,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/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.d.ts

@@ -6,6 +6,7 @@ export interface SelectOption<T> {
     readonly group?: string;
     readonly hint?: string;
     readonly value: T;
+    readonly age?: string;
 }
 interface SelectorControl {
     pause(): void;
@@ -24,6 +25,8 @@ interface SelectorOptions<T> {
     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 +36,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);
@@ -132,7 +138,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 +159,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);

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;
+}