paseo-acp-agy 1.2.3 → 1.2.5

package/dist/acp-server.js

@@ -85,12 +85,14 @@ export class ACPServer {
     }
     publishUsageUpdate(session) {
         const costUsd = roundUsageCostUsd(session.usage.totalCostUsd);
+        const maxTokens = session.usage.contextWindowMaxTokens;
+        const usedTokens = Math.min(session.usage.contextWindowUsedTokens, maxTokens);
         this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
             sessionId: session.id,
             update: {
                 sessionUpdate: "usage_update",
-                size: session.usage.contextWindowMaxTokens,
-                used: session.usage.contextWindowUsedTokens,
+                size: maxTokens,
+                used: usedTokens,
                 cost: { amount: costUsd, currency: "USD" },
                 inputTokens: session.usage.inputTokens,
                 outputTokens: session.usage.outputTokens,
@@ -98,8 +100,8 @@ export class ACPServer {
                 cachedInputTokens: session.usage.cachedInputTokens,
                 totalTokens: session.usage.totalTokens,
                 totalCostUsd: costUsd,
-                contextWindowMaxTokens: session.usage.contextWindowMaxTokens,
-                contextWindowUsedTokens: session.usage.contextWindowUsedTokens,
+                contextWindowMaxTokens: maxTokens,
+                contextWindowUsedTokens: usedTokens,
             },
         });
     }
@@ -138,7 +140,7 @@ export class ACPServer {
         const thought = turnUsage?.thinking_tokens;
         const total = turnUsage?.total_tokens ?? (input + output);
         const maxTokens = getModelContextWindow(executingModel || session.model);
-        const usedTokens = session.usage.contextWindowUsedTokens;
+        const usedTokens = Math.min(session.usage.contextWindowUsedTokens, maxTokens);
         const costUsd = roundUsageCostUsd(session.usage.totalCostUsd);
         return {
             inputTokens: input,
@@ -356,7 +358,10 @@ export class ACPServer {
                             break;
                         }
                         let hasSentNonNarration = false;
+                        let latestStepContextTokens;
+                        let stepCount = 0;
                         const onStepUpdate = (event) => {
+                            stepCount++;
                             const step = event.step_update;
                             if (!step)
                                 return;
@@ -437,15 +442,18 @@ export class ACPServer {
                                 }
                             }
                             if (step.usage) {
-                                const turnCost = calculateUsageCostUsd(executingModel, step.usage.input_tokens || 0, step.usage.output_tokens || 0, step.usage.cache_read_tokens || 0);
                                 const inputTokens = step.usage.input_tokens ?? 0;
                                 const outputTokens = step.usage.output_tokens ?? 0;
+                                if (inputTokens > 0) {
+                                    latestStepContextTokens = inputTokens + outputTokens;
+                                }
+                                const turnCost = calculateUsageCostUsd(executingModel, inputTokens, outputTokens, step.usage.cache_read_tokens || 0);
                                 const cachedReadTokens = step.usage.cache_read_tokens ?? 0;
                                 const thoughtTokens = step.usage.thinking_tokens;
                                 const totalTokens = step.usage.total_tokens ?? (inputTokens + outputTokens);
                                 const totalCostUsd = roundUsageCostUsd(session.usage.totalCostUsd + turnCost);
                                 const contextWindowMaxTokens = getModelContextWindow(executingModel);
-                                const contextWindowUsedTokens = inputTokens + outputTokens;
+                                const contextWindowUsedTokens = Math.min(inputTokens + outputTokens, contextWindowMaxTokens);
                                 this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                     sessionId: session.id,
                                     update: {
@@ -468,9 +476,10 @@ export class ACPServer {
                         try {
                             const resultEvent = await session.process.sendPrompt(promptText, onStepUpdate);
                             const turnUsage = resultEvent.result?.usage;
+                            const numTurns = resultEvent.result?.num_turns || stepCount || 1;
                             // Usage is billable even when the turn terminates with ERROR
                             // after model/tool work. Record it before branching on status.
-                            session.recordTurnUsage(turnUsage, executingModel);
+                            session.recordTurnUsage(turnUsage, executingModel, latestStepContextTokens, numTurns);
                             const usagePayload = this.turnUsagePayload(session, turnUsage, executingModel);
                             this.publishUsageUpdate(session);
                             if (session.isCancelled) {

package/dist/asar.d.ts

@@ -4,6 +4,11 @@ export interface AsarNode {
     offset?: string;
     executable?: boolean;
     unpacked?: boolean;
+    link?: string;
+}
+export interface ExtractResult {
+    unpackedPaths: string[];
+    originalHeader: AsarNode;
 }
 /**
  * Reads and parses the ASAR archive header and returns the root node and base offset for data.
@@ -20,9 +25,13 @@ export declare function listPackage(archivePath: string): string[];
  * Pure TypeScript, zero-dependency ASAR archive extractor.
  * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
  */
-export declare function extractAll(archivePath: string, destDir: string): void;
+export declare function extractAll(archivePath: string, destDir: string): ExtractResult;
+export interface CreatePackageOptions {
+    unpackedPaths?: string[];
+    originalHeader?: AsarNode;
+}
 /**
  * Pure TypeScript, zero-dependency ASAR archive builder.
  * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
  */
-export declare function createPackage(srcDir: string, destFile: string): Promise<void>;
+export declare function createPackage(srcDir: string, destFile: string, options?: CreatePackageOptions): Promise<void>;

package/dist/asar.js

@@ -61,6 +61,7 @@ export function listPackage(archivePath) {
 export function extractAll(archivePath, destDir) {
     const { header, dataBaseOffset } = readArchiveHeader(archivePath);
     const fd = fs.openSync(archivePath, "r");
+    const unpackedPaths = [];
     try {
         function extractNode(node, currentPath, relParts = []) {
             if (node.files) {
@@ -69,6 +70,20 @@ export function extractAll(archivePath, destDir) {
                     extractNode(child, path.join(currentPath, name), [...relParts, name]);
                 }
             }
+            else if (node.link) {
+                fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+                try {
+                    fs.unlinkSync(currentPath);
+                }
+                catch { }
+                fs.symlinkSync(node.link, currentPath);
+            }
+            else if (node.unpacked) {
+                // Unpacked files belong in archive.unpacked and must NOT be copied into destDir,
+                // so that re-packing does not duplicate external binaries into the asar payload.
+                const relPath = relParts.join("/");
+                unpackedPaths.push(relPath);
+            }
             else if (node.size !== undefined && node.offset !== undefined) {
                 const fileOffset = dataBaseOffset + parseInt(node.offset, 10);
                 const fileBuf = Buffer.alloc(node.size);
@@ -80,15 +95,9 @@ export function extractAll(archivePath, destDir) {
                     mode: node.executable ? 0o755 : 0o644,
                 });
             }
-            else if (node.unpacked) {
-                const unpackedSrc = path.join(archivePath + ".unpacked", ...relParts);
-                if (fs.existsSync(unpackedSrc)) {
-                    fs.mkdirSync(path.dirname(currentPath), { recursive: true });
-                    fs.copyFileSync(unpackedSrc, currentPath);
-                }
-            }
         }
         extractNode(header, destDir);
+        return { unpackedPaths, originalHeader: header };
     }
     finally {
         fs.closeSync(fd);
@@ -98,7 +107,7 @@ export function extractAll(archivePath, destDir) {
  * Pure TypeScript, zero-dependency ASAR archive builder.
  * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
  */
-export async function createPackage(srcDir, destFile) {
+export async function createPackage(srcDir, destFile, options) {
     const files = [];
     function walk(dir, rel = "") {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -106,16 +115,25 @@ export async function createPackage(srcDir, destFile) {
         for (const e of entries) {
             const entryRel = rel ? `${rel}/${e.name}` : e.name;
             const full = path.join(dir, e.name);
-            if (e.isDirectory()) {
+            const lstat = fs.lstatSync(full);
+            if (lstat.isSymbolicLink()) {
+                files.push({
+                    relPath: entryRel,
+                    fullPath: full,
+                    size: 0,
+                    isLink: true,
+                    linkTarget: fs.readlinkSync(full),
+                });
+            }
+            else if (lstat.isDirectory()) {
                 walk(full, entryRel);
             }
-            else if (e.isFile()) {
-                const stat = fs.statSync(full);
-                const executable = Boolean(stat.mode & 0o111);
+            else if (lstat.isFile()) {
+                const executable = Boolean(lstat.mode & 0o111);
                 files.push({
                     relPath: entryRel,
                     fullPath: full,
-                    size: stat.size,
+                    size: lstat.size,
                     executable: executable || undefined,
                 });
             }
@@ -134,12 +152,39 @@ export async function createPackage(srcDir, destFile) {
             curr = curr[parts[i]].files;
         }
         const leaf = parts[parts.length - 1];
-        curr[leaf] = {
-            size: f.size,
-            offset: String(currentOffset),
-            executable: f.executable,
-        };
-        currentOffset += f.size;
+        if (f.isLink) {
+            curr[leaf] = { link: f.linkTarget };
+        }
+        else {
+            curr[leaf] = {
+                size: f.size,
+                offset: String(currentOffset),
+                executable: f.executable,
+            };
+            currentOffset += f.size;
+        }
+    }
+    // Restore unpacked file references from original archive if provided
+    if (options?.unpackedPaths && options?.originalHeader) {
+        for (const relPath of options.unpackedPaths) {
+            const parts = relPath.split("/");
+            let origNode = options.originalHeader;
+            for (const p of parts) {
+                origNode = origNode?.files?.[p];
+            }
+            let curr = header.files;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (!curr[parts[i]]) {
+                    curr[parts[i]] = { files: {} };
+                }
+                curr = curr[parts[i]].files;
+            }
+            const leaf = parts[parts.length - 1];
+            curr[leaf] = {
+                size: origNode?.size ?? 0,
+                unpacked: true,
+            };
+        }
     }
     const jsonBuf = Buffer.from(JSON.stringify(header), "utf8");
     const alignedJsonLen = (jsonBuf.length + 3) & ~3;
@@ -159,7 +204,7 @@ export async function createPackage(srcDir, destFile) {
         fs.writeSync(fd, sizePickle);
         fs.writeSync(fd, headerPickle);
         for (const f of files) {
-            if (f.size > 0) {
+            if (!f.isLink && f.size > 0) {
                 const content = fs.readFileSync(f.fullPath);
                 fs.writeSync(fd, content);
             }

package/dist/paseo-patcher.d.ts

@@ -16,10 +16,16 @@ export declare function findPaseoServerInstallations(): string[];
  * injected into Paseo server's quota-fetcher providers.
  */
 export declare function generateAntigravityQuotaProviderJs(): string;
+/**
+ * Generates the TypeScript source for the Paseo 0.11+ Plugin Usage Source.
+ * This integrates Antigravity quota and balance metrics into Paseo 0.11+'s
+ * new Plugin UsageSource architecture (Settings -> Usage).
+ */
+export declare function generateAntigravityPluginUsageTs(): 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
+ * 1. For Paseo 0.11+: patches builtin-plugins/antigravity-provider with usage source
+ * 2. For Paseo <= 0.10: patches quota-fetcher/manifest.js and writes providers/antigravity.js
  * 3. Patches acp-agent.js to map context window tokens and emit usage updates
  */
 export declare function patchPaseoServer(serverDir: string): {

package/dist/paseo-patcher.js

@@ -222,6 +222,9 @@ const execFileAsync = promisify(execFile);
 let cachedAgyBin = null;
 let cachedAgyBinTime = 0;
 const BIN_CACHE_TTL_MS = 86400000; // 24 hours
+let lastSuccessfulQuota = null;
+let lastSuccessfulQuotaTime = 0;
+const QUOTA_CACHE_TTL_MS = 60000; // 60 seconds
 
 function resolveAgyBinary() {
     if (process.env.AGY_BIN_PATH) return process.env.AGY_BIN_PATH;
@@ -346,6 +349,11 @@ export class AntigravityQuotaProvider {
     }
 
     async fetchUsage() {
+        const now = Date.now();
+        if (lastSuccessfulQuota && (now - lastSuccessfulQuotaTime < QUOTA_CACHE_TTL_MS)) {
+            return lastSuccessfulQuota;
+        }
+
         try {
             const isWin = process.platform === "win32";
             const bin = resolveAgyBinary();
@@ -388,14 +396,23 @@ export class AntigravityQuotaProvider {
                 env.Path = newPath;
             }
 
-            const [usageRes, creditsRes] = await Promise.allSettled([
-                execFileAsync(bin, ["--print-timeout", "24h", "--print", "/usage"], { timeout: 15000, env, shell: isBatch, windowsHide: true }),
-                execFileAsync(bin, ["--print-timeout", "24h", "--print", "/credits"], { timeout: 15000, env, shell: isBatch, windowsHide: true }),
-            ]);
-
-            if (usageRes.status === "rejected") {
-                const reason = usageRes.reason;
-                const msg = reason instanceof Error ? reason.message : String(reason);
+            let rawUsageOut = "";
+            try {
+                const usageRes = await execFileAsync(bin, ["--print-timeout", "24h", "--print", "/usage"], {
+                    timeout: 30000,
+                    env,
+                    shell: isBatch,
+                    windowsHide: true,
+                });
+                rawUsageOut = usageRes.stdout || usageRes.stderr || "";
+            } catch (usageErr) {
+                if (lastSuccessfulQuota) {
+                    if (this.logger && typeof this.logger.warn === "function") {
+                        this.logger.warn("Transient failure fetching agy /usage; returning cached quota", { error: usageErr.message });
+                    }
+                    return lastSuccessfulQuota;
+                }
+                const msg = usageErr instanceof Error ? usageErr.message : String(usageErr);
                 return unavailableUsage({
                     providerId: this.providerId,
                     displayName: "Antigravity",
@@ -403,8 +420,16 @@ export class AntigravityQuotaProvider {
                 });
             }
 
-            const rawUsageOut = usageRes.value.stdout || usageRes.value.stderr || "";
-            const rawCreditsOut = creditsRes.status === "fulfilled" ? creditsRes.value.stdout || creditsRes.value.stderr : "";
+            let rawCreditsOut = "";
+            try {
+                const creditsRes = await execFileAsync(bin, ["--print-timeout", "24h", "--print", "/credits"], {
+                    timeout: 6000,
+                    env,
+                    shell: isBatch,
+                    windowsHide: true,
+                });
+                rawCreditsOut = creditsRes.stdout || creditsRes.stderr || "";
+            } catch {}
 
             const usageOut = (rawUsageOut || "").replace(/\\r\\n/g, "\\n");
             const creditsOut = (rawCreditsOut || "").replace(/\\r\\n/g, "\\n");
@@ -496,7 +521,7 @@ export class AntigravityQuotaProvider {
                 tone: remainingCredits > 0 ? "ok" : "default",
             });
 
-            return {
+            const result = {
                 providerId: this.providerId,
                 displayName: "Antigravity",
                 status: "available",
@@ -506,7 +531,12 @@ export class AntigravityQuotaProvider {
                 details: [],
                 error: null,
             };
+
+            lastSuccessfulQuota = result;
+            lastSuccessfulQuotaTime = Date.now();
+            return result;
         } catch (err) {
+            if (lastSuccessfulQuota) return lastSuccessfulQuota;
             return unavailableUsage({
                 providerId: this.providerId,
                 displayName: "Antigravity",
@@ -517,16 +547,387 @@ export class AntigravityQuotaProvider {
 }
 `;
 }
+/**
+ * Generates the TypeScript source for the Paseo 0.11+ Plugin Usage Source.
+ * This integrates Antigravity quota and balance metrics into Paseo 0.11+'s
+ * new Plugin UsageSource architecture (Settings -> Usage).
+ */
+export function generateAntigravityPluginUsageTs() {
+    return `import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+
+let cachedAgyBin = null;
+let lastAgyBinCheck = 0;
+const RESOLVE_TTL_MS = 30000;
+let lastSuccessfulPluginQuota = null;
+let lastSuccessfulPluginQuotaTime = 0;
+const PLUGIN_QUOTA_CACHE_TTL_MS = 60000;
+
+function resolveAgyBinary() {
+    const now = Date.now();
+    if (cachedAgyBin && (now - lastAgyBinCheck) < RESOLVE_TTL_MS) {
+        return cachedAgyBin;
+    }
+
+    if (process.env.AGY_BIN_PATH && fs.existsSync(process.env.AGY_BIN_PATH)) {
+        cachedAgyBin = process.env.AGY_BIN_PATH;
+        lastAgyBinCheck = now;
+        return cachedAgyBin;
+    }
+
+    const home = os.homedir();
+    const isWin = process.platform === "win32";
+
+    if (isWin) {
+        const localAppData = process.env.LOCALAPPDATA || (home ? path.join(home, "AppData", "Local") : "");
+        const programFiles = process.env.ProgramFiles || "C:\\\\Program Files";
+        const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\\\Program Files (x86)";
+
+        const winCandidates = [
+            path.join(localAppData, "Programs", "Antigravity", "bin", "agy.exe"),
+            path.join(localAppData, "Programs", "antigravity", "bin", "agy.exe"),
+            path.join(localAppData, "Programs", "Antigravity", "agy.exe"),
+            path.join(localAppData, "Programs", "antigravity", "agy.exe"),
+            path.join(localAppData, "antigravity", "agy.exe"),
+            path.join(programFiles, "Antigravity", "bin", "agy.exe"),
+            path.join(programFiles, "antigravity", "bin", "agy.exe"),
+            path.join(programFiles, "Antigravity", "agy.exe"),
+            path.join(programFiles, "antigravity", "agy.exe"),
+            path.join(programFilesX86, "Antigravity", "agy.exe"),
+            path.join(localAppData, "Microsoft", "WindowsApps", "agy.exe"),
+        ];
+
+        for (const cand of winCandidates) {
+            if (cand && fs.existsSync(cand)) {
+                cachedAgyBin = cand;
+                lastAgyBinCheck = now;
+                return cand;
+            }
+        }
+
+        try {
+            const out = execFileSync("where.exe", ["agy"], {
+                encoding: "utf-8",
+                timeout: 3000,
+                windowsHide: true,
+            });
+            const lines = out.split(/\\r?\\n/).map(l => l.trim()).filter(Boolean);
+            const exeMatch = lines.find(l => /\\.exe$/i.test(l) && fs.existsSync(l));
+            if (exeMatch) {
+                cachedAgyBin = exeMatch;
+                lastAgyBinCheck = now;
+                return exeMatch;
+            }
+            const scriptMatch = lines.find(l => /\\.(cmd|bat)$/i.test(l) && fs.existsSync(l));
+            if (scriptMatch) {
+                cachedAgyBin = scriptMatch;
+                lastAgyBinCheck = now;
+                return scriptMatch;
+            }
+            if (lines.length > 0 && fs.existsSync(lines[0])) {
+                cachedAgyBin = lines[0];
+                lastAgyBinCheck = now;
+                return lines[0];
+            }
+        } catch {}
+
+        cachedAgyBin = "agy.exe";
+        lastAgyBinCheck = now;
+        return cachedAgyBin;
+    } else {
+        const posixCandidates = [
+            path.join(home, ".local", "bin", "agy"),
+            "/usr/local/bin/agy",
+            "/usr/bin/agy",
+            "/opt/homebrew/bin/agy",
+        ];
+        for (const cand of posixCandidates) {
+            if (fs.existsSync(cand)) {
+                cachedAgyBin = cand;
+                lastAgyBinCheck = now;
+                return cand;
+            }
+        }
+        try {
+            const out = execFileSync("which", ["agy"], {
+                encoding: "utf-8",
+                timeout: 3000,
+            }).trim();
+            if (out && fs.existsSync(out)) {
+                cachedAgyBin = out;
+                lastAgyBinCheck = now;
+                return out;
+            }
+        } catch {}
+
+        cachedAgyBin = "agy";
+        lastAgyBinCheck = now;
+        return cachedAgyBin;
+    }
+}
+
+function toneFromUsedPct(usedPct) {
+    if (usedPct >= 90) return "critical";
+    if (usedPct >= 75) return "warn";
+    return "ok";
+}
+
+export async function fetchAntigravityUsage() {
+    const now = Date.now();
+    if (lastSuccessfulPluginQuota && (now - lastSuccessfulPluginQuotaTime < PLUGIN_QUOTA_CACHE_TTL_MS)) {
+        return lastSuccessfulPluginQuota;
+    }
+
+    try {
+        const bin = resolveAgyBinary();
+        const isWin = process.platform === "win32";
+        const isBatch = isWin && /\\.(cmd|bat)$/i.test(bin);
+
+        let usageOut = "";
+        try {
+            usageOut = execFileSync(bin, ["--print-timeout", "24h", "--print", "/usage"], {
+                encoding: "utf-8",
+                timeout: 30000,
+                windowsHide: true,
+                shell: isBatch,
+            });
+        } catch (usageErr) {
+            if (lastSuccessfulPluginQuota) return lastSuccessfulPluginQuota;
+            throw usageErr;
+        }
+
+        let creditsOut = "";
+        try {
+            creditsOut = execFileSync(bin, ["--print-timeout", "24h", "--print", "/credits"], {
+                encoding: "utf-8",
+                timeout: 6000,
+                windowsHide: true,
+                shell: isBatch,
+            });
+        } catch {}
+
+        const normalizedUsage = usageOut.replace(/\\r\\n/g, "\\n");
+        const lines = normalizedUsage.split("\\n");
+        const rawWindows = [];
+        let currentModel = "";
+
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            if (!line) continue;
+
+            if (line.endsWith(":") && !line.includes("%")) {
+                currentModel = line.slice(0, -1).trim();
+                continue;
+            }
+
+            const isGemini = /gemini/i.test(currentModel) || !/claude/i.test(currentModel);
+            const match = line.match(/^([A-Za-z0-9\\s_-]+):\\s*(\\d+)%\\s*(?:used)?(?:\\s*\\((?:resets?\\s+in\\s+)?([^)]+)\\))?/i);
+            if (match) {
+                const limitType = match[1].trim();
+                const usedPct = parseInt(match[2], 10);
+                const resetStr = match[3] ? match[3].trim() : null;
+
+                let resetsAt = null;
+                if (resetStr) {
+                    const durMatch = resetStr.match(/(?:(\\d+)h)?\\s*(?:(\\d+)m)?/i);
+                    if (durMatch && (durMatch[1] || durMatch[2])) {
+                        const h = parseInt(durMatch[1] || "0", 10);
+                        const m = parseInt(durMatch[2] || "0", 10);
+                        resetsAt = new Date(Date.now() + (h * 3600 + m * 60) * 1000).toISOString();
+                    } else {
+                        const parsed = Date.parse(resetStr);
+                        if (!isNaN(parsed)) resetsAt = new Date(parsed).toISOString();
+                    }
+                }
+
+                const isFiveHour = /session|5-?hour|5h/i.test(limitType);
+                const isWeekly = /week|7-?day/i.test(limitType);
+
+                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,
+                    shortLabel: isFiveHour ? "5h" : isWeekly ? "wk" : "",
+                    summary: true,
+                    usedPct,
+                    remainingPct: Math.max(0, 100 - 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 => ({
+            id: w.id,
+            label: w.label,
+            shortLabel: w.shortLabel,
+            summary: w.summary,
+            usedPct: w.usedPct,
+            remainingPct: w.remainingPct,
+            resetsAt: w.resetsAt,
+            tone: w.tone,
+        }));
+
+        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",
+        });
+
+        const result = {
+            status: "available",
+            planLabel: "Google Gemini",
+            windows,
+            balances,
+            details: [],
+        };
+        lastSuccessfulPluginQuota = result;
+        lastSuccessfulPluginQuotaTime = Date.now();
+        return result;
+    } catch (err) {
+        if (lastSuccessfulPluginQuota) return lastSuccessfulPluginQuota;
+        return {
+            status: "error",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+
+export function registerAntigravityUsageSource(server) {
+    if (!server || typeof server.registerUsageSource !== "function") return;
+    try {
+        server.registerUsageSource({
+            id: "antigravity",
+            label: "Antigravity",
+            icon: "icon.svg",
+            input: z.object({}).passthrough(),
+            discover: async (scope) => {
+                if (scope && scope.kind === "session" && scope.provider && scope.provider !== "antigravity") {
+                    return [];
+                }
+                return [{ key: "default", label: "Antigravity", input: {} }];
+            },
+            fetch: async () => {
+                return fetchAntigravityUsage();
+            },
+        });
+    } catch (err) {
+        console.warn("[antigravity-provider] Failed to register usage source:", err);
+    }
+}
+`;
+}
 /**
  * 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
+ * 1. For Paseo 0.11+: patches builtin-plugins/antigravity-provider with usage source
+ * 2. For Paseo <= 0.10: patches quota-fetcher/manifest.js and writes 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
+        // 1. Check for Paseo 0.11+ builtin-plugins/antigravity-provider
+        const pluginDirCandidates = [
+            path.join(serverDir, "dist", "server", "builtin-plugins", "antigravity-provider"),
+            path.join(serverDir, "dist", "builtin-plugins", "antigravity-provider"),
+            path.join(serverDir, "builtin-plugins", "antigravity-provider"),
+        ];
+        let pluginDir = pluginDirCandidates.find((d) => fs.existsSync(d));
+        if (!pluginDir && fs.existsSync(path.join(serverDir, "dist"))) {
+            const findPlugin = (dir, depth = 0) => {
+                if (depth > 5)
+                    return null;
+                try {
+                    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") {
+                            if (e.name === "antigravity-provider")
+                                return full;
+                            const found = findPlugin(full, depth + 1);
+                            if (found)
+                                return found;
+                        }
+                    }
+                }
+                catch { }
+                return null;
+            };
+            pluginDir = findPlugin(path.join(serverDir, "dist")) || undefined;
+        }
+        if (pluginDir) {
+            const serverSubdir = path.join(pluginDir, "server");
+            if (!fs.existsSync(serverSubdir)) {
+                fs.mkdirSync(serverSubdir, { recursive: true });
+            }
+            // Write / update usage.ts
+            const usageTsPath = path.join(serverSubdir, "usage.ts");
+            fs.writeFileSync(usageTsPath, generateAntigravityPluginUsageTs(), "utf-8");
+            changes.push(`Created/Updated ${usageTsPath}`);
+            // Locate index.server.ts and/or index.server.js
+            const indexCandidates = [
+                path.join(pluginDir, "index.server.ts"),
+                path.join(pluginDir, "index.server.js"),
+            ].filter((f) => fs.existsSync(f));
+            for (const indexFile of indexCandidates) {
+                let indexCode = fs.readFileSync(indexFile, "utf-8");
+                let indexModified = false;
+                if (!indexCode.includes("registerAntigravityUsageSource")) {
+                    // Add import
+                    if (!indexCode.includes('from "./server/usage.js"')) {
+                        indexCode = `import { registerAntigravityUsageSource } from "./server/usage.js";\n` + indexCode;
+                        indexModified = true;
+                    }
+                    // Inject registration call into contribute function
+                    const contributeMatch = indexCode.match(/(export\s+default\s+function\s+contribute\s*\([^)]*\)\s*\{)([\s\S]*?)(\})/);
+                    if (contributeMatch) {
+                        const before = contributeMatch[1];
+                        const body = contributeMatch[2];
+                        const after = contributeMatch[3];
+                        if (!body.includes("registerAntigravityUsageSource")) {
+                            const patchedBody = body.replace(/return\s+\(\)\s*=>\s*\{[^}]*\};?/, (m) => `server.registerUsageSource ? registerAntigravityUsageSource(server) : null;\n  ${m}`);
+                            if (patchedBody !== body) {
+                                indexCode = indexCode.replace(contributeMatch[0], `${before}${patchedBody}${after}`);
+                                indexModified = true;
+                            }
+                            else {
+                                indexCode = indexCode.replace(contributeMatch[0], `${before}${body}\n  server.registerUsageSource ? registerAntigravityUsageSource(server) : null;\n${after}`);
+                                indexModified = true;
+                            }
+                        }
+                    }
+                }
+                if (indexModified) {
+                    fs.writeFileSync(indexFile, indexCode, "utf-8");
+                    changes.push(`Patched ${indexFile} with registerAntigravityUsageSource`);
+                }
+            }
+        }
+        // 2. Check for Paseo <= 0.10 legacy quota-fetcher/manifest.js
         const manifestCandidates = [
             path.join(serverDir, "dist", "server", "services", "quota-fetcher", "manifest.js"),
             path.join(serverDir, "dist", "services", "quota-fetcher", "manifest.js"),
@@ -580,7 +981,7 @@ export function patchPaseoServer(serverDir) {
                 changes.push(`Patched ${manifestFile} with AntigravityQuotaProvider`);
             }
         }
-        // 2. Locate acp-agent.js
+        // 3. 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"),
@@ -609,19 +1010,26 @@ export function patchPaseoServer(serverDir) {
             let acpCode = fs.readFileSync(acpFile, "utf-8");
             let acpModified = false;
             // Patch mapACPUsage
-            if (!acpCode.includes("contextWindowMaxTokens: usage.contextWindowMaxTokens")) {
+            if (!acpCode.includes("contextWindowMaxTokens: usage.contextWindowMaxTokens") || !acpCode.includes("Math.min(usedTokens, maxTokens)")) {
                 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;
     }
+    const maxTokens = usage.contextWindowMaxTokens ?? usage.size ?? undefined;
+    let usedTokens = usage.contextWindowUsedTokens ?? usage.used ?? undefined;
+    if (typeof usedTokens === "number" && typeof maxTokens === "number" && maxTokens > 0) {
+        if (usedTokens > maxTokens) {
+            usedTokens = Math.min(usedTokens, maxTokens);
+        }
+    }
     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,
+        contextWindowUsedTokens: usedTokens,
     };
 }`;
                 if (oldMapRegex.test(acpCode)) {
@@ -666,7 +1074,7 @@ export function patchPaseoServer(serverDir) {
                     }
                     if (depth === 0) {
                         const currentMethodBody = acpCode.slice(startIdx, i);
-                        const needsPatch = !currentMethodBody.includes('type: "usage_updated"') || currentMethodBody.includes("this.notifySubscribers");
+                        const needsPatch = !currentMethodBody.includes("this.currentTurnUsage =") || currentMethodBody.includes("this.notifySubscribers");
                         if (needsPatch) {
                             const indent = methodMatch[1] || "    ";
                             const newHandler = `${indent}handleUsageUpdate(update) {
@@ -798,7 +1206,7 @@ export async function patchPaseoAsar(asarPath) {
             return { success: false, changes: [], error: `Asar archive not found: ${asarPath}` };
         }
         tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "paseo-asar-extract-"));
-        extractAll(asarPath, tempDir);
+        const { unpackedPaths, originalHeader } = extractAll(asarPath, tempDir);
         // Look for server directory in extracted files
         const serverCandidates = [
             path.join(tempDir, "node_modules", "@getpaseo", "server"),
@@ -841,8 +1249,27 @@ export async function patchPaseoAsar(asarPath) {
             return { success: true, changes: [] };
         }
         changes.push(...patchResult.changes);
-        // Create backup if not already present
-        const backupPath = `${asarPath}.bak`;
+        // Create backup if not already present.
+        // On macOS, never write backup inside .app bundle (e.g. app.asar.bak) because it breaks code signing seals.
+        let backupPath;
+        if (process.platform === "darwin" && asarPath.includes(".app")) {
+            const backupDir = path.join(os.homedir(), ".paseo", "backups");
+            if (!fs.existsSync(backupDir)) {
+                fs.mkdirSync(backupDir, { recursive: true });
+            }
+            backupPath = path.join(backupDir, "app.asar.bak");
+            // Clean up any orphan backup inside the .app bundle from previous runs
+            const orphanBak = `${asarPath}.bak`;
+            if (fs.existsSync(orphanBak)) {
+                try {
+                    fs.unlinkSync(orphanBak);
+                }
+                catch { }
+            }
+        }
+        else {
+            backupPath = `${asarPath}.bak`;
+        }
         if (!fs.existsSync(backupPath)) {
             try {
                 fs.copyFileSync(asarPath, backupPath);
@@ -853,7 +1280,7 @@ export async function patchPaseoAsar(asarPath) {
             }
         }
         tempAsar = path.join(os.tmpdir(), `app-${Date.now()}.asar`);
-        await createPackage(tempDir, tempAsar);
+        await createPackage(tempDir, tempAsar, { unpackedPaths, originalHeader });
         // Replace original archive with locked file handling for Windows
         try {
             fs.copyFileSync(tempAsar, asarPath);
@@ -875,6 +1302,21 @@ export async function patchPaseoAsar(asarPath) {
                 throw copyErr;
             }
         }
+        // On macOS, re-sign application bundle if inside an .app directory to satisfy Gatekeeper
+        if (process.platform === "darwin" && asarPath.includes(".app")) {
+            const appIndex = asarPath.indexOf(".app");
+            const appBundlePath = asarPath.slice(0, appIndex + 4);
+            try {
+                execFileSync("codesign", ["--force", "--deep", "--sign", "-", appBundlePath], {
+                    stdio: "ignore",
+                    timeout: 15000,
+                });
+                changes.push(`Re-signed macOS bundle at ${appBundlePath}`);
+            }
+            catch (signErr) {
+                logger.warn(`Could not re-sign ${appBundlePath}`, { error: String(signErr) });
+            }
+        }
         return { success: true, changes };
     }
     catch (err) {
@@ -950,43 +1392,15 @@ export function isPaseoServerPatched(serverDir) {
     try {
         if (!fs.existsSync(serverDir))
             return false;
-        // 1. Antigravity quota provider file
-        const antigravityJsCandidates = [
-            path.join(serverDir, "dist", "server", "services", "quota-fetcher", "providers", "antigravity.js"),
-            path.join(serverDir, "dist", "services", "quota-fetcher", "providers", "antigravity.js"),
-        ];
-        let hasProvider = antigravityJsCandidates.some((p) => fs.existsSync(p));
-        if (!hasProvider && fs.existsSync(path.join(serverDir, "dist"))) {
-            const checkRecursive = (dir, depth = 0) => {
-                if (depth > 5)
-                    return false;
-                try {
-                    const entries = fs.readdirSync(dir, { withFileTypes: true });
-                    for (const e of entries) {
-                        if (e.isDirectory() && e.name !== "node_modules") {
-                            if (checkRecursive(path.join(dir, e.name), depth + 1))
-                                return true;
-                        }
-                        else if (e.isFile() && e.name === "antigravity.js" && dir.replace(/\\/g, "/").includes("quota-fetcher")) {
-                            return true;
-                        }
-                    }
-                }
-                catch { }
-                return false;
-            };
-            hasProvider = checkRecursive(path.join(serverDir, "dist"));
-        }
-        if (!hasProvider)
-            return false;
-        // 2. Manifest check
-        const manifestCandidates = [
-            path.join(serverDir, "dist", "server", "services", "quota-fetcher", "manifest.js"),
-            path.join(serverDir, "dist", "services", "quota-fetcher", "manifest.js"),
+        // 1. Check for Paseo 0.11+ builtin-plugins/antigravity-provider
+        const pluginDirCandidates = [
+            path.join(serverDir, "dist", "server", "builtin-plugins", "antigravity-provider"),
+            path.join(serverDir, "dist", "builtin-plugins", "antigravity-provider"),
+            path.join(serverDir, "builtin-plugins", "antigravity-provider"),
         ];
-        let manifestFile = manifestCandidates.find((f) => fs.existsSync(f));
-        if (!manifestFile && fs.existsSync(path.join(serverDir, "dist"))) {
-            const findManifest = (dir, depth = 0) => {
+        let pluginDir = pluginDirCandidates.find((d) => fs.existsSync(d));
+        if (!pluginDir && fs.existsSync(path.join(serverDir, "dist"))) {
+            const findPlugin = (dir, depth = 0) => {
                 if (depth > 5)
                     return null;
                 try {
@@ -994,27 +1408,104 @@ export function isPaseoServerPatched(serverDir) {
                     for (const e of entries) {
                         const full = path.join(dir, e.name);
                         if (e.isDirectory() && e.name !== "node_modules") {
-                            const found = findManifest(full, depth + 1);
+                            if (e.name === "antigravity-provider")
+                                return full;
+                            const found = findPlugin(full, depth + 1);
                             if (found)
                                 return found;
                         }
-                        else if (e.isFile() && e.name === "manifest.js" && dir.replace(/\\/g, "/").includes("quota-fetcher")) {
-                            return full;
-                        }
                     }
                 }
                 catch { }
                 return null;
             };
-            manifestFile = findManifest(path.join(serverDir, "dist")) || undefined;
+            pluginDir = findPlugin(path.join(serverDir, "dist")) || undefined;
         }
-        if (manifestFile) {
-            const content = fs.readFileSync(manifestFile, "utf-8");
-            if (!content.includes('providerId: "antigravity"')) {
+        if (pluginDir) {
+            // Paseo 0.11+ architecture
+            const usageFile = [
+                path.join(pluginDir, "server", "usage.ts"),
+                path.join(pluginDir, "server", "usage.js"),
+            ].find((f) => fs.existsSync(f));
+            if (!usageFile)
                 return false;
+            const indexFile = [
+                path.join(pluginDir, "index.server.ts"),
+                path.join(pluginDir, "index.server.js"),
+            ].find((f) => fs.existsSync(f));
+            if (!indexFile)
+                return false;
+            const indexContent = fs.readFileSync(indexFile, "utf-8");
+            if (!indexContent.includes("registerAntigravityUsageSource"))
+                return false;
+        }
+        else {
+            // Paseo <= 0.10 legacy architecture
+            const antigravityJsCandidates = [
+                path.join(serverDir, "dist", "server", "services", "quota-fetcher", "providers", "antigravity.js"),
+                path.join(serverDir, "dist", "services", "quota-fetcher", "providers", "antigravity.js"),
+            ];
+            let hasProvider = antigravityJsCandidates.some((p) => fs.existsSync(p));
+            if (!hasProvider && fs.existsSync(path.join(serverDir, "dist"))) {
+                const checkRecursive = (dir, depth = 0) => {
+                    if (depth > 5)
+                        return false;
+                    try {
+                        const entries = fs.readdirSync(dir, { withFileTypes: true });
+                        for (const e of entries) {
+                            if (e.isDirectory() && e.name !== "node_modules") {
+                                if (checkRecursive(path.join(dir, e.name), depth + 1))
+                                    return true;
+                            }
+                            else if (e.isFile() && e.name === "antigravity.js" && dir.replace(/\\/g, "/").includes("quota-fetcher")) {
+                                return true;
+                            }
+                        }
+                    }
+                    catch { }
+                    return false;
+                };
+                hasProvider = checkRecursive(path.join(serverDir, "dist"));
+            }
+            if (!hasProvider)
+                return false;
+            // Manifest check
+            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, depth = 0) => {
+                    if (depth > 5)
+                        return null;
+                    try {
+                        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, depth + 1);
+                                if (found)
+                                    return found;
+                            }
+                            else if (e.isFile() && e.name === "manifest.js" && dir.replace(/\\/g, "/").includes("quota-fetcher")) {
+                                return full;
+                            }
+                        }
+                    }
+                    catch { }
+                    return null;
+                };
+                manifestFile = findManifest(path.join(serverDir, "dist")) || undefined;
+            }
+            if (manifestFile) {
+                const content = fs.readFileSync(manifestFile, "utf-8");
+                if (!content.includes('providerId: "antigravity"')) {
+                    return false;
+                }
             }
         }
-        // 3. ACP Agent check (context window telemetry & usage updates)
+        // 2. ACP Agent check (common to both architectures)
         const acpCandidates = [
             path.join(serverDir, "dist", "server", "server", "agent", "providers", "acp-agent.js"),
             path.join(serverDir, "dist", "server", "agent", "providers", "acp-agent.js"),
@@ -1046,7 +1537,7 @@ export function isPaseoServerPatched(serverDir) {
         }
         if (acpFile) {
             const content = fs.readFileSync(acpFile, "utf-8");
-            if (!content.includes('type: "usage_updated"') || !content.includes("contextWindowMaxTokens")) {
+            if (!content.includes("this.currentTurnUsage =") || !content.includes("contextWindowMaxTokens")) {
                 return false;
             }
         }
@@ -1064,7 +1555,11 @@ export async function isPaseoAsarPatched(asarPath) {
         if (!fs.existsSync(asarPath))
             return false;
         const files = listPackage(asarPath);
-        return files.some((f) => f.replace(/\\/g, "/").includes("quota-fetcher/providers/antigravity.js"));
+        return files.some((f) => {
+            const norm = f.replace(/\\/g, "/");
+            return norm.includes("quota-fetcher/providers/antigravity.js") ||
+                norm.includes("antigravity-provider/server/usage.");
+        });
     }
     catch {
         return false;

package/dist/protocol.js

@@ -308,14 +308,14 @@ export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
     try {
         const [usageResult, creditsResult] = await Promise.allSettled([
             execFileAsync(cmd, ["--print", "/usage"], {
-                timeout: 8_000,
+                timeout: 30_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
                 shell: isBatch,
                 windowsHide: true,
             }),
             execFileAsync(cmd, ["--print", "/credits"], {
-                timeout: 8_000,
+                timeout: 6_000,
                 maxBuffer: 1024 * 1024,
                 env: process.env,
                 shell: isBatch,
@@ -331,6 +331,10 @@ export async function fetchAntigravityUsage(binaryPath = "agy", force = false) {
         // /usage is the primary provider-availability probe. allSettled never
         // throws for an exec failure, so rejected results must be handled here.
         if (usageResult.status === "rejected") {
+            if (cachedProviderUsage && cachedProviderUsage.status === "available" && cachedProviderUsageBinaryPath === binaryPath) {
+                logger.warn("Transient failure in /usage; returning cached provider usage", { error: errorMessage(usageResult.reason) });
+                return cachedProviderUsage;
+            }
             const error = `Unable to fetch Antigravity quota: ${errorMessage(usageResult.reason)}`;
             logger.warn("Failed to fetch Antigravity provider usage", { error });
             return cacheProviderUsage(binaryPath, {

package/dist/session.d.ts

@@ -47,7 +47,7 @@ export declare class Session {
         output_tokens?: number;
         cache_read_tokens?: number;
         total_tokens?: number;
-    }, executingModel?: string): void;
+    }, executingModel?: string, latestStepContextTokens?: number, numSteps?: number): void;
     touch(): void;
     cancelTurn(): boolean;
     close(): Promise<void>;

package/dist/session.js

@@ -146,7 +146,7 @@ export class Session {
             throw err;
         }
     }
-    recordTurnUsage(turnUsage, executingModel = this.model) {
+    recordTurnUsage(turnUsage, executingModel = this.model, latestStepContextTokens, numSteps = 1) {
         if (!turnUsage)
             return;
         const input = turnUsage.input_tokens || 0;
@@ -159,10 +159,25 @@ export class Session {
         this.usage.totalTokens = this.usage.inputTokens + this.usage.outputTokens;
         // Keep the accumulator unrounded. Micro-costs must survive across turns.
         this.usage.totalCostUsd += turnCost;
-        this.usage.contextWindowUsedTokens = input + output;
-        // The selected model may have changed while this turn was running. Keep
-        // the stored meter aligned with the model currently selected for next turn.
+        // Keep the stored meter aligned with the model currently selected for next turn,
+        // but evaluate turn occupancy against the model that executed this turn.
+        const executingMaxTokens = getModelContextWindow(executingModel);
         this.usage.contextWindowMaxTokens = getModelContextWindow(this.model);
+        // Context window represents the active prompt memory buffer of the model.
+        // If we observed the latest step's context window size, use it directly.
+        // Otherwise, if input + output exceeds executingMaxTokens, it is an accumulation
+        // across multiple steps in the turn; derive the single-step context footprint.
+        let activeContextTokens = latestStepContextTokens;
+        if (!activeContextTokens || activeContextTokens <= 0) {
+            const rawTurnTokens = input + output;
+            if (rawTurnTokens > executingMaxTokens && numSteps > 1) {
+                activeContextTokens = Math.round(rawTurnTokens / numSteps);
+            }
+            else {
+                activeContextTokens = rawTurnTokens;
+            }
+        }
+        this.usage.contextWindowUsedTokens = Math.min(activeContextTokens, executingMaxTokens);
         this.persist();
     }
     touch() {

package/package.json

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