paseo-acp-agy 1.1.3 → 1.1.5

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

@@ -90,6 +90,28 @@ To include `paseo-acp-agy` in Paseo's built-in provider store (`ACP_PROVIDER_CAT
 
 ---
 
+## Plan Usage & Context Window Meter Setup
+
+To display the **Google Antigravity** quota breakdown in Paseo's `Settings -> Usage` (Plan usage) and activate the real-time context-window meter ("bolinha") in the chat composer:
+
+```bash
+npx -y paseo-acp-agy setup
+```
+
+Or if installed globally:
+```bash
+paseo-acp-agy setup
+```
+
+Then restart your Paseo app or daemon:
+```bash
+paseo daemon restart
+```
+
+> **Note**: `paseo-acp-agy` also checks and auto-configures your local Paseo server automatically whenever it launches via `--acp`. Running `setup` manually ensures your existing daemon instance picks up the telemetry hooks immediately upon restart.
+
+---
+
 ## Requirements
 
 - **Node.js**: >= 20.0.0 (Node.js 22 recommended)
@@ -98,11 +120,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.d.ts

@@ -19,6 +19,7 @@ export declare class ACPServer {
     private sendSuccess;
     private sendError;
     private publishCommands;
+    private publishUsageUpdate;
     private sessionState;
     private requireSession;
     private validateModel;

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 });
     }
@@ -79,6 +80,26 @@ export class ACPServer {
             },
         });
     }
+    publishUsageUpdate(session) {
+        const costUsd = roundUsageCostUsd(session.usage.totalCostUsd);
+        this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+            sessionId: session.id,
+            update: {
+                sessionUpdate: "usage_update",
+                size: session.usage.contextWindowMaxTokens,
+                used: session.usage.contextWindowUsedTokens,
+                cost: { amount: costUsd, currency: "USD" },
+                inputTokens: session.usage.inputTokens,
+                outputTokens: session.usage.outputTokens,
+                cachedReadTokens: session.usage.cachedInputTokens,
+                cachedInputTokens: session.usage.cachedInputTokens,
+                totalTokens: session.usage.totalTokens,
+                totalCostUsd: costUsd,
+                contextWindowMaxTokens: session.usage.contextWindowMaxTokens,
+                contextWindowUsedTokens: session.usage.contextWindowUsedTokens,
+            },
+        });
+    }
     async sessionState(session, forceModels = false) {
         const availableModels = await fetchAvailableModels(this.binaryPath, forceModels);
         return {
@@ -177,6 +198,7 @@ export class ACPServer {
                     if (!isNotification) {
                         this.sendSuccess(id, await this.sessionState(session, true));
                         this.publishCommands(session.id);
+                        this.publishUsageUpdate(session);
                     }
                     break;
                 }
@@ -211,6 +233,7 @@ export class ACPServer {
                         if (!isNotification) {
                             this.sendSuccess(id, await this.sessionState(session));
                             this.publishCommands(session.id);
+                            this.publishUsageUpdate(session);
                         }
                     }
                     catch (err) {
@@ -374,6 +397,7 @@ export class ACPServer {
                             // after model/tool work. Record it before branching on status.
                             session.recordTurnUsage(turnUsage, executingModel);
                             const usagePayload = this.turnUsagePayload(session, turnUsage, executingModel);
+                            this.publishUsageUpdate(session);
                             if (session.isCancelled) {
                                 if (!isNotification) {
                                     this.sendSuccess(id, { stopReason: "cancelled", usage: usagePayload });

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,4 +1,4 @@
-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";
@@ -6,7 +6,7 @@ import path from "node:path";
 import { logger } from "./logger.js";
 import { getEffectiveEffortForModel, } from "./protocol.js";
 import { buildAgyArgs, resolvePermissionSettings } from "./permissions.js";
-function resolveDefaultAgyBinary() {
+export function resolveDefaultAgyBinary() {
     if (process.env.AGY_BIN_PATH)
         return process.env.AGY_BIN_PATH;
     const home = os.homedir();
@@ -22,6 +22,13 @@ function resolveDefaultAgyBinary() {
                 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");
@@ -147,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);
         }
@@ -249,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/index.js

@@ -2,6 +2,7 @@
 import { ACPServer } from "./acp-server.js";
 import { logger } from "./logger.js";
 import { formatDiagnosticVersion, resolveBuildMetadata } from "./version.js";
+import { ensurePaseoIntegration } from "./paseo-patcher.js";
 const args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
     if (args.includes("--json")) {
@@ -19,9 +20,14 @@ Usage:
   paseo-acp-agy [options]
   agy-acp [options]
   npx -y paseo-acp-agy [options]
+  npx -y paseo-acp-agy setup
+
+Commands:
+  setup, patch   Configure and integrate Antigravity telemetry with Paseo
 
 Options:
   --acp          Start ACP server over stdio (default)
+  --setup        Integrate Antigravity with local Paseo server installation
   -v, --version  Show version
   --json         Show version in JSON format (with --version)
   -h, --help     Show help
@@ -32,9 +38,43 @@ Environment Variables:
   AGY_ACP_SANDBOX                   Set to 'true' to run agy in sandbox mode
   AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS Set to 'true' to auto-approve tool permissions
   AGY_BIN_PATH                      Path to agy binary (default: agy in PATH or ~/.local/bin/agy)
+  PASEO_SERVER_PATH                 Path to local @getpaseo/server directory
 `);
     process.exit(0);
 }
+if (args.includes("setup") ||
+    args.includes("patch") ||
+    args.includes("--setup") ||
+    args.includes("--patch")) {
+    process.stdout.write("Checking Paseo installation and configuring Antigravity telemetry...\n");
+    try {
+        const res = ensurePaseoIntegration({ verbose: true });
+        if (!res.found) {
+            process.stdout.write("Notice: No active @getpaseo/server installation found in standard paths.\n" +
+                "If Paseo is installed in a custom directory, set PASEO_SERVER_PATH and run setup again.\n");
+        }
+        else {
+            process.stdout.write(`Found ${res.serverPaths.length} Paseo server installation(s).\n`);
+            if (res.patchedPaths.length > 0) {
+                process.stdout.write(`Successfully integrated with: \n${res.patchedPaths.map((p) => `  - ${p}`).join("\n")}\n\n` +
+                    `Antigravity quota provider and context-window telemetry are now enabled!\n` +
+                    `Please restart Paseo (or run 'paseo daemon restart') to apply changes.\n`);
+            }
+            else {
+                process.stdout.write("Paseo is already up-to-date and configured for Antigravity telemetry.\n");
+            }
+        }
+    }
+    catch (err) {
+        process.stderr.write(`Setup encountered an issue: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    process.exit(0);
+}
+// Auto-run integration in background when starting ACP server
+try {
+    ensurePaseoIntegration();
+}
+catch { }
 const server = new ACPServer();
 const cleanup = async () => {
     try {

package/dist/paseo-patcher.d.ts

@@ -0,0 +1,34 @@
+export interface PatchResult {
+    found: boolean;
+    serverPaths: string[];
+    patchedPaths: string[];
+    errors: string[];
+}
+/**
+ * Searches the host machine for @getpaseo/server installations across
+ * Windows, macOS, and Linux.
+ */
+export declare function findPaseoServerInstallations(): string[];
+/**
+ * Returns the JavaScript source for the Antigravity quota provider to be
+ * injected into Paseo server's quota-fetcher providers.
+ */
+export declare function generateAntigravityQuotaProviderJs(): string;
+/**
+ * Patches a Paseo server installation directory to enable Antigravity:
+ * 1. Patches quota-fetcher/manifest.js to register Antigravity
+ * 2. Writes quota-fetcher/providers/antigravity.js
+ * 3. Patches acp-agent.js to map context window tokens and emit usage updates
+ */
+export declare function patchPaseoServer(serverDir: string): {
+    success: boolean;
+    changes: string[];
+    error?: string;
+};
+/**
+ * Discovers and patches all accessible Paseo installations.
+ */
+export declare function ensurePaseoIntegration(options?: {
+    verbose?: boolean;
+    targetPaths?: string[];
+}): PatchResult;

package/dist/paseo-patcher.js

@@ -0,0 +1,457 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { logger } from "./logger.js";
+/**
+ * Searches the host machine for @getpaseo/server installations across
+ * Windows, macOS, and Linux.
+ */
+export function findPaseoServerInstallations() {
+    const candidates = new Set();
+    // 1. Explicit environment variable overrides
+    if (process.env.PASEO_SERVER_PATH && fs.existsSync(process.env.PASEO_SERVER_PATH)) {
+        candidates.add(path.resolve(process.env.PASEO_SERVER_PATH));
+    }
+    if (process.env.PASEO_INSTALL_DIR && fs.existsSync(process.env.PASEO_INSTALL_DIR)) {
+        const direct = path.join(process.env.PASEO_INSTALL_DIR, "node_modules", "@getpaseo", "server");
+        if (fs.existsSync(direct))
+            candidates.add(path.resolve(direct));
+    }
+    // 2. Platform-specific default paths
+    const home = os.homedir();
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || (home ? path.join(home, "AppData", "Roaming") : "");
+        const localAppData = process.env.LOCALAPPDATA || (home ? path.join(home, "AppData", "Local") : "");
+        const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+        const winLocations = [
+            path.join(appData, "npm", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"),
+            path.join(appData, "npm", "node_modules", "@getpaseo", "server"),
+            path.join(localAppData, "npm", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"),
+            path.join(localAppData, "npm", "node_modules", "@getpaseo", "server"),
+            path.join(programFiles, "nodejs", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"),
+            path.join(programFiles, "nodejs", "node_modules", "@getpaseo", "server"),
+            path.join(localAppData, "Programs", "Paseo", "resources", "app.asar.unpacked", "node_modules", "@getpaseo", "server"),
+            path.join(localAppData, "Programs", "Paseo", "resources", "app", "node_modules", "@getpaseo", "server"),
+            path.join(programFiles, "Paseo", "resources", "app.asar.unpacked", "node_modules", "@getpaseo", "server"),
+        ];
+        for (const loc of winLocations) {
+            if (loc && fs.existsSync(loc))
+                candidates.add(path.resolve(loc));
+        }
+        // Try detecting global npm root via npm.cmd
+        try {
+            const npmRoot = execFileSync("cmd.exe", ["/c", "npm.cmd", "root", "-g"], {
+                encoding: "utf-8",
+                timeout: 2000,
+                windowsHide: true,
+            }).trim();
+            if (npmRoot && fs.existsSync(npmRoot)) {
+                const p1 = path.join(npmRoot, "@getpaseo", "cli", "node_modules", "@getpaseo", "server");
+                const p2 = path.join(npmRoot, "@getpaseo", "server");
+                if (fs.existsSync(p1))
+                    candidates.add(path.resolve(p1));
+                if (fs.existsSync(p2))
+                    candidates.add(path.resolve(p2));
+            }
+        }
+        catch { }
+        // Check where.exe paseo
+        try {
+            const whereOut = execFileSync("where.exe", ["paseo"], {
+                encoding: "utf-8",
+                timeout: 2000,
+                windowsHide: true,
+            }).trim();
+            const first = whereOut.split(/\r?\n/)[0]?.trim();
+            if (first) {
+                const paseoDir = path.dirname(first);
+                const p1 = path.join(paseoDir, "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server");
+                const p2 = path.join(paseoDir, "node_modules", "@getpaseo", "server");
+                if (fs.existsSync(p1))
+                    candidates.add(path.resolve(p1));
+                if (fs.existsSync(p2))
+                    candidates.add(path.resolve(p2));
+            }
+        }
+        catch { }
+    }
+    else {
+        // POSIX locations (Linux / macOS)
+        const posixLocations = [
+            "/usr/lib/node_modules/@getpaseo/cli/node_modules/@getpaseo/server",
+            "/usr/lib/node_modules/@getpaseo/server",
+            "/usr/local/lib/node_modules/@getpaseo/cli/node_modules/@getpaseo/server",
+            "/usr/local/lib/node_modules/@getpaseo/server",
+            "/Applications/Paseo.app/Contents/Resources/app.asar.unpacked/node_modules/@getpaseo/server",
+            "/Applications/Paseo.app/Contents/Resources/app/node_modules/@getpaseo/server",
+        ];
+        if (home) {
+            posixLocations.push(path.join(home, ".local", "share", "pnpm", "global", "5", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"), path.join(home, ".bun", "install", "global", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"));
+            // Check nvm paths if available
+            const nvmDir = path.join(home, ".nvm", "versions", "node");
+            if (fs.existsSync(nvmDir)) {
+                try {
+                    const versions = fs.readdirSync(nvmDir);
+                    for (const ver of versions) {
+                        posixLocations.push(path.join(nvmDir, ver, "lib", "node_modules", "@getpaseo", "cli", "node_modules", "@getpaseo", "server"), path.join(nvmDir, ver, "lib", "node_modules", "@getpaseo", "server"));
+                    }
+                }
+                catch { }
+            }
+        }
+        for (const loc of posixLocations) {
+            if (fs.existsSync(loc))
+                candidates.add(path.resolve(loc));
+        }
+        try {
+            const npmRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf-8", timeout: 2000 }).trim();
+            if (npmRoot && fs.existsSync(npmRoot)) {
+                const p1 = path.join(npmRoot, "@getpaseo", "cli", "node_modules", "@getpaseo", "server");
+                const p2 = path.join(npmRoot, "@getpaseo", "server");
+                if (fs.existsSync(p1))
+                    candidates.add(path.resolve(p1));
+                if (fs.existsSync(p2))
+                    candidates.add(path.resolve(p2));
+            }
+        }
+        catch { }
+    }
+    // Filter out any paths that do not actually have a dist directory or package.json
+    const verified = [];
+    for (const dir of candidates) {
+        if (fs.existsSync(path.join(dir, "dist")) || fs.existsSync(path.join(dir, "package.json"))) {
+            verified.push(dir);
+        }
+    }
+    return verified;
+}
+/**
+ * Returns the JavaScript source for the Antigravity quota provider to be
+ * injected into Paseo server's quota-fetcher providers.
+ */
+export function generateAntigravityQuotaProviderJs() {
+    return `import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { toneFromUsedPct, windowFromUsedPct, unavailableUsage } from "../usage.js";
+
+const execFileAsync = promisify(execFile);
+
+function resolveAgyBinary() {
+    if (process.env.AGY_BIN_PATH) return process.env.AGY_BIN_PATH;
+    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 { execFileSync } = require("node:child_process");
+                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";
+}
+
+export class AntigravityQuotaProvider {
+    constructor(options) {
+        this.providerId = "antigravity";
+        this.displayName = "Antigravity";
+        this.logger = typeof options?.logger?.child === "function" ? options.logger.child({ module: "antigravity-quota-provider" }) : options?.logger;
+        this.binaryPath = resolveAgyBinary();
+    }
+
+    async fetchUsage() {
+        try {
+            const isWin = process.platform === "win32";
+            const [usageRes, creditsRes] = await Promise.allSettled([
+                execFileAsync(this.binaryPath, ["--print", "/usage"], { timeout: 8000, env: process.env, shell: isWin }),
+                execFileAsync(this.binaryPath, ["--print", "/credits"], { timeout: 8000, env: process.env, shell: isWin }),
+            ]);
+
+            const usageOut = usageRes.status === "fulfilled" ? usageRes.value.stdout || usageRes.value.stderr : "";
+            const creditsOut = creditsRes.status === "fulfilled" ? creditsRes.value.stdout || creditsRes.value.stderr : "";
+
+            const rawWindows = [];
+            for (const line of usageOut.split(/[\\r\\n]+/)) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.toLowerCase().startsWith("quota:")) continue;
+
+                let scope = "";
+                let limitType = "";
+                let remainingPct = 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();
+                    remainingPct = parseInt(m[3], 10);
+                    resetsAt = m[4] ? new Date(m[4].trim()).toISOString() : null;
+                } else {
+                    const parts = trimmed.split(/\\t+|\\s{2,}/).map(p => p.trim());
+                    if (parts.length >= 3) {
+                        scope = parts[0];
+                        limitType = parts[1];
+                        const remMatch = parts[2].match(/(\\d+)%/);
+                        if (remMatch) remainingPct = parseInt(remMatch[1], 10);
+                        resetsAt = parts[3] ? new Date(parts[3]).toISOString() : null;
+                    }
+                }
+
+                if (remainingPct !== null && !isNaN(remainingPct)) {
+                    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" : isWeekly ? "Weekly" : limitType.replace(/\\s+Remaining$/i, "");
+                    if (!isGemini) {
+                        id = \`claude_\${id}\`;
+                        label = \`Claude \${label}\`;
+                    }
+
+                    rawWindows.push({
+                        id,
+                        label,
+                        utilizationPct: usedPct,
+                        resetsAt,
+                        tone: toneFromUsedPct(usedPct),
+                        isFiveHour,
+                        isGemini,
+                    });
+                }
+            }
+
+            rawWindows.sort((a, b) => {
+                if (a.isGemini && !b.isGemini) return -1;
+                if (!a.isGemini && b.isGemini) return 1;
+                if (a.isFiveHour && !b.isFiveHour) return -1;
+                if (!a.isFiveHour && b.isFiveHour) return 1;
+                return 0;
+            });
+
+            const windows = rawWindows.map(w => windowFromUsedPct(w));
+
+            const balances = [];
+            const credMatch = creditsOut.match(/Remaining\\s+credits\\s+([\\d.]+)/i);
+            const remainingCredits = credMatch ? parseFloat(credMatch[1]) : 0;
+            balances.push({
+                id: "credits",
+                label: "Credits",
+                remaining: remainingCredits,
+                unit: "usd",
+                tone: remainingCredits > 0 ? "ok" : "default",
+            });
+
+            return {
+                providerId: this.providerId,
+                displayName: "Antigravity",
+                status: "available",
+                planLabel: "Google Gemini",
+                windows,
+                balances,
+                details: [],
+                error: null,
+            };
+        } catch (err) {
+            return unavailableUsage({
+                providerId: this.providerId,
+                displayName: "Antigravity",
+                error: err.message,
+            });
+        }
+    }
+}
+`;
+}
+/**
+ * Patches a Paseo server installation directory to enable Antigravity:
+ * 1. Patches quota-fetcher/manifest.js to register Antigravity
+ * 2. Writes quota-fetcher/providers/antigravity.js
+ * 3. Patches acp-agent.js to map context window tokens and emit usage updates
+ */
+export function patchPaseoServer(serverDir) {
+    const changes = [];
+    try {
+        // 1. Locate manifest.js in quota-fetcher
+        const manifestCandidates = [
+            path.join(serverDir, "dist", "server", "services", "quota-fetcher", "manifest.js"),
+            path.join(serverDir, "dist", "services", "quota-fetcher", "manifest.js"),
+        ];
+        let manifestFile = manifestCandidates.find((f) => fs.existsSync(f));
+        if (!manifestFile && fs.existsSync(path.join(serverDir, "dist"))) {
+            const findManifest = (dir) => {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                    const full = path.join(dir, e.name);
+                    if (e.isDirectory() && e.name !== "node_modules") {
+                        const found = findManifest(full);
+                        if (found)
+                            return found;
+                    }
+                    else if (e.isFile() && e.name === "manifest.js" && dir.includes("quota-fetcher")) {
+                        return full;
+                    }
+                }
+                return null;
+            };
+            manifestFile = findManifest(path.join(serverDir, "dist")) || undefined;
+        }
+        if (manifestFile) {
+            const quotaDir = path.dirname(manifestFile);
+            const providersDir = path.join(quotaDir, "providers");
+            if (!fs.existsSync(providersDir)) {
+                fs.mkdirSync(providersDir, { recursive: true });
+            }
+            // Write / update providers/antigravity.js
+            const antigravityJsPath = path.join(providersDir, "antigravity.js");
+            fs.writeFileSync(antigravityJsPath, generateAntigravityQuotaProviderJs(), "utf-8");
+            changes.push(`Created/Updated ${antigravityJsPath}`);
+            // Patch manifest.js
+            let manifestCode = fs.readFileSync(manifestFile, "utf-8");
+            let manifestModified = false;
+            if (!manifestCode.includes('from "./providers/antigravity.js"') && !manifestCode.includes("AntigravityQuotaProvider")) {
+                manifestCode = `import { AntigravityQuotaProvider } from "./providers/antigravity.js";\n` + manifestCode;
+                manifestModified = true;
+            }
+            if (!manifestCode.includes('providerId: "antigravity"')) {
+                const entryToAdd = `    {\n        providerId: "antigravity",\n        create: (options) => new AntigravityQuotaProvider({\n            logger: options.logger,\n            fetch: options.fetch,\n        }),\n    },\n`;
+                const marker = "export const PROVIDER_USAGE_FETCHERS = [";
+                if (manifestCode.includes(marker)) {
+                    manifestCode = manifestCode.replace(marker, `${marker}\n${entryToAdd}`);
+                    manifestModified = true;
+                }
+            }
+            if (manifestModified) {
+                fs.writeFileSync(manifestFile, manifestCode, "utf-8");
+                changes.push(`Patched ${manifestFile} with AntigravityQuotaProvider`);
+            }
+        }
+        // 2. Locate acp-agent.js
+        const acpCandidates = [
+            path.join(serverDir, "dist", "server", "server", "agent", "providers", "acp-agent.js"),
+            path.join(serverDir, "dist", "server", "agent", "providers", "acp-agent.js"),
+            path.join(serverDir, "dist", "agent", "providers", "acp-agent.js"),
+        ];
+        let acpFile = acpCandidates.find((f) => fs.existsSync(f));
+        if (!acpFile && fs.existsSync(path.join(serverDir, "dist"))) {
+            const findAcp = (dir) => {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                    const full = path.join(dir, e.name);
+                    if (e.isDirectory() && e.name !== "node_modules") {
+                        const found = findAcp(full);
+                        if (found)
+                            return found;
+                    }
+                    else if (e.isFile() && e.name === "acp-agent.js") {
+                        return full;
+                    }
+                }
+                return null;
+            };
+            acpFile = findAcp(path.join(serverDir, "dist")) || undefined;
+        }
+        if (acpFile) {
+            let acpCode = fs.readFileSync(acpFile, "utf-8");
+            let acpModified = false;
+            // Patch mapACPUsage
+            if (!acpCode.includes("contextWindowMaxTokens: usage.contextWindowMaxTokens")) {
+                const oldMapRegex = /export\s+function\s+mapACPUsage\s*\([^)]*\)\s*\{[\s\S]*?return\s*\{[\s\S]*?\};\s*\}/m;
+                const newMap = `export function mapACPUsage(usage) {
+    if (!usage) {
+        return undefined;
+    }
+    return {
+        inputTokens: usage.inputTokens ?? undefined,
+        outputTokens: usage.outputTokens ?? undefined,
+        cachedInputTokens: usage.cachedReadTokens ?? usage.cachedInputTokens ?? undefined,
+        totalCostUsd: usage.totalCostUsd ?? (usage.cost?.amount !== undefined ? Number(usage.cost.amount) : undefined),
+        contextWindowMaxTokens: usage.contextWindowMaxTokens ?? usage.size ?? undefined,
+        contextWindowUsedTokens: usage.contextWindowUsedTokens ?? usage.used ?? undefined,
+    };
+}`;
+                if (oldMapRegex.test(acpCode)) {
+                    acpCode = acpCode.replace(oldMapRegex, newMap);
+                    acpModified = true;
+                }
+            }
+            // Patch handleUsageUpdate
+            if (acpCode.includes("handleUsageUpdate(update) {") && !acpCode.includes("this.notifySubscribers({")) {
+                const oldHandlerRegex = /handleUsageUpdate\s*\(\s*update\s*\)\s*\{[\s\S]*?void\s+update;?[\s\S]*?\}/m;
+                const newHandler = `handleUsageUpdate(update) {
+        if (!update) return;
+        const usage = mapACPUsage(update);
+        if (usage) {
+            this.currentTurnUsage = { ...this.currentTurnUsage, ...usage };
+            this.notifySubscribers({
+                type: "usage_updated",
+                provider: this.provider,
+                usage: this.currentTurnUsage,
+                ...(this.activeForegroundTurnId ? { turnId: this.activeForegroundTurnId } : {}),
+            });
+        }
+    }`;
+                if (oldHandlerRegex.test(acpCode)) {
+                    acpCode = acpCode.replace(oldHandlerRegex, newHandler);
+                    acpModified = true;
+                }
+            }
+            if (acpModified) {
+                fs.writeFileSync(acpFile, acpCode, "utf-8");
+                changes.push(`Patched ${acpFile} for context-window token telemetry and usage updates`);
+            }
+        }
+        return { success: true, changes };
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        logger.warn("Failed to patch Paseo server", { serverDir, error: errorMsg });
+        return { success: false, changes, error: errorMsg };
+    }
+}
+/**
+ * Discovers and patches all accessible Paseo installations.
+ */
+export function ensurePaseoIntegration(options) {
+    const serverPaths = options?.targetPaths || findPaseoServerInstallations();
+    const patchedPaths = [];
+    const errors = [];
+    for (const sPath of serverPaths) {
+        const res = patchPaseoServer(sPath);
+        if (res.success) {
+            if (res.changes.length > 0) {
+                patchedPaths.push(sPath);
+                if (options?.verbose) {
+                    logger.info(`Integrated with Paseo server at ${sPath}`, { changes: res.changes });
+                }
+            }
+        }
+        else if (res.error) {
+            errors.push(`${sPath}: ${res.error}`);
+        }
+    }
+    return {
+        found: serverPaths.length > 0,
+        serverPaths,
+        patchedPaths,
+        errors,
+    };
+}

package/dist/protocol.d.ts

@@ -173,6 +173,7 @@ export interface ProviderUsage {
     }>;
     error: string | null;
 }
+export declare function formatExecBinaryPath(binaryPath: string): string;
 export declare function fetchAntigravityUsage(binaryPath?: string, force?: boolean): Promise<ProviderUsage>;
 export declare const ALL_THINKING_LEVELS: Record<string, {
     name: string;

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;
 }
@@ -265,6 +278,12 @@ function cacheProviderUsage(binaryPath, result, now) {
     lastProviderUsageFetch = now;
     return result;
 }
+export function formatExecBinaryPath(binaryPath) {
+    if (process.platform === "win32" && binaryPath.includes(" ") && !binaryPath.startsWith('"')) {
+        return `"${binaryPath}"`;
+    }
+    return binaryPath;
+}
 export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
     const now = Date.now();
     if (!force &&
@@ -273,17 +292,20 @@ export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
         now - lastProviderUsageFetch < PROVIDER_USAGE_CACHE_TTL_MS) {
         return cachedProviderUsage;
     }
+    const cmd = formatExecBinaryPath(binaryPath);
     try {
         const [usageResult, creditsResult] = await Promise.allSettled([
-            execFileAsync(binaryPath, ["--print", "/usage"], {
+            execFileAsync(cmd, ["--print", "/usage"], {
                 timeout: 8_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
+                shell: process.platform === "win32",
             }),
-            execFileAsync(binaryPath, ["--print", "/credits"], {
+            execFileAsync(cmd, ["--print", "/credits"], {
                 timeout: 8_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
+                shell: process.platform === "win32",
             }),
         ]);
         const balances = [];
@@ -356,6 +378,7 @@ export const FALLBACK_MODELS = [
 let cachedModels = null;
 let cachedModelsBinaryPath = null;
 let lastModelFetch = 0;
+let inFlightModelFetch = null;
 const MODEL_CACHE_TTL_MS = 60_000;
 export function parseAgyModelsOutput(rawOutput) {
     const modelsMap = new Map();
@@ -369,24 +392,21 @@ export function parseAgyModelsOutput(rawOutput) {
         const modelId = parts[0];
         const label = parts[1];
         const effortMatch = modelId.match(/-(high|medium|low)$/);
-        let baseId = modelId;
-        let baseLabel = label;
-        let effort = null;
-        if (effortMatch) {
-            effort = effortMatch[1];
-            baseId = modelId.slice(0, -(effort.length + 1));
-            baseLabel = label.replace(/\s*\((High|Medium|Low)\)$/, "");
-        }
+        const baseId = effortMatch ? modelId.replace(/-(high|medium|low)$/, "") : modelId;
+        const effort = effortMatch ? effortMatch[1] : undefined;
+        const cleanLabel = effortMatch
+            ? label.replace(/\s*\((High|Medium|Low)\)$/i, "").trim()
+            : label;
         if (!modelsMap.has(baseId)) {
             modelsMap.set(baseId, {
                 modelId: baseId,
-                name: baseLabel,
+                name: cleanLabel,
                 description: label,
-                supportedEfforts: [],
+                supportedEfforts: effort ? [effort] : [],
                 contextWindowMaxTokens: getModelContextWindow(baseId),
             });
         }
-        if (effort) {
+        else if (effort) {
             const entry = modelsMap.get(baseId);
             if (!entry.supportedEfforts.includes(effort))
                 entry.supportedEfforts.push(effort);
@@ -403,27 +423,38 @@ export async function fetchAvailableModels(binaryPath = "agy", force = false) {
         now - lastModelFetch < MODEL_CACHE_TTL_MS) {
         return cachedModels;
     }
-    try {
-        const { stdout } = await execFileAsync(binaryPath, ["models"], {
-            timeout: 5_000,
-            env: process.env,
-            maxBuffer: 4 * 1024 * 1024,
-        });
-        const parsed = parseAgyModelsOutput(stdout);
-        cachedModels = parsed;
-        cachedModelsBinaryPath = binaryPath;
-        lastModelFetch = now;
-        return parsed;
-    }
-    catch (err) {
-        logger.warn("Failed to fetch models from agy CLI, using fallback models", {
-            error: err.message,
-        });
-        cachedModels = FALLBACK_MODELS;
-        cachedModelsBinaryPath = binaryPath;
-        lastModelFetch = now;
-        return FALLBACK_MODELS;
+    if (inFlightModelFetch) {
+        return inFlightModelFetch;
     }
+    inFlightModelFetch = (async () => {
+        const cmd = formatExecBinaryPath(binaryPath);
+        try {
+            const { stdout } = await execFileAsync(cmd, ["models"], {
+                timeout: 10_000,
+                env: process.env,
+                maxBuffer: 4 * 1024 * 1024,
+                shell: process.platform === "win32",
+            });
+            const parsed = parseAgyModelsOutput(stdout);
+            cachedModels = parsed;
+            cachedModelsBinaryPath = binaryPath;
+            lastModelFetch = Date.now();
+            return parsed;
+        }
+        catch (err) {
+            logger.warn("Failed to fetch models from agy CLI, using fallback models", {
+                error: err.message,
+            });
+            cachedModels = FALLBACK_MODELS;
+            cachedModelsBinaryPath = binaryPath;
+            lastModelFetch = Date.now();
+            return FALLBACK_MODELS;
+        }
+        finally {
+            inFlightModelFetch = null;
+        }
+    })();
+    return inFlightModelFetch;
 }
 export function getEffectiveEffortForModel(modelId, requestedEffort, models) {
     if (!modelId)

package/dist/slash-commands.js

@@ -5,6 +5,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { logger } from "./logger.js";
 import { sessionStore } from "./session-store.js";
+import { formatExecBinaryPath } from "./protocol.js";
 const execFileAsync = promisify(execFile);
 const AGY_COMMAND_TIMEOUT_MS = 30_000;
 const AGY_COMMAND_MAX_BUFFER = 4 * 1024 * 1024;
@@ -31,7 +32,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 +112,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 +273,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 +306,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 +314,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 });
@@ -319,11 +337,13 @@ export function formatUsageOutput(rawText) {
     return out;
 }
 async function runAgySlash(binaryPath, cwd, slashCommand) {
-    const { stdout, stderr } = await execFileAsync(binaryPath, ["--print", slashCommand], {
+    const cmd = formatExecBinaryPath(binaryPath);
+    const { stdout, stderr } = await execFileAsync(cmd, ["--print", slashCommand], {
         cwd,
         env: process.env,
         timeout: AGY_COMMAND_TIMEOUT_MS,
         maxBuffer: AGY_COMMAND_MAX_BUFFER,
+        shell: process.platform === "win32",
     });
     return stdout.trim() || stderr.trim();
 }

package/package.json

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