paseo-acp-agy 1.1.2 → 1.1.4

package/PROTOCOL.md

@@ -10,14 +10,15 @@ Each Paseo ACP session owns one persistent `agy` process:
 agy --input-format stream-json --output-format stream-json --print=""
 ```
 
-Optional session flags are applied when the process starts or is restarted:
+Session flags applied when the process starts or is restarted:
 
 - `--model <model-id>`
 - `--effort <low|medium|high>` when supported by the selected model
 - `--mode <mode-id>`
 - `--conversation <conversation-id>` when resuming
-- `--sandbox`
-- `--dangerously-skip-permissions` only when explicitly configured
+- `--add-dir <cwd>` registering the active workspace directory
+- `--dangerously-skip-permissions` (enabled by default under ACP; see Permission Model)
+- `--sandbox` when configured via `AGY_ACP_SANDBOX=1`
 
 Configuration changes schedule a controlled restart before the next prompt. On POSIX systems `agy` is launched as a process-group leader; shutdown, restart and turn cancellation signal the process group so tool subprocesses are not left orphaned.
 
@@ -69,6 +70,27 @@ For backwards compatibility, the server also accepts the exact pre-hardening ali
 
 `agy-acp` currently advertises `loadSession: false`. ACP `session/load` requires the agent to replay prior conversation history through `session/update` notifications. The adapter intentionally does not claim that capability until replay is implemented. Paseo persistence uses `session/resume`, which restores model context without replaying already-rendered history.
 
+## Permission Model & CLI Limitations
+
+In the standard ACP specification, clients like Paseo or Zed act as supervisors: an agent requests authorization for actions via `session/request_permission`, and the client presents prompts to the user or evaluates auto-accept policies.
+
+### The Antigravity headless stream-json constraint
+
+The official Antigravity CLI (`agy`) was created as a terminal-interactive CLI rather than a native ACP server:
+1. **Piped Stdio vs. Interactive TTY**: `agy` runs headlessly over JSON-RPC stdio pipes. In this mode, `agy`'s internal TTY consent prompts (`Allow <tool>? [y/n]`) cannot query the user.
+2. **Immediate Denial on Non-Interactive Stdin**: Without `--dangerously-skip-permissions`, whenever `agy` invokes a tool (`read_file`, `write_file`, shell execution) in a workspace path that has not been manually pre-trusted in `~/.gemini/antigravity-cli/settings.json`, it immediately fails with:
+   `permission check failed for <tool>: user denied permission for <tool>(<path>)`.
+3. **Absence of a Protocol-Level Permission Callback**: The `agy stream-json` protocol currently lacks an inbound pause-and-resume event (such as `permission_response`). By the time `agy` outputs a `step_update` event with `step_type: "tool"` and `state: "ACTIVE"`, execution has already been initiated by the binary.
+
+### How `agy-acp` resolves this
+
+- **Delegated Trust**: `agy-acp` applies `--dangerously-skip-permissions` by default for ACP sessions so the underlying CLI does not fail on headless stdin prompts.
+- **Workspace Demarcation**: `agy-acp` passes `--add-dir <cwd>` on startup to explicitly register the current working directory in Antigravity's workspace context.
+- **Live Tool Streaming**: Tool calls are mapped and streamed immediately via `session/update` (`tool_call` and `tool_call_update`) so Paseo provides real-time auditability of actions and outputs.
+- **Opt-out & Sandbox**: Users can customize this behavior:
+  - Setting `AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS=false` disables `--dangerously-skip-permissions` for environments where `~/.gemini/antigravity-cli/settings.json` is strictly maintained.
+  - Setting `AGY_ACP_SANDBOX=true` adds `--sandbox` to enable terminal execution restrictions.
+
 ## Turn concurrency and cancellation
 
 A session-level prompt operation is reserved synchronously before any slash-command or process startup/restart `await`. Therefore:

package/README.md

@@ -98,11 +98,43 @@ To include `paseo-acp-agy` in Paseo's built-in provider store (`ACP_PROVIDER_CAT
 
 ---
 
+## Security, Permissions & Antigravity CLI Limitations
+
+In the Agent Client Protocol (ACP) specification, the host client (e.g., [Paseo](https://paseo.sh) or Zed) acts as the security supervisor. Native ACP agents query the host via `session/request_permission` before executing tools (`read_file`, `write_file`, terminal commands).
+
+### Why `--dangerously-skip-permissions` is enabled by default
+
+The official Google Antigravity CLI (`agy`) communicates with this adapter via `--input-format stream-json --output-format stream-json`:
+1. **No Interactive TTY**: `agy` runs headlessly over piped JSON-RPC stdio. In this mode, `agy`'s internal terminal prompt (`Allow <tool>? [y/n]`) cannot reach an interactive user.
+2. **Headless Permission Denials**: Without `--dangerously-skip-permissions`, whenever `agy` accesses a workspace folder or runs a tool that has not been explicitly pre-approved in `~/.gemini/antigravity-cli/settings.json`, its internal check fails and aborts immediately with:
+   ```text
+   permission check failed for read_file: user denied permission for read_file(...)
+   ```
+3. **No External Permission Callback**: Unlike native ACP agents or Claude's Agent SDK, `agy`'s `stream-json` interface does not support an external pause-and-confirm handshake. Once a tool step starts in `agy`, it has already been scheduled internally.
+
+To prevent unrecoverable `user denied permission` errors on fresh workspaces (especially on new Windows or Linux installations), `paseo-acp-agy`:
+- Passes `--dangerously-skip-permissions` by default so tool authorization is delegated to the host application.
+- Passes `--add-dir <cwd>` on process startup to demarcate the current project workspace directory.
+- Streams tool invocations (`step_update` → `tool_call`) in real time to the Paseo UI so the user retains full visibility over all actions.
+
+### Controlling Permissions & Sandbox Mode
+
+You can adjust this behavior using environment variables in your Paseo configuration or shell:
+
+| Variable | Description | Default |
+| :--- | :--- | :--- |
+| `AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS` | Set to `false` or `0` to disable automatic skip and strictly require pre-approved permissions in `~/.gemini/antigravity-cli/settings.json` | `true` |
+| `AGY_ACP_SANDBOX` | Set to `true` or `1` to launch `agy` with terminal restrictions enabled (`--sandbox`) | `false` |
+
+---
+
 ## Environment Variables
 
 | Variable | Description | Default |
 | :--- | :--- | :--- |
 | `AGY_BIN_PATH` | Path to the Google Antigravity binary | Auto-detected from `PATH` or `~/.local/bin/agy` |
+| `AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS` | Auto-approve tool permissions in headless `agy` | `true` |
+| `AGY_ACP_SANDBOX` | Enable terminal sandbox mode (`--sandbox`) | `false` |
 | `AGY_ACP_LOG_FILE` | Enable debug file logging | Disabled |
 
 ---

package/dist/acp-server.js

@@ -4,6 +4,7 @@ import { ACP_METHODS, AVAILABLE_MODES, fetchAvailableModels, buildConfigOptionsF
 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";
 function splitModelAndEffort(modelInput) {
     if (!modelInput)
         return {};
@@ -25,7 +26,7 @@ export class ACPServer {
     constructor(options = {}) {
         this.input = options.input || process.stdin;
         this.output = options.output || process.stdout;
-        this.binaryPath = options.binaryPath || process.env.AGY_BIN_PATH || "agy";
+        this.binaryPath = options.binaryPath || resolveDefaultAgyBinary();
         this.sessionManager =
             options.sessionManager || new SessionManager({ defaultBinaryPath: this.binaryPath });
     }

package/dist/antigravity-process.d.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from "node:events";
 import { AgyInitEvent, AgyStepUpdateEvent, AgyResultEvent } from "./protocol.js";
 import { PermissionSettings } from "./permissions.js";
+export declare function resolveDefaultAgyBinary(): string;
 export interface AntigravityProcessOptions {
     binaryPath?: string;
     cwd?: string;

package/dist/antigravity-process.js

@@ -1,17 +1,40 @@
-import { spawn } from "node:child_process";
+import { spawn, execFileSync } from "node:child_process";
 import { EventEmitter } from "node:events";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { logger } from "./logger.js";
 import { getEffectiveEffortForModel, } from "./protocol.js";
-import { buildAgyArgs } from "./permissions.js";
-function resolveDefaultAgyBinary() {
+import { buildAgyArgs, resolvePermissionSettings } from "./permissions.js";
+export function resolveDefaultAgyBinary() {
     if (process.env.AGY_BIN_PATH)
         return process.env.AGY_BIN_PATH;
-    if (process.env.HOME) {
-        const localPath = path.join(process.env.HOME, ".local", "bin", "agy");
-        if (fs.existsSync(localPath))
-            return localPath;
+    const home = os.homedir();
+    if (home) {
+        if (process.platform === "win32") {
+            const candidates = [
+                path.join(home, ".local", "bin", "agy.exe"),
+                path.join(home, "AppData", "Local", "Programs", "antigravity", "agy.exe"),
+                path.join(home, ".local", "bin", "agy.cmd"),
+                path.join(home, ".local", "bin", "agy.bat"),
+            ];
+            for (const cand of candidates) {
+                if (fs.existsSync(cand))
+                    return cand;
+            }
+            try {
+                const out = execFileSync("where.exe", ["agy"], { encoding: "utf-8", timeout: 1000 }).trim();
+                const first = out.split(/\r?\n/)[0]?.trim();
+                if (first && fs.existsSync(first))
+                    return first;
+            }
+            catch { }
+        }
+        else {
+            const localPath = path.join(home, ".local", "bin", "agy");
+            if (fs.existsSync(localPath))
+                return localPath;
+        }
     }
     return "agy";
 }
@@ -38,7 +61,7 @@ export class AntigravityProcess extends EventEmitter {
         this.effort = options.effort;
         this.mode = options.mode;
         this.conversationId = options.conversationId;
-        this.permissions = options.permissions || { sandbox: false, dangerouslySkipPermissions: false };
+        this.permissions = options.permissions || resolvePermissionSettings();
         this.env = { ...process.env, ...options.env };
         // EventEmitter treats "error" specially. Keep a defensive listener for
         // callers/tests that emit it directly; child failures use process_error.
@@ -131,6 +154,15 @@ export class AntigravityProcess extends EventEmitter {
                 });
             }
         }
+        else if (pid && process.platform === "win32") {
+            try {
+                execFileSync("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
+                return true;
+            }
+            catch {
+                // Fall back to child.kill
+            }
+        }
         try {
             return child.kill(signal);
         }
@@ -212,10 +244,15 @@ export class AntigravityProcess extends EventEmitter {
             extraArgs.push("--effort", effectiveEffort);
         if (this.conversationId)
             extraArgs.push("--conversation", this.conversationId);
+        const addDirs = [...(this.permissions.addDirs || [])];
+        if (this.cwd && !addDirs.includes(this.cwd)) {
+            addDirs.push(this.cwd);
+        }
         const args = buildAgyArgs({
             sandbox: this.permissions.sandbox,
             dangerouslySkipPermissions: this.permissions.dangerouslySkipPermissions,
             mode: this.mode,
+            addDirs,
         }, extraArgs);
         logger.info("Spawning agy process", {
             binary: this.binaryPath,
@@ -228,6 +265,7 @@ export class AntigravityProcess extends EventEmitter {
             env: this.env,
             stdio: ["pipe", "pipe", "pipe"],
             detached: process.platform !== "win32",
+            shell: process.platform === "win32",
         });
         this.child = child;
         if (!child.stdin || !child.stdout || !child.stderr) {

package/dist/attachments.js

@@ -14,7 +14,9 @@ function getAttachmentsDir() {
     const attachmentsDir = path.join(getStateRoot(), "attachments");
     try {
         fs.mkdirSync(attachmentsDir, { recursive: true, mode: 0o700 });
-        fs.chmodSync(attachmentsDir, 0o700);
+        if (process.platform !== "win32") {
+            fs.chmodSync(attachmentsDir, 0o700);
+        }
     }
     catch { }
     return attachmentsDir;
@@ -88,7 +90,9 @@ export function saveBase64Image(data, mimeType = "image/png") {
     if (!fs.existsSync(filePath)) {
         try {
             fs.writeFileSync(filePath, buffer, { mode: 0o600, flag: "wx" });
-            fs.chmodSync(filePath, 0o600);
+            if (process.platform !== "win32") {
+                fs.chmodSync(filePath, 0o600);
+            }
             logger.info("Saved attached image for session", { filePath, sizeBytes: buffer.length });
         }
         catch (err) {

package/dist/permissions.d.ts

@@ -2,10 +2,12 @@ export interface PermissionSettings {
     sandbox: boolean;
     dangerouslySkipPermissions: boolean;
     mode?: string;
+    addDirs?: string[];
 }
 export declare function resolvePermissionSettings(options?: {
     sandbox?: boolean;
     dangerouslySkipPermissions?: boolean;
     mode?: string;
+    addDirs?: string[];
 }): PermissionSettings;
 export declare function buildAgyArgs(settings: PermissionSettings, extraArgs?: string[]): string[];

package/dist/permissions.js

@@ -3,12 +3,17 @@ export function resolvePermissionSettings(options) {
     const envSandbox = process.env.AGY_ACP_SANDBOX;
     const envSkipPerms = process.env.AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS;
     const sandbox = options?.sandbox ?? (envSandbox === "true" || envSandbox === "1");
-    // Never default to skip permissions; must be explicit
-    const dangerouslySkipPermissions = options?.dangerouslySkipPermissions ?? (envSkipPerms === "true" || envSkipPerms === "1");
+    // In ACP mode, permissions and tool approvals are governed by the host application (e.g. Paseo).
+    // Because agy runs non-interactively over stream-json pipes without an interactive TTY, agy's
+    // internal terminal prompts cannot query the user and will fail with "user denied permission".
+    // Therefore, dangerouslySkipPermissions defaults to true unless explicitly disabled.
+    const dangerouslySkipPermissions = options?.dangerouslySkipPermissions ??
+        (envSkipPerms !== undefined ? envSkipPerms === "true" || envSkipPerms === "1" : true);
     return {
         sandbox,
         dangerouslySkipPermissions,
         mode: options?.mode,
+        addDirs: options?.addDirs,
     };
 }
 export function buildAgyArgs(settings, extraArgs) {
@@ -22,6 +27,13 @@ export function buildAgyArgs(settings, extraArgs) {
     if (settings.mode && settings.mode !== "default") {
         args.push("--mode", settings.mode);
     }
+    if (settings.addDirs && settings.addDirs.length > 0) {
+        for (const dir of settings.addDirs) {
+            if (dir) {
+                args.push("--add-dir", dir);
+            }
+        }
+    }
     if (extraArgs && extraArgs.length > 0) {
         args.push(...extraArgs);
     }

package/dist/protocol.js

@@ -208,34 +208,47 @@ export function parseAgyQuotaOutput(raw) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.toLowerCase().startsWith("quota:"))
             continue;
-        const parts = trimmed.split(/\t+|\s{2,}/).map((p) => p.trim());
-        if (parts.length >= 3) {
-            const scope = parts[0];
-            const limitType = parts[1];
-            const remainingMatch = parts[2].match(/(\d+)%/);
-            const resetsAt = parts[3] || null;
-            if (remainingMatch) {
-                const remainingPct = parseInt(remainingMatch[1], 10);
-                const usedPct = Math.max(0, Math.min(100, 100 - remainingPct));
-                const isFiveHour = /five\s*hour/i.test(limitType);
-                const isWeekly = /weekly/i.test(limitType);
-                const isGemini = /gemini/i.test(scope);
-                let id = isFiveHour ? "session" : isWeekly ? "weekly" : "quota";
-                let label = isFiveHour ? "Session (5h)" : isWeekly ? "Weekly" : limitType;
-                if (!isGemini) {
-                    id = `claude_${id}`;
-                    label = `Claude ${label}`;
-                }
-                windows.push({
-                    id,
-                    label,
-                    usedPct,
-                    remainingPct,
-                    resetsAt,
-                    tone: deriveUsageTone(usedPct),
-                });
+        let scope = "";
+        let limitType = "";
+        let remainingMatch = null;
+        let resetsAt = null;
+        const m = trimmed.match(/^(.*?)\s{2,}(.*?Remaining)\s+(\d+%)(?:\s+(.*))?$/i);
+        if (m) {
+            scope = m[1].trim();
+            limitType = m[2].trim();
+            remainingMatch = m[3].match(/(\d+)%/);
+            resetsAt = m[4]?.trim() || null;
+        }
+        else {
+            const parts = trimmed.split(/\t+|\s{2,}/).map((p) => p.trim());
+            if (parts.length >= 3) {
+                scope = parts[0];
+                limitType = parts[1];
+                remainingMatch = parts[2].match(/(\d+)%/);
+                resetsAt = parts[3] || null;
             }
         }
+        if (remainingMatch) {
+            const remainingPct = parseInt(remainingMatch[1], 10);
+            const usedPct = Math.max(0, Math.min(100, 100 - remainingPct));
+            const isFiveHour = /five\s*hour/i.test(limitType);
+            const isWeekly = /weekly/i.test(limitType);
+            const isGemini = /gemini/i.test(scope);
+            let id = isFiveHour ? "session" : isWeekly ? "weekly" : "quota";
+            let label = isFiveHour ? "Session (5h)" : isWeekly ? "Weekly" : limitType;
+            if (!isGemini) {
+                id = `claude_${id}`;
+                label = `Claude ${label}`;
+            }
+            windows.push({
+                id,
+                label,
+                usedPct,
+                remainingPct,
+                resetsAt,
+                tone: deriveUsageTone(usedPct),
+            });
+        }
     }
     return windows;
 }
@@ -279,11 +292,13 @@ export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
                 timeout: 8_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
+                shell: process.platform === "win32",
             }),
             execFileAsync(binaryPath, ["--print", "/credits"], {
                 timeout: 8_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
+                shell: process.platform === "win32",
             }),
         ]);
         const balances = [];
@@ -408,6 +423,7 @@ export async function fetchAvailableModels(binaryPath = "agy", force = false) {
             timeout: 5_000,
             env: process.env,
             maxBuffer: 4 * 1024 * 1024,
+            shell: process.platform === "win32",
         });
         const parsed = parseAgyModelsOutput(stdout);
         cachedModels = parsed;

package/dist/session-store.js

@@ -19,7 +19,9 @@ export class SessionStore {
         this.dir = dir || path.join(getStateRoot(), "sessions");
         try {
             fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
-            fs.chmodSync(this.dir, 0o700);
+            if (process.platform !== "win32") {
+                fs.chmodSync(this.dir, 0o700);
+            }
         }
         catch { }
     }
@@ -56,8 +58,13 @@ export class SessionStore {
                 mode: 0o600,
                 flag: "wx",
             });
+            if (process.platform === "win32" && fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+            }
             fs.renameSync(tempPath, filePath);
-            fs.chmodSync(filePath, 0o600);
+            if (process.platform !== "win32") {
+                fs.chmodSync(filePath, 0o600);
+            }
         }
         catch (err) {
             try {

package/dist/slash-commands.js

@@ -31,7 +31,7 @@ function transcriptPath(conversationId) {
 }
 function summarizeConversation(cid, logFile, mtime) {
     try {
-        const lines = fs.readFileSync(logFile, "utf8").split("\n").filter(Boolean);
+        const lines = fs.readFileSync(logFile, "utf8").split(/\r?\n/).filter(Boolean);
         let firstPrompt = "";
         let userTurns = 0;
         for (const line of lines) {
@@ -111,7 +111,7 @@ export function getConversationSteps(cid) {
     if (!logFile || !fs.existsSync(logFile))
         return null;
     try {
-        const lines = fs.readFileSync(logFile, "utf8").split("\n").filter(Boolean);
+        const lines = fs.readFileSync(logFile, "utf8").split(/\r?\n/).filter(Boolean);
         const steps = [];
         let userTurns = 0;
         for (let i = 0; i < lines.length; i++) {
@@ -272,11 +272,30 @@ function formatCountdown(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)
+    for (const line of rawText.trim().split(/\r?\n/)) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.toLowerCase().startsWith("quota:"))
             continue;
-        let fam = parts[0].trim();
+        let fam = "";
+        let rawWindow = "";
+        let pctStr = "";
+        let reset = "";
+        const m = trimmedLine.match(/^(.*?)\s{2,}(.*?Remaining)\s+(\d+%)(?:\s+(.*))?$/i);
+        if (m) {
+            fam = m[1].trim();
+            rawWindow = m[2].trim();
+            pctStr = m[3].trim();
+            reset = m[4]?.trim() || "";
+        }
+        else {
+            const parts = trimmedLine.includes("\t") ? trimmedLine.split("\t") : trimmedLine.split(/\s{2,}/);
+            if (parts.length < 3)
+                continue;
+            fam = parts[0].trim();
+            rawWindow = parts[1].trim();
+            pctStr = parts[2].trim();
+            reset = parts[3]?.trim() || "";
+        }
         let icon = "🤖";
         if (fam.toLowerCase().includes("gemini")) {
             fam = "Google Gemini";
@@ -286,7 +305,7 @@ export function formatUsageOutput(rawText) {
             fam = "Claude & GPT";
             icon = "🔶";
         }
-        const rawWindow = parts[1].replace(" Remaining", "").trim();
+        rawWindow = rawWindow.replace(/\s+Remaining$/i, "").trim();
         const lowerWindow = rawWindow.toLowerCase();
         const isFiveHour = lowerWindow.includes("five hour") || /\b5\s*hour/.test(lowerWindow);
         const win = isFiveHour
@@ -294,10 +313,8 @@ export function formatUsageOutput(rawText) {
             : 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 });
@@ -324,6 +341,7 @@ async function runAgySlash(binaryPath, cwd, slashCommand) {
         env: process.env,
         timeout: AGY_COMMAND_TIMEOUT_MS,
         maxBuffer: AGY_COMMAND_MAX_BUFFER,
+        shell: process.platform === "win32",
     });
     return stdout.trim() || stderr.trim();
 }

package/dist/version.js

@@ -1,5 +1,6 @@
 import { execSync } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -31,16 +32,35 @@ function resolveAgyInfo() {
     let binaryPath = process.env.AGY_BIN_PATH;
     if (!binaryPath) {
         try {
-            binaryPath = execSync("which agy 2>/dev/null || command -v agy 2>/dev/null", { encoding: "utf8" }).trim();
+            const lookupCmd = process.platform === "win32"
+                ? "where.exe agy"
+                : "which agy 2>/dev/null || command -v agy 2>/dev/null";
+            const output = execSync(lookupCmd, { encoding: "utf8" }).trim();
+            if (output) {
+                binaryPath = output.split(/\r?\n/)[0].trim();
+            }
         }
         catch {
             // ignore
         }
     }
-    if (!binaryPath && process.env.HOME) {
-        const defaultLocalPath = path.join(process.env.HOME, ".local", "bin", "agy");
-        if (fs.existsSync(defaultLocalPath)) {
-            binaryPath = defaultLocalPath;
+    if (!binaryPath) {
+        const homeDir = os.homedir();
+        if (homeDir) {
+            const candidates = process.platform === "win32"
+                ? [
+                    path.join(homeDir, ".local", "bin", "agy.exe"),
+                    path.join(homeDir, "AppData", "Local", "Programs", "antigravity", "agy.exe"),
+                    path.join(homeDir, ".local", "bin", "agy.cmd"),
+                    path.join(homeDir, ".local", "bin", "agy.bat"),
+                ]
+                : [path.join(homeDir, ".local", "bin", "agy")];
+            for (const cand of candidates) {
+                if (fs.existsSync(cand)) {
+                    binaryPath = cand;
+                    break;
+                }
+            }
         }
     }
     if (!binaryPath)

package/package.json

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