@vascend/talos 0.1.0

package/dist/tui/clipboard-image.d.ts

@@ -0,0 +1,10 @@
+export type ClipboardImageResult = {
+    ok: true;
+    bytes: Buffer;
+    mime: string;
+} | {
+    ok: false;
+    reason: "empty" | "unsupported" | "busy" | "timeout";
+    detail: string;
+};
+export declare function readClipboardImage(): Promise<ClipboardImageResult>;

package/dist/tui/clipboard-image.js

@@ -0,0 +1,163 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { captureWindowsClipboard } from "./clipboard-windows.js";
+const CLIPBOARD_TIMEOUT_MS = 3_000;
+function helperOptions(deadline) {
+    return { timeout: Math.max(1, deadline - Date.now()), windowsHide: true, maxBuffer: 64 * 1024 * 1024 };
+}
+// Esegue un comando catturando stdout binario. Ritorna il Buffer o null se il
+// comando non esiste / fallisce / non produce output.
+function runCapture(cmd, args, deadline) {
+    if (Date.now() >= deadline)
+        return null;
+    try {
+        const res = spawnSync(cmd, args, helperOptions(deadline));
+        if (res.error || res.status !== 0)
+            return null;
+        const out = res.stdout;
+        if (!out || out.length === 0)
+            return null;
+        return Buffer.isBuffer(out) ? out : Buffer.from(out);
+    }
+    catch {
+        return null;
+    }
+}
+// True se un comando e' presente nel PATH (usato per distinguere "helper
+// mancante" da "clipboard vuota").
+function hasCommand(cmd, deadline) {
+    if (Date.now() >= deadline)
+        return false;
+    try {
+        // `command` e' un builtin POSIX, non un eseguibile nel PATH.
+        const res = process.platform === "win32"
+            ? spawnSync("where.exe", [cmd], helperOptions(deadline))
+            : spawnSync("/bin/sh", ["-c", 'command -v "$1"', "talos-clipboard", cmd], helperOptions(deadline));
+        return res.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+// I byte sono un'immagine plausibile? Controlla le firme (magic numbers) dei
+// formati comuni per non registrare spazzatura (es. testo) come immagine.
+function sniffMime(bytes) {
+    if (bytes.length < 4)
+        return null;
+    // PNG: 89 50 4E 47
+    if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)
+        return "image/png";
+    // JPEG: FF D8 FF
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff)
+        return "image/jpeg";
+    // GIF: "GIF8"
+    if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38)
+        return "image/gif";
+    // BMP: "BM"
+    if (bytes[0] === 0x42 && bytes[1] === 0x4d)
+        return "image/bmp";
+    // WEBP: "RIFF"...."WEBP"
+    if (bytes.length >= 12 && bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP")
+        return "image/webp";
+    return null;
+}
+// macOS: prova pngpaste (binario dedicato, output PNG su stdout). Se assente,
+// usa AppleScript via osascript scrivendo su un file temporaneo.
+function captureMac(deadline) {
+    if (hasCommand("pngpaste", deadline)) {
+        const bytes = runCapture("pngpaste", ["-"], deadline);
+        const mime = bytes && sniffMime(bytes);
+        if (bytes && mime)
+            return { ok: true, bytes, mime };
+        return { ok: false, reason: "empty", detail: "nessuna immagine nella clipboard" };
+    }
+    // Fallback senza dipendenze: AppleScript scrive il PNG della clipboard su file.
+    const dir = mkdtempSync(join(tmpdir(), "vascend-clip-"));
+    const file = join(dir, "clip.png");
+    const script = `set theFile to (POSIX file "${file}")\n` +
+        `try\n  set pngData to the clipboard as «class PNGf»\n  set fh to open for access theFile with write permission\n  write pngData to fh\n  close access fh\non error\n  try\n    close access theFile\n  end try\n  return "no-image"\nend try\nreturn "ok"`;
+    try {
+        const res = spawnSync("osascript", ["-e", script], { ...helperOptions(deadline), encoding: "utf8" });
+        const ok = res.status === 0 && (res.stdout ?? "").trim() === "ok" && existsSync(file);
+        if (ok) {
+            const bytes = readFileSync(file);
+            const mime = sniffMime(bytes);
+            if (mime)
+                return { ok: true, bytes, mime };
+        }
+        return { ok: false, reason: "empty", detail: "nessuna immagine nella clipboard" };
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+// Linux: Wayland (wl-paste) o X11 (xclip). Si prova prima il display server in
+// uso, poi l'altro come fallback.
+function captureLinux(deadline) {
+    const wayland = Boolean(process.env["WAYLAND_DISPLAY"]);
+    const order = wayland ? ["wl", "x"] : ["x", "wl"];
+    let sawHelper = false;
+    for (const kind of order) {
+        if (kind === "wl") {
+            if (!hasCommand("wl-paste", deadline))
+                continue;
+            sawHelper = true;
+            // -t image/png forza il formato PNG quando disponibile.
+            const bytes = runCapture("wl-paste", ["-t", "image/png"], deadline) ?? runCapture("wl-paste", ["-n"], deadline);
+            const mime = bytes && sniffMime(bytes);
+            if (bytes && mime)
+                return { ok: true, bytes, mime };
+        }
+        else {
+            if (!hasCommand("xclip", deadline))
+                continue;
+            sawHelper = true;
+            const bytes = runCapture("xclip", ["-selection", "clipboard", "-t", "image/png", "-o"], deadline);
+            const mime = bytes && sniffMime(bytes);
+            if (bytes && mime)
+                return { ok: true, bytes, mime };
+        }
+    }
+    if (!sawHelper) {
+        const need = wayland ? "wl-clipboard (wl-paste)" : "xclip";
+        return { ok: false, reason: "unsupported", detail: `serve ${need} per leggere l'immagine dalla clipboard` };
+    }
+    return { ok: false, reason: "empty", detail: "nessuna immagine nella clipboard" };
+}
+async function captureWindows(deadline) {
+    const res = await captureWindowsClipboard(deadline - Date.now());
+    const mime = sniffMime(res.bytes);
+    if (res.status === 0 && mime)
+        return { ok: true, bytes: res.bytes, mime };
+    if (res.failure === "timeout")
+        return { ok: false, reason: "timeout", detail: "lettura degli appunti scaduta; riprova con Alt+V" };
+    if (res.status === 20)
+        return { ok: false, reason: "empty", detail: "nessuna immagine nella clipboard" };
+    if (res.status === 21)
+        return { ok: false, reason: "busy", detail: "appunti ancora occupati dopo i tentativi automatici; riprova con Alt+V" };
+    return { ok: false, reason: "unsupported", detail: res.failure === "too-large"
+            ? "immagine negli appunti troppo grande (massimo 64 MB)" : "impossibile leggere l'immagine dagli appunti con PowerShell" };
+}
+// Punto d'ingresso: legge l'immagine dalla clipboard di sistema per la
+// piattaforma corrente. Il budget e' condiviso fra helper e fallback: nessun
+// processo nativo della clipboard puo' tenere la TUI in attesa senza scadenza.
+export async function readClipboardImage() {
+    // Leave room for cold PowerShell startup plus retries without blocking the UI.
+    const timeout = process.platform === "win32" ? 8_000 : CLIPBOARD_TIMEOUT_MS;
+    const deadline = Date.now() + timeout;
+    try {
+        const result = process.platform === "darwin" ? captureMac(deadline)
+            : process.platform === "linux" ? captureLinux(deadline)
+                : process.platform === "win32" ? await captureWindows(deadline)
+                    : { ok: false, reason: "unsupported", detail: `piattaforma ${process.platform} non supportata` };
+        if (!result.ok && Date.now() >= deadline) {
+            return { ok: false, reason: "timeout", detail: `lettura clipboard interrotta dopo ${timeout} ms; riprova con Alt+V` };
+        }
+        return result;
+    }
+    catch (error) {
+        return { ok: false, reason: "unsupported", detail: `clipboard non disponibile: ${error.message}` };
+    }
+}

package/dist/tui/clipboard-text.d.ts

@@ -0,0 +1,9 @@
+import type { Message } from "../core/types.js";
+export interface ClipboardCommand {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export declare function clipboardCommands(platform: NodeJS.Platform, env: NodeJS.ProcessEnv): readonly ClipboardCommand[];
+export declare function lastAssistantText(messages: readonly Message[]): string | null;
+export declare function runClipboardCommand(spec: ClipboardCommand, text: string): Promise<boolean>;
+export declare function copyText(text: string, run?: typeof runClipboardCommand, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/tui/clipboard-text.js

@@ -0,0 +1,51 @@
+import { spawn } from "node:child_process";
+// Il testo viaggia solo su stdin, mai come codice o argomento della shell.
+export function clipboardCommands(platform, env) {
+    if (platform === "win32")
+        return [{ command: "powershell.exe", args: ["-NoProfile", "-NonInteractive", "-STA", "-Command",
+                    "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; $text = [Console]::In.ReadToEnd(); Set-Clipboard -Value $text -ErrorAction Stop"] }];
+    if (platform === "darwin")
+        return [{ command: "pbcopy", args: [] }];
+    if (platform === "linux")
+        return [
+            ...(env.WAYLAND_DISPLAY ? [{ command: "wl-copy", args: [] }] : []),
+            ...(env.DISPLAY ? [{ command: "xclip", args: ["-selection", "clipboard"] }, { command: "xsel", args: ["--clipboard", "--input"] }] : []),
+        ];
+    return [];
+}
+export function lastAssistantText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "assistant")
+            continue;
+        const text = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+        if (text.trim())
+            return text;
+    }
+    return null;
+}
+export function runClipboardCommand(spec, text) {
+    return new Promise((resolve) => {
+        const child = spawn(spec.command, [...spec.args], { stdio: ["pipe", "ignore", "ignore"], windowsHide: true, shell: false });
+        let settled = false;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(ok);
+        };
+        const timer = setTimeout(() => { child.kill(); finish(false); }, 2000);
+        child.once("error", () => finish(false));
+        child.once("close", (code) => finish(code === 0));
+        child.stdin.on("error", () => { child.kill(); finish(false); });
+        child.stdin.end(text, "utf8");
+    });
+}
+export async function copyText(text, run = runClipboardCommand, platform = process.platform, env = process.env) {
+    for (const command of clipboardCommands(platform, env)) {
+        if (await run(command, text))
+            return true;
+    }
+    return false;
+}

package/dist/tui/clipboard-windows.d.ts

@@ -0,0 +1,8 @@
+export declare const WINDOWS_CLIPBOARD_SCRIPT = "\n$ErrorActionPreference = 'Stop'\nAdd-Type -AssemblyName System.Windows.Forms,System.Drawing\n$lastReadFailed = $false\nfor ($attempt = 0; $attempt -lt 16; $attempt++) {\n  $image = $null\n  $png = $null\n  $stream = $null\n  try {\n    $data = [System.Windows.Forms.Clipboard]::GetDataObject()\n    $bytes = $null\n    if ($null -ne $data) {\n      if ($data.GetDataPresent('PNG', $false)) {\n        $png = $data.GetData('PNG', $false)\n        if ($png -is [System.IO.MemoryStream]) { $bytes = $png.ToArray() }\n        elseif ($png -is [byte[]]) { $bytes = $png }\n      }\n      if ($null -eq $bytes -or $bytes.Length -lt 8) {\n        $image = $data.GetData([System.Windows.Forms.DataFormats]::Bitmap, $true)\n        if ($image -is [System.Drawing.Image]) {\n          $stream = New-Object System.IO.MemoryStream\n          $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)\n          $bytes = $stream.ToArray()\n        }\n      }\n      if ($null -ne $bytes -and $bytes.Length -ge 8) {\n        $stdout = [Console]::OpenStandardOutput()\n        $stdout.Write($bytes, 0, $bytes.Length)\n        $stdout.Flush()\n        exit 0\n      }\n    }\n    $lastReadFailed = $false\n  } catch { $lastReadFailed = $true }\n  finally {\n    if ($image -is [System.IDisposable]) { $image.Dispose() }\n    if ($png -is [System.IDisposable]) { $png.Dispose() }\n    if ($null -ne $stream) { $stream.Dispose() }\n  }\n  if ($attempt -lt 15) { Start-Sleep -Milliseconds 120 }\n}\nif ($lastReadFailed) { exit 21 }\nexit 20\n";
+export interface ClipboardHelperResult {
+    readonly status: number | null;
+    readonly bytes: Buffer;
+    readonly failure?: "timeout" | "unavailable" | "too-large";
+}
+export declare function runClipboardImageHelper(command: string, args: readonly string[], timeout: number): Promise<ClipboardHelperResult>;
+export declare function captureWindowsClipboard(timeout: number): Promise<ClipboardHelperResult>;

package/dist/tui/clipboard-windows.js

@@ -0,0 +1,84 @@
+import { spawn } from "node:child_process";
+// One STA process retries while the clipboard owner publishes a screenshot or
+// temporarily holds the clipboard lock. PNG preserves alpha when available;
+// Bitmap also covers DIB images produced by screenshot tools.
+export const WINDOWS_CLIPBOARD_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms,System.Drawing
+$lastReadFailed = $false
+for ($attempt = 0; $attempt -lt 16; $attempt++) {
+  $image = $null
+  $png = $null
+  $stream = $null
+  try {
+    $data = [System.Windows.Forms.Clipboard]::GetDataObject()
+    $bytes = $null
+    if ($null -ne $data) {
+      if ($data.GetDataPresent('PNG', $false)) {
+        $png = $data.GetData('PNG', $false)
+        if ($png -is [System.IO.MemoryStream]) { $bytes = $png.ToArray() }
+        elseif ($png -is [byte[]]) { $bytes = $png }
+      }
+      if ($null -eq $bytes -or $bytes.Length -lt 8) {
+        $image = $data.GetData([System.Windows.Forms.DataFormats]::Bitmap, $true)
+        if ($image -is [System.Drawing.Image]) {
+          $stream = New-Object System.IO.MemoryStream
+          $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+          $bytes = $stream.ToArray()
+        }
+      }
+      if ($null -ne $bytes -and $bytes.Length -ge 8) {
+        $stdout = [Console]::OpenStandardOutput()
+        $stdout.Write($bytes, 0, $bytes.Length)
+        $stdout.Flush()
+        exit 0
+      }
+    }
+    $lastReadFailed = $false
+  } catch { $lastReadFailed = $true }
+  finally {
+    if ($image -is [System.IDisposable]) { $image.Dispose() }
+    if ($png -is [System.IDisposable]) { $png.Dispose() }
+    if ($null -ne $stream) { $stream.Dispose() }
+  }
+  if ($attempt -lt 15) { Start-Sleep -Milliseconds 120 }
+}
+if ($lastReadFailed) { exit 21 }
+exit 20
+`;
+// No shell and no synchronous child process: typing, rendering and agent
+// events remain responsive throughout PowerShell startup and clipboard reads.
+export function runClipboardImageHelper(command, args, timeout) {
+    return new Promise(resolve => {
+        const child = spawn(command, [...args], { windowsHide: true, shell: false, stdio: ["ignore", "pipe", "ignore"] });
+        const chunks = [];
+        let size = 0;
+        let settled = false;
+        const finish = (status, failure) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ status, bytes: failure ? Buffer.alloc(0) : Buffer.concat(chunks), ...(failure ? { failure } : {}) });
+        };
+        const timer = setTimeout(() => { child.kill(); finish(null, "timeout"); }, Math.max(1, timeout));
+        child.stdout.on("data", (chunk) => {
+            if (settled)
+                return;
+            size += chunk.length;
+            if (size > 64 * 1024 * 1024) {
+                child.kill();
+                finish(null, "too-large");
+            }
+            else
+                chunks.push(chunk);
+        });
+        child.stdout.on("error", () => { child.kill(); finish(null, "unavailable"); });
+        child.once("error", () => finish(null, "unavailable"));
+        child.once("close", status => finish(status));
+    });
+}
+export function captureWindowsClipboard(timeout) {
+    return runClipboardImageHelper("powershell.exe", ["-NoProfile", "-NonInteractive", "-STA", "-EncodedCommand",
+        Buffer.from(WINDOWS_CLIPBOARD_SCRIPT, "utf16le").toString("base64")], timeout);
+}

package/dist/tui/collapsible-command.d.ts

@@ -0,0 +1,15 @@
+import { type CollapsibleRegistry } from "../core/collapsible-output.js";
+export interface CollapsibleSink {
+    write(text: string): void;
+    logLength(): number;
+    fold(start: number, end: number, summary: string): number;
+}
+export interface WriteCollapsibleOptions {
+    readonly summary: string;
+    readonly body: string;
+    readonly collapseThreshold?: number;
+    readonly registry?: CollapsibleRegistry;
+    readonly command?: string;
+}
+export declare function writeCollapsibleOutput(sink: CollapsibleSink, opts: WriteCollapsibleOptions): string | null;
+export declare function foldSummaryLine(lines: number, command?: string): string;

package/dist/tui/collapsible-command.js

@@ -0,0 +1,48 @@
+// Ponte fra l'OUTPUT dei comandi slash e il sistema collassabile/navigabile.
+//
+// I comandi "legacy" stampavano testo lungo INLINE con ctl.write: restava in
+// chat per sempre, gonfiando lo scrollback. Questa utility li migra al sistema
+// collassabile: l'output viene scritto, poi COLLASSATO in una riga di sintesi
+// (fold della regione viva, espandibile con /expand) e registrato nel
+// CollapsibleRegistry per il lifecycle (apri/chiudi + cleanup della memoria).
+//
+// Disaccoppiata dai singoli comandi: ognuno passa solo summary + corpo. Niente
+// dipendenze a runtime oltre alle due primitive dei prerequisiti.
+import { collapsibleRegistry } from "../core/collapsible-output.js";
+const DEFAULT_THRESHOLD = 8;
+// Scrive `body` in chat in forma COLLASSABILE: stampa la `summary`, poi il corpo,
+// quindi collassa il corpo lasciando visibile la sola summary (espandibile).
+// Registra il blocco nel CollapsibleRegistry per il lifecycle/cleanup e ritorna
+// l'id del blocco registrato (o null se l'output era troppo corto per collassare).
+export function writeCollapsibleOutput(sink, opts) {
+    const { summary, body } = opts;
+    const threshold = opts.collapseThreshold ?? DEFAULT_THRESHOLD;
+    const registry = opts.registry ?? collapsibleRegistry;
+    const bodyLines = body.replace(/\n+$/, "").split("\n");
+    // Output corto: nessun beneficio dal collasso, scrivi inline e basta.
+    if (bodyLines.length <= threshold) {
+        sink.write(body.endsWith("\n") ? body : body + "\n");
+        return null;
+    }
+    // Registra nel registry (lifecycle/cleanup). Il contenuto e' lazy: viene
+    // materializzato solo all'apertura e rilasciato alla chiusura.
+    const coId = registry.register({
+        summary,
+        content: () => body,
+        open: false,
+    });
+    // Scrive la riga di sintesi (sempre visibile) seguita dal corpo, poi collassa
+    // SOLO il corpo in un fold: in chat resta la summary, il corpo si apre con
+    // /expand. La summary include l'hint d'uso.
+    sink.write(summary.endsWith("\n") ? summary : summary + "\n");
+    const start = sink.logLength();
+    sink.write(body.endsWith("\n") ? body : body + "\n");
+    const end = sink.logLength();
+    sink.fold(start, end, foldSummaryLine(bodyLines.length, opts.command));
+    return coId;
+}
+// Riga di sintesi del fold collassato (mostrata al posto del corpo nascosto).
+export function foldSummaryLine(lines, command) {
+    const what = command ? `/${command}` : "output";
+    return `  … ${what}: ${lines} righe collassate · /expand per aprire`;
+}

package/dist/tui/command-feedback.d.ts

@@ -0,0 +1,10 @@
+interface FeedbackControl {
+    write(text: string): void;
+    writeConversation?(text: string): void;
+    setStatus(label: string | null): void;
+    setRoomStatus?(label: string | null, state?: "running" | "done" | "failed"): void;
+    refresh?(): void;
+}
+export declare function notifyStatus(ctl: FeedbackControl, text: string, failed?: boolean): void;
+export declare function withCommandFeedback<T, C extends FeedbackControl>(ctl: C, run: (control: C) => Promise<T>, show: (lines: readonly string[]) => Promise<void>): Promise<T>;
+export {};

package/dist/tui/command-feedback.js

@@ -0,0 +1,46 @@
+import { plainText } from "./terminal-text.js";
+export function notifyStatus(ctl, text, failed = false) {
+    const label = plainText(text).replace(/\s+/g, " ").trim();
+    if (!label)
+        return;
+    if (ctl.setRoomStatus)
+        ctl.setRoomStatus(label, failed ? "failed" : "done");
+    else
+        ctl.setStatus(label);
+}
+// Each command gets a private output sink: even nested menus, extensions and
+// failures cannot accidentally commit operational text to native scrollback.
+// The original sink remains available only for replaying conversation content.
+export async function withCommandFeedback(ctl, run, show) {
+    let output = "";
+    let failed = false;
+    const commandCtl = new Proxy(ctl, {
+        get(target, prop, receiver) {
+            if (prop === "write")
+                return (text) => { output = (output + text).slice(-256_000); };
+            if (prop === "writeConversation")
+                return (target.writeConversation ?? target.write).bind(target);
+            // Command output is a panel, so it must never create chat folds.
+            if (prop === "logLength")
+                return () => -1;
+            const value = Reflect.get(target, prop, receiver);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    try {
+        return await run(commandCtl);
+    }
+    catch (error) {
+        failed = true;
+        output += `\n${error instanceof Error ? error.message : String(error)}`;
+        throw error;
+    }
+    finally {
+        const lines = plainText(output).trim().split("\n").filter(l => l.trim());
+        if (lines.length === 1 && lines[0].length < 180)
+            notifyStatus(ctl, lines[0], failed);
+        else if (lines.length > 1 || lines[0])
+            await show(lines);
+        ctl.refresh?.();
+    }
+}

package/dist/tui/command-output-registry.d.ts

@@ -0,0 +1,28 @@
+import { type CommandCategory } from "./commands.js";
+export type OutputKind = "navigable" | "static" | "transient" | "none";
+export type OutputMechanism = "panel" | "notice" | "picker" | "multi-level-picker" | "live-viewer" | "fold" | "inline-text" | "action";
+export interface CommandOutputEntry {
+    readonly name: string;
+    readonly category: CommandCategory;
+    readonly output: OutputKind;
+    readonly mechanism: OutputMechanism;
+    readonly argDependent: boolean;
+    readonly longOutput: boolean;
+    readonly note: string;
+}
+export declare function outputEntries(): readonly CommandOutputEntry[];
+export declare function outputEntry(name: string): CommandOutputEntry | undefined;
+export declare function isNavigable(name: string): boolean;
+export declare function navigableCommands(): readonly CommandOutputEntry[];
+export declare function nonNavigableCommands(): readonly CommandOutputEntry[];
+export declare function migrationCandidates(): readonly CommandOutputEntry[];
+export declare function needsMigration(name: string): boolean;
+export interface OutputRegistrySummary {
+    readonly total: number;
+    readonly navigable: number;
+    readonly static: number;
+    readonly transient: number;
+    readonly none: number;
+    readonly toMigrate: number;
+}
+export declare function outputRegistrySummary(): OutputRegistrySummary;

package/dist/tui/command-output-registry.js

@@ -0,0 +1,103 @@
+// Registro/inventario dell'OUTPUT dei comandi slash builtin.
+//
+// Mappa OGNI comando builtin (vedi BUILTIN_COMMANDS) alla NATURA del suo output,
+// marcando quali gestiscono gia' OUTPUT NAVIGABILE (picker/lista con frecce,
+// fold espandibili, paginazione) e quali no (testo statico inline, o nessun
+// output). Serve a chi deve MIGRARE i comandi verso un output navigabile/
+// collassabile uniforme: l'interfaccia qui sotto identifica i candidati.
+//
+// Parte PURA: solo dati e funzioni pure, nessuna dipendenza a runtime.
+import { BUILTIN_COMMANDS } from "./commands.js";
+// Inventario completo: una voce per ciascun comando builtin canonico.
+// Classificazione derivata dall'analisi dei case di dispatch in repl.ts.
+const ENTRIES = [
+    { name: "fast", category: "modello", output: "transient", mechanism: "notice", argDependent: true, longOutput: false, note: "imposta o mostra Fast; indicatore accanto al modello" },
+    { name: "queue", category: "interfaccia", output: "navigable", mechanism: "live-viewer", argDependent: false, longOutput: true, note: "gestione immediata dei messaggi in attesa, modifica e momento di consegna" },
+    { name: "review", category: "interfaccia", output: "navigable", mechanism: "live-viewer", argDependent: true, longOutput: true, note: "schermata dedicata con sezioni, ricerca e dettaglio per operazione; Ctrl+R anche durante il run" },
+    { name: "help", category: "sistema", output: "navigable", mechanism: "picker", argDependent: false, longOutput: false, note: "palette comandi temporanea, Esc chiude senza lasciare testo" },
+    { name: "copy", category: "interfaccia", output: "transient", mechanism: "notice", argDependent: true, longOutput: false, note: "copia testo negli appunti locali; conferma solo se il helper riesce" },
+    { name: "rename", category: "sessione", output: "transient", mechanism: "notice", argDependent: true, longOutput: false, note: "salva un titolo della chat; errore di sintassi se assente" },
+    { name: "commands", category: "sistema", output: "navigable", mechanism: "picker", argDependent: false, longOutput: true, note: "palette di TUTTI i comandi (builtin, estensioni, template, skill); Enter esegue la voce scelta" },
+    { name: "model", category: "modello", output: "navigable", mechanism: "picker", argDependent: true, longOutput: false, note: "picker modelli se senza arg; testo di conferma se passato un nome" },
+    { name: "models", category: "modello", output: "navigable", mechanism: "picker", argDependent: false, longOutput: false, note: "pickModel: selettore con frecce" },
+    { name: "provider", category: "modello", output: "navigable", mechanism: "picker", argDependent: false, longOutput: false, note: "providerMenu navigabile" },
+    { name: "login", category: "modello", output: "navigable", mechanism: "picker", argDependent: false, longOutput: false, note: "stato abbonamenti, poche righe statiche" },
+    { name: "usage", category: "modello", output: "transient", mechanism: "notice", argDependent: false, longOutput: false, note: "usage provider esatto separato dalla stima locale del contesto" },
+    { name: "effort", category: "modello", output: "navigable", mechanism: "picker", argDependent: true, longOutput: false, note: "picker livelli se senza arg; indicatore aggiornato se passato" },
+    { name: "vibe", category: "vibe", output: "navigable", mechanism: "picker", argDependent: true, longOutput: false, note: "picker dei profili vibecoding; argomento imposta direttamente" },
+    { name: "context", category: "vibe", output: "navigable", mechanism: "fold", argDependent: true, longOutput: true, note: "ricevuta Context Fabric collassabile, epoch, lease e gestione pin" },
+    { name: "arch", category: "vibe", output: "navigable", mechanism: "fold", argDependent: true, longOutput: true, note: "mappa architetturale collassabile: moduli, dipendenze, cicli, entry point, hotspot" },
+    { name: "theme", category: "interfaccia", output: "navigable", mechanism: "picker", argDependent: true, longOutput: false, note: "picker temi se senza arg; indicatore aggiornato se passato" },
+    { name: "compact", category: "vascend", output: "transient", mechanism: "notice", argDependent: false, longOutput: false, note: "stream di progresso compattazione, poche righe" },
+    { name: "vascend", category: "vascend", output: "navigable", mechanism: "panel", argDependent: true, longOutput: true, note: "messaggio + renderVascendStatus in pannello temporaneo; lo status puo' crescere" },
+    { name: "todo", category: "attivita", output: "navigable", mechanism: "multi-level-picker", argDependent: false, longOutput: true, note: "lista dei gruppi e delle attività con stato; fallback testo se non TTY" },
+    { name: "collaboratori", category: "attivita", output: "navigable", mechanism: "live-viewer", argDependent: true, longOutput: true, note: "viewer live dei collaboratori paralleli + report finale" },
+    { name: "bg", category: "sistema", output: "navigable", mechanism: "panel", argDependent: true, longOutput: true, note: "lista o output di un task; l'output del task puo' essere lungo" },
+    { name: "expand", category: "interfaccia", output: "navigable", mechanism: "fold", argDependent: true, longOutput: false, note: "espande fold collassati gia' esistenti" },
+    { name: "img", category: "interfaccia", output: "transient", mechanism: "notice", argDependent: true, longOutput: false, note: "allega img #N: anteprima in pannello temporaneo da path; senza arg legge la clipboard di sistema" },
+    { name: "config", category: "sistema", output: "navigable", mechanism: "panel", argDependent: false, longOutput: true, note: "blocco di configurazione in pannello temporaneo, puo' essere lungo" },
+    { name: "cwd", category: "sistema", output: "transient", mechanism: "notice", argDependent: true, longOutput: false, note: "mostra il progetto; per cambiarlo propone un riavvio sicuro con talos -C" },
+    { name: "reload", category: "sistema", output: "transient", mechanism: "notice", argDependent: false, longOutput: false, note: "ricarica le estensioni a caldo; poche righe di diff dei tool" },
+    { name: "extensions", category: "sistema", output: "navigable", mechanism: "panel", argDependent: true, longOutput: true, note: "lista/gestione estensioni in pannello temporaneo; l'elenco cresce col numero di estensioni" },
+    { name: "tree", category: "sessione", output: "navigable", mechanism: "panel", argDependent: true, longOutput: true, note: "lista nodi sessione (statica); con id e' azione di checkout" },
+    { name: "sessions", category: "sessione", output: "navigable", mechanism: "panel", argDependent: false, longOutput: true, note: "elenco sessioni in pannello temporaneo, cresce col numero di sessioni" },
+    { name: "resume", category: "sessione", output: "navigable", mechanism: "picker", argDependent: true, longOutput: false, note: "picker sessioni se senza arg; azione diretta se passato id" },
+    { name: "new", category: "sessione", output: "none", mechanism: "action", argDependent: false, longOutput: false, note: "crea una sessione nuova e vuota (alias /clear); azzera il contesto" },
+    { name: "language", category: "interfaccia", output: "navigable", mechanism: "picker", argDependent: true, longOutput: false, note: "sceglie la lingua o segue il sistema; preferenza persistita" },
+    { name: "logout", category: "sistema", output: "transient", mechanism: "notice", argDependent: false, longOutput: false, note: "revoca best-effort sul backend + rimozione del token locale; una riga di conferma" },
+    { name: "quit", category: "sistema", output: "none", mechanism: "action", argDependent: false, longOutput: false, note: "esce, nessun output" },
+];
+// Mappa nome canonico -> voce, per lookup O(1).
+const BY_NAME = new Map(ENTRIES.map((e) => [e.name, e]));
+// Tutte le voci dell'inventario.
+export function outputEntries() {
+    return ENTRIES;
+}
+// Voce per un comando dato il nome (accetta anche gli ALIAS dei builtin, es.
+// "themes" -> "theme", "castello" -> "piano"). undefined se sconosciuto.
+export function outputEntry(name) {
+    const direct = BY_NAME.get(name);
+    if (direct)
+        return direct;
+    const canonical = aliasToCanonical(name);
+    return canonical ? BY_NAME.get(canonical) : undefined;
+}
+// Risolve un alias builtin al nome canonico (o ritorna name se gia' canonico).
+function aliasToCanonical(name) {
+    const cmd = BUILTIN_COMMANDS.find((c) => c.name === name || (c.aliases ?? []).includes(name));
+    return cmd?.name;
+}
+// True se il comando gestisce gia' output NAVIGABILE.
+export function isNavigable(name) {
+    return outputEntry(name)?.output === "navigable";
+}
+// Comandi che gestiscono gia' output navigabile.
+export function navigableCommands() {
+    return ENTRIES.filter((e) => e.output === "navigable");
+}
+// Comandi NON navigabili (static o none). Universo dei potenziali da rivedere.
+export function nonNavigableCommands() {
+    return ENTRIES.filter((e) => e.output !== "navigable");
+}
+// INTERFACCIA CHIAVE per la migrazione: i comandi DA MIGRARE verso output
+// navigabile. Criterio: output statico (inline) E potenzialmente lungo. I
+// comandi "none" (azioni senza output) non si migrano; quelli statici corti
+// (es. login, compact) non ne traggono beneficio reale.
+export function migrationCandidates() {
+    return ENTRIES.filter((e) => e.output === "static" && e.longOutput);
+}
+// True se il comando e' un candidato alla migrazione.
+export function needsMigration(name) {
+    const e = outputEntry(name);
+    return e !== undefined && e.output === "static" && e.longOutput;
+}
+export function outputRegistrySummary() {
+    return {
+        total: ENTRIES.length,
+        navigable: ENTRIES.filter((e) => e.output === "navigable").length,
+        transient: ENTRIES.filter((e) => e.output === "transient").length,
+        static: ENTRIES.filter((e) => e.output === "static").length,
+        none: ENTRIES.filter((e) => e.output === "none").length,
+        toMigrate: migrationCandidates().length,
+    };
+}

package/dist/tui/command-transcript.d.ts

@@ -0,0 +1,12 @@
+import type { ToolCallPart } from "../core/types.js";
+import type { TuiTheme } from "./branding.js";
+export type CommandState = "running" | "ok" | "error" | "background" | "stopped";
+export declare function commandSource(call: Pick<ToolCallPart, "name" | "input">): string | undefined;
+export declare function highlightCommand(source: string, t: TuiTheme): string;
+export declare function commandHeader(firstRow: string, state: CommandState, t: TuiTheme, columns: number): string;
+export declare function commandPreview(source: string, t: TuiTheme, columns: number, state?: CommandState): {
+    firstRow: string;
+    lines: string[];
+};
+export declare function commandOutput(output: string, t: TuiTheme, columns: number, isError?: boolean): string[];
+export declare function commandResultState(output: string, isError?: boolean): CommandState;