@vascend/talos 0.1.0

package/dist/tui/onboarding.js

@@ -0,0 +1,207 @@
+// Primo ingresso della TUI: lingua e termini d'uso, PRIMA del login (stile
+// Claude Code/Codex). Le scelte si conservano in ~/.talos/onboarding.json e
+// non vengono richieste di nuovo; i termini sono VERSIONATI, cosi' un loro
+// aggiornamento ripropone la schermata una volta sola.
+//
+// I collegamenti sono quelli ufficiali di vascend.it, gli stessi mostrati
+// nelle email e nella schermata di accesso di Horizon (renderer/auth.js).
+// Parte PURA: dati, i18n e persistenza; la UI la disegna repl.ts.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { talosConfigDir } from "../core/env-paths.js";
+import { LANGUAGES, normalizeLanguage, normalizePreference } from "./locales.js";
+export const LINGUE = LANGUAGES;
+// Versione dei termini accettati: alzarla ripropone la schermata.
+export const TERMINI_VERSIONE = "2026-08";
+export const LINK_TERMINI = "https://vascend.it/terms";
+export const LINK_PRIVACY = "https://vascend.it/privacy";
+function onboardingPath(env) {
+    if (env["TALOS_NO_GLOBAL_CONFIG"] === "1")
+        return null;
+    return join(talosConfigDir(env), "onboarding.json");
+}
+export function leggiOnboarding(env) {
+    const path = onboardingPath(env);
+    if (!path || !existsSync(path))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        const lingua = normalizeLanguage(raw["lingua"]);
+        const languagePreference = normalizePreference(raw["languagePreference"]);
+        return {
+            ...(lingua ? { lingua } : {}),
+            ...(languagePreference ? { languagePreference } : {}),
+            ...(typeof raw["terminiVersione"] === "string" ? { terminiVersione: raw["terminiVersione"] } : {}),
+            ...(typeof raw["terminiQuando"] === "string" ? { terminiQuando: raw["terminiQuando"] } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+export function salvaOnboarding(env, stato) {
+    const path = onboardingPath(env);
+    if (!path)
+        return false;
+    try {
+        mkdirSync(talosConfigDir(env), { recursive: true });
+        writeFileSync(path, JSON.stringify(stato), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function serveLingua(stato) {
+    return !stato.lingua;
+}
+export function serveTermini(stato) {
+    return stato.terminiVersione !== TERMINI_VERSIONE;
+}
+// Interpreta la risposta di consenso nella lingua scelta (si/sì/yes/y...).
+export function consensoAffermativo(risposta, lingua) {
+    const r = risposta.trim().toLowerCase();
+    if (lingua === "en")
+        return r === "yes" || r === "y";
+    if (lingua === "es")
+        return r === "sí" || r === "si" || r === "s";
+    if (lingua === "de")
+        return r === "ja" || r === "j";
+    return r === "si" || r === "sì" || r === "s";
+}
+export const TESTI = {
+    es: {
+        byline: "by Vascend Technologies", linguaTitolo: "Idioma", linguaPrompt: "opción",
+        linguaNonValida: "opción no válida: indica el número del idioma.",
+        terminiTitolo: "Términos y condiciones",
+        terminiCorpo: "Al continuar aceptas los Términos de servicio y la Política de privacidad de Vascend.",
+        terminiStessiLink: "Son los mismos enlaces que aparecen en nuestros correos y en Horizon:",
+        terminiEtichetta: "Términos", privacyEtichetta: "Privacidad", terminiDomanda: "¿aceptas? [sí/no]",
+        terminiRifiutati: "No se puede usar Talos sin aceptar los términos.",
+        accessoTitolo: "Iniciar sesión", serveAccount: "Talos requiere tu cuenta de Vascend (la misma que usas en Horizon).",
+        nessunaPassword: "Sin contraseña: escribe tu correo para recibir un código de un solo uso.",
+        verificoAccesso: "comprobando la sesión de Vascend…", emailPrompt: "correo:",
+        serveEmail: "se necesita un correo (Ctrl+C para salir)",
+        contatto: email => `contactando con Vascend para solicitar un código para ${email}…`,
+        accountNuovo: "cuenta nueva: el registro se realiza en este mismo proceso.",
+        nomePrompt: "nombre:", cognomePrompt: "apellidos:", registro: "creando la cuenta y enviando el código…",
+        codiceInviato: "código enviado: revisa tu correo.", codicePrompt: "código:", verifico: "verificando el código…",
+        secondoFattore: "esta cuenta tiene activada la autenticación de dos factores.", totpPrompt: "código 2FA:",
+        verifico2fa: "verificando el código y el segundo factor…", identita: chi => `identidad confirmada: ${chi}`,
+        tokenNonSalvabile: "no se puede guardar el token (configuración global desactivada): acceso válido solo durante esta sesión",
+        ritiroLicenza: "obteniendo la licencia sin conexión…", licenzaPronta: "licencia sin conexión disponible.",
+        licenzaNonDisponibile: "licencia sin conexión no disponible: se volverá a intentar al iniciar.",
+        benvenuto: nome => `sesión iniciada. Bienvenido, ${nome}.`, accessoNota: chi => `cuenta de Vascend: ${chi}`,
+        ripartiamo: "volvamos al correo.", codiceNonValido: "código no válido",
+        troppiTentativi: "demasiados intentos: vuelve a intentarlo más tarde.", accessoAnnullato: "inicio de sesión cancelado.", uscireHint: "Ctrl+C para salir",
+    },
+    de: {
+        byline: "by Vascend Technologies", linguaTitolo: "Sprache", linguaPrompt: "Auswahl",
+        linguaNonValida: "ungültige Auswahl: Gib die Nummer der Sprache ein.",
+        terminiTitolo: "Nutzungsbedingungen",
+        terminiCorpo: "Wenn du fortfährst, akzeptierst du die Nutzungsbedingungen und die Datenschutzerklärung von Vascend.",
+        terminiStessiLink: "Dies sind dieselben Links wie in unseren E-Mails und in Horizon:",
+        terminiEtichetta: "Bedingungen", privacyEtichetta: "Datenschutz", terminiDomanda: "akzeptieren? [ja/nein]",
+        terminiRifiutati: "Talos kann ohne Zustimmung zu den Bedingungen nicht verwendet werden.",
+        accessoTitolo: "Anmelden", serveAccount: "Talos benötigt dein Vascend-Konto (dasselbe wie in Horizon).",
+        nessunaPassword: "Kein Passwort: Gib deine E-Mail-Adresse ein, um einen Einmalcode zu erhalten.",
+        verificoAccesso: "Vascend-Anmeldung wird geprüft…", emailPrompt: "E-Mail:",
+        serveEmail: "Eine E-Mail-Adresse ist erforderlich (Ctrl+C zum Beenden)",
+        contatto: email => `Vascend wird kontaktiert, um einen Code für ${email} anzufordern…`,
+        accountNuovo: "Neues Konto: Die Registrierung erfolgt im selben Ablauf.",
+        nomePrompt: "Vorname:", cognomePrompt: "Nachname:", registro: "Konto wird erstellt und Code gesendet…",
+        codiceInviato: "Code gesendet: Prüfe dein Postfach.", codicePrompt: "Code:", verifico: "Code wird geprüft…",
+        secondoFattore: "Für dieses Konto ist die Zwei-Faktor-Authentifizierung aktiviert.", totpPrompt: "2FA-Code:",
+        verifico2fa: "Code und zweiter Faktor werden geprüft…", identita: chi => `Identität bestätigt: ${chi}`,
+        tokenNonSalvabile: "Token kann nicht gespeichert werden (globale Konfiguration deaktiviert): Anmeldung gilt nur für diese Sitzung",
+        ritiroLicenza: "Offline-Lizenz wird abgerufen…", licenzaPronta: "Offline-Lizenz bereit.",
+        licenzaNonDisponibile: "Offline-Lizenz derzeit nicht verfügbar: Erneuter Versuch beim nächsten Start.",
+        benvenuto: nome => `Angemeldet. Willkommen, ${nome}.`, accessoNota: chi => `Vascend-Konto: ${chi}`,
+        ripartiamo: "Beginnen wir erneut mit der E-Mail-Adresse.", codiceNonValido: "Ungültiger Code",
+        troppiTentativi: "Zu viele Versuche: Bitte später erneut versuchen.", accessoAnnullato: "Anmeldung abgebrochen.", uscireHint: "Ctrl+C zum Beenden",
+    },
+    it: {
+        byline: "by Vascend Technologies",
+        linguaTitolo: "Lingua / Language",
+        linguaPrompt: "scelta",
+        linguaNonValida: "scelta non valida: indica il numero della lingua.",
+        terminiTitolo: "Termini e condizioni",
+        terminiCorpo: "Continuando accetti i Termini di servizio e la Privacy Policy di Vascend.",
+        terminiStessiLink: "Sono gli stessi collegamenti che trovi nelle email e su Horizon:",
+        terminiEtichetta: "Termini",
+        privacyEtichetta: "Privacy",
+        terminiDomanda: "accetti? [si/no]",
+        terminiRifiutati: "senza accettare i termini Talos non puo' essere usato.",
+        accessoTitolo: "Accesso",
+        serveAccount: "Per usare Talos serve l'account Vascend (lo stesso di Horizon).",
+        nessunaPassword: "Nessuna password: scrivi la tua email, arriva un codice monouso.",
+        verificoAccesso: "verifico l'accesso Vascend…",
+        emailPrompt: "email:",
+        serveEmail: "serve un'email (Ctrl+C per uscire)",
+        contatto: (email) => `contatto Vascend e chiedo un codice per ${email}…`,
+        accountNuovo: "account nuovo: registrazione nello stesso flusso.",
+        nomePrompt: "nome:",
+        cognomePrompt: "cognome:",
+        registro: "registro l'account e invio il codice…",
+        codiceInviato: "codice inviato: controlla la posta.",
+        codicePrompt: "codice:",
+        verifico: "verifico il codice…",
+        secondoFattore: "questo account ha il secondo fattore attivo.",
+        totpPrompt: "codice 2FA:",
+        verifico2fa: "verifico codice e secondo fattore…",
+        identita: (chi) => `identita' confermata: ${chi}`,
+        tokenNonSalvabile: "token non salvabile (config globale disattivata): accesso valido solo per questa sessione",
+        ritiroLicenza: "ritiro la licenza offline (per lavorare anche senza rete)…",
+        licenzaPronta: "licenza offline pronta.",
+        licenzaNonDisponibile: "licenza offline non disponibile ora: si riprova al prossimo avvio.",
+        benvenuto: (nome) => `dentro. benvenuto, ${nome}.`,
+        accessoNota: (chi) => `accesso Vascend: ${chi}`,
+        ripartiamo: "ripartiamo dall'email.",
+        codiceNonValido: "codice non valido",
+        troppiTentativi: "troppi tentativi: riprova piu' tardi.",
+        accessoAnnullato: "accesso annullato.",
+        uscireHint: "Ctrl+C per uscire",
+    },
+    en: {
+        byline: "by Vascend Technologies",
+        linguaTitolo: "Lingua / Language",
+        linguaPrompt: "choice",
+        linguaNonValida: "invalid choice: enter the language number.",
+        terminiTitolo: "Terms and conditions",
+        terminiCorpo: "By continuing you accept the Vascend Terms of Service and Privacy Policy.",
+        terminiStessiLink: "They are the same links you find in our emails and in Horizon:",
+        terminiEtichetta: "Terms",
+        privacyEtichetta: "Privacy",
+        terminiDomanda: "accept? [yes/no]",
+        terminiRifiutati: "Talos cannot be used without accepting the terms.",
+        accessoTitolo: "Sign in",
+        serveAccount: "Talos requires your Vascend account (the same one you use in Horizon).",
+        nessunaPassword: "No password: type your email, a one-time code will arrive.",
+        verificoAccesso: "checking your Vascend session…",
+        emailPrompt: "email:",
+        serveEmail: "an email is required (Ctrl+C to quit)",
+        contatto: (email) => `contacting Vascend and requesting a code for ${email}…`,
+        accountNuovo: "new account: registration happens in the same flow.",
+        nomePrompt: "first name:",
+        cognomePrompt: "last name:",
+        registro: "creating the account and sending the code…",
+        codiceInviato: "code sent: check your inbox.",
+        codicePrompt: "code:",
+        verifico: "verifying the code…",
+        secondoFattore: "this account has two-factor authentication enabled.",
+        totpPrompt: "2FA code:",
+        verifico2fa: "verifying code and second factor…",
+        identita: (chi) => `identity confirmed: ${chi}`,
+        tokenNonSalvabile: "token cannot be saved (global config disabled): access valid for this session only",
+        ritiroLicenza: "fetching the offline license (to work without a connection)…",
+        licenzaPronta: "offline license ready.",
+        licenzaNonDisponibile: "offline license not available now: will retry on next start.",
+        benvenuto: (nome) => `you are in. welcome, ${nome}.`,
+        accessoNota: (chi) => `Vascend account: ${chi}`,
+        ripartiamo: "let's start again from the email.",
+        codiceNonValido: "invalid code",
+        troppiTentativi: "too many attempts: try again later.",
+        accessoAnnullato: "sign-in cancelled.",
+        uscireHint: "Ctrl+C to quit",
+    },
+};

package/dist/tui/paste-collapse.d.ts

@@ -0,0 +1,39 @@
+export interface PastedBlock {
+    /** Progressivo 1-based: il riferimento mostrato e' "txt #<index>". */
+    readonly index: number;
+    readonly ref: string;
+    readonly text: string;
+    readonly lines: number;
+    readonly chars: number;
+    /** Prima riga non vuota, per il badge sopra l'input. */
+    readonly preview: string;
+}
+export interface CollapseThreshold {
+    readonly minLines: number;
+    readonly minChars: number;
+}
+export declare const DEFAULT_COLLAPSE: CollapseThreshold;
+export declare function countLines(text: string): number;
+export declare function shouldCollapsePaste(text: string, threshold?: CollapseThreshold): boolean;
+export declare function firstMeaningfulLine(text: string, max?: number): string;
+export declare class PasteRegistry {
+    private readonly blocks;
+    add(text: string): PastedBlock;
+    get(index: number): PastedBlock | undefined;
+    get size(): number;
+    /** Riferimenti presenti nel testo E risolvibili qui, in ordine di apparizione. */
+    refsIn(text: string): readonly PastedBlock[];
+    /**
+     * Rimette il testo vero al posto dei riferimenti. Quello che il modello legge
+     * e' sempre il contenuto completo; i riferimenti non risolvibili restano
+     * intatti, perche' potrebbero essere testo dell'utente e non nostri token.
+     */
+    expand(text: string): string;
+    reset(): void;
+}
+export declare function findPasteRefs(text: string): readonly number[];
+export declare function pasteTokenSpanAt(buffer: string, cursor: number): {
+    start: number;
+    end: number;
+} | null;
+export declare function describePastedBlock(block: PastedBlock): string;

package/dist/tui/paste-collapse.js

@@ -0,0 +1,117 @@
+// Collasso del testo incollato nel prompt.
+//
+// Incollare un file intero nel terminale rende il prompt illeggibile: la riga di
+// input scorre per centinaia di righe e l'utente perde di vista quello che sta
+// scrivendo. Qui l'incollo grande diventa un RIFERIMENTO compatto -- `txt #1` --
+// esattamente come un'immagine diventa `img #1`. Il testo vero resta in un
+// registro e viene rimesso al suo posto SOLO al momento dell'invio: il modello
+// riceve tutto, l'utente vede una riga.
+//
+// Modulo puro: nessun I/O, nessun ANSI. Il riferimento e' testo normale, quindi
+// sopravvive a copia/incolla, cronologia e modifica manuale del buffer.
+import { TEXT_REF } from "./attachment-refs.js";
+import { tr } from "./i18n.js";
+// Sotto queste dimensioni l'incollo entra nel buffer com'e': collassare due
+// righe sarebbe solo un ostacolo in piu' fra l'utente e il suo testo.
+export const DEFAULT_COLLAPSE = { minLines: 6, minChars: 800 };
+const REF_RE = new RegExp(TEXT_REF, "gi");
+export function countLines(text) {
+    if (!text)
+        return 0;
+    return text.split("\n").length;
+}
+export function shouldCollapsePaste(text, threshold = DEFAULT_COLLAPSE) {
+    if (!text)
+        return false;
+    return countLines(text) >= threshold.minLines || text.length >= threshold.minChars;
+}
+export function firstMeaningfulLine(text, max = 60) {
+    const line = text.split("\n").map((l) => l.trim()).find(Boolean) ?? "";
+    const clean = line.replace(/\s+/g, " ");
+    return clean.length > max ? `${clean.slice(0, max - 1).trimEnd()}…` : clean;
+}
+// Registro degli incolli di UNA sessione. Come ImageRegistry: i riferimenti non
+// attraversano una sessione nuova, altrimenti `txt #1` significherebbe cose
+// diverse in momenti diversi.
+export class PasteRegistry {
+    blocks = [];
+    add(text) {
+        const index = this.blocks.length + 1;
+        let chars = 0;
+        for (const _char of text)
+            chars++;
+        const block = {
+            index,
+            ref: tr("[Text #{index} · {count} caratteri]", "[Text #{index} · {count} characters]", { index, count: chars }),
+            text,
+            lines: countLines(text),
+            chars,
+            preview: firstMeaningfulLine(text),
+        };
+        this.blocks.push(block);
+        return block;
+    }
+    get(index) {
+        return this.blocks.find((block) => block.index === index);
+    }
+    get size() {
+        return this.blocks.length;
+    }
+    /** Riferimenti presenti nel testo E risolvibili qui, in ordine di apparizione. */
+    refsIn(text) {
+        const out = [];
+        for (const index of findPasteRefs(text)) {
+            const block = this.get(index);
+            if (block && !out.includes(block))
+                out.push(block);
+        }
+        return out;
+    }
+    /**
+     * Rimette il testo vero al posto dei riferimenti. Quello che il modello legge
+     * e' sempre il contenuto completo; i riferimenti non risolvibili restano
+     * intatti, perche' potrebbero essere testo dell'utente e non nostri token.
+     */
+    expand(text) {
+        if (!this.blocks.length)
+            return text;
+        return text.replace(REF_RE, (match, digits) => {
+            const block = this.get(Number(digits));
+            return block ? block.text : match;
+        });
+    }
+    reset() {
+        this.blocks.length = 0;
+    }
+}
+// Indici dei riferimenti "txt #N" presenti in un testo.
+export function findPasteRefs(text) {
+    const out = [];
+    let match;
+    REF_RE.lastIndex = 0;
+    while ((match = REF_RE.exec(text)) !== null) {
+        const index = Number(match[1]);
+        if (Number.isFinite(index) && !out.includes(index))
+            out.push(index);
+    }
+    return out;
+}
+// Estensione del riferimento sotto il cursore: serve al backspace atomico, cosi'
+// un `txt #1` si scollega per intero invece di sbriciolarsi un carattere alla
+// volta.
+export function pasteTokenSpanAt(buffer, cursor) {
+    REF_RE.lastIndex = 0;
+    let match;
+    while ((match = REF_RE.exec(buffer)) !== null) {
+        const start = match.index;
+        const end = start + match[0].length;
+        if (cursor > start && cursor <= end)
+            return { start, end };
+    }
+    return null;
+}
+// Riga di riepilogo per il badge sopra l'input: "txt #1 · 127 righe · import ...".
+export function describePastedBlock(block) {
+    const size = block.lines === 1 ? "1 riga" : `${block.lines} righe`;
+    return block.preview ? `${block.ref} · ${size} · ${block.preview}` : `${block.ref} · ${size}`;
+}

package/dist/tui/perm-mode.d.ts

@@ -0,0 +1,8 @@
+import type { TuiTheme } from "./branding.js";
+export type PermMode = "normal" | "acceptEdits" | "auto";
+export declare const PERM_CYCLE: readonly PermMode[];
+export declare function nextPermMode(mode: PermMode): PermMode;
+export declare function autoApproves(mode: PermMode, action: string): boolean;
+export declare function renderModeHint(mode: PermMode, theme: TuiTheme): string;
+export declare function renderComposerMode(mode: PermMode, theme: TuiTheme): string;
+export declare function permModeLabel(mode: PermMode): string;

package/dist/tui/perm-mode.js

@@ -0,0 +1,41 @@
+import { tr } from "./i18n.js";
+// Ordine del ciclo Shift+Tab: normal -> acceptEdits -> auto -> normal.
+export const PERM_CYCLE = ["normal", "acceptEdits", "auto"];
+export function nextPermMode(mode) {
+    const i = PERM_CYCLE.indexOf(mode);
+    return PERM_CYCLE[(i + 1) % PERM_CYCLE.length] ?? "normal";
+}
+// Tool considerati "modifiche ai file" (auto-approvati in acceptEdits).
+const EDIT_ACTIONS = new Set(["write_file", "edit_file"]);
+// True se la modalita' approva automaticamente questa azione (niente prompt).
+export function autoApproves(mode, action) {
+    if (mode === "auto")
+        return true;
+    if (mode === "acceptEdits")
+        return EDIT_ACTIONS.has(action);
+    return false;
+}
+// Riga indicatore sopra l'input (vuota in modalita' normale, come Claude Code).
+export function renderModeHint(mode, theme) {
+    if (mode === "normal")
+        return "";
+    if (mode === "acceptEdits") {
+        return theme.green(tr("⏵ modifiche", "⏵ edits")) + theme.dim(" · Shift+Tab");
+    }
+    return theme.yellow("⏵ auto") + theme.dim(" · Shift+Tab");
+}
+export function renderComposerMode(mode, theme) {
+    if (mode === "acceptEdits")
+        return theme.green("\x1b[7m EDIT \x1b[27m");
+    if (mode === "auto")
+        return theme.yellow("\x1b[7m AUTO \x1b[27m");
+    return theme.dark("\x1b[7m ASK \x1b[27m");
+}
+// Etichetta breve per i messaggi di conferma cambio modalita'.
+export function permModeLabel(mode) {
+    if (mode === "acceptEdits")
+        return tr("accetta modifiche", "accept edits");
+    if (mode === "auto")
+        return "auto";
+    return tr("normale", "normal");
+}

package/dist/tui/prompt-queue-store.d.ts

@@ -0,0 +1,26 @@
+import type { QueuedPrompt } from "./prompt-queue.js";
+export interface QueueSnapshot {
+    readonly entries: readonly QueuedPrompt[];
+    readonly paused: boolean;
+}
+export interface QueuePersistence {
+    load(): QueueSnapshot | undefined;
+    save(snapshot: QueueSnapshot): void;
+}
+interface QueueFile extends QueueSnapshot {
+    readonly version: 1;
+    readonly sessionId: string;
+    readonly updatedAt: number;
+    readonly ownerPid: number;
+}
+export declare class PromptQueueFile implements QueuePersistence {
+    private readonly base;
+    readonly sessionId: string;
+    constructor(base: string, sessionId: string);
+    private path;
+    load(): QueueFile | undefined;
+    save(snapshot: QueueSnapshot): void;
+}
+declare function processAlive(pid: number): boolean;
+export declare function recoverableQueue(base: string, alive?: typeof processAlive): string | undefined;
+export {};

package/dist/tui/prompt-queue-store.js

@@ -0,0 +1,87 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { validateSessionId } from "../core/session.js";
+export class PromptQueueFile {
+    base;
+    sessionId;
+    constructor(base, sessionId) {
+        this.base = base;
+        this.sessionId = sessionId;
+        validateSessionId(sessionId);
+    }
+    path(create = false) {
+        const directory = join(this.base, "queues");
+        if (create)
+            mkdirSync(directory, { recursive: true });
+        if (existsSync(directory) && lstatSync(directory).isSymbolicLink())
+            throw new Error("La directory della coda è un collegamento.");
+        const file = join(directory, `${this.sessionId}.json`);
+        if (existsSync(file) && lstatSync(file).isSymbolicLink())
+            throw new Error("Il file della coda è un collegamento.");
+        return file;
+    }
+    load() {
+        const file = this.path();
+        if (!existsSync(file))
+            return undefined;
+        const data = JSON.parse(readFileSync(file, "utf8"));
+        if (data.version !== 1 || data.sessionId !== this.sessionId || !Array.isArray(data.entries)
+            || typeof data.paused !== "boolean" || !Number.isFinite(data.updatedAt))
+            throw new Error("Formato della coda non valido.");
+        const ids = new Set();
+        for (const e of data.entries) {
+            if (!e || typeof e.id !== "string" || !e.id || ids.has(e.id) || typeof e.text !== "string" || !e.text.trim()
+                || !Number.isFinite(e.queuedAt) || !["after-turn", "during-turn", "immediate"].includes(e.delivery)
+                || (e.teamBatchId !== undefined && (typeof e.teamBatchId !== "string" || !e.teamBatchId))
+                || !Array.isArray(e.parts) || !e.parts.length || !e.parts.every((p) => p &&
+                (p.type === "text" ? typeof p.text === "string" : p.type === "image" && typeof p.data === "string" && typeof p.mime === "string"))) {
+                throw new Error("Messaggio salvato in coda non valido.");
+            }
+            ids.add(e.id);
+        }
+        return data;
+    }
+    save(snapshot) {
+        const file = this.path(true);
+        const temporary = `${file}.${randomUUID()}.tmp`;
+        const data = { version: 1, sessionId: this.sessionId, updatedAt: Date.now(), ownerPid: process.pid, ...snapshot };
+        writeFileSync(temporary, JSON.stringify(data) + "\n", { encoding: "utf8", mode: 0o600, flag: "wx" });
+        renameSync(temporary, file);
+    }
+}
+function processAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+// Solo l'avvio normale recupera una chat lasciata con messaggi pendenti.
+// Una scelta esplicita (--session-id, --continue, --resume) ha precedenza.
+export function recoverableQueue(base, alive = processAlive) {
+    let files;
+    try {
+        files = readdirSync(join(base, "queues"));
+    }
+    catch {
+        return undefined;
+    }
+    const found = [];
+    for (const file of files) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const id = file.slice(0, -5);
+            const saved = new PromptQueueFile(base, id).load();
+            if (saved?.entries.length && existsSync(join(base, `${id}.jsonl`)) && !alive(saved.ownerPid))
+                found.push(saved);
+        }
+        catch { /* Una coda illeggibile non impedisce l'avvio delle altre chat. */ }
+    }
+    return found.sort((a, b) => b.updatedAt - a.updatedAt)[0]?.sessionId;
+}

package/dist/tui/prompt-queue.d.ts

@@ -0,0 +1,47 @@
+import type { ContentPart } from "../core/types.js";
+import type { QueuePersistence } from "./prompt-queue-store.js";
+import { type PendingUserMessage, type UserInbox } from "../core/user-inbox.js";
+export type PromptDelivery = "after-turn" | "during-turn" | "immediate";
+export interface QueuedPrompt extends PendingUserMessage {
+    readonly text: string;
+    readonly delivery: PromptDelivery;
+    readonly teamBatchId?: string;
+}
+export declare class PromptQueue {
+    private readonly prepare;
+    private readonly onChange;
+    private readonly persistence?;
+    private entries;
+    storageError: string;
+    private storageReadable;
+    private readonly delivered;
+    private readonly immediateListeners;
+    private pausing;
+    private holding;
+    readonly inbox: UserInbox;
+    constructor(prepare?: (text: string) => readonly ContentPart[], onChange?: () => void, persistence?: QueuePersistence | undefined, restoreInput?: (entry: QueuedPrompt) => QueuedPrompt);
+    get length(): number;
+    get teamRequestCount(): number;
+    get blocked(): boolean;
+    get paused(): boolean;
+    set paused(value: boolean);
+    get held(): boolean;
+    set held(value: boolean);
+    private get immediatePending();
+    private ready;
+    private notifyImmediate;
+    items(): readonly QueuedPrompt[];
+    get(id: string): QueuedPrompt | undefined;
+    private persist;
+    private changed;
+    add(text: string, delivery?: PromptDelivery, parts?: readonly ContentPart[], id?: string): QueuedPrompt;
+    update(id: string, text: string): boolean;
+    remove(id: string): boolean;
+    move(id: string, offset: number): boolean;
+    moveFirst(id: string): boolean;
+    setDelivery(id: string, delivery: PromptDelivery): boolean;
+    sendNow(id: string): boolean;
+    sendToTeam(): boolean;
+    takeNext(): QueuedPrompt | undefined;
+    acknowledge(id: string): string | undefined;
+}