letmecode 0.1.12 → 0.1.15

package/ink-app/dist/providers/antigravity.js

@@ -1,7 +1,6 @@
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import https from "node:https";
-import { createRequire } from "node:module";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -10,7 +9,6 @@ import { promisify } from "node:util";
 import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
 import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 import { resolveUsageRate } from "./pricing.js";
-const require = createRequire(import.meta.url);
 const execFileAsync = promisify(execFile);
 const RATE_CARD = {
     "gemini-3.5-flash": {
@@ -68,21 +66,36 @@ const RATE_CARD = {
 const UNPRICED_MODELS = new Set([
     "gpt-oss-120b"
 ]);
-const ANTIGRAVITY_PRIMARY_WINDOW_MINUTES = 5 * 60;
-const ANTIGRAVITY_WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
 const ANTIGRAVITY_QUOTA_SUMMARY_PATH = "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary";
 const ANTIGRAVITY_USER_STATUS_PATH = "/exa.language_server_pb.LanguageServerService/GetUserStatus";
-const ANTIGRAVITY_DEBUG_LOG_PATH = process.env.LETMECODE_ANTIGRAVITY_DEBUG_LOG ??
-    path.join(os.tmpdir(), "letmecode-antigravity-debug.jsonl");
-const GEMINI_QUOTA_MODELS = [
-    "gemini-3.5-flash",
-    "gemini-3.1-pro",
-    "gemini-3-flash"
-];
-const THIRD_PARTY_QUOTA_MODELS = [
-    "claude-opus-4-6",
-    "claude-sonnet-4-6",
-    "gpt-oss-120b"
+const ANTIGRAVITY_CACHE_ROOT = path.join(os.homedir(), ".config", "tokscale", "antigravity-cache");
+const QUOTA_WINDOWS = {
+    "5h": {
+        scope: "primary",
+        windowMinutes: 300
+    },
+    weekly: {
+        scope: "secondary",
+        windowMinutes: 10080
+    }
+};
+const QUOTA_MODEL_GROUPS = [
+    {
+        pattern: /gemini/,
+        models: [
+            "gemini-3.5-flash",
+            "gemini-3.1-pro",
+            "gemini-3-flash"
+        ]
+    },
+    {
+        pattern: /claude|gpt/,
+        models: [
+            "claude-opus-4-6",
+            "claude-sonnet-4-6",
+            "gpt-oss-120b"
+        ]
+    }
 ];
 const MODEL_ALIASES = {
     "gemini-3-flash-a": "gemini-3-flash",
@@ -96,8 +109,7 @@ export class AntigravityUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super("antigravity", "Antigravity");
         this.collectUsage =
-            options.collectUsage ??
-                collectAntigravityUsageFromTokscale;
+            options.collectUsage ?? readAntigravityUsageCache;
         this.collectQuota =
             options.collectQuota ??
                 collectAntigravityQuotaFromLocalRpc;
@@ -115,7 +127,7 @@ export class AntigravityUsageProvider extends UsageProviderBase {
             ? quotaResult.value
             : null;
         if (usageResult.status === "rejected") {
-            warnings.push("Could not synchronize Antigravity token usage through Tokscale.");
+            warnings.push("Could not read Antigravity token usage cache.");
         }
         if (quotaResult.status === "rejected") {
             warnings.push("Live Antigravity quota is unavailable. Ensure the Antigravity IDE is running.");
@@ -123,9 +135,6 @@ export class AntigravityUsageProvider extends UsageProviderBase {
         else if (quotaResult.value.entries.length === 0) {
             warnings.push("Antigravity local quota RPC responded, but no recognized model quota windows were found.");
         }
-        if (isAntigravityDebugEnabled()) {
-            warnings.push(`Antigravity debug log: ${ANTIGRAVITY_DEBUG_LOG_PATH}`);
-        }
         const selectedRecords = deduplicateRecords(records);
         const duplicateEvents = records.length - selectedRecords.length;
         if (duplicateEvents > 0) {
@@ -152,7 +161,7 @@ export class AntigravityUsageProvider extends UsageProviderBase {
         if (unknownPricedModels.length > 0) {
             warnings.push(`No Antigravity estimated API-equivalent rate configured for: ${unknownPricedModels.join(", ")}.`);
         }
-        const limitWindows = quotaSnapshot?.entries.map((quota) => buildAntigravityLimitWindow(quota, selectedRecords, quotaSnapshot.fetchedAt)) ?? [];
+        const limitWindows = quotaSnapshot?.entries.map((quota) => buildAntigravityLimitWindow(quota, quotaSnapshot.planType, selectedRecords, quotaSnapshot.fetchedAt)) ?? [];
         return {
             providerId: this.id,
             providerLabel: this.label,
@@ -166,7 +175,7 @@ export class AntigravityUsageProvider extends UsageProviderBase {
                     ...new Set(limitWindows.map((window) => window.planType))
                 ],
                 rootLabel: "Tokscale usage + Antigravity local quota",
-                rootPath: getAntigravityCacheRoot()
+                rootPath: ANTIGRAVITY_CACHE_ROOT
             },
             modelUsage,
             dayUsage: buildDailyUsageRows(byDay),
@@ -175,121 +184,47 @@ export class AntigravityUsageProvider extends UsageProviderBase {
             warnings,
             analytics: quotaSnapshot?.userIdHash
                 ? {
-                    agentName: normalizeAnalyticsAgentName(this.label),
+                    agentName: this.label.replace(/\s/g, ""),
                     userIdHash: quotaSnapshot.userIdHash
                 }
                 : undefined
         };
     }
 }
-export async function collectAntigravityUsage() {
-    return collectAntigravityUsageFromTokscale();
-}
-export async function collectAntigravityQuota() {
-    return collectAntigravityQuotaFromLocalRpc();
-}
-async function collectAntigravityUsageFromTokscale() {
-    await runTokscale([
-        "antigravity",
-        "sync"
-    ]);
-    return readAntigravityUsageCache(getAntigravityCacheRoot());
-}
-async function runTokscale(args) {
-    return execFileAsync(process.execPath, [require.resolve("@tokscale/cli/dist/index.js"), ...args], {
-        encoding: "utf8",
-        maxBuffer: 32 * 1024 * 1024
-    });
-}
 async function collectAntigravityQuotaFromLocalRpc() {
     const server = await findAntigravityLocalServer();
     if (!server) {
         throw new Error("Antigravity local language server was not found.");
     }
-    const fetchedAt = Date.now();
-    const [quotaResult, statusResult] = await Promise.allSettled([
-        readAntigravityQuotaSummary(server),
-        readAntigravityUserStatus(server)
-    ]);
-    printAntigravityUserStatusResponse(statusResult);
-    if (quotaResult.status === "rejected") {
-        throw quotaResult.reason;
-    }
-    const entries = parseAntigravityQuotaEntries(quotaResult.value);
-    const planType = statusResult.status === "fulfilled"
-        ? parseAntigravityPlanType(statusResult.value)
-        : "unknown";
-    const userIdHash = statusResult.status === "fulfilled"
-        ? parseAntigravityUserIdHash(statusResult.value, normalizeAnalyticsAgentName("Antigravity"))
-        : null;
-    for (const entry of entries) {
-        entry.planType = planType;
-    }
-    await writeAntigravityDebugEvent("quota-rpc-response", {
-        port: server.port,
-        quotaPath: ANTIGRAVITY_QUOTA_SUMMARY_PATH,
-        userStatusPath: ANTIGRAVITY_USER_STATUS_PATH,
-        planType,
-        entries: entries.map((entry) => ({
-            limitId: entry.limitId,
-            remainingFraction: entry.remainingFraction,
-            resetAt: new Date(entry.resetAt).toISOString(),
-            windowMinutes: entry.windowMinutes,
-            scope: entry.scope,
-            modelIds: entry.modelIds
-        })),
-        ...(isAntigravityRawDebugEnabled()
-            ? {
-                quotaPayload: quotaResult.value,
-                userStatusPayload: statusResult.status === "fulfilled"
-                    ? statusResult.value
-                    : {
-                        error: statusResult.reason instanceof Error
-                            ? statusResult.reason.message
-                            : String(statusResult.reason)
-                    }
+    const [quota, status] = await Promise.all([
+        rpc(server, ANTIGRAVITY_QUOTA_SUMMARY_PATH),
+        rpc(server, ANTIGRAVITY_USER_STATUS_PATH, {
+            metadata: {
+                ideName: "antigravity",
+                extensionName: "antigravity",
+                ideVersion: "unknown",
+                locale: "en"
             }
-            : {})
-    });
+        }).catch(() => null)
+    ]);
     return {
-        entries,
-        fetchedAt,
-        userIdHash
+        entries: parseAntigravityQuotaEntries(quota),
+        fetchedAt: Date.now(),
+        planType: parseAntigravityPlanType(status),
+        userIdHash: parseAntigravityUserIdHash(status)
     };
 }
-function printAntigravityUserStatusResponse(statusResult) {
-    try {
-        if (statusResult.status === "fulfilled") {
-            console.error("Antigravity user status response:", JSON.stringify(statusResult.value, null, 2));
-            return;
-        }
-        console.error("Antigravity user status response error:", statusResult.reason instanceof Error
-            ? statusResult.reason.message
-            : String(statusResult.reason));
-    }
-    catch {
-        // Debug printing must never disturb usage collection.
-    }
-}
-function recordsForQuotaWindow(quota, records) {
-    if (quota.modelIds.length === 0) {
-        return [];
-    }
-    const endMs = quota.resetAt;
-    const startMs = endMs - quota.windowMinutes * 60000;
+function buildAntigravityLimitWindow(quota, planType, records, fetchedAt) {
+    const startAt = quota.resetAt - quota.windowMinutes * 60000;
     const modelIds = new Set(quota.modelIds.map(resolveModelId));
-    return records.filter((record) => {
-        const modelId = resolveModelId(record.modelId);
-        return (record.timestamp >= startMs &&
-            record.timestamp < endMs &&
-            modelIds.has(modelId));
-    });
-}
-function buildAntigravityLimitWindow(quota, records, fetchedAt) {
-    const matchingRecords = recordsForQuotaWindow(quota, records);
     const byModel = new Map();
-    for (const record of matchingRecords) {
+    for (const record of records) {
         const modelId = resolveModelId(record.modelId);
+        if (record.timestamp < startAt ||
+            record.timestamp >= quota.resetAt ||
+            !modelIds.has(modelId)) {
+            continue;
+        }
         addModelUsage(byModel, modelId, usageRecordToTotals(modelId, record));
     }
     const modelUsage = [...byModel.entries()]
@@ -306,7 +241,7 @@ function buildAntigravityLimitWindow(quota, records, fetchedAt) {
     // window and may not match Antigravity's internal quota accounting exactly.
     return {
         scope: quota.scope,
-        planType: quota.planType,
+        planType,
         limitId: quota.limitId,
         windowMinutes: quota.windowMinutes,
         startTimeUtcIso: new Date(quota.resetAt - quota.windowMinutes * 60000).toISOString(),
@@ -320,236 +255,88 @@ function buildAntigravityLimitWindow(quota, records, fetchedAt) {
         eventCount: totals.eventCount
     };
 }
-const antigravityHttpsAgent = new https.Agent({
-    rejectUnauthorized: false
-});
 async function findAntigravityLocalServer() {
     const process = await findAntigravityProcess();
     if (!process) {
-        await writeAntigravityDebugEvent("process-not-found", {});
         return null;
     }
-    const ports = await findListeningLoopbackPorts(process.pid);
-    await writeAntigravityDebugEvent("process-found", {
-        pid: process.pid,
-        ports
-    });
-    return probeAntigravityPorts(ports, process.csrfToken);
-}
-async function findAntigravityProcess() {
-    const fromProc = await findAntigravityProcessFromProc();
-    if (fromProc) {
-        return fromProc;
-    }
-    return findAntigravityProcessFromPs();
-}
-async function findAntigravityProcessFromProc() {
-    let entries;
-    try {
-        entries = await fs.promises.readdir("/proc", { withFileTypes: true });
-    }
-    catch {
-        return null;
-    }
-    for (const entry of entries) {
-        if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) {
-            continue;
+    for (const port of await findListeningPorts(process.pid)) {
+        const server = {
+            port,
+            csrfToken: process.csrfToken
+        };
+        try {
+            await rpc(server, ANTIGRAVITY_QUOTA_SUMMARY_PATH);
+            return server;
         }
-        const pid = Number(entry.name);
-        const cmdline = await readProcCmdline(path.join("/proc", entry.name, "cmdline"));
-        const process = parseAntigravityProcessFromArgs(pid, cmdline);
-        if (process) {
-            return process;
+        catch {
+            // Try the next loopback listener owned by the same Antigravity process.
         }
     }
     return null;
 }
-async function readProcCmdline(filePath) {
-    try {
-        const content = await fs.promises.readFile(filePath);
-        return content
-            .toString("utf8")
-            .split("\0")
-            .filter(Boolean);
-    }
-    catch {
-        return [];
-    }
-}
-async function findAntigravityProcessFromPs() {
-    try {
-        const { stdout } = await execFileAsync("ps", ["-eo", "pid=,args="], {
-            encoding: "utf8",
-            maxBuffer: 4 * 1024 * 1024,
-            timeout: 5000
-        });
-        for (const line of stdout.split(/\r?\n/)) {
-            const match = line.match(/^\s*(\d+)\s+(.+)$/);
-            if (!match) {
-                continue;
-            }
-            const process = parseAntigravityProcessFromArgs(Number(match[1]), splitCommandLineForDiscovery(match[2]));
-            if (process) {
-                return process;
-            }
+async function findAntigravityProcess() {
+    const entries = await fs.promises.readdir("/proc").catch(() => []);
+    for (const entry of entries) {
+        if (!/^\d+$/.test(entry)) {
+            continue;
         }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
-function splitCommandLineForDiscovery(value) {
-    return value.match(/"[^"]*"|'[^']*'|\S+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
-}
-function parseAntigravityProcessFromArgs(pid, args) {
-    if (!Number.isInteger(pid) || pid <= 0 || !isAntigravityLanguageServerCommand(args)) {
-        return null;
-    }
-    const csrfToken = readNamedArg(args, "--csrf_token")?.trim();
-    if (!csrfToken) {
-        return null;
-    }
-    return { pid, csrfToken };
-}
-function isAntigravityLanguageServerCommand(args) {
-    const normalized = args.join(" ").toLowerCase();
-    return (normalized.includes("antigravity") &&
-        (normalized.includes("language-server") ||
-            normalized.includes("language_server") ||
-            normalized.includes("extension-server") ||
-            normalized.includes("extension_server")));
-}
-function readNamedArg(args, name) {
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === name) {
-            return args[index + 1] ?? null;
+        const args = await fs.promises
+            .readFile(`/proc/${entry}/cmdline`, "utf8")
+            .then((value) => value.split("\0").filter(Boolean))
+            .catch(() => []);
+        const command = args.join(" ").toLowerCase();
+        if (!command.includes("antigravity") ||
+            !/(language|extension)[_-]server/.test(command)) {
+            continue;
         }
-        if (arg.startsWith(`${name}=`)) {
-            return arg.slice(name.length + 1);
+        const tokenArg = args.find((arg) => arg.startsWith("--csrf_token="));
+        const tokenIndex = args.indexOf("--csrf_token");
+        const csrfToken = tokenArg?.slice("--csrf_token=".length) ??
+            args[tokenIndex + 1];
+        if (csrfToken) {
+            return {
+                pid: Number(entry),
+                csrfToken
+            };
         }
     }
     return null;
 }
-async function findListeningLoopbackPorts(pid) {
-    const parsers = [
-        () => findListeningLoopbackPortsWithSs(pid),
-        () => findListeningLoopbackPortsWithLsof(pid)
+async function findListeningPorts(pid) {
+    const { stdout } = await execFileAsync("ss", ["-H", "-ltnp"], { encoding: "utf8", timeout: 5000 });
+    return [
+        ...new Set(stdout
+            .split("\n")
+            .filter((line) => line.includes(`pid=${pid},`))
+            .flatMap((line) => [
+            ...line.matchAll(/(?:127\.0\.0\.1|\[::1\]):(\d+)/g)
+        ])
+            .map((match) => Number(match[1])))
     ];
-    for (const parse of parsers) {
-        const ports = await parse();
-        if (ports.length > 0) {
-            return ports;
-        }
-    }
-    return [];
 }
-async function findListeningLoopbackPortsWithSs(pid) {
-    try {
-        const { stdout } = await execFileAsync("ss", ["-H", "-ltnp"], {
-            encoding: "utf8",
-            maxBuffer: 1024 * 1024,
-            timeout: 5000
-        });
-        return uniquePorts(stdout
-            .split(/\r?\n/)
-            .filter((line) => line.includes(`pid=${pid},`) && isLoopbackListenLine(line))
-            .map(extractPortFromListenLine));
-    }
-    catch {
-        return [];
-    }
-}
-async function findListeningLoopbackPortsWithLsof(pid) {
-    try {
-        const { stdout } = await execFileAsync("lsof", ["-Pan", "-p", String(pid), "-iTCP", "-sTCP:LISTEN"], {
-            encoding: "utf8",
-            maxBuffer: 1024 * 1024,
-            timeout: 5000
-        });
-        return uniquePorts(stdout
-            .split(/\r?\n/)
-            .filter(isLoopbackListenLine)
-            .map(extractPortFromListenLine));
-    }
-    catch {
-        return [];
-    }
-}
-function isLoopbackListenLine(line) {
-    return /(?:127\.0\.0\.1|localhost|\[::1\]|::1):\d+\b/.test(line);
-}
-function extractPortFromListenLine(line) {
-    const matches = [...line.matchAll(/(?:127\.0\.0\.1|localhost|\[::1\]|::1):(\d+)/g)];
-    const value = matches.at(-1)?.[1];
-    const port = value ? Number(value) : NaN;
-    return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
-}
-function uniquePorts(ports) {
-    return [...new Set(ports.filter((port) => port !== null))];
-}
-async function probeAntigravityPorts(ports, csrfToken) {
-    for (const port of ports) {
-        const server = { port, csrfToken };
-        try {
-            await readAntigravityQuotaSummary(server);
-            await writeAntigravityDebugEvent("port-probe-ok", { port });
-            return server;
-        }
-        catch (error) {
-            await writeAntigravityDebugEvent("port-probe-failed", {
-                port,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            // Try the next loopback listener owned by the same Antigravity process.
-        }
-    }
-    return null;
-}
-async function readAntigravityQuotaSummary(server) {
-    return requestAntigravityQuotaSummary(server);
-}
-async function readAntigravityUserStatus(server) {
-    return requestAntigravityUserStatus(server);
-}
-function requestAntigravityQuotaSummary(server) {
-    return requestAntigravityRpc(server, ANTIGRAVITY_QUOTA_SUMMARY_PATH, {});
-}
-function requestAntigravityUserStatus(server) {
-    return requestAntigravityRpc(server, ANTIGRAVITY_USER_STATUS_PATH, {
-        metadata: {
-            ideName: "antigravity",
-            extensionName: "antigravity",
-            ideVersion: "unknown",
-            locale: "en"
-        }
-    });
-}
-function requestAntigravityRpc(server, rpcPath, payload) {
+function rpc(server, endpoint, payload = {}) {
     const body = JSON.stringify(payload);
     return new Promise((resolve, reject) => {
         const request = https.request({
             hostname: "127.0.0.1",
             port: server.port,
-            path: rpcPath,
+            path: endpoint,
             method: "POST",
+            rejectUnauthorized: false,
             timeout: 5000,
-            agent: antigravityHttpsAgent,
             headers: {
                 "X-Codeium-Csrf-Token": server.csrfToken,
                 "Content-Type": "application/json",
-                "Connect-Protocol-Version": "1",
-                Accept: "application/json",
-                "Content-Length": Buffer.byteLength(body)
+                "Connect-Protocol-Version": "1"
             }
         }, (response) => {
             const chunks = [];
             response.on("data", (chunk) => chunks.push(chunk));
             response.on("end", () => {
                 const responseBody = Buffer.concat(chunks).toString("utf8");
-                if (!response.statusCode || response.statusCode < 200 || response.statusCode >= 300) {
-                    reject(new Error(`Unexpected Antigravity RPC response from ${rpcPath}: ${response.statusCode ?? "unknown"}`));
+                if (!response.statusCode || response.statusCode >= 300) {
+                    reject(new Error(`RPC failed: ${response.statusCode ?? "unknown"}`));
                     return;
                 }
                 try {
@@ -561,253 +348,54 @@ function requestAntigravityRpc(server, rpcPath, payload) {
             });
         });
         request.on("timeout", () => {
-            request.destroy(new Error(`Timed out reading Antigravity RPC ${rpcPath}.`));
+            request.destroy(new Error(`Timed out reading Antigravity RPC ${endpoint}.`));
         });
         request.on("error", reject);
         request.end(body);
     });
 }
 export function parseAntigravityQuotaEntries(payload) {
-    const root = asRecord(payload);
-    const response = asRecord(root?.response);
-    const groups = asArray(response?.groups);
-    const entries = [];
-    for (const groupValue of groups) {
-        const group = asRecord(groupValue);
-        if (!group) {
-            continue;
+    const groups = payload.response?.groups ?? [];
+    return groups.flatMap((group) => {
+        const modelIds = resolveQuotaGroupModelIds(`${group.displayName ?? ""} ${group.description ?? ""}`);
+        if (!modelIds.length) {
+            return [];
         }
-        const displayName = asString(group.displayName) ?? "";
-        const description = asString(group.description) ?? "";
-        const modelIds = resolveQuotaGroupModelIds(displayName, description);
-        if (modelIds.length === 0) {
-            void writeAntigravityDebugEvent("quota-group-skipped", {
-                displayName,
-                description
-            });
-            continue;
-        }
-        for (const bucketValue of asArray(group.buckets)) {
-            const bucket = asRecord(bucketValue);
-            if (!bucket) {
-                continue;
-            }
-            const bucketId = asString(bucket.bucketId);
-            const windowConfig = resolveQuotaWindow(asString(bucket.window));
-            const remainingFraction = asFiniteNumber(bucket.remainingFraction);
-            const resetTime = asString(bucket.resetTime);
-            const resetAt = resetTime === null ? NaN : Date.parse(resetTime);
-            if (!bucketId ||
-                remainingFraction === null ||
-                remainingFraction < 0 ||
-                remainingFraction > 1 ||
+        return (group.buckets ?? []).flatMap((bucket) => {
+            const window = bucket.window
+                ? QUOTA_WINDOWS[bucket.window]
+                : undefined;
+            const resetAt = Date.parse(bucket.resetTime ?? "");
+            if (!bucket.bucketId ||
+                window === undefined ||
                 !Number.isFinite(resetAt) ||
-                !windowConfig) {
-                continue;
+                typeof bucket.remainingFraction !== "number" ||
+                bucket.remainingFraction < 0 ||
+                bucket.remainingFraction > 1) {
+                return [];
             }
-            entries.push({
-                limitId: bucketId,
-                modelIds,
-                remainingFraction,
-                resetAt,
-                windowMinutes: windowConfig.windowMinutes,
-                scope: windowConfig.scope,
-                planType: "unknown"
-            });
-        }
-    }
-    return entries;
+            return [{
+                    limitId: bucket.bucketId,
+                    modelIds,
+                    remainingFraction: bucket.remainingFraction,
+                    resetAt,
+                    ...window
+                }];
+        });
+    });
 }
 export function parseAntigravityPlanType(payload) {
-    const root = asRecord(payload);
-    const response = asRecord(root?.response);
-    const candidates = [
-        readNestedString(root, [
-            "userStatus",
-            "planStatus",
-            "planInfo",
-            "planName"
-        ]),
-        readNestedString(root, [
-            "userStatus",
-            "planStatus",
-            "planInfo",
-            "planDisplayName"
-        ]),
-        readNestedString(root, [
-            "userStatus",
-            "planStatus",
-            "planName"
-        ]),
-        readNestedString(root, [
-            "userStatus",
-            "planName"
-        ]),
-        readNestedString(response, [
-            "userStatus",
-            "planStatus",
-            "planInfo",
-            "planName"
-        ]),
-        readNestedString(response, [
-            "userStatus",
-            "planStatus",
-            "planInfo",
-            "planDisplayName"
-        ]),
-        readNestedString(response, [
-            "userStatus",
-            "planStatus",
-            "planName"
-        ]),
-        readNestedString(response, [
-            "userStatus",
-            "planName"
-        ]),
-        readNestedString(response, [
-            "planStatus",
-            "planInfo",
-            "planName"
-        ]),
-        readNestedString(response, [
-            "planInfo",
-            "planName"
-        ]),
-        readNestedString(response, ["planName"]),
-        readNestedString(root, ["planName"])
-    ];
-    const rawPlan = candidates.find((value) => Boolean(value));
-    return normalizeAntigravityPlanType(rawPlan ?? null);
+    const planName = payload.response?.userStatus?.planStatus?.planInfo?.planName;
+    return typeof planName === "string" && planName ? planName : "unknown";
 }
-export function parseAntigravityUserIdHash(payload, agentName) {
-    const root = asRecord(payload);
-    const response = asRecord(root?.response);
-    const email = readNestedString(root, ["userStatus", "email"]) ??
-        readNestedString(response, ["userStatus", "email"]) ??
-        readNestedString(root, ["email"]) ??
-        readNestedString(response, ["email"]);
-    return buildUserIdHash([agentName, email ?? ""]);
-}
-function readNestedString(value, pathParts) {
-    let current = value;
-    for (const part of pathParts) {
-        const record = asRecord(current);
-        if (!record) {
-            return null;
-        }
-        current = record[part];
-    }
-    return asString(current);
-}
-function normalizeAntigravityPlanType(value) {
-    if (!value) {
-        return "unknown";
-    }
-    const normalized = value.toLowerCase();
-    if (normalized.includes("ultra")) {
-        return "ultra";
-    }
-    if (normalized.includes("pro") || normalized.includes("premium")) {
-        return "pro";
-    }
-    if (normalized.includes("free") || normalized.includes("standard")) {
-        return "free";
-    }
-    return value;
-}
-function normalizeAnalyticsAgentName(label) {
-    return label.replace(/\s+/g, "");
-}
-function buildUserIdHash(parts) {
-    if (parts.some((part) => !part)) {
-        return null;
-    }
-    return createHash("md5").update(parts.join("-")).digest("hex");
-}
-function resolveQuotaWindow(window) {
-    switch (window) {
-        case "5h":
-            return {
-                scope: "primary",
-                windowMinutes: ANTIGRAVITY_PRIMARY_WINDOW_MINUTES
-            };
-        case "weekly":
-            return {
-                scope: "secondary",
-                windowMinutes: ANTIGRAVITY_WEEKLY_WINDOW_MINUTES
-            };
-        default:
-            return null;
-    }
-}
-function resolveQuotaGroupModelIds(displayName, description) {
-    const text = `${displayName} ${description}`.toLowerCase();
-    if (text.includes("gemini")) {
-        return GEMINI_QUOTA_MODELS;
-    }
-    if (text.includes("claude") || text.includes("gpt")) {
-        return THIRD_PARTY_QUOTA_MODELS;
-    }
-    return [];
-}
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
+export function parseAntigravityUserIdHash(payload) {
+    const email = payload.response?.userStatus?.email;
+    return typeof email === "string" && email
+        ? createHash("md5").update(email).digest("hex")
         : null;
 }
-function asArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-function asString(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function asFiniteNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function isAntigravityDebugEnabled() {
-    const value = process.env.LETMECODE_DEBUG_ANTIGRAVITY;
-    return value === "1" || value === "true" || value === "yes";
-}
-function isAntigravityRawDebugEnabled() {
-    const value = process.env.LETMECODE_DEBUG_ANTIGRAVITY_RAW;
-    return value === "1" || value === "true" || value === "yes";
-}
-async function writeAntigravityDebugEvent(event, data) {
-    if (!isAntigravityDebugEnabled()) {
-        return;
-    }
-    const line = JSON.stringify({
-        timestamp: new Date().toISOString(),
-        event,
-        data: redactDebugValue(data)
-    });
-    try {
-        await fs.promises.mkdir(path.dirname(ANTIGRAVITY_DEBUG_LOG_PATH), {
-            recursive: true
-        });
-        await fs.promises.appendFile(ANTIGRAVITY_DEBUG_LOG_PATH, `${line}\n`, "utf8");
-    }
-    catch {
-        // Debug logging must never break provider stats collection.
-    }
-}
-function redactDebugValue(value, key = "") {
-    if (isSensitiveDebugKey(key)) {
-        return "[redacted]";
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => redactDebugValue(item));
-    }
-    if (!value || typeof value !== "object") {
-        return value;
-    }
-    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
-        entryKey,
-        redactDebugValue(entryValue, entryKey)
-    ]));
-}
-function isSensitiveDebugKey(key) {
-    return /token|csrf|authorization|cookie|email/i.test(key);
+function resolveQuotaGroupModelIds(text) {
+    return (QUOTA_MODEL_GROUPS.find(({ pattern }) => pattern.test(text.toLowerCase()))?.models ?? []);
 }
 function numberOrZero(value) {
     return typeof value === "number" && Number.isFinite(value)
@@ -820,8 +408,8 @@ function clampPercent(value) {
     }
     return Math.min(100, Math.max(0, value));
 }
-async function readAntigravityUsageCache(cacheRoot) {
-    const sessionsRoot = path.join(cacheRoot, "sessions");
+async function readAntigravityUsageCache() {
+    const sessionsRoot = path.join(ANTIGRAVITY_CACHE_ROOT, "sessions");
     const records = [];
     for await (const filePath of walkJsonlFiles(sessionsRoot)) {
         const stream = fs.createReadStream(filePath, { encoding: "utf8" });
@@ -875,9 +463,6 @@ function usageRecordFromCacheEntry(value) {
         reasoning: numberOrZero(entry.reasoning)
     };
 }
-function getAntigravityCacheRoot() {
-    return path.join(os.homedir(), ".config", "tokscale", "antigravity-cache");
-}
 async function* walkJsonlFiles(directory) {
     let entries;
     try {