paseo-acp-agy 1.2.12 → 1.2.14

package/dist/acp-server.d.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from "node:events";
 import { SessionManager } from "./session.js";
 export declare class ACPServer extends EventEmitter {
     private sessionManager;
+    private mcpBridge;
     private input;
     private output;
     private binaryPath;

package/dist/acp-server.js

@@ -1,12 +1,14 @@
 import readline from "node:readline";
 import { EventEmitter } from "node:events";
 import { logger } from "./logger.js";
-import { ACP_METHODS, AVAILABLE_MODES, AVAILABLE_PERMISSIONS, fetchAvailableModels, buildConfigOptionsForSession, extractPromptText, mapToolNameToKind, extractImageMarkdownLink, isNarrationText, calculateUsageCostUsd, roundUsageCostUsd, getModelContextWindow, fetchAntigravityUsage, } from "./protocol.js";
+import { ACP_METHODS, AVAILABLE_MODES, AVAILABLE_PERMISSIONS, fetchAvailableModels, buildConfigOptionsForSession, extractPromptText, extractImageMarkdownLink, isNarrationText, calculateUsageCostUsd, roundUsageCostUsd, getModelContextWindow, fetchAntigravityUsage, } from "./protocol.js";
 import { SessionManager } from "./session.js";
 import { executeSlashCommand, AVAILABLE_SLASH_COMMANDS } from "./slash-commands.js";
 import { getShortVersion } from "./version.js";
 import { resolveDefaultAgyBinary } from "./antigravity-process.js";
 import { loadConversationTranscript } from "./transcript.js";
+import { normalizeToolCall, normalizeToolResult, extractPlanEntries } from "./tool-formatter.js";
+import { McpBridge } from "./mcp-bridge.js";
 function splitModelAndEffort(modelInput) {
     if (!modelInput)
         return {};
@@ -20,6 +22,7 @@ function splitModelAndEffort(modelInput) {
 }
 export class ACPServer extends EventEmitter {
     sessionManager;
+    mcpBridge;
     input;
     output;
     binaryPath;
@@ -31,6 +34,7 @@ export class ACPServer extends EventEmitter {
         this.input = options.input || process.stdin;
         this.output = options.output || process.stdout;
         this.binaryPath = options.binaryPath || resolveDefaultAgyBinary();
+        this.mcpBridge = new McpBridge(this.binaryPath);
         this.skipNarration =
             options.skipNarration ?? (process.env.AGY_ACP_SKIP_NARRATION === "true");
         this.sessionManager =
@@ -223,6 +227,10 @@ export class ACPServer extends EventEmitter {
                     const requestedModel = typeof params.model === "string" ? params.model : undefined;
                     const parsedModel = splitModelAndEffort(requestedModel);
                     const mode = typeof params.mode === "string" ? params.mode : undefined;
+                    const mcpServers = params.mcpServers;
+                    if (mcpServers) {
+                        void this.mcpBridge.syncServers(mcpServers);
+                    }
                     const session = this.sessionManager.createSession({
                         cwd,
                         model: parsedModel.model,
@@ -257,6 +265,10 @@ export class ACPServer extends EventEmitter {
                             this.sendError(id, -32602, "sessionId is required");
                         break;
                     }
+                    const mcpServers = params.mcpServers;
+                    if (mcpServers) {
+                        void this.mcpBridge.syncServers(mcpServers);
+                    }
                     let session = this.sessionManager.getSession(sessionId);
                     try {
                         if (!session) {
@@ -509,6 +521,17 @@ export class ACPServer extends EventEmitter {
                                         content: { type: "text", text: step.text_delta },
                                     },
                                 });
+                                // Live Plan / Todo checklist tracker
+                                const planEntries = extractPlanEntries(step.text_delta);
+                                if (planEntries) {
+                                    this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                        sessionId: session.id,
+                                        update: {
+                                            sessionUpdate: "plan",
+                                            entries: planEntries,
+                                        },
+                                    });
+                                }
                             }
                             else if (step.step_type === "thought" && step.text_delta) {
                                 hasSentNonNarration = true;
@@ -522,29 +545,40 @@ export class ACPServer extends EventEmitter {
                             }
                             else if (step.step_type === "tool" && step.tool_info) {
                                 hasSentNonNarration = true;
-                                const toolCallId = `tool_${step.step_index}`;
                                 const toolName = step.tool_name || step.tool_info.name || "tool";
-                                const toolKind = mapToolNameToKind(toolName);
+                                const toolCall = normalizeToolCall(toolName, step.tool_info.parameters || {}, step.step_index);
                                 if (step.state === "ACTIVE") {
                                     this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                         sessionId: session.id,
                                         update: {
                                             sessionUpdate: "tool_call",
-                                            toolCallId,
-                                            title: toolName,
-                                            kind: toolKind,
-                                            rawInput: step.tool_info.parameters || {},
+                                            toolCallId: toolCall.toolCallId,
+                                            title: toolCall.title,
+                                            kind: toolCall.kind,
+                                            ...(toolCall.locations ? { locations: toolCall.locations } : {}),
+                                            rawInput: toolCall.rawInput,
                                         },
                                     });
+                                    if (toolCall.questionCard) {
+                                        this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                            sessionId: session.id,
+                                            update: {
+                                                sessionUpdate: "agent_message_chunk",
+                                                content: { type: "text", text: `\n\n${toolCall.questionCard}\n\n` },
+                                            },
+                                        });
+                                    }
                                 }
                                 else if (step.state === "DONE") {
+                                    const toolRes = normalizeToolResult(toolName, step.tool_info.parameters || {}, step.tool_info.output);
                                     this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                         sessionId: session.id,
                                         update: {
                                             sessionUpdate: "tool_call_update",
-                                            toolCallId,
-                                            status: "completed",
-                                            rawOutput: step.tool_info.output ?? "",
+                                            toolCallId: toolCall.toolCallId,
+                                            status: toolRes.status,
+                                            rawOutput: toolRes.rawOutput,
+                                            ...(toolRes.content ? { content: toolRes.content } : {}),
                                         },
                                     });
                                     const imageMarkdown = extractImageMarkdownLink(toolName, step.tool_info.output, step.tool_info.parameters);
@@ -559,13 +593,14 @@ export class ACPServer extends EventEmitter {
                                     }
                                 }
                                 else if (step.state === "ERROR") {
+                                    const toolRes = normalizeToolResult(toolName, step.tool_info.parameters || {}, null, step.tool_info.error || { message: "Tool execution error" });
                                     this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                         sessionId: session.id,
                                         update: {
                                             sessionUpdate: "tool_call_update",
-                                            toolCallId,
+                                            toolCallId: toolCall.toolCallId,
                                             status: "failed",
-                                            rawOutput: step.tool_info.error?.message || "Tool execution error",
+                                            rawOutput: toolRes.rawOutput,
                                         },
                                     });
                                 }

package/dist/index.js

@@ -4,7 +4,7 @@ import { execFileSync } from "node:child_process";
 import { ACPServer } from "./acp-server.js";
 import { logger } from "./logger.js";
 import { formatDiagnosticVersion, resolveBuildMetadata } from "./version.js";
-import { ensurePaseoIntegration, findPaseoServerInstallations, findPaseoAsarPaths, isPaseoServerPatched, isPaseoAsarPatched, isPaseoRunning, } from "./paseo-patcher.js";
+import { ensurePaseoIntegration, restorePaseoIntegration, findPaseoServerInstallations, findPaseoAsarPaths, isPaseoServerPatched, isPaseoAsarPatched, isPaseoRunning, } from "./paseo-patcher.js";
 import { resolveDefaultAgyBinary, isWindowsBatchScript } from "./antigravity-process.js";
 import { parseAgyQuotaOutput } from "./protocol.js";
 const args = process.argv.slice(2);
@@ -30,11 +30,14 @@ Usage:
 Commands:
   setup, patch   Configure and integrate Antigravity telemetry with Paseo
   doctor         Diagnose Antigravity binary, quota provider, and Paseo status
+  restore        Restore original Paseo files from backup (.bak)
 
 Options:
   --acp             Start ACP server over stdio (default)
   --setup           Integrate Antigravity with local Paseo server installation
   --doctor          Run environment, binary, and telemetry diagnostics
+  --restore         Restore original Paseo files from backup
+  --force-macos-app Force patching inside macOS .app bundle (re-signs with ad-hoc)
   --skip-naration   Drop leading narration-only assistant chunks (e.g. 'I will...')
   --skip-narration  Alias for --skip-naration
   -v, --version     Show version
@@ -212,6 +215,28 @@ if (args.includes("doctor") || args.includes("--doctor")) {
     }
     process.exit(0);
 }
+if (args.includes("restore") ||
+    args.includes("unpatch") ||
+    args.includes("--restore") ||
+    args.includes("--unpatch")) {
+    process.stdout.write("Restoring original Paseo files from backup...\n");
+    try {
+        const res = await restorePaseoIntegration();
+        if (res.restored.length > 0) {
+            process.stdout.write(`Successfully restored original files:\n${res.restored.map((r) => `  - ${r}`).join("\n")}\n\n`);
+        }
+        else {
+            process.stdout.write("No backup archives (.bak) found to restore.\n\n");
+        }
+        if (res.errors.length > 0) {
+            process.stderr.write(`Errors during restore:\n${res.errors.map((e) => `  - ${e}`).join("\n")}\n`);
+        }
+    }
+    catch (err) {
+        process.stderr.write(`Restore encountered an issue: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    process.exit(0);
+}
 if (args.includes("setup") ||
     args.includes("patch") ||
     args.includes("--setup") ||
@@ -221,22 +246,35 @@ if (args.includes("setup") ||
     }
     process.stdout.write("Checking Paseo installation and configuring Antigravity telemetry...\n");
     try {
-        const res = await ensurePaseoIntegration({ verbose: true });
+        const forceMacosApp = args.includes("--force-macos-app");
+        const res = await ensurePaseoIntegration({ verbose: true, forceMacosApp });
         if (!res.found) {
             process.stdout.write("Notice: No active @getpaseo/server installation or app.asar found in standard paths.\n" +
                 "If Paseo is installed in a custom directory, set PASEO_SERVER_PATH or PASEO_ASAR_PATH and run setup again.\n");
         }
         else {
-            const totalFound = res.serverPaths.length + (res.asarPaths?.length || 0);
-            process.stdout.write(`Found ${totalFound} Paseo installation target(s) (${res.serverPaths.length} server dir(s), ${res.asarPaths?.length || 0} asar package(s)).\n`);
+            const totalFound = res.serverPaths.length + (res.asarPaths?.length || 0) + (res.skippedPaths?.length || 0);
+            process.stdout.write(`Found ${totalFound} Paseo installation target(s) (${res.serverPaths.length} server dir(s), ${res.asarPaths?.length || 0} asar package(s)` +
+                (res.skippedPaths && res.skippedPaths.length > 0 ? `, ${res.skippedPaths.length} protected macOS app bundle(s)` : "") +
+                `).\n`);
             const allPatched = [...res.patchedPaths, ...(res.patchedAsarPaths || [])];
             if (allPatched.length > 0) {
                 process.stdout.write(`Successfully integrated with: \n${allPatched.map((p) => `  - ${p}`).join("\n")}\n\n` +
                     `Antigravity quota provider and context-window telemetry are now enabled!\n`);
             }
+            else if (res.skippedPaths && res.skippedPaths.length > 0) {
+                process.stdout.write("Paseo server is ready. macOS .app bundle signature was preserved.\n");
+            }
             else {
                 process.stdout.write("Paseo is already up-to-date and configured for Antigravity telemetry.\n");
             }
+            if (res.skippedPaths && res.skippedPaths.length > 0) {
+                process.stdout.write(`\n🛡️  Preserved macOS Code Signature:\n` +
+                    `   Skipped ${res.skippedPaths.length} target(s) inside macOS .app bundle to protect official Apple Developer ID signature\n` +
+                    `   and prevent Gatekeeper "damaged app" warnings.\n` +
+                    `   (Antigravity ACP runs standalone and does not require modifying Paseo.app).\n` +
+                    `   If you specifically wish to patch the .app bundle, run with: paseo-acp-agy patch --force-macos-app\n\n`);
+            }
             if (isPaseoRunning()) {
                 const isWin = process.platform === "win32";
                 process.stdout.write(`\n⚠️  IMPORTANT: Paseo is currently running in the background!\n` +

package/dist/mcp-bridge.d.ts

@@ -0,0 +1,27 @@
+export interface McpServerStdioConfig {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    alwaysLoad?: boolean;
+}
+export interface McpServerHttpConfig {
+    type: "http" | "sse";
+    url: string;
+    headers?: Record<string, string>;
+    alwaysLoad?: boolean;
+}
+export type McpServerConfig = McpServerStdioConfig | McpServerHttpConfig;
+/**
+ * Bridges Paseo session MCP servers into Google Antigravity CLI's MCP system.
+ */
+export declare class McpBridge {
+    private readonly binaryPath;
+    private registered;
+    constructor(binaryPath?: string);
+    /**
+     * Syncs MCP servers configured by Paseo into Antigravity.
+     */
+    syncServers(servers?: Record<string, McpServerConfig>): Promise<void>;
+    private addServer;
+}

package/dist/mcp-bridge.js

@@ -0,0 +1,62 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { logger } from "./logger.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Bridges Paseo session MCP servers into Google Antigravity CLI's MCP system.
+ */
+export class McpBridge {
+    binaryPath;
+    registered = new Set();
+    constructor(binaryPath = "agy") {
+        this.binaryPath = binaryPath;
+    }
+    /**
+     * Syncs MCP servers configured by Paseo into Antigravity.
+     */
+    async syncServers(servers) {
+        if (!servers || typeof servers !== "object")
+            return;
+        for (const [name, config] of Object.entries(servers)) {
+            if (!name || !config || typeof config !== "object")
+                continue;
+            const key = `${name}:${JSON.stringify(config)}`;
+            if (this.registered.has(key))
+                continue;
+            try {
+                await this.addServer(name, config);
+                this.registered.add(key);
+                logger.info("Successfully synced MCP server from Paseo to Antigravity", { name, type: config.type });
+            }
+            catch (err) {
+                logger.warn("Could not sync MCP server to Antigravity (continuing without it)", {
+                    name,
+                    error: err.message,
+                });
+            }
+        }
+    }
+    async addServer(name, config) {
+        const args = ["mcp", "add"];
+        if (config.type === "stdio") {
+            if (config.env) {
+                for (const [k, v] of Object.entries(config.env)) {
+                    args.push("--env", `${k}=${v}`);
+                }
+            }
+            args.push(name, config.command);
+            if (config.args && config.args.length > 0) {
+                args.push(...config.args);
+            }
+        }
+        else if (config.type === "http" || config.type === "sse") {
+            if (config.headers) {
+                for (const [k, v] of Object.entries(config.headers)) {
+                    args.push("--header", `${k}: ${v}`);
+                }
+            }
+            args.push(name, config.url);
+        }
+        await execFileAsync(this.binaryPath, args, { timeout: 10_000 });
+    }
+}

package/dist/paseo-patcher.d.ts

@@ -4,6 +4,7 @@ export interface PatchResult {
     patchedPaths: string[];
     asarPaths?: string[];
     patchedAsarPaths?: string[];
+    skippedPaths?: string[];
     errors: string[];
 }
 /**
@@ -54,7 +55,15 @@ export declare function ensurePaseoIntegration(options?: {
     verbose?: boolean;
     targetPaths?: string[];
     targetAsarPaths?: string[];
+    forceMacosApp?: boolean;
 }): Promise<PatchResult>;
+/**
+ * Restores original unpatched Paseo files from backup (.bak) archives.
+ */
+export declare function restorePaseoIntegration(): Promise<{
+    restored: string[];
+    errors: string[];
+}>;
 /**
  * Checks whether a @getpaseo/server installation directory is already patched
  * for Antigravity quota and telemetry support.

package/dist/paseo-patcher.js

@@ -1461,6 +1461,14 @@ export async function patchPaseoAsar(asarPath) {
                     timeout: 15000,
                 });
                 changes.push(`Re-signed macOS bundle at ${appBundlePath}`);
+                try {
+                    execFileSync("xattr", ["-cr", appBundlePath], {
+                        stdio: "ignore",
+                        timeout: 10000,
+                    });
+                    changes.push(`Cleared quarantine extended attributes at ${appBundlePath}`);
+                }
+                catch { }
             }
             catch (signErr) {
                 logger.warn(`Could not re-sign ${appBundlePath}`, { error: String(signErr) });
@@ -1491,11 +1499,34 @@ export async function patchPaseoAsar(asarPath) {
  * Discovers and patches all accessible Paseo installations (both directory and app.asar).
  */
 export async function ensurePaseoIntegration(options) {
-    const serverPaths = options?.targetPaths || findPaseoServerInstallations();
-    const asarPaths = options?.targetAsarPaths || findPaseoAsarPaths();
+    const rawServerPaths = options?.targetPaths || findPaseoServerInstallations();
+    const rawAsarPaths = options?.targetAsarPaths || findPaseoAsarPaths();
+    const serverPaths = [];
+    const asarPaths = [];
+    const skippedPaths = [];
     const patchedPaths = [];
     const patchedAsarPaths = [];
     const errors = [];
+    for (const sPath of rawServerPaths) {
+        if (process.platform === "darwin" && sPath.includes(".app") && !options?.forceMacosApp) {
+            skippedPaths.push(sPath);
+            if (options?.verbose) {
+                logger.info(`[macOS] Skipping server path inside .app bundle to preserve Apple signature: ${sPath}`);
+            }
+            continue;
+        }
+        serverPaths.push(sPath);
+    }
+    for (const aPath of rawAsarPaths) {
+        if (process.platform === "darwin" && aPath.includes(".app") && !options?.forceMacosApp) {
+            skippedPaths.push(aPath);
+            if (options?.verbose) {
+                logger.info(`[macOS] Skipping app.asar inside .app bundle to preserve Apple signature: ${aPath}`);
+            }
+            continue;
+        }
+        asarPaths.push(aPath);
+    }
     for (const sPath of serverPaths) {
         const res = patchPaseoServer(sPath);
         if (res.success) {
@@ -1525,14 +1556,52 @@ export async function ensurePaseoIntegration(options) {
         }
     }
     return {
-        found: serverPaths.length > 0 || asarPaths.length > 0,
+        found: serverPaths.length > 0 || asarPaths.length > 0 || skippedPaths.length > 0,
         serverPaths,
         patchedPaths,
         asarPaths,
         patchedAsarPaths,
+        skippedPaths,
         errors,
     };
 }
+/**
+ * Restores original unpatched Paseo files from backup (.bak) archives.
+ */
+export async function restorePaseoIntegration() {
+    const restored = [];
+    const errors = [];
+    const home = os.homedir();
+    const macBackup = path.join(home, ".paseo", "backups", "app.asar.bak");
+    const asarCandidates = findPaseoAsarPaths();
+    for (const asarPath of asarCandidates) {
+        let backupFile = null;
+        if (process.platform === "darwin" && asarPath.includes(".app") && fs.existsSync(macBackup)) {
+            backupFile = macBackup;
+        }
+        else if (fs.existsSync(`${asarPath}.bak`)) {
+            backupFile = `${asarPath}.bak`;
+        }
+        if (backupFile) {
+            try {
+                fs.copyFileSync(backupFile, asarPath);
+                restored.push(asarPath);
+                if (process.platform === "darwin" && asarPath.includes(".app")) {
+                    const appIndex = asarPath.indexOf(".app");
+                    const appBundlePath = asarPath.slice(0, appIndex + 4);
+                    try {
+                        execFileSync("xattr", ["-cr", appBundlePath], { stdio: "ignore" });
+                    }
+                    catch { }
+                }
+            }
+            catch (err) {
+                errors.push(`Failed restoring ${asarPath}: ${err?.message || err}`);
+            }
+        }
+    }
+    return { restored, errors };
+}
 /**
  * Checks whether a @getpaseo/server installation directory is already patched
  * for Antigravity quota and telemetry support.

package/dist/protocol.d.ts

@@ -135,7 +135,7 @@ export interface SessionInfo {
     updatedAt?: string | null;
     _meta?: Record<string, unknown> | null;
 }
-export type ToolKind = "read" | "edit" | "execute" | "fetch" | "other";
+export type ToolKind = "read" | "edit" | "execute" | "fetch" | "search" | "other";
 export declare function mapToolNameToKind(toolName: string): ToolKind;
 export declare function extractPromptText(promptInput: unknown): string;
 export interface ModelDefinition {

package/dist/protocol.js

@@ -40,12 +40,18 @@ export const ACP_METHODS = {
 };
 export function mapToolNameToKind(toolName) {
     const name = toolName.toLowerCase();
+    if (name.includes("search") ||
+        name.includes("grep") ||
+        name.includes("find") ||
+        name === "search_web" ||
+        name === "grep_search" ||
+        name === "find_by_name")
+        return "search";
     if (name.includes("read") ||
         name.includes("view") ||
         name.includes("list") ||
-        name.includes("grep") ||
-        name.includes("find") ||
         name === "view_file" ||
+        name === "read_file" ||
         name === "list_dir")
         return "read";
     if (name.includes("write") ||
@@ -59,12 +65,11 @@ export function mapToolNameToKind(toolName) {
     if (name.includes("command") ||
         name.includes("terminal") ||
         name.includes("execute") ||
+        name.includes("subagent") ||
         name === "run_command")
         return "execute";
-    if (name.includes("search") ||
-        name.includes("url") ||
-        name.includes("browser") ||
-        name === "search_web")
+    if (name.includes("url") ||
+        name.includes("browser"))
         return "fetch";
     return "other";
 }

package/dist/tool-formatter.d.ts

@@ -0,0 +1,37 @@
+import { ToolKind } from "./protocol.js";
+export interface NormalizedToolCall {
+    toolCallId: string;
+    title: string;
+    kind: ToolKind;
+    locations?: Array<{
+        path: string;
+        line?: number;
+    }>;
+    rawInput: Record<string, unknown>;
+    questionCard?: string;
+}
+export interface NormalizedToolResult {
+    status: "completed" | "failed";
+    rawOutput: string;
+    content?: Array<Record<string, unknown>>;
+    imageMarkdown?: string;
+}
+export interface PlanEntry {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+}
+/**
+ * Normalizes Antigravity tool calls into standard ACP format with descriptive titles,
+ * proper kinds, clickable file locations, and normalized parameter names.
+ */
+export declare function normalizeToolCall(toolName: string, rawParams: Record<string, unknown> | undefined, stepIndex: number): NormalizedToolCall;
+/**
+ * Normalizes tool execution results into rich timeline content (diffs, terminals, text, images).
+ */
+export declare function normalizeToolResult(toolName: string, rawParams: Record<string, unknown> | undefined, output: unknown, error?: {
+    message?: string;
+}): NormalizedToolResult;
+/**
+ * Extracts markdown checklist / todo plan updates from assistant text or thoughts.
+ */
+export declare function extractPlanEntries(text: string): PlanEntry[] | null;

package/dist/tool-formatter.js

@@ -0,0 +1,219 @@
+import path from "node:path";
+/**
+ * Normalizes Antigravity tool calls into standard ACP format with descriptive titles,
+ * proper kinds, clickable file locations, and normalized parameter names.
+ */
+export function normalizeToolCall(toolName, rawParams = {}, stepIndex) {
+    const toolCallId = `tool_${stepIndex}`;
+    const normalizedParams = { ...rawParams };
+    const name = toolName.toLowerCase();
+    // 1. Shell commands: run_command
+    if (name === "run_command" ||
+        name.includes("command") ||
+        name.includes("terminal") ||
+        Boolean(rawParams.CommandLine) ||
+        Boolean(rawParams.command)) {
+        const cmd = String(rawParams.CommandLine || rawParams.command || rawParams.cmd || "").trim();
+        const summary = String(rawParams.toolSummary || rawParams.summary || "").trim();
+        const title = summary || (cmd ? truncate(cmd, 60) : "run_command");
+        normalizedParams.command = cmd;
+        normalizedParams.CommandLine = cmd;
+        return {
+            toolCallId,
+            title,
+            kind: "execute",
+            rawInput: normalizedParams,
+        };
+    }
+    // 2. File reads: read_file, view_file, list_dir
+    if (name === "read_file" || name === "view_file" || name === "list_dir" || name.includes("read")) {
+        const rawPath = String(rawParams.Path || rawParams.path || rawParams.AbsolutePath || rawParams.filePath || rawParams.file || "").trim();
+        const startLine = typeof rawParams.StartLine === "number" ? rawParams.StartLine : undefined;
+        const base = rawPath ? path.basename(rawPath) : "read_file";
+        const title = rawPath ? (startLine ? `${base}:${startLine}` : base) : "read_file";
+        normalizedParams.path = rawPath;
+        normalizedParams.filePath = rawPath;
+        normalizedParams.Path = rawPath;
+        return {
+            toolCallId,
+            title,
+            kind: "read",
+            locations: rawPath ? [{ path: rawPath, ...(startLine ? { line: startLine } : {}) }] : undefined,
+            rawInput: normalizedParams,
+        };
+    }
+    // 3. File edits / writes: edit_file, write_file, replace_file_content, multi_replace_file_content
+    if (name === "edit_file" ||
+        name === "write_file" ||
+        name === "replace_file_content" ||
+        name === "multi_replace_file_content" ||
+        name === "sed_file" ||
+        name.includes("edit") ||
+        name.includes("write")) {
+        const rawPath = String(rawParams.Path || rawParams.path || rawParams.AbsolutePath || rawParams.filePath || rawParams.TargetFile || "").trim();
+        const base = rawPath ? path.basename(rawPath) : "edit_file";
+        const target = String(rawParams.Target || rawParams.oldText || rawParams.oldString || "");
+        const replacement = String(rawParams.Replacement || rawParams.newText || rawParams.newString || rawParams.Content || "");
+        normalizedParams.path = rawPath;
+        normalizedParams.filePath = rawPath;
+        normalizedParams.Path = rawPath;
+        normalizedParams.oldText = target;
+        normalizedParams.oldString = target;
+        normalizedParams.newText = replacement;
+        normalizedParams.newString = replacement;
+        return {
+            toolCallId,
+            title: base,
+            kind: "edit",
+            locations: rawPath ? [{ path: rawPath }] : undefined,
+            rawInput: normalizedParams,
+        };
+    }
+    // 4. Search tools: search_web, grep_search, find_by_name
+    if (name === "search_web" || name === "grep_search" || name === "find_by_name" || name.includes("search")) {
+        const query = String(rawParams.query || rawParams.pattern || rawParams.CommandLine || "").trim();
+        const title = query ? `Busca: ${truncate(query, 50)}` : "search";
+        normalizedParams.query = query;
+        return {
+            toolCallId,
+            title,
+            kind: "search",
+            rawInput: normalizedParams,
+        };
+    }
+    // 5. Subagents: invoke_subagent, browser_subagent, manage_subagents
+    if (name.includes("subagent")) {
+        const role = String(rawParams.Role || rawParams.TypeName || rawParams.type || "Subagente").trim();
+        const prompt = String(rawParams.Prompt || rawParams.prompt || "").trim();
+        const title = `🤖 Subagente: ${role}`;
+        normalizedParams.role = role;
+        normalizedParams.prompt = prompt;
+        return {
+            toolCallId,
+            title,
+            kind: "execute",
+            rawInput: normalizedParams,
+        };
+    }
+    // 6. Interactive Questions: ask_question
+    if (name === "ask_question") {
+        const questions = Array.isArray(rawParams.questions) ? rawParams.questions : [];
+        const questionCard = formatQuestionCard(questions);
+        return {
+            toolCallId,
+            title: "❓ Pergunta do Assistente",
+            kind: "other",
+            rawInput: normalizedParams,
+            questionCard: questionCard || undefined,
+        };
+    }
+    // 7. General fallback
+    const summary = String(rawParams.toolSummary || rawParams.summary || "").trim();
+    return {
+        toolCallId,
+        title: summary || toolName,
+        kind: "other",
+        rawInput: normalizedParams,
+    };
+}
+/**
+ * Normalizes tool execution results into rich timeline content (diffs, terminals, text, images).
+ */
+export function normalizeToolResult(toolName, rawParams = {}, output, error) {
+    if (error) {
+        return {
+            status: "failed",
+            rawOutput: error.message || "Tool execution error",
+        };
+    }
+    const outputStr = typeof output === "string" ? output : JSON.stringify(output ?? "");
+    const name = toolName.toLowerCase();
+    const content = [];
+    // Edit tools: emit diff block so Paseo displays visual green/red syntax diffs
+    if (name === "edit_file" ||
+        name === "replace_file_content" ||
+        name === "multi_replace_file_content" ||
+        name === "write_file") {
+        const filePath = String(rawParams.Path || rawParams.path || rawParams.AbsolutePath || "");
+        const oldText = String(rawParams.Target || rawParams.oldText || rawParams.oldString || "");
+        const newText = String(rawParams.Replacement || rawParams.newText || rawParams.newString || rawParams.Content || "");
+        if (oldText || newText) {
+            content.push({
+                type: "diff",
+                path: filePath,
+                oldText,
+                newText,
+            });
+        }
+    }
+    else if (name === "read_file" || name === "view_file") {
+        if (outputStr.trim()) {
+            content.push({
+                type: "text",
+                text: outputStr,
+            });
+        }
+    }
+    return {
+        status: "completed",
+        rawOutput: outputStr,
+        content: content.length > 0 ? content : undefined,
+    };
+}
+/**
+ * Extracts markdown checklist / todo plan updates from assistant text or thoughts.
+ */
+export function extractPlanEntries(text) {
+    if (!text || typeof text !== "string")
+        return null;
+    const lines = text.split(/\r?\n/);
+    const entries = [];
+    for (const line of lines) {
+        const match = line.match(/^[-*]\s+\[([ xX/\\-])\]\s+(.+)$/);
+        if (match) {
+            const mark = match[1].trim();
+            const content = match[2].trim();
+            let status = "pending";
+            if (mark === "x" || mark === "X") {
+                status = "completed";
+            }
+            else if (mark === "/" || mark === "-") {
+                status = "in_progress";
+            }
+            entries.push({ content, status });
+        }
+    }
+    return entries.length >= 2 ? entries : null;
+}
+/**
+ * Formats Antigravity's ask_question structure into a clear, responsive markdown card.
+ */
+function formatQuestionCard(questions) {
+    if (!questions || questions.length === 0)
+        return "";
+    const cards = [];
+    for (const q of questions) {
+        if (!q || typeof q !== "object")
+            continue;
+        const prompt = q.question || "Escolha uma opção:";
+        const options = Array.isArray(q.options) ? q.options : [];
+        let card = `### ❓ Pergunta do Assistente\n> **${prompt}**\n\n`;
+        if (options.length > 0) {
+            card += `*Responda indicando o número da opção desejada:*\n`;
+            card += options
+                .map((opt, idx) => {
+                const isRec = opt.includes("(Recommended)") || opt.includes("(Recomendado)");
+                const clean = opt.replace(/^\(Recommended\)\s*/i, "").replace(/^\(Recomendado\)\s*/i, "");
+                return `- **[${idx + 1}]** ${clean}${isRec ? " *(Recomendado)*" : ""}`;
+            })
+                .join("\n");
+        }
+        cards.push(card);
+    }
+    return cards.join("\n\n---\n\n");
+}
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 3) + "...";
+}

package/dist/transcript.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { logger } from "./logger.js";
-import { mapToolNameToKind } from "./protocol.js";
+import { normalizeToolCall } from "./tool-formatter.js";
 /**
  * Strips XML-like tags injected by harness or system prompts (e.g., <USER_REQUEST>, <ADDITIONAL_METADATA>)
  * to recover the clean user prompt for history display in clients like Paseo.
@@ -106,21 +106,20 @@ export function loadConversationTranscript(conversationId) {
                     for (let i = 0; i < step.tool_calls.length; i++) {
                         const tc = step.tool_calls[i];
                         const rawArgs = (tc.args || tc.parameters || {});
-                        const toolName = String(tc.name || tc.tool_name || rawArgs.toolAction || "tool");
-                        const title = String(rawArgs.toolSummary ||
-                            rawArgs.toolAction ||
-                            tc.toolSummary ||
-                            tc.toolAction ||
-                            tc.name ||
-                            "tool");
-                        const toolCallId = `tool_${stepIndex}_${i}`;
-                        lastToolCallId = toolCallId;
+                        const toolName = String(tc.name || tc.tool_name || tc.toolAction || rawArgs.toolAction || "tool");
+                        const mergedParams = {
+                            ...rawArgs,
+                            toolSummary: rawArgs.toolSummary || tc.toolSummary,
+                            toolAction: rawArgs.toolAction || tc.toolAction,
+                        };
+                        const toolCall = normalizeToolCall(toolName, mergedParams, stepIndex * 100 + i);
+                        lastToolCallId = toolCall.toolCallId;
                         replayItems.push({
                             type: "tool_call",
-                            toolCallId,
-                            title,
-                            kind: mapToolNameToKind(toolName),
-                            rawInput: rawArgs,
+                            toolCallId: toolCall.toolCallId,
+                            title: toolCall.title,
+                            kind: toolCall.kind,
+                            rawInput: toolCall.rawInput,
                         });
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-acp-agy",
-  "version": "1.2.12",
+  "version": "1.2.14",
   "description": "ACP (Agent Client Protocol) provider for Google Antigravity in Paseo and Zed",
   "type": "module",
   "main": "dist/index.js",