paseo-acp-agy 1.1.0

package/dist/session.js

@@ -0,0 +1,227 @@
+import crypto from "node:crypto";
+import { AntigravityProcess } from "./antigravity-process.js";
+import { logger } from "./logger.js";
+import { resolvePermissionSettings } from "./permissions.js";
+import { calculateUsageCostUsd, getModelContextWindow } from "./protocol.js";
+import { sessionStore, } from "./session-store.js";
+export class Session {
+    id;
+    cwd;
+    model;
+    effort;
+    mode;
+    createdAt;
+    lastActivity;
+    isCancelled = false;
+    process;
+    usage;
+    store;
+    promptOperationActive = false;
+    constructor(options = {}) {
+        this.id = options.id || crypto.randomUUID();
+        this.cwd = options.cwd || process.cwd();
+        this.model = options.model || "gemini-3.7-flash";
+        this.effort = options.effort || "high";
+        this.mode = options.mode || "default";
+        this.createdAt = new Date();
+        this.lastActivity = new Date();
+        this.store = options.store || sessionStore;
+        this.usage = options.usage || {
+            inputTokens: 0,
+            outputTokens: 0,
+            cachedInputTokens: 0,
+            totalTokens: 0,
+            totalCostUsd: 0,
+            contextWindowUsedTokens: 0,
+            contextWindowMaxTokens: getModelContextWindow(this.model),
+        };
+        const permissions = resolvePermissionSettings({
+            sandbox: options.sandbox,
+            dangerouslySkipPermissions: options.dangerouslySkipPermissions,
+            mode: this.mode,
+        });
+        this.process = new AntigravityProcess({
+            binaryPath: options.binaryPath,
+            cwd: this.cwd,
+            model: this.model,
+            effort: this.effort,
+            mode: this.mode,
+            conversationId: options.conversationId,
+            permissions,
+            env: options.env,
+        });
+        this.process.on("init", () => this.persist());
+        this.process.on("result", () => this.persist());
+        this.persist();
+    }
+    persistedState() {
+        return {
+            sessionId: this.id,
+            conversationId: this.process.currentConversationId,
+            cwd: this.cwd,
+            model: this.model,
+            effort: this.effort,
+            mode: this.mode,
+            usage: this.usage,
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    persist() {
+        this.store.save(this.persistedState());
+    }
+    get isPromptOperationActive() {
+        return this.promptOperationActive;
+    }
+    tryBeginPromptOperation() {
+        if (this.promptOperationActive)
+            return false;
+        this.promptOperationActive = true;
+        this.isCancelled = false;
+        return true;
+    }
+    endPromptOperation() {
+        this.promptOperationActive = false;
+    }
+    setModel(model) {
+        this.model = model;
+        this.usage.contextWindowMaxTokens = getModelContextWindow(model);
+        this.process.setModel(model);
+        this.persist();
+    }
+    setEffort(effort) {
+        this.effort = effort;
+        this.process.setEffort(effort);
+        this.persist();
+    }
+    setMode(mode) {
+        this.mode = mode;
+        this.process.setMode(mode);
+        this.persist();
+    }
+    setConversationId(conversationId) {
+        this.process.setConversationId(conversationId);
+        this.persist();
+    }
+    async ensureReadyForResume() {
+        const conversationId = this.process.currentConversationId;
+        if (!conversationId) {
+            throw new Error(`ACP session ${this.id} has no persisted Antigravity conversation ID`);
+        }
+        try {
+            await this.process.ensureReady(conversationId);
+            this.persist();
+        }
+        catch (err) {
+            this.persist();
+            throw err;
+        }
+    }
+    async resumeConversation(conversationId) {
+        const previousConversationId = this.process.currentConversationId;
+        this.setConversationId(conversationId);
+        try {
+            await this.ensureReadyForResume();
+        }
+        catch (err) {
+            // A failed manual /resume must not poison the current Paseo session.
+            this.setConversationId(previousConversationId);
+            this.persist();
+            throw err;
+        }
+    }
+    recordTurnUsage(turnUsage, executingModel = this.model) {
+        if (!turnUsage)
+            return;
+        const input = turnUsage.input_tokens || 0;
+        const output = turnUsage.output_tokens || 0;
+        const cached = turnUsage.cache_read_tokens || 0;
+        const turnCost = calculateUsageCostUsd(executingModel, input, output, cached);
+        this.usage.inputTokens += input;
+        this.usage.outputTokens += output;
+        this.usage.cachedInputTokens += cached;
+        this.usage.totalTokens = this.usage.inputTokens + this.usage.outputTokens;
+        // Keep the accumulator unrounded. Micro-costs must survive across turns.
+        this.usage.totalCostUsd += turnCost;
+        this.usage.contextWindowUsedTokens = input + output;
+        // The selected model may have changed while this turn was running. Keep
+        // the stored meter aligned with the model currently selected for next turn.
+        this.usage.contextWindowMaxTokens = getModelContextWindow(this.model);
+        this.persist();
+    }
+    touch() {
+        this.lastActivity = new Date();
+    }
+    cancelTurn() {
+        const processCancelled = this.process.cancelCurrentTurn();
+        const cancelled = this.promptOperationActive || processCancelled;
+        if (cancelled)
+            this.isCancelled = true;
+        return cancelled;
+    }
+    async close() {
+        logger.info("Closing session", { sessionId: this.id });
+        this.persist();
+        this.promptOperationActive = false;
+        await this.process.close();
+    }
+}
+export class SessionManager {
+    sessions = new Map();
+    defaultBinaryPath;
+    store;
+    constructor(options) {
+        this.defaultBinaryPath = options?.defaultBinaryPath;
+        this.store = options?.store || sessionStore;
+    }
+    createSession(options = {}) {
+        const persisted = options.id ? this.store.load(options.id) : null;
+        if (options.id && !persisted) {
+            throw new Error(`Cannot restore unknown ACP session: ${options.id}`);
+        }
+        const session = new Session({
+            id: options.id,
+            binaryPath: options.binaryPath || this.defaultBinaryPath,
+            cwd: options.cwd || persisted?.cwd,
+            model: options.model || persisted?.model,
+            effort: options.effort || persisted?.effort,
+            mode: options.mode || persisted?.mode,
+            conversationId: options.conversationId || persisted?.conversationId,
+            usage: options.usage || persisted?.usage,
+            sandbox: options.sandbox,
+            dangerouslySkipPermissions: options.dangerouslySkipPermissions,
+            env: options.env,
+            store: this.store,
+        });
+        this.sessions.set(session.id, session);
+        logger.info("Created new session", {
+            sessionId: session.id,
+            cwd: session.cwd,
+            model: session.model,
+            effort: session.effort,
+            resumedConversation: Boolean(session.process.currentConversationId),
+        });
+        return session;
+    }
+    getSession(id) {
+        return this.sessions.get(id);
+    }
+    hasPersistedSession(id) {
+        return this.store.load(id) !== null;
+    }
+    async closeSession(id) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return false;
+        await session.close();
+        this.sessions.delete(id);
+        return true;
+    }
+    async closeAll() {
+        logger.info("Closing all active sessions", { count: this.sessions.size });
+        await Promise.allSettled(Array.from(this.sessions.values(), (session) => session.close()));
+        this.sessions.clear();
+    }
+    listSessions() {
+        return Array.from(this.sessions.values());
+    }
+}

package/dist/slash-commands.d.ts

@@ -0,0 +1,33 @@
+import { Session } from "./session.js";
+export interface SlashCommandDefinition {
+    name: string;
+    description: string;
+    argumentHint?: string;
+}
+export declare const AVAILABLE_SLASH_COMMANDS: SlashCommandDefinition[];
+export interface RecentConversation {
+    id: string;
+    mtime: number;
+    dateStr: string;
+    firstPrompt: string;
+    totalSteps: number;
+    userTurns: number;
+}
+export interface ConversationStepItem {
+    index: number;
+    role: "user" | "assistant" | "tool";
+    text: string;
+}
+export declare function listRecentConversations(limit?: number): RecentConversation[];
+export declare function getConversationSteps(cid: string): {
+    totalSteps: number;
+    userTurns: number;
+    steps: ConversationStepItem[];
+} | null;
+export declare function formatStepsTimeline(steps: ConversationStepItem[]): string;
+export declare function resolveTargetConversationId(targetId: string): string | null;
+export declare function formatUsageOutput(rawText: string): string;
+export declare function executeSlashCommand(promptText: string, session: Session, binaryPath: string): Promise<{
+    handled: boolean;
+    response?: string;
+}>;

package/dist/slash-commands.js

@@ -0,0 +1,434 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "./logger.js";
+import { sessionStore } from "./session-store.js";
+const execFileAsync = promisify(execFile);
+const AGY_COMMAND_TIMEOUT_MS = 30_000;
+const AGY_COMMAND_MAX_BUFFER = 4 * 1024 * 1024;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const SAFE_LOOKUP_ID_RE = /^[A-Za-z0-9_-]{6,128}$/;
+const SAFE_CONVERSATION_PREFIX_RE = /^[0-9a-f-]{6,36}$/i;
+export const AVAILABLE_SLASH_COMMANDS = [
+    { name: "resume", description: "Listar ou retomar uma sessão anterior (/resume ou /resume <id>)", argumentHint: "<conversation-ou-agent-id>" },
+    { name: "usage", description: "Exibir uso e quota restante dos modelos (Gemini, Claude, GPT)" },
+    { name: "quota", description: "Alias para /usage" },
+    { name: "help", description: "Exibir lista de comandos e opções disponíveis" },
+    { name: "credits", description: "Exibir saldo de créditos G1" },
+    { name: "skills", description: "Listar skills instaladas no Antigravity" },
+    { name: "agents", description: "Listar agentes disponíveis" },
+    { name: "changelog", description: "Exibir notas de versão e novidades do Antigravity" },
+];
+function brainDir() {
+    return path.join(os.homedir(), ".gemini", "antigravity-cli", "brain");
+}
+function transcriptPath(conversationId) {
+    if (!UUID_RE.test(conversationId))
+        return null;
+    return path.join(brainDir(), conversationId, ".system_generated", "logs", "transcript.jsonl");
+}
+function summarizeConversation(cid, logFile, mtime) {
+    try {
+        const lines = fs.readFileSync(logFile, "utf8").split("\n").filter(Boolean);
+        let firstPrompt = "";
+        let userTurns = 0;
+        for (const line of lines) {
+            if (!line.includes('"USER_INPUT"'))
+                continue;
+            userTurns++;
+            if (!firstPrompt) {
+                try {
+                    const parsed = JSON.parse(line);
+                    let text = String(parsed.content || "");
+                    if (text.includes("<USER_REQUEST>")) {
+                        text = text.split("<USER_REQUEST>")[1].split("</USER_REQUEST>")[0];
+                    }
+                    firstPrompt = text.trim().replace(/\s+/g, " ").slice(0, 80);
+                }
+                catch { }
+            }
+        }
+        const date = new Date(mtime);
+        return {
+            id: cid,
+            mtime,
+            dateStr: date.toLocaleString("pt-BR", {
+                timeZone: "America/Sao_Paulo",
+                month: "2-digit",
+                day: "2-digit",
+                hour: "2-digit",
+                minute: "2-digit",
+            }),
+            firstPrompt: firstPrompt || "(sem texto inicial)",
+            totalSteps: lines.length,
+            userTurns,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function listRecentConversations(limit = 10) {
+    const root = brainDir();
+    if (!fs.existsSync(root) || limit <= 0)
+        return [];
+    try {
+        // Stat every candidate first, then read only the newest transcripts. This
+        // keeps /resume proportional to the requested result count instead of the
+        // total accumulated history size.
+        const candidates = [];
+        for (const cid of fs.readdirSync(root)) {
+            if (!UUID_RE.test(cid))
+                continue;
+            const logFile = transcriptPath(cid);
+            if (!logFile || !fs.existsSync(logFile))
+                continue;
+            try {
+                candidates.push({ id: cid, logFile, mtime: fs.statSync(logFile).mtimeMs });
+            }
+            catch { }
+        }
+        candidates.sort((a, b) => b.mtime - a.mtime);
+        const results = [];
+        for (const candidate of candidates.slice(0, limit)) {
+            const summary = summarizeConversation(candidate.id, candidate.logFile, candidate.mtime);
+            if (summary)
+                results.push(summary);
+        }
+        return results;
+    }
+    catch (err) {
+        logger.warn("Failed to read recent conversations from brain", {
+            error: err.message,
+        });
+        return [];
+    }
+}
+export function getConversationSteps(cid) {
+    const logFile = transcriptPath(cid);
+    if (!logFile || !fs.existsSync(logFile))
+        return null;
+    try {
+        const lines = fs.readFileSync(logFile, "utf8").split("\n").filter(Boolean);
+        const steps = [];
+        let userTurns = 0;
+        for (let i = 0; i < lines.length; i++) {
+            try {
+                const data = JSON.parse(lines[i]);
+                const idx = typeof data.step_index === "number" ? data.step_index : i;
+                const type = data.type;
+                let text = "";
+                let role = "assistant";
+                if (type === "USER_INPUT") {
+                    userTurns++;
+                    role = "user";
+                    let raw = String(data.content || "");
+                    if (raw.includes("<USER_REQUEST>")) {
+                        raw = raw.split("<USER_REQUEST>")[1].split("</USER_REQUEST>")[0];
+                    }
+                    text = raw.trim().replace(/\s+/g, " ").slice(0, 90);
+                }
+                else if (type === "PLANNER_RESPONSE") {
+                    const toolCalls = Array.isArray(data.tool_calls) ? data.tool_calls : [];
+                    if (toolCalls.length > 0) {
+                        role = "tool";
+                        const toolNames = toolCalls.map((tc) => {
+                            const name = tc.name || tc.tool_name || "tool";
+                            let target = "";
+                            if (tc.args) {
+                                if (typeof tc.args.AbsolutePath === "string") {
+                                    target = path.basename(tc.args.AbsolutePath.replace(/"/g, ""));
+                                }
+                                else if (typeof tc.args.CommandLine === "string") {
+                                    target = tc.args.CommandLine.slice(0, 25);
+                                }
+                            }
+                            return target ? `${name}(${target})` : name;
+                        });
+                        text = "Ferramenta: " + toolNames.join(", ");
+                    }
+                    else if (data.content) {
+                        text = String(data.content).trim().replace(/\s+/g, " ").slice(0, 90);
+                    }
+                }
+                if (text)
+                    steps.push({ index: idx, role, text });
+            }
+            catch { }
+        }
+        return { totalSteps: lines.length, userTurns, steps };
+    }
+    catch {
+        return null;
+    }
+}
+export function formatStepsTimeline(steps) {
+    if (steps.length === 0)
+        return "";
+    let md = "#### 📜 Histórico de Passos (Steps):\n";
+    const append = (step) => {
+        const roleLabel = step.role === "user" ? "User" : step.role === "tool" ? "Ferramenta" : "Assistente";
+        md += `• **Step ${step.index}** *(${roleLabel})*: ${step.text}\n`;
+    };
+    if (steps.length <= 8) {
+        steps.forEach(append);
+    }
+    else {
+        steps.slice(0, 2).forEach(append);
+        md += `• *... (${steps.length - 7} passos intermediários ocultos) ...*\n`;
+        steps.slice(-5).forEach(append);
+    }
+    return md;
+}
+export function resolveTargetConversationId(targetId) {
+    const cleanId = targetId.trim();
+    if (!cleanId || !SAFE_LOOKUP_ID_RE.test(cleanId))
+        return null;
+    const persisted = sessionStore.load(cleanId);
+    if (persisted?.conversationId && UUID_RE.test(persisted.conversationId)) {
+        return persisted.conversationId;
+    }
+    const root = brainDir();
+    if (UUID_RE.test(cleanId) && fs.existsSync(path.join(root, cleanId)))
+        return cleanId;
+    if (SAFE_CONVERSATION_PREFIX_RE.test(cleanId)) {
+        try {
+            const matches = fs
+                .readdirSync(root)
+                .filter((entry) => UUID_RE.test(entry) && entry.startsWith(cleanId));
+            if (matches.length === 1)
+                return matches[0];
+            if (matches.length > 1)
+                return null;
+        }
+        catch { }
+    }
+    const paseoAgentsDir = path.join(os.homedir(), ".paseo", "agents");
+    if (!fs.existsSync(paseoAgentsDir))
+        return null;
+    try {
+        for (const sub of fs.readdirSync(paseoAgentsDir)) {
+            const fullSub = path.join(paseoAgentsDir, sub);
+            if (!fs.statSync(fullSub).isDirectory())
+                continue;
+            for (const file of fs.readdirSync(fullSub)) {
+                if (!file.startsWith(cleanId) || !file.endsWith(".json"))
+                    continue;
+                const agentJson = JSON.parse(fs.readFileSync(path.join(fullSub, file), "utf8"));
+                const paseoSessionId = agentJson.runtimeInfo?.sessionId;
+                if (typeof paseoSessionId !== "string")
+                    continue;
+                const state = sessionStore.load(paseoSessionId);
+                if (state?.conversationId && UUID_RE.test(state.conversationId)) {
+                    return state.conversationId;
+                }
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+function renderProgressBar(percentage) {
+    const filled = Math.max(0, Math.min(10, Math.round(percentage / 10)));
+    return "█".repeat(filled) + "░".repeat(10 - filled);
+}
+function getStatusBadge(percentage) {
+    if (percentage >= 70)
+        return "🟢";
+    if (percentage >= 30)
+        return "🟡";
+    return "🔴";
+}
+function formatCountdown(isoStr) {
+    try {
+        const target = new Date(isoStr);
+        const diffMs = target.getTime() - Date.now();
+        if (!Number.isFinite(diffMs))
+            return isoStr;
+        if (diffMs <= 0)
+            return "agora";
+        const diffHours = Math.floor(diffMs / 3_600_000);
+        const diffMins = Math.floor((diffMs % 3_600_000) / 60_000);
+        const timeStr = target.toLocaleTimeString("pt-BR", {
+            timeZone: "America/Sao_Paulo",
+            hour: "2-digit",
+            minute: "2-digit",
+        });
+        const dateStr = target.toLocaleDateString("pt-BR", {
+            timeZone: "America/Sao_Paulo",
+            day: "2-digit",
+            month: "2-digit",
+        });
+        if (diffHours < 24)
+            return `em **${diffHours}h ${diffMins}m** *(às ${timeStr})*`;
+        const days = Math.floor(diffHours / 24);
+        return `em **${days} ${days === 1 ? "dia" : "dias"}** *(${dateStr} às ${timeStr})*`;
+    }
+    catch {
+        return isoStr;
+    }
+}
+export function formatUsageOutput(rawText) {
+    const groups = new Map();
+    for (const line of rawText.trim().split("\n")) {
+        const parts = line.includes("\t") ? line.split("\t") : line.split(/\s{2,}/);
+        if (parts.length < 3)
+            continue;
+        let fam = parts[0].trim();
+        let icon = "🤖";
+        if (fam.toLowerCase().includes("gemini")) {
+            fam = "Google Gemini";
+            icon = "🔷";
+        }
+        else if (fam.toLowerCase().includes("claude")) {
+            fam = "Claude & GPT";
+            icon = "🔶";
+        }
+        const rawWindow = parts[1].replace(" Remaining", "").trim();
+        const lowerWindow = rawWindow.toLowerCase();
+        const isFiveHour = lowerWindow.includes("five hour") || /\b5\s*hour/.test(lowerWindow);
+        const win = isFiveHour
+            ? "Janela de 5 Horas"
+            : lowerWindow.includes("weekly")
+                ? "Cota Semanal"
+                : rawWindow;
+        const pctStr = parts[2].trim();
+        const parsedPct = Number.parseInt(pctStr.replace("%", ""), 10);
+        const pct = Number.isFinite(parsedPct) ? parsedPct : 0;
+        const reset = parts[3]?.trim() || "";
+        if (!groups.has(fam))
+            groups.set(fam, { icon, items: [] });
+        groups.get(fam).items.push({ win, isFiveHour, pct, pctStr, reset });
+    }
+    if (groups.size === 0) {
+        return `### 📊 Quota de Uso do Antigravity\n\n\`\`\`text\n${rawText.trim()}\n\`\`\``;
+    }
+    let out = "### ⚡ Quotas de Uso — Antigravity\n\n";
+    for (const [fam, data] of groups.entries()) {
+        data.items.sort((a, b) => Number(b.isFiveHour) - Number(a.isFiveHour));
+        out += `**${data.icon} ${fam}**\n`;
+        for (const item of data.items) {
+            out += `• **${item.win}:** ${getStatusBadge(item.pct)} **${item.pctStr}** livre  \n`;
+            out += `  \`[${renderProgressBar(item.pct)}]\` · Reset ${item.reset ? formatCountdown(item.reset) : ""}\n`;
+        }
+        out += "\n";
+    }
+    out += "---\n> 💡 *A janela de 5 horas renova dinamicamente conforme o tempo passa.*";
+    return out;
+}
+async function runAgySlash(binaryPath, cwd, slashCommand) {
+    const { stdout, stderr } = await execFileAsync(binaryPath, ["--print", slashCommand], {
+        cwd,
+        env: process.env,
+        timeout: AGY_COMMAND_TIMEOUT_MS,
+        maxBuffer: AGY_COMMAND_MAX_BUFFER,
+    });
+    return stdout.trim() || stderr.trim();
+}
+export async function executeSlashCommand(promptText, session, binaryPath) {
+    const trimmed = promptText.trim();
+    if (!trimmed.startsWith("/"))
+        return { handled: false };
+    const parts = trimmed.slice(1).split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1).join(" ").trim();
+    logger.info("Intercepted slash command", { command, args, sessionId: session.id });
+    switch (command) {
+        case "resume": {
+            if (!args) {
+                const recent = listRecentConversations(10);
+                if (recent.length === 0) {
+                    return {
+                        handled: true,
+                        response: "Nenhuma sessão anterior foi encontrada no histórico local do Antigravity.",
+                    };
+                }
+                let list = "### 📋 Sessões Recentes do Antigravity\n\n";
+                for (const conversation of recent) {
+                    const stepsText = conversation.totalSteps > 0
+                        ? ` · 🟢 **${conversation.totalSteps} steps** (${conversation.userTurns} turno${conversation.userTurns !== 1 ? "s" : ""})`
+                        : "";
+                    list += `• **${conversation.dateStr}**${stepsText}  \n  *${conversation.firstPrompt}*  \n  \`/resume ${conversation.id}\`\n\n`;
+                }
+                list += "---\n💡 *Copie ou digite `/resume <ID>` acima para retomar qualquer sessão.*";
+                return { handled: true, response: list };
+            }
+            const resolvedConvId = resolveTargetConversationId(args);
+            if (!resolvedConvId) {
+                return {
+                    handled: true,
+                    response: `❌ **Sessão não encontrada.**\n\nNão foi possível localizar o histórico para \`${args}\`.\n\nDigite \`/resume\` sem argumentos para ver a lista de sessões disponíveis.`,
+                };
+            }
+            try {
+                // Validate --conversation immediately instead of reporting success and
+                // discovering a broken resume on the user's next message.
+                await session.resumeConversation(resolvedConvId);
+            }
+            catch (err) {
+                return {
+                    handled: true,
+                    response: `❌ **Falha ao retomar sessão.**\n\n${err.message}`,
+                };
+            }
+            logger.info("Resumed conversation for session", {
+                sessionId: session.id,
+                conversationId: resolvedConvId,
+            });
+            const details = getConversationSteps(resolvedConvId);
+            const stepsSection = details?.steps.length ? `\n${formatStepsTimeline(details.steps)}\n` : "";
+            const stepsInfo = details
+                ? `- **Total de Steps:** ${details.totalSteps} steps (${details.userTurns} turno${details.userTurns !== 1 ? "s" : ""})\n`
+                : "";
+            return {
+                handled: true,
+                response: `✅ **Sessão retomada com sucesso!**\n\n- **Conversation ID:** \`${resolvedConvId}\`\n${stepsInfo}- **Modelo Ativo:** \`${session.model}\`\n${stepsSection}---\n💡 *Contexto carregado. Envie sua próxima mensagem para continuar a partir de onde parou!*`,
+            };
+        }
+        case "usage":
+        case "quota":
+            try {
+                return { handled: true, response: formatUsageOutput(await runAgySlash(binaryPath, session.cwd, "/usage")) };
+            }
+            catch (err) {
+                return { handled: true, response: `Erro ao obter uso de quota: ${err.message}` };
+            }
+        case "credits":
+            try {
+                return { handled: true, response: `### 💳 Saldo de Créditos Antigravity\n\n\`\`\`text\n${await runAgySlash(binaryPath, session.cwd, "/credits")}\n\`\`\`` };
+            }
+            catch (err) {
+                return { handled: true, response: `Erro ao consultar créditos: ${err.message}` };
+            }
+        case "skills":
+            try {
+                return { handled: true, response: `### 🛠️ Skills Instaladas\n\n\`\`\`text\n${await runAgySlash(binaryPath, session.cwd, "/skills")}\n\`\`\`` };
+            }
+            catch (err) {
+                return { handled: true, response: `Erro ao listar skills: ${err.message}` };
+            }
+        case "agents":
+            try {
+                return { handled: true, response: `### 🤖 Agentes Disponíveis\n\n\`\`\`text\n${await runAgySlash(binaryPath, session.cwd, "/agents")}\n\`\`\`` };
+            }
+            catch (err) {
+                return { handled: true, response: `Erro ao listar agentes: ${err.message}` };
+            }
+        case "changelog":
+            try {
+                return { handled: true, response: `### 📜 Notas de Atualização (Changelog)\n\n${await runAgySlash(binaryPath, session.cwd, "/changelog")}` };
+            }
+            catch (err) {
+                return { handled: true, response: `Erro ao buscar changelog: ${err.message}` };
+            }
+        case "help":
+            return {
+                handled: true,
+                response: "### 📖 Comandos Disponíveis no Antigravity (Paseo)\n\n| Comando | Descrição |\n|:---|:---|\n| `/resume` | Lista as últimas 10 sessões disponíveis para retomada |\n| `/resume <id>` | Retoma e valida a sessão especificada |\n| `/usage` | Exibe o consumo e cotas restantes (Gemini, Claude, GPT) |\n| `/credits` | Exibe o saldo de créditos G1 |\n| `/skills` | Lista as skills instaladas no ambiente |\n| `/agents` | Lista os tipos de agentes configurados |\n| `/changelog` | Exibe as notas de versão do Antigravity |\n| `/help` | Exibe este painel de ajuda |\n",
+            };
+        default:
+            return { handled: false };
+    }
+}