@vascend/talos 0.1.0

package/dist/tui/prompt-queue.js

@@ -0,0 +1,187 @@
+import { randomUUID } from "node:crypto";
+import { pendingText } from "../core/user-inbox.js";
+import { groupTeamPrompts, teamPrompt } from "./queue-team.js";
+// Un solo proprietario dei messaggi: restano modificabili fino al prelievo
+// atomico del turno. La schermata di gestione sospende entrambi i percorsi.
+export class PromptQueue {
+    prepare;
+    onChange;
+    persistence;
+    entries = [];
+    storageError = "";
+    storageReadable = true;
+    delivered = new Map();
+    immediateListeners = new Set();
+    pausing = false;
+    holding = false;
+    inbox;
+    constructor(prepare = text => [{ type: "text", text }], onChange = () => { }, persistence, restoreInput = entry => entry) {
+        this.prepare = prepare;
+        this.onChange = onChange;
+        this.persistence = persistence;
+        try {
+            const saved = persistence?.load();
+            if (saved) {
+                this.entries = saved.entries.map(restoreInput).map(e => ({ ...e,
+                    delivery: e.text.trimStart().startsWith("/") ? "after-turn" : e.delivery === "immediate" ? "during-turn" : e.delivery,
+                    teamBatchId: e.text.trimStart().startsWith("/") ? undefined : e.teamBatchId }));
+                this.pausing = this.entries.length > 0;
+                if (this.entries.length)
+                    this.persist();
+            }
+        }
+        catch (error) {
+            this.storageReadable = false;
+            this.storageError = `Ripristino coda non riuscito: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        const queue = this;
+        this.inbox = {
+            push(input, id) {
+                const parts = typeof input === "string" ? queue.prepare(input) : input;
+                return queue.add(pendingText({ id: "", parts, queuedAt: 0 }), "during-turn", parts, id).id;
+            },
+            promote: id => queue.moveFirst(id),
+            get pending() { return queue.entries.filter(e => queue.ready(e)).length; },
+            onImmediate(listener) {
+                queue.immediateListeners.add(listener);
+                if (queue.immediatePending)
+                    listener();
+                return () => { queue.immediateListeners.delete(listener); };
+            },
+            drain() {
+                const ready = queue.entries.filter(e => queue.ready(e));
+                if (!ready.length)
+                    return [];
+                const messages = groupTeamPrompts(ready);
+                queue.entries = queue.entries.filter(e => !queue.ready(e));
+                for (const entry of messages)
+                    queue.delivered.set(entry.id, entry.text);
+                queue.changed();
+                return messages.map(entry => ({ ...entry, ...(entry.delivery === "immediate" ? { immediate: true } : {}) }));
+            },
+        };
+    }
+    get length() { return this.entries.length; }
+    get teamRequestCount() { return this.entries.filter(e => !e.text.trimStart().startsWith("/")).length; }
+    get blocked() { return this.paused || this.held; }
+    get paused() { return this.pausing; }
+    set paused(value) {
+        this.pausing = value;
+        if (value)
+            this.entries = this.entries.map(e => e.delivery === "immediate" ? { ...e, delivery: "during-turn" } : e);
+        this.changed();
+    }
+    get held() { return this.holding; }
+    set held(value) { this.holding = value; this.notifyImmediate(); }
+    get immediatePending() { return !this.held && this.entries.some(e => e.delivery === "immediate"); }
+    ready(entry) {
+        return !this.held && (entry.delivery === "immediate" || (!this.paused && entry.delivery === "during-turn"));
+    }
+    notifyImmediate() {
+        if (this.immediatePending)
+            for (const listener of this.immediateListeners)
+                listener();
+    }
+    items() { return this.entries; }
+    get(id) { return this.entries.find(e => e.id === id); }
+    persist() {
+        if (!this.storageReadable)
+            return;
+        try {
+            this.persistence?.save({ entries: this.entries, paused: this.paused });
+            this.storageError = "";
+        }
+        catch (error) {
+            this.storageError = `Coda non salvata: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    changed() { this.persist(); this.onChange(); }
+    add(text, delivery = "after-turn", parts = this.prepare(text), id) {
+        if (!text.trim())
+            throw new Error("Il messaggio non può essere vuoto.");
+        if (text.trimStart().startsWith("/"))
+            delivery = "after-turn";
+        const entry = { id: id ?? `queued-${randomUUID()}`, text, parts, delivery, queuedAt: Date.now() };
+        if (this.get(entry.id))
+            throw new Error("Messaggio già in coda.");
+        this.entries = [...this.entries, entry];
+        this.changed();
+        this.notifyImmediate();
+        return entry;
+    }
+    update(id, text) {
+        if (!this.get(id))
+            return false;
+        if (!text.trim())
+            throw new Error("Il messaggio non può essere vuoto. Usa Elimina per rimuoverlo.");
+        const parts = this.prepare(text);
+        this.entries = this.entries.map(e => e.id === id ? { ...e, text, parts,
+            teamBatchId: text.trimStart().startsWith("/") ? undefined : e.teamBatchId,
+            delivery: text.trimStart().startsWith("/") ? "after-turn" : e.delivery } : e);
+        this.changed();
+        return true;
+    }
+    remove(id) {
+        if (!this.get(id))
+            return false;
+        this.entries = this.entries.filter(e => e.id !== id);
+        this.changed();
+        return true;
+    }
+    move(id, offset) {
+        const from = this.entries.findIndex(e => e.id === id);
+        if (from < 0)
+            return false;
+        const to = Math.max(0, Math.min(this.entries.length - 1, from + offset));
+        const entries = [...this.entries];
+        const [entry] = entries.splice(from, 1);
+        entries.splice(to, 0, entry);
+        this.entries = entries;
+        this.changed();
+        return true;
+    }
+    moveFirst(id) { return this.move(id, -this.entries.length); }
+    setDelivery(id, delivery) {
+        const entry = this.get(id);
+        if (!entry || (delivery !== "after-turn" && entry.text.trimStart().startsWith("/")))
+            return false;
+        this.entries = this.entries.map(e => e.id === id ? { ...e, delivery, teamBatchId: undefined } : e);
+        this.changed();
+        this.notifyImmediate();
+        return true;
+    }
+    sendNow(id) {
+        if (!this.get(id) || this.get(id).text.trimStart().startsWith("/"))
+            return false;
+        this.moveFirst(id);
+        return this.setDelivery(id, "immediate");
+    }
+    sendToTeam() {
+        if (this.teamRequestCount < 3)
+            return false;
+        const teamBatchId = `team-${randomUUID()}`;
+        this.entries = this.entries.map(e => e.text.trimStart().startsWith("/") ? e
+            : { ...e, delivery: "immediate", teamBatchId });
+        this.changed();
+        this.notifyImmediate();
+        return true;
+    }
+    takeNext() {
+        if (this.held)
+            return undefined;
+        const first = this.entries.find(e => e.delivery === "immediate") ?? (!this.paused ? this.entries[0] : undefined);
+        if (!first)
+            return undefined;
+        const group = first.teamBatchId ? this.entries.filter(e => e.teamBatchId === first.teamBatchId) : [first];
+        const message = first.teamBatchId ? teamPrompt(group) : first;
+        const ids = new Set(group.map(e => e.id));
+        this.entries = this.entries.filter(e => !ids.has(e.id));
+        this.changed();
+        return message;
+    }
+    acknowledge(id) {
+        const text = this.delivered.get(id);
+        this.delivered.delete(id);
+        return text;
+    }
+}

package/dist/tui/provider-menu.d.ts

@@ -0,0 +1,33 @@
+import { type ProviderSpec } from "../providers/catalog.js";
+import type { ProviderRegistry } from "../providers/registry.js";
+export interface ProviderRow {
+    readonly id: string;
+    readonly label: string;
+    readonly kind: ProviderSpec["kind"];
+    readonly configured: boolean;
+    readonly active: boolean;
+    readonly needsKey: boolean;
+    readonly source: "env" | "saved" | "local" | null;
+    readonly modelCount: number;
+    readonly baseUrl: string | null;
+    readonly spec: ProviderSpec;
+}
+export declare function scopedEnvName(providerId: string, suffix: "API_KEY" | "BASE_URL"): string;
+export declare function providerRows(env: NodeJS.ProcessEnv, registry: ProviderRegistry, currentModel: string): readonly ProviderRow[];
+export declare function rowStatusLabel(row: ProviderRow): string;
+export declare function providerKeyHint(spec: ProviderSpec): string;
+export interface SaveOutcome {
+    readonly ok: boolean;
+    readonly error?: string;
+}
+export declare function saveProviderKey(env: NodeJS.ProcessEnv, providerId: string, apiKey: string): SaveOutcome;
+export declare function saveProviderBaseUrl(env: NodeJS.ProcessEnv, providerId: string, baseUrl: string): SaveOutcome;
+export declare function removeProvider(env: NodeJS.ProcessEnv, providerId: string): SaveOutcome;
+export declare function isRemovable(env: NodeJS.ProcessEnv, providerId: string): boolean;
+export type ProviderAction = "set-key" | "set-endpoint" | "oauth" | "remove" | "use-model" | "back";
+export interface ActionOption {
+    readonly action: ProviderAction;
+    readonly label: string;
+    readonly detail: string;
+}
+export declare function actionsFor(env: NodeJS.ProcessEnv, row: ProviderRow): readonly ActionOption[];

package/dist/tui/provider-menu.js

@@ -0,0 +1,175 @@
+// Logica del menu provider navigabile (/provider). Parte PURA, senza
+// dipendenze dalla TUI: calcola lo stato dei provider e incapsula le azioni di
+// persistenza (salva chiave, salva endpoint, rimuovi). La UI in repl.ts si
+// occupa solo di disegnare i picker e raccogliere l'input.
+//
+// Obiettivo UX: un solo punto da cui (1) vedere tutti i provider e il loro
+// stato, (2) configurarne uno con la chiave/endpoint in modo guidato, (3)
+// aggiungere un provider non ancora attivo, (4) rimuovere una credenziale.
+// Niente passaggi meccanici: ogni provider sa gia' che chiave vuole e dove.
+import { PROVIDER_CATALOG } from "../providers/catalog.js";
+import { saveCredential, deleteCredential, loadCredentials } from "../core/credentials.js";
+// Nome della variabile d'ambiente scoped, allineato a registry.ts/credentials.ts.
+export function scopedEnvName(providerId, suffix) {
+    const norm = providerId.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    return `TALOS_${norm}_${suffix}`;
+}
+function envValue(env, name) {
+    return String(env[name] ?? "").trim();
+}
+// Stabilisce come e' configurata la chiave di un provider, distinguendo una
+// variabile esportata "a mano" dall'utente da una credenziale salvata da noi.
+function keySource(env, spec, saved) {
+    if (!spec.envKey)
+        return "local"; // locale (Ollama): nessuna chiave
+    const scoped = scopedEnvName(spec.id, "API_KEY");
+    // Se la credenziale salvata e' stata applicata, compare nella scoped var: per
+    // distinguerla dalla env "vera" dell'utente guardiamo prima la envKey nuda e
+    // la scoped NON salvata.
+    const rawKey = envValue(env, spec.envKey);
+    if (rawKey)
+        return "env";
+    if (saved)
+        return "saved";
+    if (envValue(env, scoped))
+        return "env";
+    return null;
+}
+// Endpoint corrente del provider (override scoped, env dedicata, o baseUrl del
+// catalogo). Per i locali usa l'host configurato.
+function currentBaseUrl(env, spec) {
+    const scoped = envValue(env, scopedEnvName(spec.id, "BASE_URL"));
+    if (scoped)
+        return scoped;
+    if (spec.baseUrlEnv) {
+        const host = envValue(env, spec.baseUrlEnv);
+        if (host)
+            return /\/v\d+\/?$/.test(host) ? host.replace(/\/$/, "") : `${host.replace(/\/$/, "")}/v1`;
+        return spec.defaultBaseUrl ?? null;
+    }
+    return spec.baseUrl ?? null;
+}
+// Costruisce le righe di stato per TUTTI i provider del catalogo, segnando
+// quale e' attivo per il modello corrente. L'ordine segue il catalogo, ma i
+// provider configurati vengono portati in cima per accesso rapido.
+export function providerRows(env, registry, currentModel) {
+    const resolved = registry.resolve(currentModel);
+    const activeId = resolved ? resolved.provider.id : null;
+    const saved = loadCredentials(env);
+    const rows = PROVIDER_CATALOG.map((spec) => {
+        const inRegistry = Boolean(registry.get(spec.id));
+        const needsKey = Boolean(spec.envKey);
+        const baseUrl = currentBaseUrl(env, spec);
+        const source = spec.optionalEndpoint && !baseUrl
+            ? null
+            : keySource(env, spec, Boolean(saved[spec.id]?.apiKey));
+        return {
+            id: spec.id,
+            label: spec.label,
+            kind: spec.kind,
+            configured: inRegistry,
+            active: spec.id === activeId,
+            needsKey,
+            source,
+            modelCount: spec.models.length,
+            baseUrl,
+            spec,
+        };
+    });
+    // Configurati prima (attivo in testa), poi i non configurati.
+    return [...rows].sort((a, b) => {
+        if (a.active !== b.active)
+            return a.active ? -1 : 1;
+        if (a.configured !== b.configured)
+            return a.configured ? -1 : 1;
+        return 0;
+    });
+}
+// Riepilogo di stato a una riga, da mostrare nel picker accanto al nome.
+export function rowStatusLabel(row) {
+    if (row.active)
+        return "attivo";
+    if (row.source === "local")
+        return "locale";
+    if (row.source === "env")
+        return "configurato (env)";
+    if (row.source === "saved")
+        return "configurato";
+    return "da configurare";
+}
+// Suggerimento d'aiuto per ottenere la chiave del provider.
+export function providerKeyHint(spec) {
+    switch (spec.id) {
+        case "openrouter":
+            return "ottieni la chiave su https://openrouter.ai/keys (sk-or-...) o usa il login OAuth";
+        case "anthropic":
+            return "ottieni la chiave su https://console.anthropic.com/settings/keys (sk-ant-...)";
+        case "openai":
+            return "ottieni la chiave su https://platform.openai.com/api-keys (sk-...)";
+        case "ollama":
+            return "provider locale: imposta solo l'endpoint (default http://localhost:11434/v1)";
+        case "lmstudio":
+            return "provider locale: avvia il server di LM Studio (default http://127.0.0.1:1234/v1)";
+        case "opensource":
+            return "collega l'endpoint /v1 di Unsloth, vLLM, llama.cpp o qualsiasi server OpenAI-compatible";
+        case "xai":
+            return "ottieni la chiave xAI per Grok su https://console.x.ai (XAI_API_KEY)";
+        default:
+            return spec.envKey ? `imposta la API key (variabile ${spec.envKey})` : "provider locale: nessuna chiave";
+    }
+}
+// Salva la API key di un provider sul file globale. Validazione di forma
+// minima; la validazione di rete (per OpenRouter) la fa il chiamante.
+export function saveProviderKey(env, providerId, apiKey) {
+    const key = apiKey.trim();
+    if (!key)
+        return { ok: false, error: "API key vuota" };
+    const ok = saveCredential(env, providerId, { apiKey: key });
+    return ok ? { ok: true } : { ok: false, error: "impossibile salvare (config globale disattivata?)" };
+}
+// Salva/aggiorna l'endpoint (baseUrl) di un provider. Una stringa vuota
+// rimuove l'override e ripristina il default del catalogo.
+export function saveProviderBaseUrl(env, providerId, baseUrl) {
+    const ok = saveCredential(env, providerId, { baseUrl: baseUrl.trim() });
+    return ok ? { ok: true } : { ok: false, error: "impossibile salvare l'endpoint" };
+}
+// Rimuove la credenziale salvata di un provider. Non tocca le env esportate
+// dall'utente (quelle hanno precedenza e restano).
+export function removeProvider(env, providerId) {
+    const ok = deleteCredential(env, providerId);
+    return ok ? { ok: true } : { ok: false, error: "impossibile rimuovere la credenziale" };
+}
+// Indica se la chiave di un provider e' stata salvata da noi (rimovibile dal
+// menu) o proviene da una env esportata dall'utente (non rimovibile dal menu).
+export function isRemovable(env, providerId) {
+    return Boolean(loadCredentials(env)[providerId]?.apiKey || loadCredentials(env)[providerId]?.baseUrl);
+}
+// Calcola le azioni disponibili per un provider, in base al suo stato. Niente
+// scelte inutili: un locale non mostra "imposta chiave", un provider senza
+// credenziale salvata non mostra "rimuovi".
+export function actionsFor(env, row) {
+    const out = [];
+    if (row.needsKey) {
+        out.push({
+            action: "set-key",
+            label: row.source === "saved" || row.source === "env" ? "aggiorna API key" : "imposta API key",
+            detail: providerKeyHint(row.spec),
+        });
+        if (row.id === "openrouter") {
+            out.push({ action: "oauth", label: "accedi con OAuth (browser)", detail: "autorizza su openrouter.ai senza incollare la chiave" });
+        }
+    }
+    out.push({
+        action: "set-endpoint",
+        label: "imposta endpoint (baseUrl)",
+        detail: row.baseUrl ? `attuale: ${row.baseUrl}` : "endpoint API personalizzato",
+    });
+    if (row.configured) {
+        out.push({ action: "use-model", label: "scegli un modello di questo provider", detail: "apre il picker dei modelli" });
+    }
+    if (isRemovable(env, row.id)) {
+        out.push({ action: "remove", label: "rimuovi credenziale salvata", detail: "elimina chiave/endpoint dal config" });
+    }
+    out.push({ action: "back", label: "← torna all'elenco", detail: "" });
+    return out;
+}

package/dist/tui/question.d.ts

@@ -0,0 +1,24 @@
+import type { TuiTheme } from "./branding.js";
+export declare function renderQuestion(question: string, theme: TuiTheme, columns: number): string;
+export interface QuestionChoiceOptions {
+    readonly title: string;
+    readonly options: readonly {
+        label: string;
+        detail: string;
+    }[];
+    readonly index: number;
+    readonly offset: number;
+    readonly columns: number;
+    readonly rows: number;
+    readonly theme: TuiTheme;
+}
+export declare function renderQuestionChoices(opts: QuestionChoiceOptions): {
+    lines: string[];
+    ranges: {
+        start: number;
+        end: number;
+    }[];
+    offset: number;
+    maxOffset: number;
+    pageSize: number;
+};

package/dist/tui/question.js

@@ -0,0 +1,32 @@
+import { fitLine, wrapText } from "./terminal-text.js";
+export function renderQuestion(question, theme, columns) {
+    return "\n" + wrapText(question, Math.max(2, columns - 5), true).map((line, index) => (index === 0 ? theme.accent("  ? ") : "    ") + theme.silver(line)).join("\n") + "\n";
+}
+// The question and choices share a scrollable body. A long title must never
+// push the choices or navigation beyond the visible terminal area.
+export function renderQuestionChoices(opts) {
+    const t = opts.theme;
+    const width = Math.max(4, opts.columns - 2);
+    const body = wrapText(opts.title, width - 2, true).map(line => " " + t.bold(line));
+    body.push("");
+    const ranges = opts.options.map((option, index) => {
+        const start = body.length;
+        const text = option.label + (option.detail ? ` · ${option.detail}` : "");
+        const rows = wrapText(text, width - 4, true);
+        for (const [part, line] of rows.entries()) {
+            const prefix = part ? "    " : `${index === opts.index ? "›" : " "} ${index + 1} `;
+            body.push(index === opts.index ? t.selected(prefix + line) : t.silver(prefix + line));
+        }
+        return { start, end: body.length };
+    });
+    const shortcuts = width >= 58 ? "↑↓ scegli · PgUp/PgDn scorri · Invio conferma · Esc annulla"
+        : "↑↓ scegli · PgUp/PgDn scorri · Invio · Esc";
+    const footer = wrapText(shortcuts, width, true).map(t.muted);
+    const pageSize = Math.max(1, opts.rows - footer.length - 1);
+    const maxOffset = Math.max(0, body.length - pageSize);
+    const offset = Math.max(0, Math.min(opts.offset, maxOffset));
+    const heading = t.bold("Domanda") + (maxOffset ? t.dim(` · ${offset + 1}–${Math.min(body.length, offset + pageSize)}/${body.length}`) : "");
+    const lines = [heading, ...body.slice(offset, offset + pageSize), ...footer]
+        .map(line => " " + fitLine(line, width));
+    return { lines, ranges, offset, maxOffset, pageSize };
+}

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

@@ -0,0 +1,25 @@
+import { PromptQueue, type QueuedPrompt } from "./prompt-queue.js";
+import type { ScreenKey, TerminalScreen } from "./terminal-screen.js";
+export interface QueueStyle {
+    readonly heading: (s: string) => string;
+    readonly muted: (s: string) => string;
+    readonly selected: (s: string) => string;
+    readonly text?: (s: string) => string;
+}
+export declare const PLAIN_QUEUE_STYLE: QueueStyle;
+export declare const deliveryLabel: (entry: QueuedPrompt) => string;
+export declare function queuePreview(queue: PromptQueue, width: number, style?: QueueStyle, idle?: boolean): readonly string[];
+export declare class QueueScreen implements TerminalScreen {
+    private readonly queue;
+    private readonly edit;
+    private readonly style;
+    private selectedId?;
+    private notice;
+    private detailOffset;
+    private detailPage;
+    constructor(queue: PromptQueue, edit: (id: string) => void, style?: QueueStyle);
+    private selected;
+    render(width: number, height: number): readonly string[];
+    key(text: string, key: ScreenKey): "close" | void;
+    scroll(delta: number): void;
+}

package/dist/tui/queue-screen.js

@@ -0,0 +1,152 @@
+import { PromptQueue } from "./prompt-queue.js";
+import { tr } from "./i18n.js";
+import { fitLine, oneLine, terminalWidth, wrapText } from "./terminal-text.js";
+export const PLAIN_QUEUE_STYLE = { heading: s => s, muted: s => s, selected: s => s };
+export const deliveryLabel = (entry) => (entry.teamBatchId ? tr("al team · ", "to team · ") : "")
+    + (entry.delivery === "immediate" ? tr("invio immediato · attendo operazione", "send now · waiting for operation")
+        : entry.delivery === "during-turn" ? tr("durante il lavoro", "during work") : tr("dopo la risposta", "after response"));
+export function queuePreview(queue, width, style = PLAIN_QUEUE_STYLE, idle = false) {
+    if (!queue.length)
+        return queue.storageError ? [fitLine(`  ${queue.storageError}`, width - 1)] : [];
+    const next = queue.items().find(entry => entry.delivery === "immediate")
+        ?? (!idle && !queue.paused ? queue.items().find(entry => entry.delivery === "during-turn") : undefined)
+        ?? queue.items()[0];
+    const immediate = next.delivery === "immediate";
+    const paused = queue.paused && !immediate;
+    const mode = immediate ? next.teamBatchId ? tr("in invio al team", "sending to team") : tr("in invio", "sending")
+        : paused ? tr("in pausa", "paused") : next.delivery === "during-turn" ? tr("dopo la risposta o l'operazione", "after response or operation") : tr("dopo la risposta", "after response");
+    const noun = queue.length === 1 ? tr("Messaggio", "Message") : `${queue.length} ${tr("messaggi", "messages")}`;
+    const full = `${noun} ${mode}`;
+    const shortMode = immediate ? next.teamBatchId ? tr("invio al team", "to team") : tr("invio", "sending") : paused ? tr("pausa", "paused")
+        : next.delivery === "during-turn" ? tr("dopo risposta/operazione", "after response/tool") : tr("dopo risposta", "after response");
+    const short = queue.length === 1 ? `${noun} · ${shortMode}` : `${queue.length} · ${shortMode}`;
+    const keys = [paused && idle ? tr("Invio riprende", "Enter resume") : !immediate && !next.text.trimStart().startsWith("/") ? tr("Alt+S subito", "Alt+S send now") : "",
+        "Alt+Q", queue.teamRequestCount >= 3 ? "Alt+T team" : ""].filter(Boolean);
+    const max = Math.max(0, width - 1);
+    let hint = ` (${keys.join(" · ")})`;
+    const label = terminalWidth(`  • ${full}${hint}`) <= max ? full : short;
+    while (keys.length > 1 && terminalWidth(`  • ${label}${hint}`) > max) {
+        keys.splice(keys.findIndex(key => key !== "Alt+Q"), 1);
+        hint = ` (${keys.join(" · ")})`;
+    }
+    const title = fitLine(`  • ${label}`, max - terminalWidth(hint));
+    const rows = [(style.text ?? style.muted)(title) + style.muted(hint),
+        style.muted(fitLine(`    ↳ ${oneLine(next.text)}`, max))];
+    if (queue.storageError)
+        rows.push(queue.storageError);
+    return rows.map(row => fitLine(row, width - 1));
+}
+export class QueueScreen {
+    queue;
+    edit;
+    style;
+    selectedId;
+    notice = "";
+    detailOffset = 0;
+    detailPage = 3;
+    constructor(queue, edit, style = PLAIN_QUEUE_STYLE) {
+        this.queue = queue;
+        this.edit = edit;
+        this.style = style;
+    }
+    selected() {
+        const entry = (this.selectedId && this.queue.get(this.selectedId)) || this.queue.items()[0];
+        this.selectedId = entry?.id;
+        return entry;
+    }
+    render(width, height) {
+        const w = Math.max(1, width - 2), h = Math.max(1, height);
+        const t = this.style;
+        const selected = this.selected();
+        const items = this.queue.items();
+        const head = [t.heading(`${tr("Messaggi in coda", "Queued messages")} · ${items.length}${this.queue.paused ? tr(" · pausa", " · paused") : ""}`),
+            t.muted(tr("La consegna resta sospesa finché questa schermata è aperta.", "Delivery is paused while this screen is open."))];
+        const help = [tr("↑↓ scegli · Invio modifica · Canc elimina · Shift+↑↓ riordina", "↑↓ select · Enter edit · Del remove · Shift+↑↓ reorder"),
+            tr("s Invia subito · t cambia momento · p pausa/riprendi · Esc chat", "s Send now · t timing · p pause/resume · Esc chat")];
+        if (this.queue.teamRequestCount >= 3)
+            help.push(tr("g / Alt+T · Invia al team le {count} richieste", "g / Alt+T · Send {count} requests to team", { count: this.queue.teamRequestCount }));
+        const body = [];
+        if (!selected)
+            body.push(tr("Nessun messaggio in attesa.", "No queued messages."));
+        else {
+            const index = items.indexOf(selected);
+            const cap = Math.max(1, Math.min(6, Math.floor((h - 9) / 2)));
+            const start = Math.max(0, Math.min(index - Math.floor(cap / 2), items.length - cap));
+            for (const [offset, entry] of items.slice(start, start + cap).entries()) {
+                const label = fitLine(`${entry.id === selected.id ? "›" : " "} ${start + offset + 1}. ${oneLine(entry.text)}`, w);
+                body.push(entry.id === selected.id ? t.selected(label) : label);
+                body.push(t.muted(`   ${deliveryLabel(entry)}`));
+            }
+            const detail = wrapText(selected.text, w, true);
+            this.detailPage = Math.max(1, h - head.length - help.length - body.length - 4);
+            this.detailOffset = Math.max(0, Math.min(this.detailOffset, detail.length - this.detailPage));
+            body.push("", t.heading(`${tr("Testo", "Text")} · ${this.detailOffset + 1}–${Math.min(detail.length, this.detailOffset + this.detailPage)}/${detail.length} · ${tr("PgSu/PgGiù scorri", "PgUp/PgDn scroll")}`));
+            body.push(...detail.slice(this.detailOffset, this.detailOffset + this.detailPage));
+        }
+        const note = this.notice || this.queue.storageError || (selected?.delivery === "immediate"
+            ? tr("Invia subito interrompe la risposta; un'operazione già avviata termina prima.", "Send now interrupts the response; a running operation finishes first.")
+            : selected?.delivery === "during-turn"
+                ? tr("Durante il lavoro: dopo la risposta o l'operazione corrente.", "During work: after the current response or operation.")
+                : tr("Dopo la risposta: un nuovo turno, in ordine di coda.", "After response: a new turn, in queue order."));
+        const footer = [t.muted(note), ...help.map(t.muted)];
+        const room = Math.max(0, h - head.length - footer.length - 1);
+        const rows = [...head, "", ...body.slice(0, room)];
+        while (rows.length < h - footer.length)
+            rows.push("");
+        return [...rows, ...footer].slice(0, h).map(row => " " + fitLine(row, w));
+    }
+    key(text, key) {
+        if (key.name === "escape" || (key.ctrl && key.name === "c") || (key.meta && key.name === "q"))
+            return "close";
+        this.notice = "";
+        if (text === "g" || (key.meta && key.name === "t")) {
+            if (this.queue.sendToTeam())
+                return "close";
+            this.notice = tr("Invia al team richiede almeno 3 richieste in coda; i comandi sono esclusi.", "Send to team requires at least 3 queued requests, excluding commands.");
+            return;
+        }
+        const entry = this.selected();
+        if (text === "p") {
+            this.queue.paused = !this.queue.paused;
+            return;
+        }
+        if (!entry)
+            return;
+        if (key.name === "pageup" || key.name === "pagedown") {
+            this.detailOffset = Math.max(0, this.detailOffset + (key.name === "pageup" ? -this.detailPage : this.detailPage));
+            return;
+        }
+        if (key.name === "up" || key.name === "down") {
+            const offset = key.name === "up" ? -1 : 1;
+            if (key.shift)
+                this.queue.move(entry.id, offset);
+            else
+                this.scroll(offset);
+        }
+        else if ((key.name === "return" && key.meta) || text === "s") {
+            if (this.queue.sendNow(entry.id))
+                return "close";
+            this.notice = tr("I comandi vengono eseguiti dopo la risposta.", "Commands run after the response.");
+        }
+        else if (key.name === "return" || text === "e")
+            this.edit(entry.id);
+        else if (key.name === "delete" || text === "d") {
+            const index = this.queue.items().indexOf(entry);
+            this.queue.remove(entry.id);
+            this.selectedId = this.queue.items()[Math.min(index, this.queue.length - 1)]?.id;
+        }
+        else if (text === "t") {
+            if (!this.queue.setDelivery(entry.id, entry.delivery === "after-turn" ? "during-turn" : "after-turn")) {
+                this.notice = tr("I comandi vengono eseguiti dopo la risposta.", "Commands run after the response.");
+            }
+        }
+    }
+    scroll(delta) {
+        const items = this.queue.items();
+        const selected = this.selected();
+        if (!selected)
+            return;
+        this.selectedId = items[Math.max(0, Math.min(items.length - 1, items.indexOf(selected) + delta))]?.id;
+        this.detailOffset = 0;
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { QueuedPrompt } from "./prompt-queue.js";
+export declare function teamPrompt(entries: readonly QueuedPrompt[]): QueuedPrompt;
+export declare function groupTeamPrompts(entries: readonly QueuedPrompt[]): readonly QueuedPrompt[];

package/dist/tui/queue-team.js

@@ -0,0 +1,28 @@
+// Le richieste restano separate e modificabili nella coda. Il messaggio unico
+// viene costruito soltanto alla consegna, usando testo espanso e allegati salvati.
+export function teamPrompt(entries) {
+    const first = entries[0];
+    const heading = `Ingaggia il team e implementa tutte le ${entries.length} richieste in coda.`;
+    const parts = [{ type: "text", text: heading + "\n"
+                + "Organizza i collaboratori con team_engage, oppure assegna questi incarichi al team già attivo con team_say. "
+                + "Distribuisci le attività indipendenti in parallelo, includendo il testo completo e gli allegati pertinenti. "
+                + "Rispetta l'ordine quando ci sono dipendenze e coordina le modifiche agli stessi file. "
+                + "Porta avanti anche il lavoro già in corso. Segui ogni richiesta fino all'implementazione, "
+                + "raccogli i risultati, integrali e verifica il risultato complessivo. "
+                + "Nella risposta finale rendi conto di tutte le richieste e di eventuali blocchi concreti." }];
+    for (const [index, entry] of entries.entries()) {
+        parts.push({ type: "text", text: `\nRichiesta ${index + 1} di ${entries.length}` }, ...entry.parts);
+    }
+    return { ...first, parts, text: [heading, ...entries.map((entry, index) => `Richiesta ${index + 1} di ${entries.length}\n${entry.text}`)].join("\n\n") };
+}
+export function groupTeamPrompts(entries) {
+    const seen = new Set();
+    return entries.flatMap(entry => {
+        if (!entry.teamBatchId)
+            return [entry];
+        if (seen.has(entry.teamBatchId))
+            return [];
+        seen.add(entry.teamBatchId);
+        return [teamPrompt(entries.filter(item => item.teamBatchId === entry.teamBatchId))];
+    });
+}