llm-agent-cli 2.0.0 → 2.0.2

package/dist/index.js

@@ -13,7 +13,7 @@ import { ContextManager } from "./context.js";
 import { ReplInput } from "./input.js";
 import { preprocessPrompt } from "./preprocessor.js";
 import { detectProjectContext } from "./project.js";
-import { renderMarkdown } from "./renderer.js";
+import { renderMarkdown, renderPanel as renderPanelComponent, renderTable as renderTableComponent, contextBar as contextBarComponent, renderErrorCard, renderModelBadge, renderToolProgress, formatCost, getTheme, setTheme, getThemeName, stripAnsi as stripAnsiComponent, fitCell as fitCellComponent, } from "./renderer.js";
 import { SessionStore } from "./session.js";
 import { listAvailableTools } from "./tools/index.js";
 import { resolveProtectedPath, getRuntimeConfig } from "./tools/security.js";
@@ -21,6 +21,26 @@ import { run_linter, run_tests, security_scan } from "./tools/linter.js";
 import { loadCredentials, resolveConnectionFromEnvOrCreds, runLogin, runLogout, runWhoami, } from "./auth.js";
 import { loadMemory, appendMemory, clearMemory, showMemory, } from "./memory.js";
 const PERMISSION_MODES = ["safe", "standard", "yolo"];
+/** UI accessor — always reads from the active theme so theme switches propagate. */
+function UI() {
+    return getTheme();
+}
+const ICON = {
+    spark: "✦",
+    gear: "⚙",
+    shield: "🛡",
+    folder: "📁",
+    network: "🌐",
+    model: "🧠",
+    stack: "🧩",
+    session: "🗂",
+    tip: "💡",
+    status: "●",
+    command: "⌘",
+    token: "◉",
+    retry: "↻",
+    ttft: "⚡",
+};
 function isPermissionMode(value) {
     return PERMISSION_MODES.includes(value);
 }
@@ -28,58 +48,131 @@ function isOutputFormat(value) {
     return value === "text" || value === "json";
 }
 function formatUsd(value) {
-    return `$${value.toFixed(4)}`;
+    return formatCost(value);
+}
+function stripAnsi(value) {
+    return stripAnsiComponent(value);
+}
+function badge(label, tone = "info") {
+    const ui = UI();
+    const color = tone === "success"
+        ? ui.success
+        : tone === "warning"
+            ? ui.warning
+            : tone === "danger"
+                ? ui.danger
+                : tone === "muted"
+                    ? ui.muted
+                    : ui.info;
+    return color(`◈ ${label}`);
+}
+function fitCell(value, width) {
+    return fitCellComponent(value, width);
+}
+function renderPanel(lines) {
+    return renderPanelComponent(lines);
 }
-function looksLikeMarkdown(text) {
-    return /(^\s{0,3}#{1,6}\s|\*\*|`[^`]+`|^\s*[-*+]\s|\|.+\|)/m.test(text);
+function printTable(headers, rows, widths) {
+    return renderTableComponent(headers, rows, widths);
+}
+function contextBar(ratio, width = 18) {
+    return contextBarComponent(ratio, width);
 }
 function printBanner(runtime, permissionMode) {
+    const ui = UI();
     const model = process.env.LLM_ROUTER_MODEL ?? "auto";
     const baseUrl = process.env.LLM_ROUTER_BASE_URL ?? "(not set)";
-    console.log(chalk.bold.cyan(`\n  ╔══════════════════════════════════════╗\n  ║        LLM-Router CLI Agent          ║\n  ║   Powered by your local LLM-Router   ║\n  ╚══════════════════════════════════════╝`));
-    console.log(chalk.dim(`  Router: ${baseUrl}  |  Model: ${model}`));
-    console.log(chalk.dim(`  Session: ${runtime.sessionId}`));
-    console.log(chalk.dim(`  Workspace: ${runtime.project.workspaceRoot}`));
-    console.log(chalk.dim(`  Permissions: ${permissionMode}`));
-    console.log(chalk.dim(`  Type /help for commands`));
-    console.log();
+    const permissionTone = permissionMode === "safe"
+        ? "success"
+        : permissionMode === "yolo"
+            ? "danger"
+            : "warning";
+    const headerLine = `${ui.title(`${ICON.spark} LLM-Router Agent`)}  ${badge(permissionMode, permissionTone)}  ${ui.muted("v2.0")}`;
+    const routerLine = `  ${ui.muted("router")}   ${ui.info(baseUrl)}`;
+    const modelLine = `  ${ui.muted("model")}    ${ui.success(model)}`;
+    const wsLine = `  ${ui.muted("workspace")} ${runtime.project.workspaceRoot}`;
+    const stackLine = `  ${ui.muted("stack")}    ${runtime.project.language} ${ui.muted("·")} ${runtime.project.framework} ${ui.muted("·")} ${runtime.project.packageManager}`;
+    const sessionLine = `  ${ui.muted("session")}  ${ui.muted(runtime.sessionId)}`;
+    const themeLine = `  ${ui.muted("theme")}    ${ui.muted(getThemeName())}`;
+    const panel = renderPanel([
+        ` ${headerLine}`,
+        ``,
+        ` ${routerLine}`,
+        ` ${modelLine}`,
+        ` ${wsLine}`,
+        ` ${stackLine}`,
+        ` ${sessionLine}`,
+        ` ${themeLine}`,
+    ]);
+    console.log("");
+    console.log(panel);
+    console.log("");
+    console.log(ui.muted(`  /help  /tools  /models  /cost  /compact  /theme`));
+    console.log("");
+}
+function printCommandGroup(title, commands) {
+    console.log(UI().accent.bold(` ${title}`));
+    console.log(printTable(["Command", "Description"], commands.map(([cmd, desc]) => [UI().info(cmd), desc]), [28, 70]));
+    console.log("");
 }
 function printHelp() {
-    console.log(chalk.bold("\nSlash commands:"));
-    console.log(chalk.cyan("  /help") + "         — show commands");
-    console.log(chalk.cyan("  /exit") + "         — quit");
-    console.log(chalk.cyan("  /clear") + "        — clear terminal");
-    console.log(chalk.cyan("  /compact") + "      — summarize and compact conversation");
-    console.log(chalk.cyan("  /models") + "       — list router models");
-    console.log(chalk.cyan("  /cost") + "         — show token/cost totals");
-    console.log(chalk.cyan("  /save [name]") + "  — save named session snapshot");
-    console.log(chalk.cyan("  /load [name]") + "  — load named session or list names");
-    console.log(chalk.cyan("  /retry") + "        — resend last user prompt");
-    console.log(chalk.cyan("  /undo") + "         — remove last user+assistant turn");
-    console.log(chalk.cyan("  /cd <path>") + "    — change working directory (within workspace)");
-    console.log(chalk.cyan("  /tools") + "        — list tools");
-    console.log(chalk.cyan("  /permissions") + "  — show permission mode");
-    console.log(chalk.cyan("  /verbose") + "      — toggle verbose tool output");
-    console.log(chalk.cyan("  /review [path]") + " — code review a file or directory");
-    console.log(chalk.cyan("  /scan [path]") + "  — security scan (secrets, XSS, SQLi, etc.)");
-    console.log(chalk.cyan("  /lint [path]") + "  — run project linter");
-    console.log(chalk.cyan("  /test [path]") + "  — run test suite");
-    console.log(chalk.cyan("  /memory") + "       — show persistent memory (global + project)");
-    console.log(chalk.cyan("  /remember <text>") + " — append a fact to project memory");
-    console.log(chalk.cyan("  /remember --global <text>") + " — append to global memory");
-    console.log(chalk.cyan("  /memory clear") + " — clear project memory");
-    console.log(chalk.cyan("  /memory clear --global") + " — clear global memory");
+    console.log("");
+    console.log(renderPanel([` ${UI().title(`${ICON.command} Command Palette`)}`]));
+    console.log("");
+    printCommandGroup("🧭 Core", [
+        ["/help", "Show this help"],
+        ["/exit", "Quit the CLI"],
+        ["/clear", "Clear terminal output only"],
+        ["/retry", "Resend last prompt"],
+        ["/undo", "Remove last user+assistant turn"],
+    ]);
+    printCommandGroup("🗂 Session", [
+        ["/compact", "Summarize and compress conversation"],
+        ["/save [name]", "Save named session snapshot"],
+        ["/load [name]", "Load named session or list saved names"],
+        ["/models", "List available router models"],
+        ["/cost", "Show token and cost totals"],
+    ]);
+    printCommandGroup("📁 Workspace", [
+        ["/cd <path>", "Change working directory (within workspace root)"],
+        ["/tools", "List tools and descriptions"],
+        ["/permissions", "Show current permission mode"],
+        ["/verbose", "Toggle verbose tool result output"],
+        ["/theme <name>", "Switch UI theme: dark, light, minimal"],
+    ]);
+    printCommandGroup("🧪 Quality", [
+        ["/review [path]", "Run a structured code review prompt"],
+        ["/lint [path]", "Run linter (auto detects toolchain)"],
+        ["/test [path]", "Run tests (auto detects runner)"],
+        ["/scan [path]", "Run security scan"],
+    ]);
+    printCommandGroup("🔑 Auth", [
+        ["/login", "Log in (opens browser for Google/GitHub auth)"],
+        ["/logout", "Log out and clear credentials"],
+        ["/whoami", "Show current account and router URL"],
+    ]);
+    printCommandGroup("🧠 Memory", [
+        ["/memory", "Show global + project memory"],
+        ["/memory clear", "Clear project memory"],
+        ["/memory clear --global", "Clear global memory"],
+        ["/remember <text>", "Remember fact in project memory"],
+        ["/remember --global <text>", "Remember fact in global memory"],
+    ]);
     console.log();
-    console.log(chalk.bold("Multiline input:"));
-    console.log(chalk.dim("  End a line with \\ to continue onto next line."));
-    console.log(chalk.dim("  Type <<< then paste lines; end with a single . line."));
+    console.log(UI().accent.bold("⌨ Input Modes"));
+    console.log(UI().muted("  • End a line with \\ for multiline continuation"));
+    console.log(UI().muted("  • Type <<< then paste blocks; finish with a single . line"));
     console.log();
 }
 function printTools() {
-    console.log(chalk.bold("\nAvailable tools:"));
-    for (const tool of listAvailableTools()) {
-        console.log(`  ${chalk.yellow(tool.name)} — ${tool.description}`);
-    }
+    const tools = listAvailableTools();
+    const rows = tools.map((tool) => [
+        `${ICON.gear} ${UI().info(tool.name)}`,
+        tool.description,
+    ]);
+    console.log("");
+    console.log(UI().accent.bold(`${ICON.gear} Tools (${tools.length})`));
+    console.log(printTable(["Name", "Description"], rows, [30, 68]));
     console.log();
 }
 function modelFlag(model, key) {
@@ -120,22 +213,26 @@ function formatModels(models) {
     const rows = models.map((model) => ({
         id: String(model.id ?? ""),
         tier: String(model.tier ?? ""),
-        owner: String(model.owned_by ?? ""),
+        provider: String(model.provider ?? model.owned_by ?? ""),
+        context: Number(model.contextWindow ?? model.context_window ?? 0),
         caps: extractModelCapabilities(model),
+        isBlocked: Boolean(model.isBlocked ?? model.is_blocked ?? false),
     }));
-    const headers = ["ID", "TIER", "OWNER", "CAPABILITIES"];
-    const widths = [40, 10, 12, 45];
-    const line = (values) => values
-        .map((value, idx) => {
-        const width = widths[idx] ?? 20;
-        if (value.length <= width)
-            return value.padEnd(width, " ");
-        return `${value.slice(0, Math.max(0, width - 1))}…`;
-    })
-        .join("  ");
-    const divider = widths.map((w) => "-".repeat(w)).join("  ");
-    const body = rows.map((row) => line([row.id, row.tier, row.owner, row.caps]));
-    return [line(headers), divider, ...body].join("\n");
+    const tierText = (tier) => {
+        if (tier === "strong" || tier === "reasoning")
+            return UI().success(tier);
+        if (tier === "cheap")
+            return UI().warning(tier);
+        return UI().info(tier || "unknown");
+    };
+    return printTable(["Model", "Tier", "Provider", "Context", "Capabilities", "Status"], rows.map((row) => [
+        `${ICON.model} ${row.id}`,
+        tierText(row.tier),
+        row.provider || "-",
+        row.context > 0 ? `${Math.round(row.context / 1000)}k` : "-",
+        row.caps || "-",
+        row.isBlocked ? UI().warning("blocked") : UI().success("active"),
+    ]), [35, 10, 14, 9, 32, 10]);
 }
 async function readAllStdin() {
     const chunks = [];
@@ -193,6 +290,10 @@ async function bootstrapRuntime(options) {
                 sessionId,
                 workspaceRoot: project.workspaceRoot,
             }, resumed);
+            const ui = UI();
+            const historyLen = resumed.history?.length ?? 0;
+            console.log(ui.success(`${ICON.session} Session restored: ${options.resume}`));
+            console.log(ui.muted(`  ${historyLen} messages recovered, cwd: ${resumed.cwd || process.cwd()}`));
         }
     }
     return {
@@ -210,6 +311,56 @@ async function bootstrapRuntime(options) {
 async function persistSnapshot(runtime) {
     await runtime.sessions.appendSnapshot(runtime.sessionId, runtime.agent.exportState(runtime.context.serializeState()));
 }
+/**
+ * Turn a raw tool name + args JSON into a concise, human-readable action label.
+ * e.g. "read_file" + '{"path":"src/index.ts"}' → "Reading src/index.ts"
+ */
+function humanizeToolAction(toolName, argsPreview) {
+    // Try to extract a path or key arg from the preview
+    let target = "";
+    try {
+        const parsed = JSON.parse(argsPreview.replace(/\.\.\.$/, ""));
+        target = parsed.path || parsed.file_path || parsed.pattern || parsed.command || parsed.url || parsed.directory || "";
+    }
+    catch {
+        // argsPreview may be truncated / not valid JSON — try to extract a path-like string
+        const pathMatch = argsPreview.match(/["']?([^\s"',{}]+\.[a-z]{1,6})["']?/i)
+            || argsPreview.match(/["']?([^\s"',{}]{3,60})["']?/);
+        target = pathMatch?.[1] ?? "";
+    }
+    // Shorten long paths to last 2 segments
+    if (target.length > 50) {
+        const parts = target.split("/");
+        target = parts.length > 2 ? `…/${parts.slice(-2).join("/")}` : target.slice(-47) + "…";
+    }
+    const suffix = target ? ` ${UI().info(target)}` : "";
+    const verbs = {
+        read_file: "Reading",
+        write_to_file: "Writing",
+        apply_diff: "Editing",
+        list_directory: "Listing",
+        create_directory: "Creating directory",
+        delete_file: "Deleting",
+        move_file: "Moving",
+        get_file_info: "Checking",
+        search_files: "Searching",
+        find_files: "Finding files",
+        show_diff: "Diffing",
+        search_and_replace_all: "Replacing in",
+        fetch_url: "Fetching",
+        run_bash_command: "Running",
+        git_status: "Git status",
+        git_diff: "Git diff",
+        git_log: "Git log",
+        git_blame: "Git blame",
+        git_stash: "Git stash",
+        run_linter: "Linting",
+        run_tests: "Testing",
+        security_scan: "Scanning",
+    };
+    const verb = verbs[toolName] ?? toolName;
+    return `${verb}${suffix}`;
+}
 async function executeTurn(runtime, rawPrompt, signal, outputFormat, streamOutput) {
     const preprocessed = await preprocessPrompt(rawPrompt, Math.min(runtime.config.maxReadBytes, 16_000));
     if (preprocessed.includedFiles.length > 0) {
@@ -231,18 +382,26 @@ async function executeTurn(runtime, rawPrompt, signal, outputFormat, streamOutpu
             process.stderr.write(`warning: ${warning}\n`);
         }
     }
-    const spinner = ora({ text: "Thinking...", color: "cyan" }).start();
+    const turnStartedAt = Date.now();
+    let firstTokenAt = 0;
+    const spinner = ora({
+        text: `${ICON.spark} thinking...`,
+        color: "cyan",
+        spinner: "dots",
+    }).start();
     let printedToken = false;
     let printedAgentPrefix = false;
     let toolTimer = null;
     let toolStartAt = 0;
     let currentToolLabel = "";
+    let toolGroupTotal = 0;
     const clearToolTimer = () => {
         if (toolTimer) {
             clearInterval(toolTimer);
             toolTimer = null;
         }
     };
+    const ui = UI();
     const callbacks = {
         onToken: async (token) => {
             if (!streamOutput)
@@ -251,37 +410,55 @@ async function executeTurn(runtime, rawPrompt, signal, outputFormat, streamOutpu
                 spinner.stop();
             clearToolTimer();
             if (!printedAgentPrefix) {
-                processStdout.write(chalk.bold.white("Agent: "));
+                if (!firstTokenAt)
+                    firstTokenAt = Date.now();
+                processStdout.write(ui.accent.bold(`${ICON.spark} Assistant  `));
                 printedAgentPrefix = true;
             }
             printedToken = true;
             processStdout.write(token);
         },
-        onRetry: async (attempt, delayMs) => {
-            spinner.text = `Retry ${attempt}/3 in ${Math.floor(delayMs / 1000)}s...`;
+        onRetry: async (attempt, delayMs, reason) => {
+            const normalizedReason = reason.replace(/\s+/g, " ").trim();
+            const shortReason = normalizedReason.length > 72
+                ? `${normalizedReason.slice(0, 69)}...`
+                : normalizedReason;
+            spinner.text = `${ICON.retry} retry ${attempt}/3 in ${Math.floor(delayMs / 1000)}s (${shortReason})`;
         },
         onToolStart: async (event) => {
             if (!streamOutput)
                 return;
             clearToolTimer();
             toolStartAt = Date.now();
-            currentToolLabel = `${event.toolName} ${event.argsPreview}`;
-            spinner.start(`> ${currentToolLabel} (0s)`);
+            toolGroupTotal = event.total;
+            currentToolLabel = humanizeToolAction(event.toolName, event.argsPreview);
+            const progressPrefix = event.total > 1 ? ui.muted(`[${event.index}/${event.total}] `) : "";
+            spinner.start(`${progressPrefix}${chalk.dim(currentToolLabel)} (0.0s)`);
             toolTimer = setInterval(() => {
-                const elapsed = Math.floor((Date.now() - toolStartAt) / 1000);
-                spinner.text = `> ${currentToolLabel} (${elapsed}s)`;
-            }, 1000);
+                const elapsed = ((Date.now() - toolStartAt) / 1000).toFixed(1);
+                spinner.text = `${progressPrefix}${chalk.dim(currentToolLabel)} (${elapsed}s)`;
+            }, 200);
         },
         onToolEnd: async (event) => {
             if (!streamOutput)
                 return;
             clearToolTimer();
+            const elapsed = ((Date.now() - toolStartAt) / 1000).toFixed(1);
             spinner.stop();
+            const label = humanizeToolAction(event.toolName, "");
+            console.log(renderToolProgress(event.index, event.total, label, elapsed !== "0.0" ? `${elapsed}s` : undefined));
             if (runtime.agent.isVerboseTools()) {
-                console.log(chalk.dim(`\n[${event.toolName}]\n${event.resultPreview}`));
+                console.log(ui.muted(`    ${event.resultPreview.split("\n").join("\n    ")}`));
             }
             else if (event.truncated) {
-                console.log(chalk.yellow(`\nTool ${event.toolName} output was truncated before returning to model.`));
+                console.log(ui.warning(`    Output truncated before returning to model.`));
+            }
+            // Restart spinner so the user sees progress while the agent processes
+            // tool results and calls the router again.
+            if (event.index === event.total) {
+                printedToken = false;
+                printedAgentPrefix = false;
+                spinner.start(`${ICON.spark} thinking...`);
             }
         },
     };
@@ -295,15 +472,11 @@ async function executeTurn(runtime, rawPrompt, signal, outputFormat, streamOutpu
         const responseText = result.response;
         if (streamOutput) {
             if (!printedToken) {
-                console.log(chalk.bold.white("Agent:"));
+                console.log(UI().accent.bold(`${ICON.spark} Assistant`));
                 console.log(renderMarkdown(responseText).trimEnd());
             }
             else {
                 processStdout.write("\n");
-                if (looksLikeMarkdown(responseText)) {
-                    console.log(chalk.dim("[Rendered Markdown]"));
-                    console.log(renderMarkdown(responseText).trimEnd());
-                }
             }
         }
         if (!streamOutput && outputFormat === "text") {
@@ -311,16 +484,30 @@ async function executeTurn(runtime, rawPrompt, signal, outputFormat, streamOutpu
         }
         if (result.usage) {
             const metrics = runtime.context.recordTurn(result.model, result.usage);
+            const turnMs = Date.now() - turnStartedAt;
+            const ttftMs = firstTokenAt ? firstTokenAt - turnStartedAt : 0;
             if (streamOutput) {
-                console.log(chalk.dim(`[↑ ${metrics.promptTokens.toLocaleString()} | ↓ ${metrics.completionTokens.toLocaleString()} | ~${formatUsd(metrics.turnCostUsd)} | total ${formatUsd(metrics.cumulativeCostUsd)}]`));
+                const parts = [
+                    renderModelBadge(result.model),
+                    `ctx ${contextBar(metrics.contextUtilization)} ${(metrics.contextUtilization * 100).toFixed(1)}%`,
+                    `${ICON.token} in ${metrics.promptTokens.toLocaleString()}`,
+                    `${ICON.token} out ${metrics.completionTokens.toLocaleString()}`,
+                    `turn ${formatUsd(metrics.turnCostUsd)}`,
+                    `total ${formatUsd(metrics.cumulativeCostUsd)}`,
+                ];
+                if (ttftMs > 0) {
+                    parts.push(`${ICON.ttft} ${(ttftMs / 1000).toFixed(2)}s TTFT`);
+                }
+                parts.push(`${(turnMs / 1000).toFixed(1)}s`);
+                console.log(UI().muted(parts.join("  |  ")));
             }
             if (metrics.warnThresholdCrossed && streamOutput) {
-                console.log(chalk.yellow(`Context usage warning: ${(metrics.contextUtilization * 100).toFixed(1)}% of configured window (${runtime.config.contextWindowTokens.toLocaleString()} tokens).`));
+                console.log(UI().warning(`Context usage warning: ${(metrics.contextUtilization * 100).toFixed(1)}% of configured window (${runtime.config.contextWindowTokens.toLocaleString()} tokens).`));
             }
             if (metrics.autoCompactRecommended) {
                 const summary = await runtime.agent.compactHistory(signal);
                 if (streamOutput) {
-                    console.log(chalk.yellow(`Auto-compact triggered at ${(metrics.contextUtilization * 100).toFixed(1)}% context usage.`));
+                    console.log(UI().warning(`Auto-compact triggered at ${(metrics.contextUtilization * 100).toFixed(1)}% context usage.`));
                     console.log(renderMarkdown(summary).trimEnd());
                 }
             }
@@ -357,23 +544,58 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
             return { handled: true, shouldExit: true };
         case "/clear":
             console.clear();
+            printBanner(runtime, runtime.agent.getPermissionMode());
             return { handled: true, shouldExit: false };
         case "/tools":
             printTools();
             return { handled: true, shouldExit: false };
-        case "/permissions":
-            console.log(`Current permission mode: ${runtime.agent.getPermissionMode()}`);
+        case "/permissions": {
+            const mode = runtime.agent.getPermissionMode();
+            const policyRows = mode === "safe"
+                ? [
+                    ["Writes", UI().danger("disabled")],
+                    ["Shell", UI().danger("disabled")],
+                    ["Approvals", UI().success("n/a")],
+                ]
+                : mode === "standard"
+                    ? [
+                        ["Writes", UI().warning("requires confirmation")],
+                        ["Shell", UI().warning("requires confirmation")],
+                        ["Approvals", UI().info("interactive")],
+                    ]
+                    : [
+                        ["Writes", UI().success("enabled")],
+                        ["Shell", UI().success("enabled")],
+                        ["Approvals", UI().warning("auto-approved")],
+                    ];
+            console.log("");
+            console.log(UI().accent.bold(`${ICON.shield} Permission Mode`));
+            console.log(printTable(["Setting", "Value"], policyRows, [18, 28]));
+            console.log(UI().muted(`Current mode: ${mode}`));
+            console.log("");
             return { handled: true, shouldExit: false };
+        }
         case "/verbose": {
             const next = !runtime.agent.isVerboseTools();
             runtime.agent.setVerboseTools(next);
-            console.log(`Verbose tool output: ${next ? "ON" : "OFF"}`);
+            console.log(next
+                ? UI().success("Verbose tool output: ON")
+                : UI().muted("Verbose tool output: OFF"));
             await persistSnapshot(runtime);
             return { handled: true, shouldExit: false };
         }
         case "/cost": {
             const summary = runtime.context.getCostSummary();
-            console.log(`${chalk.dim("input")}: ${summary.inputTokens.toLocaleString()}  ${chalk.dim("output")}: ${summary.outputTokens.toLocaleString()}  ${chalk.dim("total")}: ${summary.totalTokens.toLocaleString()}  ${chalk.dim("cost")}: ${formatUsd(summary.totalCostUsd)}`);
+            const rows = [
+                ["Input tokens", summary.inputTokens.toLocaleString()],
+                ["Output tokens", summary.outputTokens.toLocaleString()],
+                ["Total tokens", summary.totalTokens.toLocaleString()],
+                ["Estimated cost", formatUsd(summary.totalCostUsd)],
+            ];
+            console.log("");
+            console.log(UI().accent.bold(`${ICON.token} Session Cost`));
+            console.log(printTable(["Metric", "Value"], rows, [20, 22]));
+            console.log("");
             return { handled: true, shouldExit: false };
         }
         case "/compact": {
@@ -384,18 +606,21 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
         }
         case "/models": {
             const models = await runtime.agent.listModels();
+            console.log("");
+            console.log(UI().accent.bold(`${ICON.model} Models (${models.length})`));
             console.log(formatModels(models));
+            console.log("");
             return { handled: true, shouldExit: false };
         }
         case "/undo": {
             const undone = runtime.agent.undoLastTurn();
             if (undone) {
                 setLastRawPrompt(undone);
-                console.log("Removed last user+assistant turn.");
+                console.log(UI().success("Removed last user+assistant turn."));
                 await persistSnapshot(runtime);
             }
             else {
-                console.log("Nothing to undo.");
+                console.log(UI().muted("Nothing to undo."));
             }
             return { handled: true, shouldExit: false };
         }
@@ -404,17 +629,21 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
         case "/save": {
             const name = argText || `session-${new Date().toISOString().replace(/[:.]/g, "-")}`;
             const location = await runtime.sessions.saveNamed(name, runtime.agent.exportState(runtime.context.serializeState()));
-            console.log(`Saved session as \"${name}\" -> ${location}`);
+            console.log(UI().success(`Saved session "${name}"`));
+            console.log(UI().muted(`Path: ${location}`));
             return { handled: true, shouldExit: false };
         }
         case "/load": {
             if (!argText) {
                 const names = await runtime.sessions.listNamed();
                 if (names.length === 0) {
-                    console.log("No named sessions found.");
+                    console.log(UI().muted("No named sessions found."));
                 }
                 else {
-                    console.log(`Named sessions: ${names.join(", ")}`);
+                    console.log("");
+                    console.log(UI().accent.bold(`Named Sessions (${names.length})`));
+                    console.log(names.map((name) => `  ${UI().info(name)}`).join("\n"));
+                    console.log("");
                 }
                 return { handled: true, shouldExit: false };
             }
@@ -425,7 +654,7 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
             }
             await restoreSnapshot(runtime, loaded);
             setLastRawPrompt(loaded.lastUserInput);
-            console.log(`Loaded session \"${argText}\".`);
+            console.log(UI().success(`Loaded session "${argText}".`));
             await persistSnapshot(runtime);
             return { handled: true, shouldExit: false };
         }
@@ -441,7 +670,7 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
                 return { handled: true, shouldExit: false };
             }
             process.chdir(path.resolve(resolved));
-            console.log(`Working directory: ${process.cwd()}`);
+            console.log(UI().success(`Working directory: ${process.cwd()}`));
             await persistSnapshot(runtime);
             return { handled: true, shouldExit: false };
         }
@@ -451,11 +680,14 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
             try {
                 const result = await run_linter({ path: targetPath, linter: "auto", fix: false });
                 spinner.stop();
+                console.log("");
+                console.log(UI().accent.bold(`Lint Results — ${targetPath}`));
                 console.log(result);
+                console.log("");
             }
             catch (err) {
                 spinner.stop();
-                console.log(chalk.red(`Linter error: ${err instanceof Error ? err.message : String(err)}`));
+                console.log(UI().danger(`Linter error: ${err instanceof Error ? err.message : String(err)}`));
             }
             return { handled: true, shouldExit: false };
         }
@@ -465,11 +697,14 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
             try {
                 const result = await run_tests({ path: targetPath, runner: "auto", bail: false });
                 spinner.stop();
+                console.log("");
+                console.log(UI().accent.bold(`Test Results${targetPath ? ` — ${targetPath}` : ""}`));
                 console.log(result);
+                console.log("");
             }
             catch (err) {
                 spinner.stop();
-                console.log(chalk.red(`Test runner error: ${err instanceof Error ? err.message : String(err)}`));
+                console.log(UI().danger(`Test runner error: ${err instanceof Error ? err.message : String(err)}`));
             }
             return { handled: true, shouldExit: false };
         }
@@ -479,11 +714,14 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
             try {
                 const result = await security_scan({ path: targetPath, include_low_severity: false });
                 spinner.stop();
+                console.log("");
+                console.log(UI().accent.bold(`Security Scan — ${targetPath}`));
                 console.log(result);
+                console.log("");
             }
             catch (err) {
                 spinner.stop();
-                console.log(chalk.red(`Scan error: ${err instanceof Error ? err.message : String(err)}`));
+                console.log(UI().danger(`Scan error: ${err instanceof Error ? err.message : String(err)}`));
             }
             return { handled: true, shouldExit: false };
         }
@@ -493,7 +731,10 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
             // /memory clear --global — clear global memory
             if (!argText) {
                 const output = await showMemory(runtime.workspaceRoot);
+                console.log("");
+                console.log(UI().accent.bold("Memory"));
                 console.log(output);
+                console.log("");
                 return { handled: true, shouldExit: false };
             }
             const memArgs = argText.split(/\s+/);
@@ -502,17 +743,17 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
                 await clearMemory(scope, runtime.workspaceRoot);
                 const fresh = await loadMemory(runtime.workspaceRoot);
                 runtime.agent.updateMemory(fresh);
-                console.log(`${scope === "global" ? "Global" : "Project"} memory cleared.`);
+                console.log(UI().success(`${scope === "global" ? "Global" : "Project"} memory cleared.`));
                 return { handled: true, shouldExit: false };
             }
-            console.log(`Unknown /memory subcommand: ${argText}`);
+            console.log(UI().warning(`Unknown /memory subcommand: ${argText}`));
             return { handled: true, shouldExit: false };
         }
         case "/remember": {
             // /remember <text>          — append to project memory
             // /remember --global <text> — append to global memory
             if (!argText) {
-                console.log("Usage: /remember <text>  or  /remember --global <text>");
+                console.log(UI().warning("Usage: /remember <text>  or  /remember --global <text>"));
                 return { handled: true, shouldExit: false };
             }
             let scope = "project";
@@ -522,14 +763,61 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
                 fact = fact.slice("--global".length).trim();
             }
             if (!fact) {
-                console.log("Nothing to remember — provide text after the flag.");
+                console.log(UI().warning("Nothing to remember — provide text after the flag."));
                 return { handled: true, shouldExit: false };
             }
             const savedPath = await appendMemory(fact, scope, runtime.workspaceRoot);
             const fresh = await loadMemory(runtime.workspaceRoot);
             runtime.agent.updateMemory(fresh);
-            console.log(chalk.green(`Remembered (${scope}): ${fact}`));
-            console.log(chalk.dim(`  → ${savedPath}`));
+            console.log(UI().success(`Remembered (${scope}): ${fact}`));
+            console.log(UI().muted(`Path: ${savedPath}`));
+            return { handled: true, shouldExit: false };
+        }
+        case "/logout": {
+            try {
+                await runLogout();
+                console.log(UI().success("Logged out. Run /login or restart to switch accounts."));
+            }
+            catch (err) {
+                console.log(UI().danger(`Logout error: ${err instanceof Error ? err.message : String(err)}`));
+            }
+            return { handled: true, shouldExit: false };
+        }
+        case "/login": {
+            const routerUrl = process.env.LLM_ROUTER_BASE_URL || "";
+            try {
+                await runLogin({ routerUrl });
+                // Reload credentials into env so the agent uses the new account immediately
+                const conn = await resolveConnectionFromEnvOrCreds();
+                if (conn) {
+                    console.log(UI().success("Logged in. New credentials active for this session."));
+                }
+            }
+            catch (err) {
+                console.log(UI().danger(`Login error: ${err instanceof Error ? err.message : String(err)}`));
+            }
+            return { handled: true, shouldExit: false };
+        }
+        case "/whoami": {
+            await runWhoami();
+            return { handled: true, shouldExit: false };
+        }
+        case "/theme": {
+            const validThemes = ["dark", "light", "minimal"];
+            if (!argText || !validThemes.includes(argText)) {
+                console.log("");
+                console.log(UI().accent.bold(`Themes`));
+                console.log(printTable(["Theme", "Description"], [
+                    [getThemeName() === "dark" ? UI().success("dark (active)") : "dark", "Full color with warm accent tones"],
+                    [getThemeName() === "light" ? UI().success("light (active)") : "light", "Muted palette for light terminals"],
+                    [getThemeName() === "minimal" ? UI().success("minimal (active)") : "minimal", "No color, bold/dim only"],
+                ], [22, 45]));
+                console.log(UI().muted(`\nUsage: /theme <dark|light|minimal>`));
+                console.log("");
+                return { handled: true, shouldExit: false };
+            }
+            setTheme(argText);
+            console.log(UI().success(`Theme set to: ${argText}`));
             return { handled: true, shouldExit: false };
         }
         case "/review": {
@@ -554,7 +842,7 @@ async function handleSlashCommand(runtime, commandLine, setLastRawPrompt) {
             }
             catch (err) {
                 if (!(err instanceof Error && err.name === "TurnCancelledError")) {
-                    console.log(chalk.red(`Review error: ${err instanceof Error ? err.message : String(err)}`));
+                    console.log(UI().danger(`Review error: ${err instanceof Error ? err.message : String(err)}`));
                 }
             }
             return { handled: true, shouldExit: false };
@@ -575,10 +863,16 @@ async function runNonInteractive(runtime, options) {
     await executeTurn(runtime, promptText, controller.signal, options.outputFormat, false);
 }
 async function runInteractive(runtime, options) {
+    _isInteractiveSession = true;
     printBanner(runtime, options.permissions);
     const health = await checkRouterHealth();
     if (!health.ok) {
-        console.log(chalk.yellow(`Warning: ${health.message} — check LLM_ROUTER_BASE_URL before running requests.`));
+        console.log(UI().warning(`${ICON.status} connection warning`));
+        console.log(UI().warning(`  ${health.message} — check LLM_ROUTER_BASE_URL.`));
+        console.log();
+    }
+    else {
+        console.log(UI().success(`${ICON.status} router connection healthy.`));
         console.log();
     }
     const replInput = new ReplInput(runtime.paths.historyFile, runtime.config.historyLimit);
@@ -602,7 +896,25 @@ async function runInteractive(runtime, options) {
         });
     });
     while (true) {
-        const userInput = await replInput.prompt();
+        // ora spinners write ANSI codes to stdout while readline manages the same
+        // stream, which can leave the readline interface in a closed/corrupt state
+        // (especially on Node.js 22+).  Always reset after a turn so the next
+        // prompt() call starts with a fresh, healthy interface.
+        let userInput;
+        try {
+            userInput = await replInput.prompt();
+        }
+        catch {
+            try {
+                await replInput.resetInterface();
+                userInput = await replInput.prompt();
+            }
+            catch {
+                // Truly unrecoverable (e.g. stdin closed / Ctrl-D); exit gracefully.
+                console.log(chalk.yellow("\nSession ended."));
+                return;
+            }
+        }
         const trimmed = userInput.trim();
         if (!trimmed)
             continue;
@@ -617,18 +929,19 @@ async function runInteractive(runtime, options) {
             }
             if (trimmed === "/retry") {
                 if (!lastRawPrompt) {
-                    console.log("No previous prompt to retry.");
+                    console.log(UI().warning("No previous prompt to retry."));
                     continue;
                 }
             }
             else {
-                console.log(`Unknown command: ${trimmed}`);
+                console.log(UI().warning(`Unknown command: ${trimmed}`));
+                console.log(UI().muted(`${ICON.tip} Run /help to view available commands.`));
                 continue;
             }
         }
         const rawPrompt = trimmed === "/retry" ? lastRawPrompt ?? "" : userInput;
         if (!rawPrompt.trim()) {
-            console.log("No previous prompt to retry.");
+            console.log(UI().warning("No previous prompt to retry."));
             continue;
         }
         lastRawPrompt = rawPrompt;
@@ -642,31 +955,52 @@ async function runInteractive(runtime, options) {
             }
             else {
                 const message = err instanceof Error ? err.message : String(err);
-                console.log(chalk.red(`Error: ${message}`));
+                // Contextual error suggestions
+                let suggestion;
+                if (message.includes("504") || message.includes("timeout")) {
+                    suggestion = "The upstream model timed out. Try a faster model with --model or check /models.";
+                }
+                else if (message.includes("context") || message.includes("token")) {
+                    suggestion = "Try /compact to reduce context usage, or start a new session.";
+                }
+                else if (message.includes("429") || message.includes("rate")) {
+                    suggestion = "Rate limited. Wait a moment and try again, or switch models.";
+                }
+                else if (message.includes("401") || message.includes("auth")) {
+                    suggestion = "Authentication failed. Try /login or check your API key.";
+                }
+                console.log(renderErrorCard(message, suggestion));
             }
         }
         finally {
             activeTurnController = null;
         }
         console.log();
+        // Reset readline interface after every turn so ora spinner side-effects
+        // don't accumulate and corrupt the next prompt() call.
+        await replInput.resetInterface();
     }
     await replInput.close();
 }
 // ── First-run setup wizard ────────────────────────────────────────────────────
 async function runFirstTimeSetup() {
-    const { confirm, input, select } = await import("@inquirer/prompts");
-    console.log(chalk.bold.cyan("\n  Welcome to LLM-Router CLI Agent!\n"));
-    console.log(chalk.dim("  No connection configured. Let's get you set up.\n"));
+    const { input, select } = await import("@inquirer/prompts");
+    console.log("");
+    console.log(renderPanel([
+        ` ${UI().title(`${ICON.spark} Welcome to LLM-Router CLI Agent`)}`,
+        ` ${UI().muted("No connection found. Let's configure authentication.")}`,
+    ]));
+    console.log("");
     const routerUrl = await input({
         message: "Router URL:",
-        default: "https://api.llm-router.dev",
+        default: "https://llm-router-6o4u74bhpq-uc.a.run.app",
         validate: (v) => {
             try {
                 new URL(v);
                 return true;
             }
             catch {
-                return "Enter a valid URL (e.g. https://api.llm-router.dev)";
+                return "Enter a valid URL (e.g. https://llm-router-6o4u74bhpq-uc.a.run.app)";
             }
         },
     });
@@ -695,7 +1029,7 @@ async function runFirstTimeSetup() {
         });
         process.env.LLM_ROUTER_BASE_URL = routerUrl;
         process.env.LLM_ROUTER_API_KEY = apiKey;
-        console.log(chalk.green("\n✓ API key saved.\n"));
+        console.log(UI().success(`\n${ICON.status} API key saved.\n`));
     }
     return true;
 }
@@ -761,7 +1095,14 @@ program
     await persistSnapshot(runtime);
     const nonInteractive = Boolean(options.prompt) || !processStdin.isTTY;
     if (nonInteractive) {
-        await runNonInteractive(runtime, options);
+        try {
+            await runNonInteractive(runtime, options);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(chalk.red(`\nError: ${msg}`));
+            process.exit(1);
+        }
         return;
     }
     await runInteractive(runtime, options);
@@ -781,7 +1122,7 @@ program
         const { input } = await import("@inquirer/prompts");
         routerUrl = await input({
             message: "Router URL:",
-            default: "https://api.llm-router.dev",
+            default: "https://llm-router-6o4u74bhpq-uc.a.run.app",
             validate: (v) => {
                 try {
                     new URL(v);
@@ -897,6 +1238,21 @@ program
         console.log();
     }
 });
+// Safety net: catch any unhandled promise rejections so they display a useful
+// message instead of crashing the process silently (Node 22 terminates on them).
+// In interactive mode we log but do NOT exit — the REPL should survive stray
+// async errors (e.g. failed snapshot writes, readline hiccups).
+let _isInteractiveSession = false;
+process.on("unhandledRejection", (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    if (_isInteractiveSession) {
+        console.error(chalk.red(`\nAsync error (non-fatal): ${msg}`));
+    }
+    else {
+        console.error(chalk.red(`\nUnhandled error: ${msg}`));
+        process.exit(1);
+    }
+});
 program.parseAsync().catch((err) => {
     const message = err instanceof Error ? err.message : String(err);
     console.error(chalk.red(message));