just-usage 0.0.4 → 0.0.6

package/dist/cli.js

@@ -15,8 +15,8 @@ import { mkdirSync } from "node:fs";
 // package.json
 var package_default = {
   name: "just-usage",
-  version: "0.0.4",
-  description: "One local page for your coding-CLI subscription quotas: Claude, Codex, Cursor, OpenCode Go.",
+  version: "0.0.6",
+  description: "One local page for your coding-CLI subscription quotas: Claude, Codex, Cursor, Antigravity, Grok, OpenCode Go.",
   type: "module",
   license: "MIT",
   author: "spheceo",
@@ -31,6 +31,8 @@ var package_default = {
     "codex",
     "cursor",
     "opencode",
+    "antigravity",
+    "grok",
     "quota",
     "usage",
     "rate-limit",
@@ -49,7 +51,7 @@ var package_default = {
     node: ">=20"
   },
   scripts: {
-    dev: "bun --watch src/cli.ts",
+    dev: "bun run src/cli.ts",
     build: "bun run scripts/build.ts",
     test: "bun test",
     typecheck: "tsc --noEmit",
@@ -86,7 +88,9 @@ var paths = {
   registry: () => join(configDir(), "accounts.json"),
   secrets: () => join(configDir(), "secrets.json"),
   updateCache: () => join(configDir(), "update-check.json"),
-  profiles: (provider) => join(configDir(), "profiles", provider)
+  profiles: (provider) => join(configDir(), "profiles", provider),
+  runDir: () => join(configDir(), "run"),
+  runRecord: (port) => join(configDir(), "run", `${port}.json`)
 };
 
 // src/format.ts
@@ -477,12 +481,15 @@ async function codexLogin(codexHome, onAuthUrl, timeoutMs = 5 * 60000) {
 
 // src/adapters/claude.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
 
 // src/proc.ts
 import { spawn as spawn2 } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { delimiter, join as join2 } from "node:path";
 function run(cmd, args, opts = {}) {
   return new Promise((resolve) => {
     let stdout = "";
@@ -496,7 +503,7 @@ function run(cmd, args, opts = {}) {
       resolve({ code, stdout, stderr });
     };
     const child = spawn2(cmd, args, {
-      env: { ...process.env, ...opts.env },
+      env: spawnEnv(opts.env),
       stdio: ["pipe", "pipe", "pipe"]
     });
     const timer = setTimeout(() => {
@@ -519,23 +526,70 @@ function run(cmd, args, opts = {}) {
 }
 function runInteractive(cmd, args, env) {
   return new Promise((resolve, reject) => {
-    const child = spawn2(cmd, args, { env: { ...process.env, ...env }, stdio: "inherit" });
+    const child = spawn2(cmd, args, { env: spawnEnv(env), stdio: "inherit" });
     child.on("error", reject);
     child.on("close", (code) => resolve(code));
   });
 }
 var whichCache = new Map;
-function which(bin) {
+function extraBinDirs() {
+  const home = homedir2();
+  const dirs = [
+    join2(home, ".local", "bin"),
+    join2(home, "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/home/linuxbrew/.linuxbrew/bin",
+    join2(home, ".npm-global", "bin")
+  ];
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA;
+    if (local)
+      dirs.push(join2(local, "agy", "bin"));
+  }
+  return dirs.filter((d) => existsSync(d));
+}
+function spawnEnv(extra) {
+  const pathKey = process.platform === "win32" && process.env.Path && !process.env.PATH ? "Path" : "PATH";
+  const current = extra?.[pathKey] ?? extra?.PATH ?? process.env[pathKey] ?? process.env.PATH ?? "";
+  const seen = new Set;
+  const parts = [];
+  for (const dir of [...extraBinDirs(), ...current.split(delimiter)]) {
+    if (!dir || seen.has(dir))
+      continue;
+    seen.add(dir);
+    parts.push(dir);
+  }
+  return { ...process.env, ...extra, [pathKey]: parts.join(delimiter) };
+}
+async function resolveBin(bin) {
+  const finder = process.platform === "win32" ? "where" : "which";
+  const res = await run(finder, [bin], { timeoutMs: 5000 });
+  if (res.code === 0) {
+    const first = res.stdout.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
+    if (first && existsSync(first))
+      return first;
+  }
+  const names = process.platform === "win32" ? [bin, `${bin}.exe`, `${bin}.cmd`] : [bin];
+  for (const dir of extraBinDirs()) {
+    for (const name of names) {
+      const candidate = join2(dir, name);
+      if (existsSync(candidate))
+        return candidate;
+    }
+  }
+  return null;
+}
+function clearBinCache() {
+  whichCache.clear();
+  versionCache.clear();
+}
+function which(bin, opts = {}) {
+  if (opts.fresh)
+    whichCache.delete(bin);
   let p = whichCache.get(bin);
   if (!p) {
-    p = (async () => {
-      const finder = process.platform === "win32" ? "where" : "which";
-      const res = await run(finder, [bin], { timeoutMs: 5000 });
-      if (res.code !== 0)
-        return null;
-      const first = res.stdout.split(/\r?\n/).map((s) => s.trim()).find(Boolean);
-      return first ?? null;
-    })();
+    p = resolveBin(bin);
     whichCache.set(bin, p);
   }
   return p;
@@ -577,7 +631,7 @@ function withTimeout(p, ms, label) {
 }
 
 // src/secrets.ts
-import { existsSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync, writeFileSync, chmodSync } from "node:fs";
 import { dirname } from "node:path";
 var SERVICE = "just-usage";
 
@@ -604,7 +658,7 @@ class FileStore {
   kind = "file";
   read() {
     const file = paths.secrets();
-    if (!existsSync(file))
+    if (!existsSync2(file))
       return {};
     try {
       return JSON.parse(readFileSync(file, "utf8"));
@@ -676,8 +730,8 @@ async function readClaudeCredentials(configDir) {
         return creds;
     }
   }
-  const file = join2(configDir ?? join2(homedir2(), ".claude"), ".credentials.json");
-  if (existsSync2(file))
+  const file = join3(configDir ?? join3(homedir3(), ".claude"), ".credentials.json");
+  if (existsSync3(file))
     return parseCreds(readFileSync2(file, "utf8"));
   return null;
 }
@@ -828,24 +882,389 @@ async function verifyClaudeToken(token) {
 // src/accounts.ts
 import { renameSync, rmSync as rmSync2 } from "node:fs";
 
+// src/adapters/antigravity.ts
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+var AGY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+var AGY_CLIENT_SECRET = "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";
+var AGY_REDIRECT_URI = "https://antigravity.google/oauth-callback";
+var AGY_SCOPES = [
+  "openid",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile",
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/cclog",
+  "https://www.googleapis.com/auth/experimentsandconfigs"
+];
+var USAGE_HOST = "https://daily-cloudcode-pa.googleapis.com";
+var KEYCHAIN_SERVICE = "gemini";
+var KEYCHAIN_ACCOUNT = "antigravity";
+var FALLBACK_CLI_VERSION2 = "1.1.26";
+function settingsFile() {
+  return join4(homedir4(), ".gemini", "antigravity-cli", "settings.json");
+}
+function usesGeminiApiKey() {
+  try {
+    if (!existsSync4(settingsFile()))
+      return false;
+    const parsed = JSON.parse(readFileSync3(settingsFile(), "utf8"));
+    return parsed.modelProvider === "gemini" && Boolean(process.env.GEMINI_API_KEY?.trim());
+  } catch {
+    return false;
+  }
+}
+function parseAgyKeyringBlob(raw) {
+  const text = raw.replace(/\r?\n$/, "");
+  const prefix = "go-keyring-base64:";
+  const json = text.startsWith(prefix) ? Buffer.from(text.slice(prefix.length), "base64").toString("utf8") : text;
+  try {
+    const parsed = JSON.parse(json);
+    const token = isObject(parsed.token) ? parsed.token : parsed;
+    if (typeof token.access_token !== "string" || !token.access_token)
+      return null;
+    if (typeof token.refresh_token !== "string" || !token.refresh_token)
+      return null;
+    const expiry = typeof token.expiry === "string" ? Date.parse(token.expiry) : typeof token.expiry === "number" ? token.expiry : NaN;
+    return {
+      accessToken: token.access_token,
+      refreshToken: token.refresh_token,
+      expiry: Number.isFinite(expiry) ? expiry : null
+    };
+  } catch {
+    return null;
+  }
+}
+function parseStoredAgySecret(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.refresh_token !== "string" || !parsed.refresh_token)
+      return parseAgyKeyringBlob(raw);
+    return {
+      accessToken: typeof parsed.access_token === "string" ? parsed.access_token : "",
+      refreshToken: parsed.refresh_token,
+      expiry: typeof parsed.expiry === "number" ? parsed.expiry : typeof parsed.expiry === "string" ? Date.parse(parsed.expiry) || null : null
+    };
+  } catch {
+    return parseAgyKeyringBlob(raw);
+  }
+}
+function serializeAgySecret(token) {
+  return JSON.stringify({
+    access_token: token.accessToken,
+    refresh_token: token.refreshToken,
+    expiry: token.expiry
+  });
+}
+async function tokenFromKeychain() {
+  if (process.platform !== "darwin")
+    return null;
+  const res = await run("security", ["find-generic-password", "-s", KEYCHAIN_SERVICE, "-a", KEYCHAIN_ACCOUNT, "-w"], { timeoutMs: 20000 });
+  if (res.code !== 0)
+    return null;
+  return parseAgyKeyringBlob(res.stdout);
+}
+async function tokenFromSecretTool() {
+  if (process.platform === "darwin" || process.platform === "win32")
+    return null;
+  const res = await run("secret-tool", ["lookup", "service", KEYCHAIN_SERVICE, "username", KEYCHAIN_ACCOUNT], { timeoutMs: 20000 });
+  if (res.code !== 0)
+    return null;
+  return parseAgyKeyringBlob(res.stdout);
+}
+function tokenFromOauthFile() {
+  const file = join4(homedir4(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+  if (!existsSync4(file))
+    return null;
+  try {
+    return parseAgyKeyringBlob(readFileSync3(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readDefaultAgyToken() {
+  return await tokenFromKeychain() ?? await tokenFromSecretTool() ?? tokenFromOauthFile();
+}
+function createPkce() {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash2("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function antigravityAuthUrl(opts) {
+  const url = new URL("https://accounts.google.com/o/oauth2/v2/auth");
+  url.searchParams.set("client_id", AGY_CLIENT_ID);
+  url.searchParams.set("redirect_uri", AGY_REDIRECT_URI);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("scope", AGY_SCOPES.join(" "));
+  url.searchParams.set("access_type", "offline");
+  url.searchParams.set("prompt", "consent");
+  url.searchParams.set("state", opts.state);
+  url.searchParams.set("code_challenge", opts.challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  return url.toString();
+}
+function isAntigravityCallbackUrl(raw) {
+  let u;
+  try {
+    u = new URL(raw.trim());
+  } catch {
+    return false;
+  }
+  return u.protocol === "https:" && u.hostname === "antigravity.google" && u.pathname === "/oauth-callback" && Boolean(u.searchParams.get("code"));
+}
+function parseAntigravityAuthInput(raw) {
+  const text = raw.trim().replace(/^["']|["']$/g, "");
+  if (!text)
+    return null;
+  if (isAntigravityCallbackUrl(text)) {
+    const u = new URL(text);
+    return { code: u.searchParams.get("code"), state: u.searchParams.get("state") };
+  }
+  if (/^https?:\/\//i.test(text))
+    return null;
+  if (/^4\/[A-Za-z0-9_\-/]+$/.test(text) && text.length >= 20)
+    return { code: text, state: null };
+  return null;
+}
+async function userAgent2() {
+  const v = await binVersion("agy") ?? FALLBACK_CLI_VERSION2;
+  return `antigravity-cli/${v}`;
+}
+function headers2(token, ua) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "User-Agent": ua
+  };
+}
+async function refreshAgyToken(refreshToken) {
+  const res = await fetchJson("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: AGY_CLIENT_ID,
+      client_secret: AGY_CLIENT_SECRET,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token"
+    }).toString()
+  });
+  if (res.status !== 200 || !isObject(res.body) || typeof res.body.access_token !== "string")
+    return null;
+  const expiresIn = typeof res.body.expires_in === "number" ? res.body.expires_in : 3600;
+  return {
+    accessToken: res.body.access_token,
+    refreshToken: typeof res.body.refresh_token === "string" && res.body.refresh_token ? res.body.refresh_token : refreshToken,
+    expiry: Date.now() + expiresIn * 1000
+  };
+}
+async function exchangeAntigravityCode(code, verifier) {
+  const res = await fetchJson("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: AGY_CLIENT_ID,
+      client_secret: AGY_CLIENT_SECRET,
+      code,
+      code_verifier: verifier,
+      grant_type: "authorization_code",
+      redirect_uri: AGY_REDIRECT_URI
+    }).toString()
+  });
+  if (res.status !== 200 || !isObject(res.body) || typeof res.body.access_token !== "string" || typeof res.body.refresh_token !== "string") {
+    throw new Error(isObject(res.body) && typeof res.body.error_description === "string" ? res.body.error_description : `Token exchange failed (HTTP ${res.status}).`);
+  }
+  const expiresIn = typeof res.body.expires_in === "number" ? res.body.expires_in : 3600;
+  return {
+    accessToken: res.body.access_token,
+    refreshToken: res.body.refresh_token,
+    expiry: Date.now() + expiresIn * 1000
+  };
+}
+async function fetchAgyEmail(accessToken) {
+  const res = await fetchJson("https://www.googleapis.com/oauth2/v2/userinfo", {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (res.status !== 200 || !isObject(res.body) || typeof res.body.email !== "string")
+    return null;
+  return res.body.email;
+}
+var GOOGLE_AI_PLANS = {
+  "g1-plus-tier": "Plus",
+  "g1-pro-tier": "Pro",
+  "g1-ultra-tier": "Ultra"
+};
+var PRODUCT_TIER_NAMES = /^(antigravity|gemini code assist)$/i;
+function planFromTier(tier) {
+  if (!tier)
+    return null;
+  const id = typeof tier.id === "string" ? tier.id.trim().toLowerCase() : "";
+  if (id && GOOGLE_AI_PLANS[id])
+    return GOOGLE_AI_PLANS[id];
+  if (id.includes("ultra"))
+    return "Ultra";
+  if (id.includes("pro"))
+    return "Pro";
+  if (id.includes("plus"))
+    return "Plus";
+  const name = typeof tier.name === "string" ? tier.name.trim() : "";
+  if (name && !PRODUCT_TIER_NAMES.test(name))
+    return name;
+  if (id === "free-tier")
+    return "Free";
+  if (id === "standard-tier")
+    return "Standard";
+  if (id === "legacy-tier")
+    return "Legacy";
+  return name || null;
+}
+function planFromCodeAssist(body) {
+  if (!isObject(body))
+    return null;
+  const current = isObject(body.currentTier) ? body.currentTier : null;
+  const paid = isObject(body.paidTier) ? body.paidTier : null;
+  return planFromTier(paid) ?? planFromTier(current);
+}
+function windowMinutes(window) {
+  const key = (window ?? "").toLowerCase().replace(/[_-]/g, "");
+  if (key === "5h" || key === "fivehour" || key === "fivehours")
+    return 300;
+  if (key === "weekly" || key === "week")
+    return 10080;
+  return null;
+}
+function usageLabel(minutes, fallback) {
+  if (minutes === 300)
+    return "5h Usage";
+  if (minutes === 10080)
+    return "Weekly Usage";
+  return fallback.replace(/\s+remaining$/i, "").trim() || "Usage";
+}
+function normalizeAntigravityQuota(body) {
+  if (!isObject(body) || !Array.isArray(body.groups))
+    return [];
+  const out = [];
+  for (const group of body.groups) {
+    if (!isObject(group) || !Array.isArray(group.buckets))
+      continue;
+    const rawGroup = typeof group.displayName === "string" && group.displayName.trim() ? group.displayName.trim() : undefined;
+    const groupName = rawGroup && !/^gemini models$/i.test(rawGroup) ? rawGroup : undefined;
+    for (const bucket of group.buckets) {
+      if (!isObject(bucket) || bucket.disabled === true)
+        continue;
+      const remaining = typeof bucket.remainingFraction === "number" ? bucket.remainingFraction : null;
+      const used = remaining === null ? null : clampPercent((1 - remaining) * 100);
+      if (used === null)
+        continue;
+      const id = typeof bucket.bucketId === "string" && bucket.bucketId ? bucket.bucketId : `${groupName ?? "quota"}:${out.length}`;
+      const minutes = windowMinutes(typeof bucket.window === "string" ? bucket.window : undefined);
+      const fallback = typeof bucket.displayName === "string" ? bucket.displayName : "Usage";
+      out.push({
+        id,
+        label: usageLabel(minutes, fallback),
+        group: groupName,
+        usedPercent: used,
+        resetsAt: isoOrNull(bucket.resetTime),
+        windowMinutes: minutes,
+        kind: "rolling"
+      });
+    }
+  }
+  return out;
+}
+async function resolveToken2(account) {
+  if (account.kind === "token") {
+    const raw = await secretStore().get(account.id);
+    if (!raw)
+      return { fail: snapshot(account, "error", { message: "Stored Google session missing. Remove the account and sign in again." }) };
+    const parsed = parseStoredAgySecret(raw);
+    if (!parsed)
+      return { fail: snapshot(account, "error", { message: "Stored Google session is unreadable. Remove the account and sign in again." }) };
+    return { token: parsed };
+  }
+  const token = await readDefaultAgyToken();
+  if (!token) {
+    if (usesGeminiApiKey()) {
+      return { fail: snapshot(account, "unsupported", { message: "This CLI is using a Gemini API key, which has no subscription quota." }) };
+    }
+    return { fail: snapshot(account, "signed_out", { message: "Not signed in. Run `agy` and complete Google sign-in." }) };
+  }
+  return { token };
+}
+async function liveToken(account, token) {
+  if (token.expiry && token.expiry > Date.now() + 60000 && token.accessToken)
+    return token;
+  const refreshed = await refreshAgyToken(token.refreshToken);
+  if (!refreshed) {
+    return { fail: snapshot(account, "error", { message: "Google session expired. Sign in again with `agy`." }) };
+  }
+  if (account.kind === "token") {
+    await secretStore().set(account.id, serializeAgySecret(refreshed));
+  }
+  return refreshed;
+}
+async function fetchAntigravity(account) {
+  try {
+    const resolved = await resolveToken2(account);
+    if ("fail" in resolved)
+      return resolved.fail;
+    const live = await liveToken(account, resolved.token);
+    if ("fail" in live)
+      return live.fail;
+    const ua = await userAgent2();
+    const h = headers2(live.accessToken, ua);
+    const [usage, assist, email] = await Promise.all([
+      fetchJson(`${USAGE_HOST}/v1internal:retrieveUserQuotaSummary`, { method: "POST", headers: h, body: "{}" }),
+      fetchJson(`${USAGE_HOST}/v1internal:loadCodeAssist`, {
+        method: "POST",
+        headers: h,
+        body: JSON.stringify({ metadata: { ideType: "ANTIGRAVITY" } })
+      }),
+      account.email ? Promise.resolve(account.email) : fetchAgyEmail(live.accessToken)
+    ]);
+    const plan = assist.status === 200 ? planFromCodeAssist(assist.body) : null;
+    if (usage.status === 401) {
+      return snapshot(account, "error", { email, plan, message: "Google session rejected (401). Sign in again." });
+    }
+    if (usage.status === 403) {
+      return snapshot(account, "unsupported", {
+        email,
+        plan,
+        message: "This Google account has no Antigravity quota. A Google AI Pro / Antigravity subscription is required."
+      });
+    }
+    if (usage.status !== 200) {
+      return snapshot(account, "error", { email, plan, message: `Usage endpoint returned HTTP ${usage.status}.` });
+    }
+    const windows = normalizeAntigravityQuota(usage.body);
+    if (windows.length === 0) {
+      return snapshot(account, "unsupported", { email, plan, message: "Usage response had no recognizable windows (schema may have changed)." });
+    }
+    return snapshot(account, "ok", { email, plan, windows });
+  } catch (e) {
+    return snapshot(account, "error", { message: errorMessage(e) });
+  }
+}
+
 // src/adapters/opencode.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
 var USAGE_URL2 = "https://opencode.ai/zen/go/v1/usage";
 function openCodeAuthFile() {
   if (process.env.OPENCODE_AUTH_FILE)
     return process.env.OPENCODE_AUTH_FILE;
   const xdg = process.env.XDG_DATA_HOME;
-  const base = xdg && xdg.trim() ? xdg : join3(homedir3(), ".local", "share");
-  return join3(base, "opencode", "auth.json");
+  const base = xdg && xdg.trim() ? xdg : join5(homedir5(), ".local", "share");
+  return join5(base, "opencode", "auth.json");
 }
 function readOpenCodeGoKey() {
   const file = openCodeAuthFile();
-  if (!existsSync3(file))
+  if (!existsSync5(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync3(file, "utf8"));
+    const parsed = JSON.parse(readFileSync4(file, "utf8"));
     const entry = parsed["opencode-go"];
     if (isObject(entry) && typeof entry.key === "string" && entry.key)
       return entry.key;
@@ -904,15 +1323,73 @@ async function fetchOpenCode(account) {
   }
 }
 
+// src/log.ts
+import { appendFileSync } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join6 } from "node:path";
+var SECRET_KEY = /^(.*[._-]?)?(secret|token|password|authorization|cookie|verifier|refresh_token|access_token|api[_-]?key|key)$/i;
+var SKIP_KEY = /^(url|authurl|callback|body|headers|authorization)$/i;
+var MAX_STRING = 400;
+function logDir() {
+  const override = process.env.JUST_USAGE_LOG_DIR;
+  if (override && override.trim())
+    return override.trim();
+  return join6(homedir6(), ".just-usage", "logs");
+}
+function logFile(at = new Date) {
+  return join6(logDir(), `${at.toISOString().slice(0, 10)}.log`);
+}
+function sanitizeFields(fields) {
+  if (!fields)
+    return {};
+  const out = {};
+  for (const [k, v] of Object.entries(fields)) {
+    if (v === undefined)
+      continue;
+    if (SECRET_KEY.test(k) || SKIP_KEY.test(k))
+      continue;
+    if (v === null || typeof v === "number" || typeof v === "boolean") {
+      out[k] = v;
+      continue;
+    }
+    if (typeof v === "string") {
+      out[k] = v.length <= MAX_STRING ? v : `${v.slice(0, MAX_STRING)}…`;
+      continue;
+    }
+    if (Array.isArray(v) && v.every((x) => typeof x === "string" || typeof x === "number")) {
+      out[k] = v.slice(0, 20);
+    }
+  }
+  return out;
+}
+function log(level, event, fields) {
+  try {
+    ensureDir(logDir());
+    const line = JSON.stringify({
+      ts: new Date().toISOString(),
+      level,
+      event,
+      pid: process.pid,
+      v: VERSION,
+      ...sanitizeFields(fields)
+    });
+    appendFileSync(logFile(), `${line}
+`, { encoding: "utf8", mode: 384 });
+  } catch {}
+}
+function logError(event, e, fields) {
+  log("error", event, { ...fields, message: errorMessage(e) });
+}
+
 // src/registry.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, rmSync } from "node:fs";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2, rmSync } from "node:fs";
+import { dirname as dirname2, join as join7 } from "node:path";
 function readRegistry() {
   const file = paths.registry();
-  if (!existsSync4(file))
+  if (!existsSync6(file))
     return { version: 1, accounts: [] };
   try {
-    const parsed = JSON.parse(readFileSync4(file, "utf8"));
+    const parsed = JSON.parse(readFileSync5(file, "utf8"));
     return { version: 1, accounts: Array.isArray(parsed.accounts) ? parsed.accounts : [] };
   } catch {
     return { version: 1, accounts: [] };
@@ -945,7 +1422,7 @@ function newAccountId(provider, hint) {
   }
 }
 function profileDirFor(provider, id) {
-  return join4(paths.profiles(provider), id.split(":")[1] ?? "account");
+  return join7(paths.profiles(provider), id.split(":")[1] ?? "account");
 }
 function saveAccount(record) {
   const reg = readRegistry();
@@ -1002,6 +1479,7 @@ async function addClaudeToken(token, label) {
     createdAt: new Date().toISOString()
   };
   saveAccount(account);
+  log("info", "account.add", { account: account.id, provider: account.provider, kind: account.kind });
   return { account };
 }
 async function addOpenCodeKey(key, label) {
@@ -1024,6 +1502,12 @@ async function addOpenCodeKey(key, label) {
     createdAt: new Date().toISOString()
   };
   saveAccount(account);
+  log("info", "account.add", {
+    account: account.id,
+    provider: account.provider,
+    kind: account.kind,
+    warning: status === 403 ? "no-subscription" : undefined
+  });
   return {
     account,
     warning: status === 403 ? "Key is valid but has no active OpenCode Go subscription." : undefined
@@ -1035,7 +1519,9 @@ function renameExtraAccount(id, label) {
   if (!getAccount(id))
     throw new AccountError(`Unknown account: ${id}`, 404);
   updateAccount(id, { label: label.trim() });
-  return getAccount(id);
+  const account = getAccount(id);
+  log("info", "account.rename", { account: account.id, provider: account.provider });
+  return account;
 }
 async function removeExtraAccount(id) {
   if (id.endsWith(":default"))
@@ -1045,6 +1531,7 @@ async function removeExtraAccount(id) {
     throw new AccountError(`Unknown account: ${id}`, 404);
   if (rec.kind === "token")
     await secretStore().delete(id);
+  log("info", "account.remove", { account: rec.id, provider: rec.provider, kind: rec.kind });
   return rec;
 }
 function saveCodexProfile(opts) {
@@ -1066,6 +1553,7 @@ function saveCodexProfile(opts) {
     createdAt: new Date().toISOString()
   };
   saveAccount(account);
+  log("info", "account.add", { account: account.id, provider: account.provider, kind: account.kind });
   return account;
 }
 function isLocalCallbackUrl(raw) {
@@ -1105,7 +1593,7 @@ function dropCodexSession(id, removeDir) {
   }
 }
 async function beginCodexAdd(label) {
-  if (!await which("codex"))
+  if (!await which("codex", { fresh: true }))
     throw new AccountError("codex is not installed (npm i -g @openai/codex).");
   const tmpId = newAccountId("codex", label?.trim() || "pending");
   const dir = ensureDir(profileDirFor("codex", tmpId));
@@ -1124,11 +1612,14 @@ async function beginCodexAdd(label) {
   handle.completed.then((info) => {
     rec.account = saveCodexProfile({ label: rec.label, tmpId, dir, email: info.email });
     rec.status = "done";
+    log("info", "account.login.done", { account: rec.account.id, provider: "codex" });
   }).catch((e) => {
     rec.status = "error";
     rec.error = e instanceof Error ? e.message : String(e);
+    logError("account.login.error", e, { provider: "codex" });
   });
   codexSessions.set(id, rec);
+  log("info", "account.login.start", { provider: "codex", kind: "add" });
   return { sessionId: id, authUrl: handle.authUrl };
 }
 async function beginCodexRelogin(accountId) {
@@ -1153,11 +1644,14 @@ async function beginCodexRelogin(accountId) {
     updateAccount(existing.id, { email: info.email });
     rec.account = { ...existing, email: info.email };
     rec.status = "done";
+    log("info", "account.login.done", { account: existing.id, provider: "codex" });
   }).catch((e) => {
     rec.status = "error";
     rec.error = e instanceof Error ? e.message : String(e);
+    logError("account.login.error", e, { account: existing.id, provider: "codex" });
   });
   codexSessions.set(id, rec);
+  log("info", "account.login.start", { account: existing.id, provider: "codex", kind: "relogin" });
   return { sessionId: id, authUrl: handle.authUrl };
 }
 function codexSessionStatus(sessionId) {
@@ -1176,50 +1670,151 @@ async function submitCodexCallback(sessionId, url) {
     return;
   await submitLocalCallback(url);
 }
+var agySessions = new Map;
+function dropAgySession(id) {
+  const rec = agySessions.get(id);
+  if (!rec)
+    return;
+  clearTimeout(rec.timer);
+  agySessions.delete(id);
+}
+function startAgySession(opts) {
+  const pkce = createPkce();
+  const state = crypto.randomUUID();
+  const id = crypto.randomUUID();
+  const authUrl = antigravityAuthUrl({ state, challenge: pkce.challenge });
+  const rec = {
+    id,
+    label: opts.label?.trim() || undefined,
+    accountId: opts.accountId,
+    state,
+    verifier: pkce.verifier,
+    authUrl,
+    status: "waiting",
+    timer: setTimeout(() => dropAgySession(id), SESSION_TTL_MS)
+  };
+  rec.timer.unref?.();
+  agySessions.set(id, rec);
+  return { sessionId: id, authUrl };
+}
+async function beginAntigravityAdd(label) {
+  if (!await which("agy", { fresh: true }))
+    throw new AccountError("agy is not installed (https://antigravity.google/docs/cli/install).");
+  const started = startAgySession({ label });
+  log("info", "account.login.start", { provider: "antigravity", kind: "add" });
+  return started;
+}
+async function beginAntigravityRelogin(accountId) {
+  const existing = getAccount(accountId);
+  if (!existing)
+    throw new AccountError(`Unknown account: ${accountId}`, 404);
+  if (existing.provider !== "antigravity" || existing.kind !== "token") {
+    throw new AccountError(`${accountId} cannot be re-authenticated this way.`);
+  }
+  const started = startAgySession({ accountId });
+  log("info", "account.login.start", { account: accountId, provider: "antigravity", kind: "relogin" });
+  return started;
+}
+function antigravitySessionStatus(sessionId) {
+  const rec = agySessions.get(sessionId);
+  if (!rec)
+    return { status: "error", error: "Login session expired." };
+  return { status: rec.status, authUrl: rec.authUrl, error: rec.error, account: rec.account };
+}
+async function submitAntigravityCallback(sessionId, raw) {
+  const parsed = parseAntigravityAuthInput(raw);
+  if (!parsed) {
+    throw new AccountError("Paste the code from the Antigravity page, or the antigravity.google/oauth-callback URL.");
+  }
+  const rec = agySessions.get(sessionId);
+  if (!rec)
+    throw new AccountError("Login session expired.", 404);
+  if (rec.status === "done" && rec.account)
+    return rec.account;
+  const { code, state } = parsed;
+  if (state && state !== rec.state)
+    throw new AccountError("Sign-in state did not match. Start again.");
+  try {
+    const token = await exchangeAntigravityCode(code, rec.verifier);
+    const email = await fetchAgyEmail(token.accessToken);
+    const named = rec.label?.trim() || "";
+    if (rec.accountId) {
+      await secretStore().set(rec.accountId, serializeAgySecret(token));
+      updateAccount(rec.accountId, { email });
+      rec.account = getAccount(rec.accountId);
+    } else {
+      const id = newAccountId("antigravity", named || email || "account");
+      await secretStore().set(id, serializeAgySecret(token));
+      rec.account = {
+        id,
+        provider: "antigravity",
+        label: named,
+        kind: "token",
+        email,
+        createdAt: new Date().toISOString()
+      };
+      saveAccount(rec.account);
+    }
+    rec.status = "done";
+    log("info", rec.accountId ? "account.login.done" : "account.add", {
+      account: rec.account.id,
+      provider: "antigravity",
+      kind: rec.account.kind
+    });
+    return rec.account;
+  } catch (e) {
+    rec.status = "error";
+    rec.error = e instanceof Error ? e.message : String(e);
+    logError("account.login.error", e, { provider: "antigravity", account: rec.accountId });
+    throw new AccountError(rec.error);
+  }
+}
 
 // src/collect.ts
-import { hostname } from "node:os";
+import { existsSync as existsSync9 } from "node:fs";
+import { homedir as homedir9, hostname } from "node:os";
+import { join as join10 } from "node:path";
 
 // src/adapters/cursor.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join8 } from "node:path";
 var USAGE_URL3 = "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage";
 var GROK_BOT_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService/GetSandUsageStatus";
 var PLAN_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService/GetPlanInfo";
-var KEYCHAIN_ACCOUNT = "cursor-user";
-var KEYCHAIN_SERVICE = "cursor-access-token";
+var KEYCHAIN_ACCOUNT2 = "cursor-user";
+var KEYCHAIN_SERVICE2 = "cursor-access-token";
 function tokenFromAuthJson(parsed) {
   if (!isObject(parsed))
     return null;
   return typeof parsed.accessToken === "string" && parsed.accessToken ? parsed.accessToken : null;
 }
 function tokenFromAuthFile(file) {
-  if (!existsSync5(file))
+  if (!existsSync7(file))
     return null;
   try {
-    return tokenFromAuthJson(JSON.parse(readFileSync5(file, "utf8")));
+    return tokenFromAuthJson(JSON.parse(readFileSync6(file, "utf8")));
   } catch {
     return null;
   }
 }
 function authFiles() {
-  const home = homedir4();
+  const home = homedir7();
   const out = [];
   if (process.platform === "win32") {
-    const roaming = process.env.APPDATA || join5(home, "AppData", "Roaming");
-    out.push(join5(roaming, "Cursor", "auth.json"));
+    const roaming = process.env.APPDATA || join8(home, "AppData", "Roaming");
+    out.push(join8(roaming, "Cursor", "auth.json"));
   } else if (process.platform !== "darwin") {
-    const xdg = process.env.XDG_CONFIG_HOME || join5(home, ".config");
-    out.push(join5(xdg, "cursor", "auth.json"));
+    const xdg = process.env.XDG_CONFIG_HOME || join8(home, ".config");
+    out.push(join8(xdg, "cursor", "auth.json"));
   }
-  out.push(join5(home, ".cursor", "auth.json"));
+  out.push(join8(home, ".cursor", "auth.json"));
   return out;
 }
-async function tokenFromKeychain() {
+async function tokenFromKeychain2() {
   if (process.platform !== "darwin")
     return null;
-  const res = await run("security", ["find-generic-password", "-a", KEYCHAIN_ACCOUNT, "-s", KEYCHAIN_SERVICE, "-w"], { timeoutMs: 20000 });
+  const res = await run("security", ["find-generic-password", "-a", KEYCHAIN_ACCOUNT2, "-s", KEYCHAIN_SERVICE2, "-w"], { timeoutMs: 20000 });
   if (res.code !== 0)
     return null;
   const v = res.stdout.replace(/\r?\n$/, "");
@@ -1234,7 +1829,7 @@ async function readCursorAccessToken() {
     if (fromFile)
       return fromFile;
   }
-  const fromKeychain = await tokenFromKeychain();
+  const fromKeychain = await tokenFromKeychain2();
   if (fromKeychain)
     return fromKeychain;
   if (process.env.CURSOR_AUTH_FILE)
@@ -1392,6 +1987,236 @@ async function fetchCursor(account) {
   }
 }
 
+// src/adapters/grok.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join9 } from "node:path";
+var DEFAULT_PROXY = "https://cli-chat-proxy.grok.com/v1";
+var TOKEN_URL = "https://auth.x.ai/oauth2/token";
+var FALLBACK_CLI_VERSION3 = "1.0.13";
+var TIER_NAMES = {
+  supergrok: "SuperGrok",
+  supergrok_lite: "SuperGrok Lite",
+  supergrok_plus: "SuperGrok Plus",
+  supergrok_heavy: "SuperGrok Heavy",
+  x_premium: "X Premium",
+  x_premium_plus: "X Premium+"
+};
+function authFile() {
+  if (process.env.GROK_AUTH_FILE)
+    return process.env.GROK_AUTH_FILE;
+  return join9(homedir8(), ".grok", "auth.json");
+}
+function proxyBase() {
+  const raw = process.env.GROK_CLI_CHAT_PROXY_BASE_URL?.trim();
+  if (!raw)
+    return DEFAULT_PROXY;
+  return raw.replace(/\/+$/, "");
+}
+function num(v) {
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  if (isObject(v) && typeof v.val === "number" && Number.isFinite(v.val))
+    return v.val;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function money2(n) {
+  return `$${n.toFixed(n % 1 ? 2 : 0)}`;
+}
+function sessionFromEntry(entry) {
+  const access = typeof entry.key === "string" && entry.key ? entry.key : null;
+  if (!access)
+    return null;
+  const expiry = typeof entry.expires_at === "string" ? Date.parse(entry.expires_at) : NaN;
+  return {
+    accessToken: access,
+    refreshToken: typeof entry.refresh_token === "string" && entry.refresh_token ? entry.refresh_token : null,
+    clientId: typeof entry.oidc_client_id === "string" && entry.oidc_client_id ? entry.oidc_client_id : null,
+    email: typeof entry.email === "string" && entry.email.trim() ? entry.email.trim() : null,
+    expiresAt: Number.isFinite(expiry) ? expiry : null,
+    authMode: typeof entry.auth_mode === "string" ? entry.auth_mode : null
+  };
+}
+function sessionFromAuthJson(parsed) {
+  if (!isObject(parsed))
+    return null;
+  if (typeof parsed.key === "string" && parsed.key)
+    return sessionFromEntry(parsed);
+  const entries = Object.values(parsed).filter(isObject);
+  const oidc = entries.find((e) => e.auth_mode === "oidc" && typeof e.key === "string" && e.key);
+  if (oidc)
+    return sessionFromEntry(oidc);
+  const any = entries.find((e) => typeof e.key === "string" && e.key);
+  return any ? sessionFromEntry(any) : null;
+}
+function readGrokSession() {
+  const file = authFile();
+  if (!existsSync8(file))
+    return null;
+  try {
+    return sessionFromAuthJson(JSON.parse(readFileSync7(file, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function grokUsesApiKey(session) {
+  if (session?.authMode === "oidc" && session.accessToken)
+    return false;
+  return Boolean(process.env.XAI_API_KEY?.trim()) || session?.authMode === "api_key";
+}
+function planFromGrokSettings(body) {
+  if (!isObject(body))
+    return null;
+  if (typeof body.subscription_tier_display === "string" && body.subscription_tier_display.trim()) {
+    return body.subscription_tier_display.trim();
+  }
+  const raw = typeof body.subscription_tier === "string" ? body.subscription_tier.trim() : "";
+  if (!raw)
+    return null;
+  return TIER_NAMES[raw] ?? raw.replace(/_/g, " ");
+}
+function creditsRoot(body) {
+  if (!isObject(body))
+    return null;
+  return isObject(body.config) ? body.config : body;
+}
+function normalizeGrokCredits(body) {
+  const cfg = creditsRoot(body);
+  if (!cfg)
+    return [];
+  const out = [];
+  const period = isObject(cfg.currentPeriod) ? cfg.currentPeriod : null;
+  const periodType = typeof period?.type === "string" ? period.type : "";
+  const weekly = periodType.includes("WEEKLY");
+  const resetsAt = isoOrNull(period?.end) ?? isoOrNull(cfg.billingPeriodEnd);
+  const used = clampPercent(num(cfg.creditUsagePercent));
+  if (used !== null) {
+    out.push({
+      id: "weekly",
+      label: weekly || !periodType ? "Weekly Usage" : "Usage",
+      usedPercent: used,
+      resetsAt,
+      windowMinutes: weekly || !periodType ? 10080 : null,
+      kind: weekly || !periodType ? "rolling" : "cycle"
+    });
+  }
+  const cap = num(cfg.onDemandCap);
+  const spent = num(cfg.onDemandUsed);
+  if (cap && cap > 0 && spent !== null) {
+    out.push({
+      id: "on_demand",
+      label: "On-demand",
+      usedPercent: clampPercent(spent / cap * 100),
+      resetsAt,
+      windowMinutes: weekly ? 10080 : null,
+      kind: weekly ? "rolling" : "cycle",
+      note: `${money2(spent)} of ${money2(cap)}`
+    });
+  }
+  return out;
+}
+async function clientVersion() {
+  return await binVersion("grok") ?? FALLBACK_CLI_VERSION3;
+}
+function headers3(token, version, email) {
+  const h = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/json",
+    "User-Agent": "xai-grok-cli",
+    "x-grok-client-version": version,
+    "x-grok-client-mode": "cli"
+  };
+  if (email)
+    h["x-email"] = email;
+  return h;
+}
+async function refreshAccessToken(session) {
+  if (!session.refreshToken || !session.clientId)
+    return null;
+  const res = await fetchJson(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: session.refreshToken,
+      client_id: session.clientId
+    }).toString()
+  });
+  if (res.status !== 200 || !isObject(res.body) || typeof res.body.access_token !== "string" || !res.body.access_token) {
+    return null;
+  }
+  const expiresIn = typeof res.body.expires_in === "number" ? res.body.expires_in : 3600;
+  return {
+    ...session,
+    accessToken: res.body.access_token,
+    refreshToken: typeof res.body.refresh_token === "string" && res.body.refresh_token ? res.body.refresh_token : session.refreshToken,
+    expiresAt: Date.now() + expiresIn * 1000
+  };
+}
+async function liveSession(session) {
+  if (session.expiresAt && session.expiresAt > Date.now() + 60000)
+    return session;
+  return await refreshAccessToken(session) ?? (session.expiresAt && session.expiresAt > Date.now() ? session : null);
+}
+async function fetchGrok(account) {
+  try {
+    const stored = readGrokSession();
+    if (!stored) {
+      if (grokUsesApiKey(null)) {
+        return snapshot(account, "unsupported", { message: "This CLI is using an xAI API key, which has no SuperGrok quota." });
+      }
+      return snapshot(account, "signed_out", { message: "Not signed in. Run `grok login --oauth`." });
+    }
+    if (stored.authMode && stored.authMode !== "oidc") {
+      return snapshot(account, "unsupported", { email: stored.email, message: "This CLI is using an xAI API key, which has no SuperGrok quota." });
+    }
+    let session = await liveSession(stored);
+    if (!session) {
+      return snapshot(account, "error", { email: stored.email, message: "Grok session expired. Run `grok login --oauth`." });
+    }
+    const version = await clientVersion();
+    const base = proxyBase();
+    const get = (token, path) => fetchJson(`${base}${path}`, { headers: headers3(token, version, session.email) });
+    let [credits, settings] = await Promise.all([
+      get(session.accessToken, "/billing?format=credits"),
+      get(session.accessToken, "/settings").catch(() => ({ status: 0, body: null, text: "" }))
+    ]);
+    if (credits.status === 401 || credits.status === 403) {
+      const refreshed = await refreshAccessToken(session);
+      if (refreshed) {
+        session = refreshed;
+        [credits, settings] = await Promise.all([
+          get(session.accessToken, "/billing?format=credits"),
+          get(session.accessToken, "/settings").catch(() => ({ status: 0, body: null, text: "" }))
+        ]);
+      }
+    }
+    const email = session.email ?? account.email ?? null;
+    const plan = settings.status === 200 ? planFromGrokSettings(settings.body) : null;
+    if (credits.status === 401 || credits.status === 403) {
+      return snapshot(account, "error", { email, plan, message: `Grok rejected the session (${credits.status}). Run \`grok login --oauth\`.` });
+    }
+    if (credits.status !== 200) {
+      return snapshot(account, "error", { email, plan, message: `Usage endpoint returned HTTP ${credits.status}.` });
+    }
+    const windows = normalizeGrokCredits(credits.body);
+    if (windows.length === 0) {
+      return snapshot(account, "unsupported", {
+        email,
+        plan,
+        message: "Signed in, but this account has no SuperGrok / Grok Build allowance."
+      });
+    }
+    return snapshot(account, "ok", { email, plan, windows });
+  } catch (e) {
+    return snapshot(account, "error", { message: errorMessage(e) });
+  }
+}
+
 // src/adapters/index.ts
 function fetchSnapshot(account) {
   switch (account.provider) {
@@ -1401,6 +2226,10 @@ function fetchSnapshot(account) {
       return fetchCodex(account);
     case "cursor":
       return fetchCursor(account);
+    case "antigravity":
+      return fetchAntigravity(account);
+    case "grok":
+      return fetchGrok(account);
     case "opencode":
       return fetchOpenCode(account);
   }
@@ -1411,6 +2240,8 @@ var PROVIDERS = [
   { id: "claude", name: "Claude", bin: "claude" },
   { id: "codex", name: "Codex", bin: "codex" },
   { id: "cursor", name: "Cursor", bin: "cursor-agent" },
+  { id: "antigravity", name: "Antigravity", bin: "agy" },
+  { id: "grok", name: "Grok", bin: "grok" },
   { id: "opencode", name: "OpenCode Go", bin: "opencode" }
 ];
 function providerName(id) {
@@ -1418,10 +2249,53 @@ function providerName(id) {
 }
 
 // src/collect.ts
+function providerHomeMarkers(id) {
+  const home = homedir9();
+  switch (id) {
+    case "antigravity":
+      return [
+        join10(home, ".gemini", "antigravity-cli", "antigravity-oauth-token"),
+        join10(home, ".gemini", "antigravity-cli", "settings.json"),
+        join10(home, ".gemini", "antigravity-cli", "installation_id")
+      ];
+    case "claude":
+      return [join10(home, ".claude", ".credentials.json"), join10(home, ".claude", "settings.json")];
+    case "codex":
+      return [join10(home, ".codex", "auth.json"), join10(home, ".codex", "config.toml")];
+    case "cursor":
+      return [join10(home, ".cursor", "auth.json")];
+    case "grok":
+      return [join10(home, ".grok", "auth.json")];
+    case "opencode": {
+      const xdg = process.env.XDG_DATA_HOME;
+      const base = xdg && xdg.trim() ? xdg : join10(home, ".local", "share");
+      return [join10(base, "opencode", "auth.json")];
+    }
+  }
+}
+function providerHomeExists(id) {
+  return providerHomeMarkers(id).some((file) => existsSync9(file));
+}
+function isProviderPresent(opts) {
+  if (opts.binPath)
+    return true;
+  if (opts.provider === "opencode")
+    return true;
+  return opts.homeExists;
+}
 async function detectProviders() {
+  clearBinCache();
   return Promise.all(PROVIDERS.map(async (p) => {
-    const path = await which(p.bin);
-    return { id: p.id, installed: path !== null, version: null };
+    const path = await which(p.bin, { fresh: true });
+    const homeExists = providerHomeExists(p.id);
+    const installed = isProviderPresent({ binPath: path, homeExists, provider: p.id });
+    log("info", "detect", {
+      provider: p.id,
+      installed,
+      path: path ?? undefined,
+      home: homeExists || undefined
+    });
+    return { id: p.id, installed, version: null };
   }));
 }
 function resolveAccounts(provider, installed) {
@@ -1436,9 +2310,24 @@ function resolveAccounts(provider, installed) {
 }
 async function fetchAccount(account) {
   try {
-    return await withTimeout(fetchSnapshot(account), FETCH_TIMEOUT_MS, `${account.provider} fetch`);
+    const snap = await withTimeout(fetchSnapshot(account), FETCH_TIMEOUT_MS, `${account.provider} fetch`);
+    log(snap.status === "error" ? "error" : "info", "quotas.fetch", {
+      account: snap.account.id,
+      provider: snap.account.provider,
+      status: snap.status,
+      windows: snap.windows.length,
+      message: snap.message ?? undefined
+    });
+    return snap;
   } catch (e) {
-    return snapshot(account, "error", { message: e instanceof Error ? e.message : String(e) });
+    const snap = snapshot(account, "error", { message: e instanceof Error ? e.message : String(e) });
+    log("error", "quotas.fetch", {
+      account: account.id,
+      provider: account.provider,
+      status: snap.status,
+      message: snap.message ?? undefined
+    });
+    return snap;
   }
 }
 async function collectReport(update, only) {
@@ -1448,10 +2337,19 @@ async function collectReport(update, only) {
     const accounts = resolveAccounts(p.id, pres.installed);
     const [snapshots, version] = await Promise.all([
       Promise.all(accounts.map(fetchAccount)),
-      pres.installed ? binVersion(p.bin) : Promise.resolve(null)
+      pres.installed ? binVersion(await which(p.bin) ?? p.bin) : Promise.resolve(null)
     ]);
     return { id: p.id, name: p.name, installed: pres.installed, version, accounts: snapshots };
   }));
+  const accounts = providers.flatMap((p) => p.accounts);
+  log("info", "quotas.collect", {
+    providers: providers.length,
+    accounts: accounts.length,
+    ok: accounts.filter((a) => a.status === "ok").length,
+    error: accounts.filter((a) => a.status === "error").length,
+    signed_out: accounts.filter((a) => a.status === "signed_out").length,
+    unsupported: accounts.filter((a) => a.status === "unsupported").length
+  });
   return {
     version: VERSION,
     hostname: formatHostname(hostname()),
@@ -1495,10 +2393,235 @@ class ReportCache {
   }
 }
 
+// src/instance.ts
+import { existsSync as existsSync10, readdirSync, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+function looksLikeJustUsageCommand(command) {
+  const s = command.replace(/\\/g, "/").toLowerCase();
+  return s.includes("just-usage") || /\/just-usage\/(?:src\/|dist\/)?cli\.(ts|js)\b/.test(s);
+}
+function parseRunRecord(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isObject(parsed))
+      return null;
+    const pid = typeof parsed.pid === "number" ? parsed.pid : Number(parsed.pid);
+    const port = typeof parsed.port === "number" ? parsed.port : Number(parsed.port);
+    if (!Number.isInteger(pid) || pid <= 0)
+      return null;
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+      return null;
+    return {
+      pid,
+      port,
+      host: typeof parsed.host === "string" && parsed.host ? parsed.host : "0.0.0.0",
+      startedAt: typeof parsed.startedAt === "string" ? parsed.startedAt : ""
+    };
+  } catch {
+    return null;
+  }
+}
+function writeRunRecord(opts) {
+  ensureDir(paths.runDir());
+  writeFileSync3(paths.runRecord(opts.port), JSON.stringify({
+    pid: process.pid,
+    port: opts.port,
+    host: opts.host,
+    startedAt: new Date().toISOString()
+  }), { encoding: "utf8", mode: 384 });
+}
+function readRunRecord(port) {
+  const file = paths.runRecord(port);
+  if (!existsSync10(file))
+    return null;
+  return parseRunRecord(readFileSync8(file, "utf8"));
+}
+function removeRunRecord(port) {
+  const file = paths.runRecord(port);
+  try {
+    unlinkSync(file);
+  } catch {}
+}
+function listRunPorts() {
+  const dir = paths.runDir();
+  if (!existsSync10(dir))
+    return [];
+  const ports = [];
+  for (const name of readdirSync(dir)) {
+    const m = name.match(/^(\d+)\.json$/);
+    if (!m)
+      continue;
+    const port = Number(m[1]);
+    if (Number.isInteger(port) && port > 0 && port <= 65535)
+      ports.push(port);
+  }
+  return ports.sort((a, b) => a - b);
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function processCommand(pid) {
+  if (process.platform === "win32") {
+    const res = await run("wmic", ["process", "where", `ProcessId=${pid}`, "get", "CommandLine", "/value"], { timeoutMs: 5000 });
+    const line = res.stdout.split(/\r?\n/).map((s) => s.trim()).find((s) => s.toLowerCase().startsWith("commandline="));
+    return line ? line.slice(line.indexOf("=") + 1).trim() : "";
+  }
+  const res = await run("ps", ["-p", String(pid), "-www", "-o", "command="], { timeoutMs: 5000 });
+  return res.stdout.split(/\r?\n/).map((s) => s.trim()).find((s) => s && !/^command$/i.test(s)) ?? "";
+}
+async function pidsOnPort(port) {
+  if (process.platform === "win32") {
+    const res = await run("netstat", ["-ano"], { timeoutMs: 8000 });
+    const re = new RegExp(`[:\\[]${port}\\]?(?:\\s+\\S+){1,2}\\s+LISTENING\\s+(\\d+)`, "gi");
+    const pids = new Set;
+    for (const m of res.stdout.matchAll(re)) {
+      const pid = Number(m[1]);
+      if (Number.isInteger(pid) && pid > 0)
+        pids.add(pid);
+    }
+    return [...pids];
+  }
+  const res = await run("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], { timeoutMs: 8000 });
+  const pids = new Set;
+  for (const line of res.stdout.split(/\r?\n/)) {
+    const pid = Number(line.trim());
+    if (Number.isInteger(pid) && pid > 0)
+      pids.add(pid);
+  }
+  return [...pids];
+}
+function parseHealth(body) {
+  if (!isObject(body) || body.ok !== true)
+    return null;
+  const pid = typeof body.pid === "number" && Number.isInteger(body.pid) && body.pid > 0 ? body.pid : null;
+  return {
+    ok: true,
+    version: typeof body.version === "string" ? body.version : null,
+    name: typeof body.name === "string" ? body.name : null,
+    pid
+  };
+}
+function isJustUsageHealth(info) {
+  if (!info?.ok)
+    return false;
+  if (info.name && info.name !== PACKAGE_NAME)
+    return false;
+  return info.name === PACKAGE_NAME || Boolean(info.version);
+}
+async function fetchHealth(port) {
+  try {
+    const res = await fetchJson(`http://127.0.0.1:${port}/api/health`, { timeoutMs: 2000 });
+    if (res.status !== 200)
+      return null;
+    return parseHealth(res.body);
+  } catch {
+    return null;
+  }
+}
+async function oursOnPort(port) {
+  const record = readRunRecord(port);
+  const listeners = await pidsOnPort(port);
+  const health = await fetchHealth(port);
+  const ours = new Set;
+  const known = new Set(listeners);
+  if (record && processAlive(record.pid))
+    known.add(record.pid);
+  if (health?.pid && processAlive(health.pid))
+    known.add(health.pid);
+  for (const pid of known) {
+    if (pid === process.pid)
+      continue;
+    const command = await processCommand(pid);
+    const listening = listeners.includes(pid);
+    if (looksLikeJustUsageCommand(command) || isJustUsageHealth(health) && (listening || pid === record?.pid || pid === health?.pid)) {
+      ours.add(pid);
+    }
+  }
+  return { pids: [...ours], health, listening: listeners.length > 0 };
+}
+async function terminate(pids) {
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {}
+  }
+  const deadline = Date.now() + 2500;
+  while (Date.now() < deadline && pids.some(processAlive)) {
+    await new Promise((r) => setTimeout(r, 80));
+  }
+  for (const pid of pids) {
+    if (!processAlive(pid))
+      continue;
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+  }
+}
+async function stopPort(port) {
+  const found = await oursOnPort(port);
+  if (found.pids.length === 0) {
+    if (found.listening && !isJustUsageHealth(found.health)) {
+      log("warn", "stop.busy", { port });
+      return { status: "busy", port };
+    }
+    removeRunRecord(port);
+    log("info", "stop.idle", { port });
+    return { status: "idle", port };
+  }
+  await terminate(found.pids);
+  removeRunRecord(port);
+  log("info", "stop.ok", { port, pids: found.pids });
+  return { status: "stopped", port, pids: found.pids };
+}
+async function stopServers(opts) {
+  const ports = opts.all ? [...new Set([DEFAULT_PORT, ...listRunPorts(), ...opts.port ? [opts.port] : []])] : [opts.port ?? DEFAULT_PORT];
+  const out = [];
+  for (const port of ports)
+    out.push(await stopPort(port));
+  return out;
+}
+function formatStopResults(results) {
+  const stopped = results.filter((r) => r.status === "stopped");
+  const busy = results.filter((r) => r.status === "busy");
+  const lines = [];
+  for (const r of stopped) {
+    lines.push(`Stopped ${PACKAGE_NAME} on port ${r.port} (pid ${r.pids.join(", ")}).`);
+  }
+  for (const r of busy) {
+    lines.push(`Port ${r.port} is in use, but it is not a ${PACKAGE_NAME} server.`);
+  }
+  if (stopped.length === 0 && busy.length === 0) {
+    if (results.length === 1)
+      lines.push(`No ${PACKAGE_NAME} server is running on port ${results[0].port}.`);
+    else
+      lines.push(`No ${PACKAGE_NAME} server is running.`);
+  }
+  const code = busy.length ? 1 : stopped.length ? 0 : 1;
+  return { text: lines.join(`
+`), code };
+}
+
 // src/server.ts
 import { createServer } from "node:http";
 import { hostname as hostname2, networkInterfaces } from "node:os";
 
+// src/ui/favicon.svg
+var favicon_default = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" rx="2.5" fill="#000"/>
+  <defs>
+    <mask id="card">
+      <rect x="6" y="6" width="20" height="20" rx="4.5" fill="#fff"/>
+      <rect x="20.5" y="20.5" width="5.5" height="5.5" fill="#000"/>
+    </mask>
+  </defs>
+  <rect width="32" height="32" fill="#fff" mask="url(#card)"/>
+</svg>
+`;
+
 // src/ui/index.html
 var ui_default = `<!doctype html>
 <html lang="en">
@@ -1507,7 +2630,7 @@ var ui_default = `<!doctype html>
 <meta name="viewport" content="width=device-width,initial-scale=1">
 <meta name="color-scheme" content="dark">
 <title>just-usage</title>
-<link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='7' fill='%23000'/%3E%3Crect x='7' y='14' width='18' height='4' rx='2' fill='%232a2a2a'/%3E%3Crect x='7' y='14' width='11' height='4' rx='2' fill='%23fff'/%3E%3C/svg%3E">
+<link rel="icon" type="image/svg+xml" href="/favicon.svg">
 <style>
   :root {
     --bg: #000;
@@ -1613,24 +2736,25 @@ var ui_default = `<!doctype html>
   .credits-avail:hover, .credits-avail:focus-visible { color: var(--fg); }
   .credits-tip {
     display: none; position: absolute; right: 0; bottom: calc(100% + 8px);
-    min-width: 240px; padding: 8px 10px;
+    min-width: 0; padding: 8px 10px;
     background: var(--surface); border: 1px solid var(--line-2); border-radius: 8px;
     color: var(--muted); font-size: 11px; line-height: 1.45; white-space: nowrap; z-index: 5;
   }
   .credits-avail:hover .credits-tip, .credits-avail:focus-visible .credits-tip { display: block; }
-  .credits-tip-row { display: flex; align-items: baseline; gap: 12px; }
+  .credits-tip-row { display: flex; align-items: baseline; gap: 10px; width: max-content; }
   .credits-tip-row + .credits-tip-row { margin-top: 6px; }
   .credits-tip-n { color: var(--fg); font-variant-numeric: tabular-nums; min-width: 1em; }
-  .credits-tip-date { color: var(--fg); flex: 1; }
-  .credits-tip-left { color: var(--dim); font-variant-numeric: tabular-nums; margin-left: auto; }
+  .credits-tip-date { color: var(--fg); }
+  .credits-tip-left { color: var(--dim); font-variant-numeric: tabular-nums; }
 
   #dash[hidden], #settings[hidden] { display: none; }
   .settings { display: flex; flex-direction: column; gap: 22px; }
   .opts-label { font-size: 11px; color: var(--dim); letter-spacing: .04em; text-transform: uppercase; margin-bottom: 8px; }
-  .opts-row { display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 6px 0; user-select: none; }
-  .opts-row.dragging {
-    background: var(--surface); border: 1px solid var(--line-2); border-radius: 8px; padding: 6px 8px;
-  }
+  #opts-providers { position: relative; }
+  .opts-row { display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 6px 0; user-select: none; transition: opacity .22s ease; }
+  .opts-row.dragging { opacity: .62; cursor: grabbing; }
+  .opts-row.dragging .grip { cursor: grabbing; }
+  .opts-email { margin-top: 10px; padding-top: 16px; border-top: 1px solid var(--line); }
   .opts-prov { display: flex; align-items: center; gap: 8px; min-width: 0; }
   .opts-row img.logo { width: 14px; height: 14px; }
   .grip {
@@ -1662,11 +2786,11 @@ var ui_default = `<!doctype html>
   .seg input { appearance: none; position: absolute; }
   .seg label:has(input:checked) { background: #121212; color: var(--fg); }
   .opts-actions { display: flex; justify-content: flex-end; align-items: center; gap: 12px; padding-top: 2px; }
-  .opts-actions:has(#opts-signed-in:not([hidden])) { justify-content: space-between; }
   .opts-link { background: none; border: none; color: var(--muted); font: inherit; font-size: 12px; cursor: pointer; padding: 0; }
   .opts-link:hover { color: var(--fg); }
   .opts-link[hidden] { display: none; }
   .acct-group { padding-bottom: 12px; }
+  .acct-group:last-child { padding-bottom: 0; }
   .acct-group + .acct-group { border-top: 1px solid var(--line); padding-top: 12px; }
   .acct-head { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; font-size: 13px; }
   .acct-head img.logo { width: 14px; height: 14px; }
@@ -1683,6 +2807,7 @@ var ui_default = `<!doctype html>
     border: 1px solid var(--line); border-radius: 12px;
     padding: 0;
   }
+  dialog.dlg form { margin: 0; }
   dialog.dlg::backdrop { background: rgba(0, 0, 0, .9); }
   .dlg-head {
     display: flex; justify-content: space-between; align-items: center;
@@ -1751,19 +2876,18 @@ var ui_default = `<!doctype html>
         <label><input type="radio" name="meter" value="used"> Used</label>
       </div>
     </div>
-    <label class="opts-row" for="opts-email">
-      <span>Show email on accounts</span>
-      <input class="chk" id="opts-email" type="checkbox">
-    </label>
     <div>
       <div class="opts-inline tight">
         <div class="opts-label">Accounts</div>
         <button class="refresh" id="acct-add" type="button">Add account</button>
       </div>
       <div id="opts-accounts"></div>
+      <label class="opts-row opts-email" for="opts-email">
+        <span>Show email on accounts</span>
+        <input class="chk" id="opts-email" type="checkbox">
+      </label>
     </div>
     <div class="opts-actions">
-      <button class="opts-link" id="opts-signed-in" type="button">Signed-in only</button>
       <button class="refresh" id="refresh" type="button">Refresh data</button>
     </div>
   </div>
@@ -1774,11 +2898,13 @@ var ui_default = `<!doctype html>
 </div>
 
 <dialog class="dlg" id="add-acct">
-  <div class="dlg-head">
-    <strong id="add-acct-title">Add account</strong>
-    <button class="opts-link" id="add-acct-close" type="button">Close</button>
-  </div>
-  <div class="dlg-body" id="add-acct-body"></div>
+  <form autocomplete="off" onsubmit="return false">
+    <div class="dlg-head">
+      <strong id="add-acct-title">Add account</strong>
+      <button class="opts-link" id="add-acct-close" type="button">Close</button>
+    </div>
+    <div class="dlg-body" id="add-acct-body"></div>
+  </form>
 </dialog>
 
 <script>
@@ -1787,13 +2913,17 @@ var ui_default = `<!doctype html>
     ["claude", "Claude"],
     ["codex", "Codex"],
     ["cursor", "Cursor"],
+    ["antigravity", "Antigravity"],
+    ["grok", "Grok"],
     ["opencode", "OpenCode Go"],
   ];
   const SIGNIN_HINT = {
     claude: "Run <code>claude</code>, then <code>/login</code>.",
     codex: "Run <code>codex login</code>.",
     cursor: "Run <code>cursor-agent login</code>.",
+    grok: "Run <code>grok login --oauth</code>.",
     opencode: "Run <code>opencode auth login</code> or <code>just-usage add opencode</code>.",
+    antigravity: "Run <code>agy</code> and complete Google sign-in.",
   };
   const $ = (id) => document.getElementById(id);
   let report = null;
@@ -1802,8 +2932,8 @@ var ui_default = `<!doctype html>
     if (cached && Array.isArray(cached.providers)) report = cached;
   } catch {}
   const params = new URLSearchParams(location.search);
-  const wanted = params.get("tab");
-  let active = PROVIDERS.some(([id]) => id === wanted) ? wanted : localStorage.getItem("ju.tab") || "claude";
+  let active = localStorage.getItem("ju.tab") || "claude";
+  if (!PROVIDERS.some(([id]) => id === active)) active = "claude";
   let settingsOpen = params.get("view") === "settings";
   let loading = false;
   let busy = false;
@@ -1823,22 +2953,37 @@ var ui_default = `<!doctype html>
   } catch {}
   let dragging = false;
   let showLeft = localStorage.getItem("ju.showLeft") !== "0";
-  let order = PROVIDERS.map(([id]) => id);
+  const defaultOrder = PROVIDERS.map(([id]) => id);
+  let order = defaultOrder.slice();
   try {
     const raw = JSON.parse(localStorage.getItem("ju.order"));
     if (Array.isArray(raw)) {
-      const known = new Set(order);
+      const known = new Set(defaultOrder);
       const next = raw.filter((id) => known.has(id));
-      for (const id of order) if (!next.includes(id)) next.push(id);
+      for (const id of defaultOrder) {
+        if (next.includes(id)) continue;
+        const after = defaultOrder.slice(defaultOrder.indexOf(id) + 1).find((x) => next.includes(x));
+        next.splice(after ? next.indexOf(after) : next.length, 0, id);
+      }
+      if (!localStorage.getItem("ju.orderGen") && next[next.length - 1] === "grok") {
+        const i = next.indexOf("opencode");
+        if (i !== -1) {
+          next.pop();
+          next.splice(i, 0, "grok");
+        }
+      }
       order = next;
     }
   } catch {}
+  localStorage.setItem("ju.orderGen", "2");
+  localStorage.setItem("ju.order", JSON.stringify(order));
 
   const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
   const rich = (s) => esc(s).replace(/\`([^\`]+)\`/g, "<code>$1</code>");
   const sev = (p) => (p == null ? null : p >= 85 ? "crit" : p >= 60 ? "warn" : "ok");
   const rank = { ok: 1, warn: 2, crit: 3 };
-  const logo = (id) => \`<img class="logo" src="/logos/\${id}.svg?v=2" alt="" width="14" height="14">\`;
+  const logo = (id) => \`<img class="logo" src="/logos/\${id}.svg?v=5" alt="" width="14" height="14">\`;
+  const noSuggest = \`autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"\`;
   const formatPlan = (p) => String(p).replace(/\\S+/g, (w) => w.charAt(0).toUpperCase() + w.slice(1));
   const GENERIC_LABELS = new Set(["", "default", "token", "go", "pending", "profile", "account", "codex"]);
   function isGenericLabel(label, email) {
@@ -1893,14 +3038,24 @@ var ui_default = `<!doctype html>
     return d === 1 ? "1 day ago" : \`\${d} days ago\`;
   }
 
-  function isSignedIn(p) {
-    return !!p?.accounts.some((a) => a.status !== "signed_out");
+  function isDefaultVisible(p) {
+    return !!p?.accounts.some((a) => a.status === "ok" || a.status === "error");
+  }
+
+  /** true/false = user chose; missing = auto-show when the CLI is signed in. */
+  function explicitEnabled(id) {
+    if (!enabled || typeof enabled !== "object" || !Object.hasOwn(enabled, id)) return null;
+    if (enabled[id] === true) return true;
+    if (enabled[id] === false) return false;
+    return null;
   }
 
   function visibleIds() {
-    if (enabled) return order.filter((id) => enabled[id]);
-    if (!report) return [];
-    return order.filter((id) => isSignedIn(report.providers.find((x) => x.id === id)));
+    return order.filter((id) => {
+      const choice = explicitEnabled(id);
+      if (choice !== null) return choice;
+      return isDefaultVisible(report?.providers.find((x) => x.id === id));
+    });
   }
 
   function ensureActive() {
@@ -1915,10 +3070,8 @@ var ui_default = `<!doctype html>
     if (next) localStorage.setItem("ju.providers", JSON.stringify(next));
     else localStorage.removeItem("ju.providers");
     ensureActive();
-    if (settingsOpen) {
-      renderTabs();
-      $("opts-signed-in").hidden = !enabled;
-    } else render();
+    if (settingsOpen) renderTabs();
+    else render();
   }
 
   function persistOrder(next) {
@@ -1929,16 +3082,17 @@ var ui_default = `<!doctype html>
     else render();
   }
 
+  function syncUrl() {
+    const want = settingsOpen ? \`\${location.pathname}?view=settings\` : location.pathname;
+    if (location.pathname + location.search !== want) history.replaceState(null, "", want);
+  }
+
   function setView(open) {
     settingsOpen = open;
     $("dash").hidden = open;
     $("settings").hidden = !open;
-    const btn = $("opts-btn");
     $("opts-label").textContent = open ? "Back" : "Options";
-    const q = new URLSearchParams();
-    if (open) q.set("view", "settings");
-    else q.set("tab", active);
-    history.replaceState(null, "", q.toString() ? \`?\${q}\` : location.pathname);
+    syncUrl();
     if (open) {
       renderSettings();
       renderChrome();
@@ -1989,9 +3143,16 @@ var ui_default = `<!doctype html>
     return html;
   }
 
+  function planBadge(provider, plan) {
+    if (!plan) return "";
+    const name = PROVIDERS.find(([id]) => id === provider)?.[1] || provider;
+    if (plan.toLowerCase() === name.toLowerCase() || plan.toLowerCase() === provider) return "";
+    return \`<span class="plan">\${esc(formatPlan(plan))}</span>\`;
+  }
+
   function renderCard(a, provider, index) {
     const title = accountTitle(a, index);
-    const plan = a.account.plan ? \`<span class="plan">\${esc(formatPlan(a.account.plan))}</span>\` : "";
+    const plan = planBadge(provider, a.account.plan);
     let badge = "";
     if (a.status === "ok") {
       let worst = null;
@@ -2071,7 +3232,7 @@ var ui_default = `<!doctype html>
     }).join("");
     for (const input of $("opts-providers").querySelectorAll("input")) {
       input.onchange = () => {
-        const next = Object.fromEntries(order.map((id) => [id, vis.has(id)]));
+        const next = { ...(enabled || {}) };
         next[input.dataset.id] = input.checked;
         persistEnabled(next);
       };
@@ -2084,22 +3245,48 @@ var ui_default = `<!doctype html>
         const row = grip.closest(".opts-row");
         dragging = true;
         row.classList.add("dragging");
+        document.body.style.cursor = "grabbing";
+        try { grip.setPointerCapture(e.pointerId); } catch {}
+        const ease = "transform .36s cubic-bezier(.4, 0, .2, 1)";
         const place = (clientY) => {
-          const others = [...list.querySelectorAll(".opts-row")].filter((r) => r !== row);
-          const before = others.find((r) => {
-            const b = r.getBoundingClientRect();
-            return clientY < b.top + b.height / 2;
-          });
+          const rows = [...list.querySelectorAll(".opts-row")];
+          const others = rows.filter((r) => r !== row);
+          const y = clientY - list.getBoundingClientRect().top + list.scrollTop;
+          const before = others.find((r) => y < r.offsetTop + r.offsetHeight / 2 - 6);
+          if ((before && row.nextElementSibling === before) || (!before && list.lastElementChild === row)) return;
+          const first = new Map(rows.map((r) => {
+            r.style.transition = "none";
+            return [r, r.getBoundingClientRect()];
+          }));
           if (before) list.insertBefore(row, before);
           else list.appendChild(row);
+          for (const r of rows) {
+            r.style.transform = "";
+            const from = first.get(r);
+            const dy = from.top - r.getBoundingClientRect().top;
+            r.style.transform = dy ? \`translateY(\${dy}px)\` : "";
+          }
+          list.getBoundingClientRect();
+          for (const r of rows) {
+            if (!r.style.transform) continue;
+            r.style.transition = ease;
+            r.style.transform = "";
+          }
         };
         const move = (ev) => place(ev.clientY);
         const stop = () => {
           document.removeEventListener("pointermove", move);
           document.removeEventListener("pointerup", stop);
           document.removeEventListener("pointercancel", stop);
+          document.body.style.cursor = "";
           dragging = false;
           row.classList.remove("dragging");
+          window.setTimeout(() => {
+            for (const r of list.querySelectorAll(".opts-row")) {
+              r.style.transition = "";
+              r.style.transform = "";
+            }
+          }, 380);
           const next = [...list.querySelectorAll(".opts-row")].map((r) => r.dataset.id);
           if (next.join() !== order.join()) persistOrder(next);
         };
@@ -2108,7 +3295,6 @@ var ui_default = `<!doctype html>
         document.addEventListener("pointercancel", stop);
       };
     }
-    $("opts-signed-in").hidden = !enabled;
     for (const input of $("opts-meter").querySelectorAll("input")) {
       input.checked = (input.value === "left") === showLeft;
     }
@@ -2139,7 +3325,7 @@ var ui_default = `<!doctype html>
         const extra = a.account.kind === "default" ? "from CLI" : a.account.kind;
         if (renaming === a.account.id) {
           return \`<div class="acct-row">
-            <span class="acct-rename"><input class="field acct-rename-input" data-id="\${esc(a.account.id)}" value="\${esc(title)}">
+            <span class="acct-rename"><input class="field acct-rename-input" data-id="\${esc(a.account.id)}" value="\${esc(title)}" \${noSuggest}>
               <button class="refresh acct-rename-save" type="button" data-id="\${esc(a.account.id)}">Save</button></span>
             <button class="opts-link acct-rename-cancel" type="button">Cancel</button>
           </div>\`;
@@ -2225,25 +3411,30 @@ var ui_default = `<!doctype html>
       body = \`<div class="pick">
           <button class="pick-btn" type="button" data-id="claude">\${logo("claude")} Claude</button>
           <button class="pick-btn" type="button" data-id="codex">\${logo("codex")} Codex</button>
+          <button class="pick-btn" type="button" data-id="antigravity">\${logo("antigravity")} Antigravity</button>
           <button class="pick-btn" type="button" data-id="opencode">\${logo("opencode")} OpenCode Go</button>
         </div>
-        <div class="acct-note">One Cursor account for now — whatever <code>cursor-agent</code> is signed in as.</div>\`;
+        <div class="acct-note">One Cursor account for now — whatever <code>cursor-agent</code> is signed in as.</div>
+        <div class="acct-note">One Grok account for now — whatever <code>grok</code> is signed in as.</div>\`;
     } else if (wizard.step === "label") {
       body = \`<div class="acct-note">Optional. Leave blank to show as Account 2, Account 3, …</div>
-        <input class="field" id="wiz-label" placeholder="Label (optional)" value="\${esc(wizard.label)}">
+        <input class="field" id="wiz-label" placeholder="Label (optional)" value="\${esc(wizard.label)}" \${noSuggest}>
         <div class="acct-actions"><button class="opts-link" id="wiz-back" type="button">Back</button>
           <button class="refresh" id="wiz-next" type="button">Continue</button></div>\`;
-    } else if (wizard.provider === "codex") {
-      body = \`<div class="acct-note">Sign in with ChatGPT. If you are not on this machine, paste the localhost callback after the redirect.</div>
+    } else if (wizard.provider === "codex" || wizard.provider === "antigravity") {
+      const oauth = wizard.provider === "codex"
+        ? { note: "Sign in with ChatGPT. If you are not on this machine, paste the localhost callback after the redirect.", action: "Sign in with ChatGPT", ph: "http://localhost:… callback", start: "wiz-codex", submit: "Submit callback" }
+        : { note: "Sign in with Google. Copy the code from the Antigravity page (or paste the callback URL). This extra login does not replace <code>agy</code>'s default account.", action: "Sign in with Google", ph: "4/0A… code from the page", start: "wiz-agy", submit: "Submit code" };
+      body = \`<div class="acct-note">\${oauth.note}</div>
         \${wizard.authUrl ? \`<div class="acct-url">Open <a href="\${esc(wizard.authUrl)}" target="_blank" rel="noreferrer">this sign-in URL</a></div>
-          <input class="field" id="wiz-callback" placeholder="http://localhost:… callback" value="\${esc(wizard.callback)}">
-          <button class="refresh" id="wiz-callback-go" type="button">Submit callback</button>\` 
-          : \`<button class="refresh" id="wiz-codex" type="button">Sign in with ChatGPT</button>\`}
+          <input class="field" id="wiz-callback" placeholder="\${esc(oauth.ph)}" value="\${esc(wizard.callback)}" \${noSuggest}>
+          <button class="refresh" id="wiz-callback-go" type="button">\${oauth.submit || "Submit callback"}</button>\` 
+          : \`<button class="refresh" id="\${oauth.start}" type="button">\${oauth.action}</button>\`}
         <button class="opts-link" id="wiz-back" type="button">Back</button>\`;
     } else {
       const ph = wizard.provider === "claude" ? "Setup token from <code>claude setup-token</code>" : "OpenCode Go API key";
       body = \`<div class="acct-note">\${ph}.</div>
-        <input class="field" id="wiz-secret" type="password" placeholder="\${wizard.provider === "claude" ? "Setup token" : "API key"}" value="\${esc(wizard.secret)}" autocomplete="off">
+        <input class="field" id="wiz-secret" type="password" placeholder="\${wizard.provider === "claude" ? "Setup token" : "API key"}" value="\${esc(wizard.secret)}" \${noSuggest}>
         <div class="acct-actions"><button class="opts-link" id="wiz-back" type="button">Back</button>
           <button class="refresh" id="wiz-save" type="button">Add</button></div>\`;
     }
@@ -2271,8 +3462,10 @@ var ui_default = `<!doctype html>
     if (save) save.onclick = addToken;
     const start = $("wiz-codex");
     if (start) start.onclick = startCodex;
+    const startAgy = $("wiz-agy");
+    if (startAgy) startAgy.onclick = startAntigravity;
     const submit = $("wiz-callback-go");
-    if (submit) submit.onclick = submitCodexCallback;
+    if (submit) submit.onclick = wizard.provider === "antigravity" ? submitAntigravityCallback : submitCodexCallback;
   }
 
   async function addToken() {
@@ -2329,6 +3522,56 @@ var ui_default = `<!doctype html>
     }
   }
 
+  async function startAntigravity() {
+    if (busy) return;
+    const popup = window.open("about:blank", "_blank");
+    busy = true;
+    wizardMsg("Starting sign-in…", false);
+    renderWizard();
+    try {
+      const body = await api("/api/accounts/antigravity/start", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ label: wizard.label }),
+      });
+      wizard.sessionId = body.sessionId;
+      wizard.authUrl = body.authUrl;
+      if (body.authUrl) {
+        if (popup) popup.location.replace(body.authUrl);
+        else window.location.assign(body.authUrl);
+      } else {
+        popup?.close();
+      }
+      wizardMsg("Copy the code from the Antigravity page and paste it here.", false);
+    } catch (e) {
+      popup?.close();
+      wizardMsg(e.message, true);
+    } finally {
+      busy = false;
+      renderWizard();
+    }
+  }
+
+  async function submitAntigravityCallback() {
+    if (!wizard.sessionId) return;
+    if (busy) return;
+    busy = true;
+    try {
+      await api("/api/accounts/antigravity/callback", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sessionId: wizard.sessionId, url: wizard.callback }),
+      });
+      closeWizard();
+      await load(true);
+    } catch (e) {
+      wizardMsg(e.message, true);
+      renderWizard();
+    } finally {
+      busy = false;
+    }
+  }
+
   async function submitCodexCallback() {
     if (!wizard.sessionId) return;
     try {
@@ -2422,7 +3665,10 @@ var ui_default = `<!doctype html>
         for (const a of p.accounts || []) {
           const old = prev?.accounts.find((x) => x.account.id === a.account.id);
           if (!a.account.email && old?.account.email) a.account.email = old.account.email;
-          if (!a.account.plan && old?.account.plan) a.account.plan = old.account.plan;
+          if (!a.account.plan && old?.account.plan) {
+            const name = PROVIDERS.find(([id]) => id === p.id)?.[1] || p.id;
+            if (old.account.plan.toLowerCase() !== name.toLowerCase()) a.account.plan = old.account.plan;
+          }
         }
       }
     }
@@ -2465,7 +3711,6 @@ var ui_default = `<!doctype html>
 
   $("opts-btn").onclick = () => setView(!settingsOpen);
   $("refresh").onclick = () => load(true, true);
-  $("opts-signed-in").onclick = () => persistEnabled(null);
   $("opts-email").onchange = () => {
     showEmail = $("opts-email").checked;
     localStorage.setItem("ju.showEmail", showEmail ? "1" : "0");
@@ -2508,6 +3753,7 @@ var ui_default = `<!doctype html>
   document.addEventListener("visibilitychange", () => {
     if (document.visibilityState === "visible") maybeAutoRefresh();
   });
+  syncUrl();
   if (report) render();
   load(false);
 })();
@@ -2516,6 +3762,13 @@ var ui_default = `<!doctype html>
 </html>
 `;
 
+// src/ui/logos/antigravity.svg
+var antigravity_default = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#ececec" role="img">
+  <title>Antigravity</title>
+  <path d="M21.218 22.023c1.273.954 3.182.318 1.432-1.432C17.4 15.5 18.513 1.5 11.99 1.5 5.468 1.5 6.581 15.5 1.331 20.591c-1.91 1.91.16 2.386 1.432 1.432C7.695 18.682 7.377 12.795 11.99 12.795c4.614 0 4.296 5.887 9.228 9.228Z"/>
+</svg>
+`;
+
 // src/ui/logos/claude.svg
 var claude_default = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#ececec" role="img">
   <title>Claude</title>
@@ -2537,6 +3790,14 @@ var cursor_default = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24
 </svg>
 `;
 
+// src/ui/logos/grok.svg
+var grok_default = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" fill="#ececec" role="img">
+  <title>Grok</title>
+  <path d="M210.484 312.759 343.465 210.383c6.519-5.019 15.837-3.061 18.943 4.734 16.35 41.114 9.046 90.523-23.483 124.446-32.528 33.924-77.788 41.364-119.157 24.42l-45.191 21.82c64.817 46.205 143.527 34.778 192.712-16.552 39.014-40.687 51.097-96.147 39.799-146.16l.102.107c-16.383-73.472 4.028-102.839 45.84-162.891.99-1.424 1.98-2.848 2.97-4.307L400.978 113.382v-.178L210.45 312.794"/>
+  <path d="M183.042 337.641c-46.523-46.347-38.502-118.074 1.194-159.438 29.354-30.613 77.447-43.107 119.43-24.739l45.089-21.714c-8.123-6.123-18.534-12.708-30.48-17.336-53.998-23.173-118.645-11.64-162.54 34.102-42.222 44.033-55.499 111.738-32.699 169.511 17.033 43.179-10.888 73.721-39.013 104.548C74.056 433.503 64.055 444.431 56 456l127.007-118.323"/>
+</svg>
+`;
+
 // src/ui/logos/opencode.svg
 var opencode_default = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#ececec" fill-rule="evenodd" role="img">
   <title>OpenCode</title>
@@ -2549,7 +3810,9 @@ var LOGOS = {
   claude: claude_default,
   codex: codex_default,
   cursor: cursor_default,
-  opencode: opencode_default
+  opencode: opencode_default,
+  antigravity: antigravity_default,
+  grok: grok_default
 };
 function json(res, status, body) {
   const text = JSON.stringify(body);
@@ -2598,11 +3861,30 @@ async function startServer(opts) {
     cache.invalidate();
     return out;
   };
+  const quietPath = (path) => path === "/favicon.svg" || path === "/favicon.ico" || path.startsWith("/logos/");
   const handler = async (req, res) => {
     const url = new URL(req.url ?? "/", "http://localhost");
+    const started = Date.now();
     res.setHeader("X-Content-Type-Options", "nosniff");
+    if (!quietPath(url.pathname)) {
+      res.on("finish", () => {
+        const status = res.statusCode;
+        log(status >= 500 ? "error" : status >= 400 ? "warn" : "info", "http", {
+          method: req.method ?? "GET",
+          path: url.pathname,
+          refresh: url.searchParams.get("refresh") === "1" || undefined,
+          status,
+          ms: Date.now() - started
+        });
+      });
+    }
     try {
       const method = req.method ?? "GET";
+      if ((url.pathname === "/favicon.svg" || url.pathname === "/favicon.ico") && (method === "GET" || method === "HEAD")) {
+        res.writeHead(200, { "Content-Type": "image/svg+xml; charset=utf-8", "Cache-Control": "public, max-age=86400" });
+        res.end(favicon_default);
+        return;
+      }
       if (url.pathname === "/" && (method === "GET" || method === "HEAD")) {
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
         res.end(ui_default);
@@ -2625,7 +3907,7 @@ async function startServer(opts) {
         return;
       }
       if (url.pathname === "/api/health" && (method === "GET" || method === "HEAD")) {
-        json(res, 200, { ok: true, version: VERSION });
+        json(res, 200, { ok: true, name: PACKAGE_NAME, version: VERSION, pid: process.pid });
         return;
       }
       if (url.pathname === "/api/accounts" && method === "POST") {
@@ -2641,7 +3923,23 @@ async function startServer(opts) {
           json(res, 200, await mutated(() => addOpenCodeKey(secret, label)));
           return;
         }
-        json(res, 400, { error: "Add Claude with a setup-token, OpenCode with an API key, or start a Codex sign-in." });
+        json(res, 400, { error: "Add Claude with a setup-token, OpenCode with an API key, or start a Codex / Antigravity sign-in." });
+        return;
+      }
+      if (url.pathname === "/api/accounts/antigravity/start" && method === "POST") {
+        const body = await readJson(req);
+        const accountId = str(body.accountId);
+        json(res, 200, accountId ? await beginAntigravityRelogin(accountId) : await beginAntigravityAdd(str(body.label) || undefined));
+        return;
+      }
+      if (url.pathname === "/api/accounts/antigravity/callback" && method === "POST") {
+        const body = await readJson(req);
+        json(res, 200, { ok: true, account: await mutated(() => submitAntigravityCallback(str(body.sessionId), str(body.url))) });
+        return;
+      }
+      const agySession = url.pathname.match(/^\/api\/accounts\/antigravity\/session\/([^/]+)$/);
+      if (agySession && (method === "GET" || method === "HEAD")) {
+        json(res, 200, antigravitySessionStatus(decodeURIComponent(agySession[1])));
         return;
       }
       if (url.pathname === "/api/accounts/codex/start" && method === "POST") {
@@ -2681,6 +3979,7 @@ async function startServer(opts) {
       json(res, 404, { error: "not found" });
     } catch (e) {
       if (e instanceof AccountError) {
+        log("warn", "http.error", { path: url.pathname, status: e.status, message: e.message });
         json(res, e.status, { error: e.message });
         return;
       }
@@ -2688,6 +3987,7 @@ async function startServer(opts) {
         json(res, 400, { error: "Invalid JSON." });
         return;
       }
+      logError("http.error", e, { path: url.pathname, status: 500 });
       json(res, 500, { error: e instanceof Error ? e.message : String(e) });
     }
   };
@@ -2695,7 +3995,17 @@ async function startServer(opts) {
   return new Promise((resolve, reject) => {
     server.once("error", reject);
     server.listen(opts.port, opts.host, () => {
-      resolve({ close: () => server.close(), urls: reachableUrls(opts.host, opts.port, tailscaleIp) });
+      writeRunRecord({ port: opts.port, host: opts.host });
+      const urls = reachableUrls(opts.host, opts.port, tailscaleIp);
+      log("info", "serve.start", { host: opts.host, port: opts.port, urls: urls.map((u) => u.url) });
+      resolve({
+        close: () => {
+          log("info", "serve.stop", { port: opts.port });
+          removeRunRecord(opts.port);
+          server.close();
+        },
+        urls
+      });
     });
   });
 }
@@ -2703,7 +4013,6 @@ function isTailscale(ip) {
   const [a, b] = ip.split(".").map(Number);
   return a === 100 && b !== undefined && b >= 64 && b <= 127;
 }
-var TAILSCALE_NOTE = "Tailscale only. Not same-Wi-Fi. Other devices need Tailscale too.";
 async function detectTailscaleIp() {
   const res = await run("tailscale", ["status", "--json"], { timeoutMs: 4000 });
   if (res.code !== 0)
@@ -2744,7 +4053,7 @@ function reachableUrls(host, port, tailscaleIp = null) {
     }
   }
   if (tailscaleIp) {
-    urls.push({ kind: "tailscale", url: `http://${tailscaleIp}:${port}`, note: TAILSCALE_NOTE });
+    urls.push({ kind: "tailscale", url: `http://${tailscaleIp}:${port}` });
   }
   return urls;
 }
@@ -2809,15 +4118,15 @@ function renderReport(report, now = Date.now()) {
 }
 
 // src/update.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
 var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
 function readCache() {
   const file = paths.updateCache();
-  if (!existsSync6(file))
+  if (!existsSync11(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync6(file, "utf8"));
+    const parsed = JSON.parse(readFileSync9(file, "utf8"));
     if (typeof parsed.checkedAt === "string" && typeof parsed.latest === "string")
       return parsed;
   } catch {}
@@ -2826,7 +4135,7 @@ function readCache() {
 function writeCache(c) {
   try {
     ensureDir(dirname3(paths.updateCache()));
-    writeFileSync3(paths.updateCache(), JSON.stringify(c) + `
+    writeFileSync4(paths.updateCache(), JSON.stringify(c) + `
 `);
   } catch {}
 }
@@ -2871,11 +4180,15 @@ async function checkForUpdate(force = false) {
       latest = null;
     }
   }
-  if (!latest)
+  if (!latest) {
+    log("warn", "update.check", { ok: false });
     return cached ? toInfo(cached) : null;
+  }
   const entry = { checkedAt: new Date().toISOString(), latest };
   writeCache(entry);
-  return toInfo(entry);
+  const info = toInfo(entry);
+  log("info", "update.check", { latest: info.latest, available: info.available });
+  return info;
 }
 function toInfo(c) {
   return { current: VERSION, latest: c.latest, available: semverGt(c.latest, VERSION), checkedAt: c.checkedAt };
@@ -2906,7 +4219,10 @@ function upgradeCommand(pm, version = "latest") {
 async function runUpgrade(pm, version = "latest") {
   const [cmd, args] = upgradeCommand(pm, version);
   console.log(`$ ${cmd} ${args.join(" ")}`);
-  return runInteractive(cmd, args);
+  log("info", "update.upgrade", { pm, version });
+  const code = await runInteractive(cmd, args);
+  log(code === 0 ? "info" : "error", "update.upgrade.done", { pm, version, code: code ?? undefined });
+  return code;
 }
 
 // src/cli.ts
@@ -2919,20 +4235,74 @@ Usage
       --port <n>                 Port (default ${DEFAULT_PORT})
       --host <addr>              Bind address (default ${DEFAULT_HOST}; use 127.0.0.1 for local only)
       --no-open                  Don't open a browser
+  just-usage stop [options]      Stop a running just-usage server
+      --port <n>                 Port (default ${DEFAULT_PORT})
+      --all                      Stop every just-usage server this CLI started
   just-usage status [--json]     Print quotas in the terminal
   just-usage accounts            List accounts
-  just-usage add <provider>      Add an account (codex | claude | opencode)
+  just-usage add <provider>      Add an account (codex | claude | opencode | antigravity)
       --label <name>             Friendly name
       --token                    Claude only: paste a \`claude setup-token\` instead of a profile login
   just-usage login <account-id>  Re-authenticate a profile account
   just-usage remove <account-id> Remove an account and anything we stored for it
   just-usage upgrade [--check]   Update to the latest release
   just-usage --version
+  just-usage stop --help         More on stopping a running server
 
 Providers: ${PROVIDERS.map((p) => p.name).join(", ")}
 Cursor uses whatever \`cursor-agent\` is logged in as (single account).
+Grok uses whatever \`grok login --oauth\` stored (single account).
+Antigravity extras are extra Google logins; they do not replace \`agy\`'s signed-in account.
+
+Logs are appended to ~/.just-usage/logs (one JSON line per action).
+
+Stop
+  \`just-usage stop\` asks the server to exit — the same as Ctrl+C in the terminal
+  that started it. Use this when that terminal is gone or another instance is
+  still holding the port.
+
+  just-usage stop                Stop the default server (port ${DEFAULT_PORT})
+  just-usage stop --port 5758    Stop a server you started on another port
+  just-usage stop --all          Stop every just-usage server recorded here
+
+  It only stops a process it can confirm is just-usage (pid file, health route,
+  or command line). An unrelated process on the same port is left alone.
+`;
+var STOP_HELP = `${PACKAGE_NAME} stop
+Stop a running just-usage server.
+
+Usage
+  just-usage stop
+  just-usage stop --port <n>
+  just-usage stop --all
+
+What it does
+  The server writes a small pid file under ~/.config/just-usage/run/ when it
+  starts. \`stop\` reads that file and asks the process to exit (SIGTERM, then
+  SIGKILL if it ignores the first signal).
+
+  If the pid file is missing or stale — for example after a crash — \`stop\`
+  looks for a listener on the port and checks GET /api/health. Only a confirmed
+  just-usage server is stopped.
+
+Options
+  --port <n>     Port the server is bound to (default ${DEFAULT_PORT})
+  --all          Stop every just-usage server this CLI has a pid file for,
+                 plus the default port if that is still running
+  --help, -h     Show this help
+
+Examples
+  just-usage stop
+  just-usage serve --port 5758
+  just-usage stop --port 5758
+  just-usage stop --all
+
+See also
+  just-usage serve               Start the server
+  just-usage --help              All commands
 `;
 function fail(msg, code = 1) {
+  log("error", "cli.fail", { message: msg, code });
   console.error(msg);
   process.exit(code);
 }
@@ -2994,17 +4364,22 @@ Update available: v${u.current} → v${u.latest}. Run: just-usage upgrade
     server = await startServer({ host, port, getUpdate: () => update });
   } catch (e) {
     const code = e.code;
-    if (code === "EADDRINUSE")
-      fail(`Port ${port} is already in use. Try: just-usage serve --port ${port + 1}`);
+    if (code === "EADDRINUSE") {
+      const stop = port === DEFAULT_PORT ? "just-usage stop" : `just-usage stop --port ${port}`;
+      fail(`Port ${port} is already in use. Stop it with: ${stop}
+Or start another: just-usage serve --port ${port + 1}`);
+    }
+    logError("serve.error", e, { host, port });
     throw e;
   }
   console.log(`${PACKAGE_NAME} v${VERSION}`);
   for (const u of server.urls) {
     const tag = u.kind === "local" ? "local    " : u.kind === "tailscale" ? "tailscale" : "network  ";
-    console.log(`  ${tag} ${u.url}${u.note ? ` — ${u.note}` : ""}`);
+    console.log(`  ${tag} ${u.url}`);
   }
+  const stopHint = port === DEFAULT_PORT ? "just-usage stop" : `just-usage stop --port ${port}`;
   console.log(`
-Press Ctrl+C to stop.`);
+Press Ctrl+C to stop. From another terminal: ${stopHint}`);
   if (shouldOpen)
     openInBrowser(server.urls[0].url);
   const shutdown = () => {
@@ -3016,6 +4391,7 @@ Press Ctrl+C to stop.`);
 }
 async function cmdStatus(argv) {
   const { values } = parseArgs({ args: argv, options: { json: { type: "boolean" } }, allowPositionals: true, strict: false });
+  log("info", "cli.status", { json: values.json === true });
   const [report, update] = await Promise.all([collectReport(null), checkForUpdate().catch(() => null)]);
   report.update = update;
   if (values.json) {
@@ -3026,10 +4402,11 @@ async function cmdStatus(argv) {
 }
 function cmdAccounts() {
   const rows = listAccounts();
-  console.log("Default accounts come from each CLI's own login (codex login, claude /login, cursor-agent login, opencode auth login).");
+  log("info", "cli.accounts", { extra: rows.length });
+  console.log("Default accounts come from each CLI's own login (codex login, claude /login, cursor-agent login, grok login --oauth, opencode auth login, agy).");
   if (rows.length === 0) {
     console.log(`
-No extra accounts. Add one with: just-usage add codex | claude | opencode`);
+No extra accounts. Add one with: just-usage add codex | claude | opencode | antigravity`);
     return;
   }
   console.log("");
@@ -3077,9 +4454,11 @@ async function addClaudeProfile(label) {
   if (!status?.loggedIn) {
     const { rmSync } = await import("node:fs");
     rmSync(dir, { recursive: true, force: true });
+    log("error", "account.login.error", { provider: "claude", message: "login did not complete" });
     fail("Login did not complete; nothing was saved.");
   }
   saveAccount({ id, provider: "claude", label: label ?? id.split(":")[1], kind: "profile", path: dir, email: null, createdAt: new Date().toISOString() });
+  log("info", "account.add", { account: id, provider: "claude", kind: "profile" });
   console.log(`
 Added ${id}. Note: on macOS the first read may trigger a Keychain prompt — choose "Always Allow".`);
 }
@@ -3103,7 +4482,7 @@ async function cmdAdd(argv) {
   });
   const provider = positionals[0];
   if (!isProvider(provider))
-    fail(`Usage: just-usage add <codex|claude|opencode> [--label name] [--token]`);
+    fail(`Usage: just-usage add <codex|claude|opencode|antigravity> [--label name] [--token]`);
   switch (provider) {
     case "codex":
       return addCodex(values.label);
@@ -3111,8 +4490,28 @@ async function cmdAdd(argv) {
       return values.token ? addClaudeTokenCli(values.label) : addClaudeProfile(values.label);
     case "opencode":
       return addOpenCodeCli(values.label);
+    case "antigravity":
+      return addAntigravityCli(values.label);
     case "cursor":
       fail("Cursor is single-account: just-usage shows whatever `cursor-agent` is logged in as.");
+    case "grok":
+      fail("Grok is single-account: just-usage shows whatever `grok` is logged in as.");
+  }
+}
+async function addAntigravityCli(label) {
+  const { sessionId, authUrl } = await beginAntigravityAdd(label);
+  console.log(`
+Open this URL to sign in (opening your browser):
+${authUrl}
+`);
+  openInBrowser(authUrl);
+  console.log("After Google sign-in, copy the code from the Antigravity page (or paste the callback URL).");
+  const callback = await prompt("Code: ");
+  try {
+    const account = await submitAntigravityCallback(sessionId, callback);
+    console.log(`Added ${account.id}${account.email ? ` (${account.email})` : ""}.`);
+  } catch (e) {
+    fail(e instanceof Error ? e.message : String(e));
   }
 }
 async function cmdLogin(argv) {
@@ -3124,6 +4523,7 @@ async function cmdLogin(argv) {
     fail(`Unknown account: ${id}`);
   if (rec.kind !== "profile" || !rec.path)
     fail(`${id} is a ${rec.kind} account; remove and re-add it instead.`);
+  log("info", "account.login.start", { account: id, provider: rec.provider, kind: "relogin" });
   if (rec.provider === "codex") {
     const info = await codexLogin(rec.path, (url) => {
       console.log(`
@@ -3133,10 +4533,15 @@ ${url}
       openInBrowser(url);
     });
     updateAccount(id, { email: info.email });
+    log("info", "account.login.done", { account: id, provider: "codex" });
     console.log(`Re-authenticated ${id}${info.email ? ` (${info.email})` : ""}.`);
   } else if (rec.provider === "claude") {
     await runInteractive("claude", ["auth", "login"], { CLAUDE_CONFIG_DIR: rec.path });
     const status = await claudeAuthStatus(rec.path);
+    log(status?.loggedIn ? "info" : "error", status?.loggedIn ? "account.login.done" : "account.login.error", {
+      account: id,
+      provider: "claude"
+    });
     console.log(status?.loggedIn ? `Re-authenticated ${id}.` : "Login did not complete.");
   } else {
     fail(`${providerName(rec.provider)} accounts cannot be re-authenticated this way.`);
@@ -3155,6 +4560,28 @@ async function cmdRemove(argv) {
     fail(e instanceof Error ? e.message : String(e));
   }
 }
+async function cmdStop(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(STOP_HELP);
+    return;
+  }
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      port: { type: "string", short: "p" },
+      all: { type: "boolean" }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  const port = values.port ? Number(values.port) : undefined;
+  if (values.port && (!Number.isInteger(port) || port <= 0 || port > 65535))
+    fail(`invalid port: ${values.port}`);
+  const { text, code } = formatStopResults(await stopServers({ port, all: values.all === true }));
+  console.log(text);
+  if (code !== 0)
+    process.exit(code);
+}
 async function cmdUpgrade(argv) {
   const { values } = parseArgs({ args: argv, options: { check: { type: "boolean" }, yes: { type: "boolean", short: "y" } }, allowPositionals: true, strict: false });
   const info = await checkForUpdate(true);
@@ -3181,6 +4608,7 @@ async function cmdUpgrade(argv) {
 async function main() {
   const argv = process.argv.slice(2);
   const cmd = argv[0];
+  log("info", "cli", { command: cmd ?? "serve" });
   if (cmd === "--version" || cmd === "-v" || cmd === "version") {
     console.log(VERSION);
     return;
@@ -3194,6 +4622,9 @@ async function main() {
       return cmdServe([]);
     case "serve":
       return cmdServe(argv.slice(1));
+    case "stop":
+    case "quit":
+      return cmdStop(argv.slice(1));
     case "status":
       return cmdStatus(argv.slice(1));
     case "accounts":
@@ -3217,6 +4648,7 @@ ${HELP}`);
   }
 }
 main().catch((e) => {
+  logError("cli.crash", e);
   console.error(e instanceof Error ? e.message : String(e));
   process.exit(1);
 });