@vascend/talos 0.1.0

package/dist/tui/restore-queued-input.d.ts

@@ -0,0 +1,3 @@
+import { type ImageRegistry } from "./image-attachments.js";
+import type { QueuedPrompt } from "./prompt-queue.js";
+export declare function restoreQueuedInput(entry: QueuedPrompt, images: ImageRegistry): QueuedPrompt;

package/dist/tui/restore-queued-input.js

@@ -0,0 +1,20 @@
+import { pendingText } from "../core/user-inbox.js";
+import { findImageRefs } from "./image-attachments.js";
+import { IMAGE_REF } from "./attachment-refs.js";
+// Il testo espanso e i byte sono salvati insieme alla coda: un riavvio non
+// dipende dai registri in memoria o dall'esistenza del file immagine originale.
+export function restoreQueuedInput(entry, images) {
+    const oldRefs = findImageRefs(entry.text);
+    const replacements = new Map();
+    const extra = [];
+    const restoredImages = entry.parts.filter(part => part.type === "image").map((part, index) => {
+        const restored = images.addData(Buffer.from(part.data, "base64"), part.mime, "ripristinata dalla coda");
+        if (oldRefs[index] !== undefined)
+            replacements.set(oldRefs[index], restored.ref);
+        else
+            extra.push(restored.ref);
+        return { ...part, source: restored.ref };
+    });
+    const text = [pendingText(entry).replace(new RegExp(IMAGE_REF, "gi"), (ref, id) => replacements.get(Number(id)) ?? ref), ...extra].join(" ");
+    return { ...entry, text, parts: [{ type: "text", text }, ...restoredImages] };
+}

package/dist/tui/review-detail.d.ts

@@ -0,0 +1,6 @@
+import type { TuiTheme } from "./branding.js";
+import type { ReviewEntry } from "./review-store.js";
+export type DetailTab = "output" | "input" | "diff" | "before" | "after";
+export declare const DETAIL_LABELS: Readonly<Record<DetailTab, string>>;
+export declare function detailTabs(entry: ReviewEntry): readonly DetailTab[];
+export declare function detailLines(entry: ReviewEntry, tab: DetailTab, width: number, t: TuiTheme): readonly string[];

package/dist/tui/review-detail.js

@@ -0,0 +1,56 @@
+import { renderDiff } from "./diff.js";
+import { padLine, plainText, wrapText } from "./terminal-text.js";
+import { commandSource, highlightCommand } from "./command-transcript.js";
+export const DETAIL_LABELS = {
+    output: "Risultato", input: "Parametri", diff: "Confronto", before: "Prima", after: "Dopo",
+};
+export function detailTabs(entry) {
+    return ["output", ...(entry.input ? ["input"] : []),
+        ...(entry.change ? ["diff", "before", "after"] : [])];
+}
+export function detailLines(entry, tab, width, t) {
+    if (tab === "diff") {
+        const change = entry.change;
+        if (!change)
+            return [t.muted("Nessuna modifica associata.")];
+        const note = change.scope === "fragment" ? "Frammento" : change.scope === "append" ? "Aggiunta"
+            : change.scope === "reported" ? "Frammento segnalato" : "Confronto";
+        if (change.before === undefined && change.scope !== "append") {
+            return [...wrapText("Versione precedente non disponibile.", width).map(t.muted), ...numbered(change.after, width, t)];
+        }
+        const before = plainText(change.before ?? "");
+        const after = plainText(change.after);
+        const diff = renderDiff(before, after, t, { columns: width, context: 2, path: entry.target, wrapLines: true });
+        if (!diff)
+            return [t.muted("Nessuna differenza.")];
+        const rows = diff.trimEnd().split("\n").slice(1);
+        const counts = /\+\d+ −\d+/.exec(plainText(rows[0] ?? ""))?.[0] ?? "";
+        return [t.muted(`${note} · ${counts}`), ...rows.slice(1)];
+    }
+    let body;
+    if (tab === "input" && entry.input && entry.tool) {
+        const source = commandSource({ name: entry.tool, input: entry.input });
+        if (source !== undefined) {
+            const args = entry.tool === "execute" && entry.input["mode"] === "call" || entry.tool === "tool_invoke"
+                ? entry.input["args"] : entry.input;
+            const settings = Object.fromEntries(Object.entries(args ?? {}).filter(([key]) => !["command", "code"].includes(key)));
+            return [...numbered(source, width, t, true),
+                ...(Object.keys(settings).length ? ["", t.muted("Parametri"), ...numbered(JSON.stringify(settings, null, 2), width, t)] : [])];
+        }
+    }
+    if (tab === "input")
+        body = JSON.stringify(entry.input ?? {}, null, 2);
+    else if (tab === "before")
+        body = entry.change?.before ?? "Versione precedente non disponibile per questa operazione.";
+    else if (tab === "after")
+        body = entry.change?.after ?? "";
+    else
+        body = entry.output ?? (entry.state === "running" ? "Operazione in corso. Il risultato apparirà qui appena disponibile."
+            : entry.state === "stopped" ? "Nessun risultato ricevuto prima della fine del turno." : "Nessun output testuale.");
+    return numbered(body || "(vuoto)", width, t);
+}
+function numbered(body, width, t, code = false) {
+    const source = plainText(body).split("\n");
+    const gutter = String(source.length).length;
+    return source.flatMap((line, index) => wrapText(line, Math.max(2, width - gutter - 3)).map((row, part) => t.dim(padLine(part ? "" : String(index + 1), gutter) + " │ ") + (code ? highlightCommand(row, t) : row)));
+}

package/dist/tui/review-files.d.ts

@@ -0,0 +1,3 @@
+import type { ReviewEntry, ReviewStore } from "./review-store.js";
+export declare function fileChanges(store: ReviewStore, target: string): readonly ReviewEntry[];
+export declare function fileEntries(store: ReviewStore): readonly ReviewEntry[];

package/dist/tui/review-files.js

@@ -0,0 +1,22 @@
+export function fileChanges(store, target) {
+    return store.entries().filter(e => e.target === target && (e.change || e.kind === "file"));
+}
+// Una voce stabile per file, senza fondere frammenti diversi in un falso diff completo.
+export function fileEntries(store) {
+    const groups = new Map();
+    for (const entry of store.entries()) {
+        if (!entry.change && entry.kind !== "file")
+            continue;
+        const entries = groups.get(entry.target) ?? [];
+        entries.push(entry);
+        groups.set(entry.target, entries);
+    }
+    return [...groups].map(([target, entries]) => {
+        const latest = entries.at(-1);
+        const count = entries.length;
+        return { id: `file:${target}`, kind: "file", title: `${count} ${count === 1 ? "modifica" : "modifiche"}`,
+            target, actor: [...new Set(entries.map(e => e.actor))].join(", "),
+            state: entries.some(e => e.state === "running") ? "running" : latest.state,
+            output: entries.map(e => `${e.title}\n${e.output ?? ""}`).join("\n") };
+    });
+}

package/dist/tui/review-render.d.ts

@@ -0,0 +1,22 @@
+import type { TuiTheme } from "./branding.js";
+import type { ReviewEntry, ReviewState, ReviewStore } from "./review-store.js";
+export interface ReviewContext {
+    readonly cwd: string;
+    readonly model: string;
+    readonly permissions: string;
+    readonly sessionId: string;
+    readonly usage?: string;
+    readonly context?: string;
+    readonly plan?: string;
+}
+export declare const REVIEW_TABS: readonly ["Riepilogo", "Attività", "Modifiche", "Team", "Problemi"];
+export declare const STATE_LABELS: Readonly<Record<ReviewState, string>>;
+export declare function stateMark(state: ReviewState, t: TuiTheme): string;
+export declare function duration(entry: ReviewEntry): string;
+export declare function reviewTabs(tab: number, width: number, t: TuiTheme, navigating?: boolean): string;
+export declare function reviewNextStep(store: ReviewStore): {
+    tab: number;
+    label: string;
+};
+export declare function overview(store: ReviewStore, context: ReviewContext, width: number, t: TuiTheme, expanded?: boolean): readonly string[];
+export declare function entryRows(entry: ReviewEntry, selected: boolean, width: number, t: TuiTheme): readonly string[];

package/dist/tui/review-render.js

@@ -0,0 +1,98 @@
+import { teamEntries } from "./review-team.js";
+import { fitLine, oneLine, padLine, terminalWidth, wrapText } from "./terminal-text.js";
+export const REVIEW_TABS = ["Riepilogo", "Attività", "Modifiche", "Team", "Problemi"];
+export const STATE_LABELS = {
+    running: "in corso", ok: "riuscita", error: "errore", stopped: "interrotta", info: "nota",
+};
+export function stateMark(state, t) {
+    return state === "running" ? t.accent("◌") : state === "ok" ? t.green("✓")
+        : state === "error" ? t.red("×") : state === "stopped" ? t.yellow("–") : t.muted("·");
+}
+export function duration(entry) {
+    if (!entry.startedAt)
+        return "";
+    const end = entry.endedAt ?? (entry.state === "running" ? Date.now() : entry.startedAt);
+    const seconds = Math.max(0, Math.floor((end - entry.startedAt) / 1000));
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+export function reviewTabs(tab, width, t, navigating = true) {
+    if (!navigating)
+        return t.muted(REVIEW_TABS[tab] + " / ") + t.bold("Dettaglio");
+    const full = REVIEW_TABS.map((label, i) => i === tab
+        ? t.accent(`\x1b[7m${i + 1} ${label}\x1b[27m`) : t.muted(`${i + 1} ${label}`)).join(" ");
+    if (terminalWidth(full) <= width)
+        return full;
+    return t.accent(`${tab + 1} ${REVIEW_TABS[tab]}`) + t.dim("   ← → sezioni");
+}
+export function reviewNextStep(store) {
+    const entries = store.entries();
+    if (entries.some(e => e.state === "error" || e.state === "stopped"))
+        return { tab: 4, label: "Esamina i problemi" };
+    if (entries.some(e => e.change || e.kind === "file"))
+        return { tab: 2, label: "Controlla le modifiche" };
+    return { tab: 1, label: "Esplora le attività" };
+}
+export function overview(store, context, width, t, expanded = false) {
+    const entries = store.entries();
+    const tools = entries.filter(e => e.kind === "tool");
+    const active = tools.filter(e => e.state === "running");
+    const failed = entries.filter(e => e.state === "error" || e.state === "stopped");
+    const changed = entries.filter(e => e.change || e.kind === "file");
+    const done = tools.filter(e => e.state === "ok").length;
+    const files = new Set(changed.map(e => e.target)).size;
+    const metrics = [`${tools.length} operazioni`, `${done} ok`, `${files} file`, `${failed.length} da esaminare`];
+    const rows = wrapText(metrics.join(" · "), width).map(t.bold);
+    const field = (label, value, full = expanded) => {
+        const prefix = t.muted(padLine(label, 10));
+        const body = full ? wrapText(value, Math.max(2, width - 10)) : [oneLine(value)];
+        body.forEach((line, i) => rows.push(fitLine((i ? " ".repeat(10) : prefix) + line, width)));
+    };
+    field("Stato", store.label);
+    if (entries.length) {
+        rows.push("");
+        rows.push(t.accent(reviewNextStep(store).label));
+        if (failed.length)
+            rows.push(...wrapText("Apri Problemi per leggere gli errori e le operazioni interrotte.", width).map(t.muted));
+        else if (files)
+            rows.push(...wrapText("Apri Modifiche per confrontare il contenuto prima e dopo.", width).map(t.muted));
+        rows.push("");
+    }
+    const agents = teamEntries(store);
+    if (agents.length)
+        field("Team", `${agents.length} collaboratori · ${agents.filter(e => e.state === "running").length} attivi · 4 Team per seguire ciascuno`);
+    if (active.length) {
+        for (const e of active.slice(0, 2))
+            rows.push(fitLine(stateMark(e.state, t) + ` ${e.title}  ` + t.muted(oneLine(e.target)), width));
+        if (active.length > 2)
+            rows.push(t.dim(`+${active.length - 2} in corso · 2 Attività`));
+    }
+    if (store.goal) {
+        field("Obiettivo", store.goal);
+    }
+    if (context.plan)
+        field("Piano", context.plan);
+    if (expanded) {
+        rows.push("");
+        field("Progetto", context.cwd);
+        field("Modello", context.model + ` · ${context.permissions}`);
+        field("Sessione", context.sessionId, true);
+        if (context.usage)
+            field("Consumi", context.usage, true);
+        if (context.context)
+            field("Contesto", context.context, true);
+    }
+    if (!entries.length)
+        rows.push(...wrapText("Nessuna attività da esaminare. Le operazioni compariranno qui durante il lavoro.", width).map(t.muted));
+    return rows;
+}
+export function entryRows(entry, selected, width, t) {
+    const lead = selected ? t.accent("▸") : " ";
+    const titleWidth = width >= 70 ? 13 : width >= 45 ? 9 : 0;
+    const title = titleWidth ? padLine(fitLine(selected ? t.bold(entry.title) : entry.title, titleWidth), titleWidth) + " " : "";
+    const prefix = lead + " " + stateMark(entry.state, t) + " " + title;
+    const meta = [entry.actor !== "Talos" && width >= 70 ? oneLine(entry.actor) : "", width >= 55 ? duration(entry) : ""].filter(Boolean).join(" · ");
+    const suffix = meta ? " " + t.muted(fitLine(meta, Math.min(22, Math.floor(width / 4)))) : "";
+    const targetWidth = Math.max(1, width - terminalWidth(prefix) - terminalWidth(suffix));
+    const target = oneLine(entry.target) || entry.title;
+    return [fitLine(prefix + padLine(selected ? t.bold(target) : t.muted(target), targetWidth) + suffix, width)];
+}

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

@@ -0,0 +1,38 @@
+import type { TuiTheme } from "./branding.js";
+import { type ReviewContext } from "./review-render.js";
+import { ReviewStore } from "./review-store.js";
+import type { ScreenKey, TerminalScreen } from "./terminal-screen.js";
+export declare function reviewSection(value?: string): number;
+export declare class ReviewScreen implements TerminalScreen {
+    private readonly store;
+    private readonly theme;
+    private readonly context;
+    private tab;
+    private actor?;
+    private actorFilter;
+    private teamPosition?;
+    private file?;
+    private filePosition?;
+    private backToFiles;
+    private resetMatching;
+    private backToTeam;
+    private selectedId?;
+    private detailId?;
+    private detailTab;
+    private offset;
+    private listOffset;
+    private query;
+    private searching;
+    private expandedOverview;
+    private pageSize;
+    private maxOffset;
+    private matching;
+    private detailCache;
+    constructor(store: ReviewStore, theme: () => TuiTheme, context: () => ReviewContext, section?: string);
+    private entries;
+    render(width: number, height: number): readonly string[];
+    key(text: string, key: ScreenKey): "close" | void;
+    scroll(delta: number): void;
+    paste(text: string): void;
+}
+export declare function reviewText(store: ReviewStore, context: ReviewContext, theme: TuiTheme, width: number, section?: string): string;

package/dist/tui/review-screen.js

@@ -0,0 +1,358 @@
+import { DETAIL_LABELS, detailLines, detailTabs } from "./review-detail.js";
+import { entryRows, overview, reviewNextStep, reviewTabs, STATE_LABELS, stateMark } from "./review-render.js";
+import { ReviewStore } from "./review-store.js";
+import { teamEntries } from "./review-team.js";
+import { fileChanges, fileEntries } from "./review-files.js";
+import { fitLine, oneLine, terminalWidth, wrapText } from "./terminal-text.js";
+export function reviewSection(value = "") {
+    const names = { attivita: 1, "attività": 1, activity: 1,
+        modifiche: 2, files: 2, file: 2, team: 3, problemi: 4, errors: 4 };
+    return names[value.toLowerCase()] ?? 0;
+}
+export class ReviewScreen {
+    store;
+    theme;
+    context;
+    tab;
+    actor;
+    actorFilter = "tutti";
+    teamPosition;
+    file;
+    filePosition;
+    backToFiles() {
+        this.file = undefined;
+        this.selectedId = this.filePosition?.selectedId;
+        this.query = this.filePosition?.query ?? "";
+        this.listOffset = this.filePosition?.listOffset ?? 0;
+        this.offset = 0;
+        this.resetMatching();
+    }
+    resetMatching() { this.matching = undefined; }
+    backToTeam() {
+        this.actor = undefined;
+        this.actorFilter = "tutti";
+        this.selectedId = this.teamPosition?.selectedId;
+        this.query = this.teamPosition?.query ?? "";
+        this.listOffset = this.teamPosition?.listOffset ?? 0;
+        this.offset = 0;
+        this.resetMatching();
+    }
+    selectedId;
+    detailId;
+    detailTab = "output";
+    offset = 0;
+    listOffset = 0;
+    query = "";
+    searching = false;
+    expandedOverview = false;
+    pageSize = 8;
+    maxOffset = 0;
+    matching;
+    detailCache;
+    constructor(store, theme, context, section = "") {
+        this.store = store;
+        this.theme = theme;
+        this.context = context;
+        this.tab = reviewSection(section);
+    }
+    entries() {
+        if (this.matching?.revision === this.store.revision && this.matching.tab === this.tab && this.matching.query === this.query)
+            return this.matching.entries;
+        const query = this.query.toLocaleLowerCase();
+        const source = this.tab === 3 && !this.actor ? teamEntries(this.store)
+            : this.tab === 2 ? this.file ? [...fileChanges(this.store, this.file)].reverse().map((e, i, all) => ({ ...e, title: `Modifica ${all.length - i}/${all.length}` })) : fileEntries(this.store)
+                : this.store.entries();
+        const entries = source.filter(e => {
+            if (this.actor && e.actor !== this.actor)
+                return false;
+            if (this.actor && this.actorFilter === "attivi" && e.state !== "running")
+                return false;
+            if (this.actor && this.actorFilter === "problemi" && e.state !== "error" && e.state !== "stopped")
+                return false;
+            if (this.actor && this.actorFilter === "file" && !e.change && e.kind !== "file")
+                return false;
+            if (this.tab === 2 && !e.change && e.kind !== "file")
+                return false;
+            if (this.tab === 3 && e.actor === "Talos" && e.kind !== "team")
+                return false;
+            if (this.tab === 4 && e.state !== "error" && e.state !== "stopped")
+                return false;
+            return !query || `${e.title}\n${e.target}\n${e.actor}\n${e.output ?? ""}`.toLocaleLowerCase().includes(query);
+        });
+        this.matching = { revision: this.store.revision, tab: this.tab, query: this.query, entries };
+        return entries;
+    }
+    render(width, height) {
+        const t = this.theme();
+        const w = Math.max(4, width - 3);
+        const h = Math.max(1, height);
+        const margin = width >= 12 ? " " : "";
+        const tabs = reviewTabs(this.tab, w, t, !this.detailId);
+        const head = [t.bold("Revisione") + (this.store.running ? t.accent(" · in corso") : t.dim(" · " + oneLine(this.store.label))), tabs];
+        if (h >= 12)
+            head.push(t.dim(this.detailId ? "← → cambia dettaglio · ↑ ↓ scorri" : "← → cambia sezione · 1–5 accesso diretto"));
+        if (this.tab === 2 && !this.detailId) {
+            head.push(t.bold(this.file ? `Modifiche > ${oneLine(this.file)}` : `Scegli un file · ${fileEntries(this.store).length} file`));
+            if (this.file && h >= 12)
+                head.push(t.muted("Ultima modifica in cima · Invio confronto · Esc file"));
+        }
+        if (this.tab === 3 && !this.detailId) {
+            const agents = teamEntries(this.store);
+            const counts = `${agents.length} · ${agents.filter(e => e.state === "running").length} attivi · ${agents.filter(e => e.state === "error").length} errori`;
+            head.push(t.bold(this.actor ? `Team > ${oneLine(this.actor)}` : `Collaboratori · ${counts}`));
+            if (this.actor) {
+                const agent = agents.find(e => e.actor === this.actor);
+                head.push(t.muted(oneLine(agent?.output?.split("\n")[0] ?? "Incarico non disponibile")));
+                head.push(t.muted(`f filtro: ${this.actorFilter} · Esc team`));
+            }
+        }
+        let body = [];
+        const selected = this.detailId ? this.store.get(this.detailId) : undefined;
+        if (this.detailId && !selected) {
+            this.detailId = undefined;
+            this.offset = 0;
+        }
+        if (selected) {
+            const actor = selected.actor !== "Talos" && selected.actor !== selected.title ? ` [${selected.actor}]` : "";
+            head.push(stateMark(selected.state, t) + " " + t.bold(selected.title) + t.muted(actor + " · " + STATE_LABELS[selected.state]) +
+                (h < 16 ? t.muted(" · " + oneLine(selected.target)) : ""));
+            if (h >= 16)
+                head.push(...wrapText(oneLine(selected.target), w).slice(0, 2).map(t.muted));
+            const sections = detailTabs(selected).map(tab => tab === this.detailTab ? t.accent(`[${DETAIL_LABELS[tab]}]`) : t.muted(DETAIL_LABELS[tab])).join(" ");
+            head.push(terminalWidth(sections) <= w ? sections : t.accent(`[${DETAIL_LABELS[this.detailTab]}]`) + t.dim(" · Tab"));
+            const cache = this.detailCache;
+            if (!cache || cache.entry !== selected || cache.tab !== this.detailTab || cache.width !== w || cache.theme !== t) {
+                this.detailCache = { entry: selected, tab: this.detailTab, width: w, theme: t, lines: detailLines(selected, this.detailTab, w, t) };
+            }
+            body = this.detailCache.lines;
+        }
+        else if (this.tab === 0) {
+            body = overview(this.store, this.context(), w, t, this.expandedOverview);
+        }
+        else {
+            const entries = this.entries();
+            let index = entries.findIndex(e => e.id === this.selectedId);
+            if (index < 0) {
+                index = 0;
+                this.selectedId = entries[0]?.id;
+            }
+            if (this.tab === 3 && !this.actor && entries[index]) {
+                const info = entries[index].output?.split("\n") ?? [];
+                head.push(t.muted(oneLine(info[0] ?? "")));
+                head.push(t.muted(oneLine(info[4] ?? "")));
+            }
+            if (this.query || this.searching)
+                head.push(t.accent(`Cerca: ${this.query}${this.searching ? "▏" : ""}`) + t.dim(` · ${entries.length} risultati`));
+            if (h >= 16 && entries[index] && !(this.tab === 3 && !this.actor)) {
+                const entry = entries[index];
+                head.push(t.bold(entry.title) + t.muted(` · ${STATE_LABELS[entry.state]}`));
+                head.push(...wrapText(oneLine(entry.target) || entry.title, w).slice(0, 2).map(t.muted));
+            }
+            this.pageSize = Math.max(1, h - head.length - 1);
+            this.listOffset = Math.min(this.listOffset, Math.max(0, entries.length - this.pageSize));
+            if (index < this.listOffset)
+                this.listOffset = index;
+            if (index >= this.listOffset + this.pageSize)
+                this.listOffset = index - this.pageSize + 1;
+            body = entries.slice(this.listOffset, this.listOffset + this.pageSize).flatMap(entry => entryRows(entry, entry.id === this.selectedId, w, t));
+            if (!entries.length) {
+                const empty = this.query ? "Nessun risultato. Premi / per cambiare ricerca o Esc per azzerarla."
+                    : this.tab === 4 ? "Nessun problema registrato."
+                        : this.tab === 2 ? "Nessuna modifica registrata. I confronti compariranno qui dopo le modifiche ai file."
+                            : this.actor ? "Nessuna attività per questo filtro. Premi f per cambiare filtro o Esc per tornare al team."
+                                : this.tab === 3 ? "Nessun collaboratore registrato."
+                                    : "Nessuna attività registrata. Le operazioni compariranno qui durante il lavoro.";
+                body = wrapText(empty, w).map(t.muted);
+            }
+        }
+        const available = Math.max(1, h - head.length - 1);
+        if (selected || this.tab === 0)
+            this.pageSize = available;
+        this.maxOffset = Math.max(0, body.length - available);
+        this.offset = Math.min(this.offset, this.maxOffset);
+        const visible = body.slice(this.offset, this.offset + available);
+        const range = selected || this.tab === 0
+            ? `${body.length ? this.offset + 1 : 0}–${Math.min(this.offset + available, body.length)}/${body.length}`
+            : `${this.entries().length ? this.listOffset + 1 : 0}–${Math.min(this.listOffset + this.pageSize, this.entries().length)}/${this.entries().length}`;
+        const retention = this.store.evicted ? ` · ${this.store.evicted} esclusi` : "";
+        const hint = this.searching ? "Invio conferma · Esc cancella ricerca"
+            : selected ? "Esc elenco · Tab dettaglio · ↑↓ scorri"
+                : this.tab === 0 ? `Invio: ${reviewNextStep(this.store).label.toLocaleLowerCase()} · i ${this.expandedOverview ? "riduci" : "dettagli"} · Esc chat`
+                    : this.actor ? "Esc team · Invio apri · f filtro · / cerca"
+                        : this.tab === 3 ? "Esc chat · Invio agente · / cerca"
+                            : this.tab === 2 ? `↑↓ seleziona · Invio ${this.file ? "confronto" : "file"} · / cerca · Esc ${this.query ? "azzera" : this.file ? "file" : "chat"}`
+                                : `↑↓ seleziona · Invio apri · / cerca · Esc ${this.query ? "azzera" : "chat"}`;
+        const back = this.searching ? "Esc annulla" : selected ? "Esc elenco" : this.query ? "Esc azzera" : this.actor ? "Esc team" : this.file ? "Esc file" : "Esc chat";
+        const compactHint = this.searching ? "Invio cerca · Esc annulla" : selected ? "Esc elenco · Tab · ↑↓"
+            : this.tab === 0 ? "Invio apri · i dettagli · Esc chat" : `↑↓ · Invio apri · / cerca · ${back}`;
+        const footer = [t.dim(terminalWidth(hint + "  " + range + retention) <= w
+                ? hint + "  " + range + retention : terminalWidth(compactHint) <= w ? compactHint : back)];
+        const rows = [...head, ...visible, ...Array.from({ length: Math.max(0, h - head.length - visible.length - footer.length) }, () => ""), ...footer];
+        // Nei terminali molto bassi conserviamo sempre la via d'uscita.
+        const fitted = rows.length > h ? [...rows.slice(0, Math.max(0, h - 1)), footer[0]] : rows;
+        return fitted.map(line => fitLine(margin + fitLine(line, w), Math.max(1, width - 1)));
+    }
+    key(text, key) {
+        if (key.ctrl && (key.name === "r" || key.name === "c" || key.name === "o"))
+            return "close";
+        if (text === "i" && !key.ctrl && !key.meta && this.tab === 0 && !this.detailId) {
+            this.expandedOverview = !this.expandedOverview;
+            this.offset = 0;
+            return;
+        }
+        if (this.searching) {
+            if (key.name === "escape") {
+                this.searching = false;
+                this.query = "";
+            }
+            else if (key.name === "return" || key.name === "enter")
+                this.searching = false;
+            else if (key.name === "backspace")
+                this.query = Array.from(this.query).slice(0, -1).join("");
+            else if (text && !key.ctrl && !key.meta)
+                this.query += text.replace(/[\x00-\x1f\x7f]/g, "");
+            this.selectedId = undefined;
+            this.listOffset = 0;
+            return;
+        }
+        if (key.name === "escape" || key.name === "backspace") {
+            if (this.detailId) {
+                this.detailId = undefined;
+                this.offset = 0;
+                return;
+            }
+            if (this.query) {
+                this.query = "";
+                this.listOffset = 0;
+                return;
+            }
+            if (this.actor) {
+                this.backToTeam();
+                return;
+            }
+            if (this.file) {
+                this.backToFiles();
+                return;
+            }
+            return "close";
+        }
+        if (this.tab === 0 && !this.detailId && (key.name === "return" || key.name === "enter")) {
+            this.tab = reviewNextStep(this.store).tab;
+            this.selectedId = undefined;
+            this.offset = 0;
+            this.listOffset = 0;
+            this.resetMatching();
+            return;
+        }
+        if (this.detailId && (key.name === "tab" || key.name === "left" || key.name === "right")) {
+            const e = this.store.get(this.detailId);
+            if (!e)
+                return;
+            const tabs = detailTabs(e);
+            const step = key.shift || key.name === "left" ? -1 : 1;
+            this.detailTab = tabs[(tabs.indexOf(this.detailTab) + step + tabs.length) % tabs.length];
+            this.offset = 0;
+            return;
+        }
+        if (text === "f" && this.actor && !this.detailId) {
+            const filters = ["tutti", "attivi", "problemi", "file"];
+            this.actorFilter = filters[(filters.indexOf(this.actorFilter) + 1) % filters.length];
+            this.selectedId = undefined;
+            this.listOffset = 0;
+            this.resetMatching();
+            return;
+        }
+        if (/^[1-5]$/.test(text) || (!this.detailId && ["tab", "left", "right"].includes(key.name ?? ""))) {
+            this.actor = undefined;
+            this.actorFilter = "tutti";
+            this.file = undefined;
+            this.resetMatching();
+            this.tab = /^[1-5]$/.test(text) ? Number(text) - 1 : (this.tab + (key.shift || key.name === "left" ? 4 : 1)) % 5;
+            this.detailId = undefined;
+            this.selectedId = undefined;
+            this.offset = 0;
+            this.listOffset = 0;
+            this.query = "";
+            return;
+        }
+        if (text === "/" && this.tab !== 0 && !this.detailId) {
+            this.searching = true;
+            return;
+        }
+        if ((key.name === "return" || key.name === "enter") && this.selectedId && !this.detailId) {
+            if (this.tab === 2 && !this.file) {
+                const entry = this.entries().find(e => e.id === this.selectedId);
+                if (!entry)
+                    return;
+                const changes = fileChanges(this.store, entry.target);
+                if (changes.length === 1) {
+                    this.detailId = changes[0].id;
+                    this.detailTab = changes[0].change ? "diff" : "output";
+                }
+                else {
+                    this.filePosition = { selectedId: this.selectedId, query: this.query, listOffset: this.listOffset };
+                    this.file = entry.target;
+                    this.query = "";
+                    this.selectedId = changes.at(-1)?.id;
+                    this.listOffset = 0;
+                    this.resetMatching();
+                }
+                this.offset = 0;
+                return;
+            }
+            if (this.tab === 3 && !this.actor) {
+                const entry = this.entries().find(e => e.id === this.selectedId);
+                if (!entry)
+                    return;
+                this.teamPosition = { selectedId: this.selectedId, query: this.query, listOffset: this.listOffset };
+                this.actor = entry.actor;
+                this.query = "";
+                this.selectedId = undefined;
+                this.listOffset = 0;
+                this.offset = 0;
+                this.resetMatching();
+                return;
+            }
+            this.detailId = this.selectedId;
+            this.detailTab = this.tab === 2 && this.store.get(this.detailId)?.change ? "diff" : "output";
+            this.offset = 0;
+            return;
+        }
+        const step = key.name === "pageup" ? -this.pageSize : key.name === "pagedown" ? this.pageSize
+            : key.name === "up" ? -1 : key.name === "down" ? 1 : key.name === "home" ? -Infinity : key.name === "end" ? Infinity : 0;
+        if (step)
+            this.scroll(step);
+    }
+    scroll(delta) {
+        if (this.detailId || this.tab === 0) {
+            this.offset = Math.max(0, Math.min(this.maxOffset, this.offset + delta));
+            return;
+        }
+        const entries = this.entries();
+        const i = Math.max(0, entries.findIndex(e => e.id === this.selectedId));
+        this.selectedId = entries[Math.max(0, Math.min(entries.length - 1, i + delta))]?.id;
+    }
+    paste(text) {
+        if (this.searching) {
+            this.query += oneLine(text);
+            this.selectedId = undefined;
+            this.listOffset = 0;
+        }
+    }
+}
+// Fallback leggibile su pipe/readline: nessuna scorciatoia interattiva finta.
+export function reviewText(store, context, theme, width, section = "") {
+    const entry = store.get(section);
+    if (entry)
+        return `\n${entry.title} · ${oneLine(entry.target)}\n` + detailLines(entry, "output", width - 4, theme).join("\n") + "\n";
+    const actor = section.startsWith("team ") ? section.slice(5) : undefined;
+    const tab = actor ? 3 : reviewSection(section);
+    if (tab === 3 && !actor)
+        return "\n" + (teamEntries(store).map(e => `${stateMark(e.state, theme)} ${oneLine(e.target)}\n${e.output}\n/review team ${e.actor}`).join("\n\n") || "Nessun collaboratore registrato.") + "\n";
+    if (actor)
+        return "\n" + store.entries().filter(e => e.actor === actor).map(e => `${stateMark(e.state, theme)} ${e.title} · ${oneLine(e.target)}\n/review ${e.id}`).join("\n") + "\n";
+    if (tab === 0)
+        return "\n" + overview(store, context, width - 4, theme, true).join("\n") + "\n/review attivita · /review modifiche · /review team · /review problemi\n";
+    const entries = store.entries().filter(e => tab === 2 ? e.change || e.kind === "file" : tab === 3 ? e.actor !== "Talos" || e.kind === "team" : tab === 4 ? e.state === "error" || e.state === "stopped" : true);
+    return "\n" + (entries.length ? entries.map(e => `${stateMark(e.state, theme)} ${e.title} · ${oneLine(e.target)}\n  /review ${e.id}`).join("\n") : "Nessun elemento registrato.") + "\n";
+}