@gpc-cli/core 0.9.28 → 0.9.30

package/dist/index.js

@@ -40,6 +40,21 @@ var NetworkError = class extends GpcError {
 
 // src/output.ts
 import process2 from "process";
+function isColorEnabled() {
+  if (process2.env["NO_COLOR"] !== void 0 && process2.env["NO_COLOR"] !== "") return false;
+  const fc = process2.env["FORCE_COLOR"];
+  if (fc === "1" || fc === "2" || fc === "3") return true;
+  return process2.stdout.isTTY ?? false;
+}
+function ansi(code, s) {
+  return isColorEnabled() ? `\x1B[${code}m${s}\x1B[0m` : s;
+}
+function bold(s) {
+  return ansi(1, s);
+}
+function dim(s) {
+  return ansi(2, s);
+}
 function detectOutputFormat() {
   return process2.stdout.isTTY ? "table" : "json";
 }
@@ -150,10 +165,20 @@ ${formatYaml(value, indent + 1)}`;
   }
   return String(data);
 }
-var MAX_CELL_WIDTH = 60;
-function truncateCell(value) {
-  if (value.length <= MAX_CELL_WIDTH) return value;
-  return value.slice(0, MAX_CELL_WIDTH - 3) + "...";
+var DEFAULT_CELL_WIDTH = 60;
+function computeMaxCellWidth(colCount) {
+  const cols = process2.stdout.columns;
+  if (cols && colCount > 0) {
+    return Math.max(20, Math.floor(cols / colCount) - 2);
+  }
+  return DEFAULT_CELL_WIDTH;
+}
+function truncateCell(value, maxWidth = DEFAULT_CELL_WIDTH) {
+  if (value.length <= maxWidth) return value;
+  return value.slice(0, maxWidth - 3) + "...";
+}
+function isNumericCell(value) {
+  return /^-?\d[\d,]*(\.\d+)?%?$/.test(value.trim());
 }
 function cellValue(val) {
   if (val === null || val === void 0) return "";
@@ -170,12 +195,29 @@ function formatTable(data) {
   if (!firstRow) return "";
   const keys = Object.keys(firstRow);
   if (keys.length === 0) return "";
+  const colCount = keys.length;
+  const maxCellWidth = computeMaxCellWidth(colCount);
   const widths = keys.map(
-    (key) => Math.max(key.length, ...rows.map((row) => truncateCell(cellValue(row[key])).length))
+    (key) => Math.max(
+      key.length,
+      ...rows.map((row) => truncateCell(cellValue(row[key]), maxCellWidth).length)
+    )
+  );
+  const isNumeric = keys.map(
+    (key) => rows.every((row) => {
+      const v = cellValue(row[key]);
+      return v === "" || isNumericCell(v);
+    })
   );
-  const header = keys.map((key, i) => key.padEnd(widths[i] ?? 0)).join("  ");
-  const separator = widths.map((w) => "-".repeat(w)).join("  ");
-  const body = rows.map((row) => keys.map((key, i) => truncateCell(cellValue(row[key])).padEnd(widths[i] ?? 0)).join("  ")).join("\n");
+  const header = keys.map((key, i) => bold(key.padEnd(widths[i] ?? 0))).join("  ");
+  const separator = widths.map((w) => dim("\u2500".repeat(w))).join("  ");
+  const body = rows.map(
+    (row) => keys.map((key, i) => {
+      const cell = truncateCell(cellValue(row[key]), maxCellWidth);
+      const w = widths[i] ?? 0;
+      return isNumeric[i] ? cell.padStart(w) : cell.padEnd(w);
+    }).join("  ")
+  ).join("\n");
   return `${header}
 ${separator}
 ${body}`;
@@ -284,6 +326,28 @@ function buildTestCase(item, commandName, index = 0) {
     failed: false
   };
 }
+async function maybePaginate(output) {
+  const isTTY = process2.stdout.isTTY;
+  const termHeight = process2.stdout.rows ?? 24;
+  const lineCount = output.split("\n").length;
+  if (!isTTY || lineCount <= termHeight) {
+    console.log(output);
+    return;
+  }
+  const pager = process2.env["GPC_PAGER"] ?? process2.env["PAGER"] ?? "less";
+  try {
+    const { spawn } = await import("child_process");
+    const child = spawn(pager, [], {
+      stdio: ["pipe", "inherit", "inherit"],
+      env: { ...process2.env, LESS: process2.env["LESS"] ?? "-FRX" }
+    });
+    child.stdin.write(output);
+    child.stdin.end();
+    await new Promise((resolve2) => child.on("close", resolve2));
+  } catch {
+    console.log(output);
+  }
+}
 function formatJunit(data, commandName = "command") {
   const { cases, failures } = toTestCases(data, commandName);
   const tests = cases.length;
@@ -496,6 +560,7 @@ async function getAppInfo(client, packageName) {
 
 // src/commands/releases.ts
 import { stat as stat2 } from "fs/promises";
+import { ApiError as ApiError2 } from "@gpc-cli/api";
 
 // src/utils/file-validation.ts
 import { readFile, stat } from "fs/promises";
@@ -745,12 +810,13 @@ async function updateRollout(client, packageName, track, action, userFraction) {
     let newFraction;
     switch (action) {
       case "increase":
-        if (!userFraction) throw new GpcError(
-          "--to <percentage> is required for rollout increase",
-          "ROLLOUT_MISSING_FRACTION",
-          2,
-          "Specify the target rollout percentage with --to, e.g.: gpc rollout increase --to 0.5"
-        );
+        if (!userFraction)
+          throw new GpcError(
+            "--to <percentage> is required for rollout increase",
+            "ROLLOUT_MISSING_FRACTION",
+            2,
+            "Specify the target rollout percentage with --to, e.g.: gpc rollout increase --to 0.5"
+          );
         if (userFraction <= 0 || userFraction > 1) {
           throw new GpcError(
             "Rollout percentage must be between 0 and 1 (e.g., 0.1 for 10%)",
@@ -1161,6 +1227,70 @@ function diffListings(local, remote) {
   return diffs;
 }
 
+// src/utils/listing-text.ts
+var DEFAULT_LIMITS = {
+  title: 30,
+  shortDescription: 80,
+  fullDescription: 4e3,
+  video: 256
+};
+function lintListing(language, fields, limits = DEFAULT_LIMITS) {
+  const fieldResults = [];
+  for (const [field, limit] of Object.entries(limits)) {
+    const value = fields[field] ?? "";
+    const chars = [...value].length;
+    const pct = Math.round(chars / limit * 100);
+    let status = "ok";
+    if (chars > limit) status = "over";
+    else if (pct >= 80) status = "warn";
+    fieldResults.push({ field, chars, limit, pct, status });
+  }
+  const valid = fieldResults.every((r) => r.status !== "over");
+  return { language, fields: fieldResults, valid };
+}
+function lintListings(listings, limits) {
+  return listings.map((l) => lintListing(l.language, l.fields, limits));
+}
+function tokenize(text) {
+  return text.split(/(\s+)/);
+}
+function wordDiff(before, after) {
+  const aTokens = tokenize(before);
+  const bTokens = tokenize(after);
+  const m = aTokens.length;
+  const n = bTokens.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  const cell = (r, c) => dp[r]?.[c] ?? 0;
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      dp[i2][j2] = aTokens[i2 - 1] === bTokens[j2 - 1] ? cell(i2 - 1, j2 - 1) + 1 : Math.max(cell(i2 - 1, j2), cell(i2, j2 - 1));
+    }
+  }
+  const result = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && aTokens[i - 1] === bTokens[j - 1]) {
+      result.unshift({ text: aTokens[i - 1] ?? "", type: "equal" });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || cell(i, j - 1) >= cell(i - 1, j))) {
+      result.unshift({ text: bTokens[j - 1] ?? "", type: "insert" });
+      j--;
+    } else {
+      result.unshift({ text: aTokens[i - 1] ?? "", type: "delete" });
+      i--;
+    }
+  }
+  return result;
+}
+function formatWordDiff(diff) {
+  return diff.map((t) => {
+    if (t.type === "equal") return t.text;
+    if (t.type === "insert") return `[+${t.text}]`;
+    return `[-${t.text}]`;
+  }).join("");
+}
+
 // src/commands/listings.ts
 function validateLanguage(lang) {
   if (!isValidBcp47(lang)) {
@@ -1231,6 +1361,57 @@ async function pullListings(client, packageName, dir) {
     throw error;
   }
 }
+async function lintLocalListings(dir) {
+  const localListings = await readListingsFromDir(dir);
+  return lintListings(
+    localListings.map((l) => ({
+      language: l.language,
+      fields: {
+        title: l.title,
+        shortDescription: l.shortDescription,
+        fullDescription: l.fullDescription,
+        video: l.video
+      }
+    }))
+  );
+}
+async function analyzeRemoteListings(client, packageName, options) {
+  const listings = await getListings(client, packageName);
+  const results = lintListings(
+    listings.map((l) => ({
+      language: l.language,
+      fields: {
+        title: l.title,
+        shortDescription: l.shortDescription,
+        fullDescription: l.fullDescription,
+        video: l["video"]
+      }
+    }))
+  );
+  let missingLocales;
+  if (options?.expectedLocales) {
+    const present = new Set(listings.map((l) => l.language));
+    missingLocales = options.expectedLocales.filter((loc) => !present.has(loc));
+  }
+  return { results, missingLocales };
+}
+async function diffListingsEnhanced(client, packageName, dir, options) {
+  const allDiffs = await diffListingsCommand(client, packageName, dir);
+  let result = allDiffs;
+  if (options?.lang) {
+    result = allDiffs.filter((d) => d.language === options.lang);
+  }
+  if (options?.wordLevel) {
+    return result.map((d) => {
+      if (d.field === "fullDescription" && d.local && d.remote) {
+        const diff = wordDiff(d.remote, d.local);
+        return { ...d, diffSummary: formatWordDiff(diff) };
+      }
+      return d;
+    });
+  }
+  return result;
+}
 async function pushListings(client, packageName, dir, options) {
   const localListings = await readListingsFromDir(dir);
   if (localListings.length === 0) {
@@ -1244,6 +1425,33 @@ async function pushListings(client, packageName, dir, options) {
   for (const listing of localListings) {
     validateLanguage(listing.language);
   }
+  if (!options?.force) {
+    const lintResults = lintListings(
+      localListings.map((l) => ({
+        language: l.language,
+        fields: {
+          title: l.title,
+          shortDescription: l.shortDescription,
+          fullDescription: l.fullDescription,
+          video: l["video"]
+        }
+      }))
+    );
+    const overLimit = lintResults.filter((r) => !r.valid);
+    if (overLimit.length > 0) {
+      const details = overLimit.map((r) => {
+        const over = r.fields.filter((f) => f.status === "over");
+        return `${r.language}: ${over.map((f) => `${f.field} (${f.chars}/${f.limit})`).join(", ")}`;
+      }).join("\n");
+      throw new GpcError(
+        `Listing push blocked: field(s) exceed character limits:
+${details}`,
+        "LISTING_CHAR_LIMIT_EXCEEDED",
+        1,
+        "Fix the character limit violations listed above, or use --force to push anyway."
+      );
+    }
+  }
   const edit = await client.edits.insert(packageName);
   try {
     if (options?.dryRun) {
@@ -1358,8 +1566,8 @@ var ALL_IMAGE_TYPES = [
   "tvBanner"
 ];
 async function exportImages(client, packageName, dir, options) {
-  const { mkdir: mkdir6, writeFile: writeFile8 } = await import("fs/promises");
-  const { join: join8 } = await import("path");
+  const { mkdir: mkdir7, writeFile: writeFile9 } = await import("fs/promises");
+  const { join: join9 } = await import("path");
   const edit = await client.edits.insert(packageName);
   try {
     let languages;
@@ -1390,12 +1598,12 @@ async function exportImages(client, packageName, dir, options) {
       const batch = tasks.slice(i, i + concurrency);
       const results = await Promise.all(
         batch.map(async (task) => {
-          const dirPath = join8(dir, task.language, task.imageType);
-          await mkdir6(dirPath, { recursive: true });
+          const dirPath = join9(dir, task.language, task.imageType);
+          await mkdir7(dirPath, { recursive: true });
           const response = await fetch(task.url);
           const buffer = Buffer.from(await response.arrayBuffer());
-          const filePath = join8(dirPath, `${task.index}.png`);
-          await writeFile8(filePath, buffer);
+          const filePath = join9(dirPath, `${task.index}.png`);
+          await writeFile9(filePath, buffer);
           return buffer.length;
         })
       );
@@ -1565,9 +1773,7 @@ function generateMigrationPlan(detection) {
   }
   for (const lane of detection.lanes) {
     if (lane.gpcEquivalent) {
-      checklist.push(
-        `Replace Fastlane lane "${lane.name}" with: ${lane.gpcEquivalent} <your.aab>`
-      );
+      checklist.push(`Replace Fastlane lane "${lane.name}" with: ${lane.gpcEquivalent} <your.aab>`);
     }
     if (lane.actions.includes("capture_android_screenshots")) {
       warnings.push(
@@ -1642,7 +1848,9 @@ async function writeMigrationOutput(result, dir) {
   lines.push("| `supply(skip_upload_aab: true)` | `gpc listings push` |");
   lines.push("| `capture_android_screenshots` | No equivalent \u2014 use separate tool |");
   lines.push("");
-  lines.push("See the full migration guide: https://yasserstudio.github.io/gpc/migration/from-fastlane");
+  lines.push(
+    "See the full migration guide: https://yasserstudio.github.io/gpc/migration/from-fastlane"
+  );
   lines.push("");
   await writeFile2(migrationPath, lines.join("\n"), "utf-8");
   files.push(migrationPath);
@@ -1898,6 +2106,234 @@ async function publish(client, packageName, filePath, options) {
 
 // src/commands/reviews.ts
 import { paginateAll } from "@gpc-cli/api";
+
+// src/utils/sentiment.ts
+var POSITIVE_WORDS = /* @__PURE__ */ new Set([
+  "great",
+  "excellent",
+  "amazing",
+  "awesome",
+  "fantastic",
+  "love",
+  "good",
+  "best",
+  "perfect",
+  "wonderful",
+  "helpful",
+  "easy",
+  "fast",
+  "smooth",
+  "reliable",
+  "clean",
+  "beautiful",
+  "intuitive",
+  "works",
+  "recommend",
+  "useful",
+  "thank",
+  "thanks",
+  "brilliant",
+  "superb",
+  "flawless",
+  "outstanding",
+  "delightful",
+  "nice"
+]);
+var NEGATIVE_WORDS = /* @__PURE__ */ new Set([
+  "bad",
+  "terrible",
+  "awful",
+  "horrible",
+  "worst",
+  "hate",
+  "broken",
+  "crash",
+  "crashes",
+  "bug",
+  "bugs",
+  "slow",
+  "laggy",
+  "freeze",
+  "freezes",
+  "error",
+  "errors",
+  "fail",
+  "fails",
+  "useless",
+  "disappointing",
+  "disappointed",
+  "frustrating",
+  "frustration",
+  "annoying",
+  "problem",
+  "problems",
+  "issue",
+  "issues",
+  "fix",
+  "please",
+  "not working",
+  "doesn't work",
+  "stopped",
+  "uninstall",
+  "deleted",
+  "waste",
+  "rubbish",
+  "garbage",
+  "terrible"
+]);
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "is",
+  "it",
+  "this",
+  "that",
+  "was",
+  "are",
+  "be",
+  "been",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "i",
+  "me",
+  "my",
+  "we",
+  "you",
+  "he",
+  "she",
+  "they",
+  "them",
+  "their",
+  "its",
+  "not",
+  "no",
+  "very",
+  "so",
+  "just",
+  "really",
+  "app",
+  "application",
+  "update"
+]);
+function analyzeSentiment(text) {
+  const lower = text.toLowerCase();
+  const words = lower.split(/\W+/).filter(Boolean);
+  let posScore = 0;
+  let negScore = 0;
+  for (const word of words) {
+    if (POSITIVE_WORDS.has(word)) posScore++;
+    if (NEGATIVE_WORDS.has(word)) negScore++;
+  }
+  const total = posScore + negScore;
+  if (total === 0) return { score: 0, label: "neutral", magnitude: 0 };
+  const score = (posScore - negScore) / total;
+  const magnitude = Math.min(1, total / 10);
+  const label = score > 0.1 ? "positive" : score < -0.1 ? "negative" : "neutral";
+  return { score, label, magnitude };
+}
+function clusterTopics(texts) {
+  const TOPIC_KEYWORDS = {
+    performance: ["slow", "lag", "laggy", "freeze", "fast", "speed", "quick", "smooth"],
+    crashes: ["crash", "crashes", "crash", "crashing", "force close", "stops", "stopped"],
+    "ui/ux": ["ui", "design", "interface", "layout", "button", "screen", "menu", "navigation"],
+    battery: ["battery", "drain", "power", "charging", "drain"],
+    updates: ["update", "updated", "version", "new version", "after update"],
+    notifications: ["notification", "notifications", "alert", "alerts", "push"],
+    "login/auth": ["login", "sign in", "logout", "password", "account", "auth"],
+    "feature requests": ["please add", "would be nice", "missing", "need", "wish", "want"],
+    bugs: ["bug", "bugs", "issue", "error", "problem", "glitch", "broken"],
+    pricing: ["price", "pricing", "expensive", "cheap", "subscription", "pay", "cost", "free"]
+  };
+  const clusterMap = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    const lower = text.toLowerCase();
+    const sentiment = analyzeSentiment(text);
+    for (const [topic, keywords] of Object.entries(TOPIC_KEYWORDS)) {
+      if (keywords.some((kw) => lower.includes(kw))) {
+        const existing = clusterMap.get(topic) ?? { count: 0, totalScore: 0 };
+        clusterMap.set(topic, {
+          count: existing.count + 1,
+          totalScore: existing.totalScore + sentiment.score
+        });
+      }
+    }
+  }
+  return Array.from(clusterMap.entries()).map(([topic, { count, totalScore }]) => ({
+    topic,
+    count,
+    avgScore: count > 0 ? Math.round(totalScore / count * 100) / 100 : 0
+  })).filter((c) => c.count > 0).sort((a, b) => b.count - a.count);
+}
+function keywordFrequency(texts, topN = 20) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const text of texts) {
+    const words = text.toLowerCase().split(/\W+/).filter((w) => w.length > 3 && !STOP_WORDS.has(w));
+    for (const word of words) {
+      freq.set(word, (freq.get(word) ?? 0) + 1);
+    }
+  }
+  return Array.from(freq.entries()).map(([word, count]) => ({ word, count })).sort((a, b) => b.count - a.count).slice(0, topN);
+}
+function analyzeReviews(reviews) {
+  if (reviews.length === 0) {
+    return {
+      totalReviews: 0,
+      avgRating: 0,
+      sentiment: { positive: 0, negative: 0, neutral: 0, avgScore: 0 },
+      topics: [],
+      keywords: [],
+      ratingDistribution: {}
+    };
+  }
+  const texts = reviews.map((r) => r.text);
+  const sentiments = texts.map((t) => analyzeSentiment(t));
+  const positive = sentiments.filter((s) => s.label === "positive").length;
+  const negative = sentiments.filter((s) => s.label === "negative").length;
+  const neutral = sentiments.filter((s) => s.label === "neutral").length;
+  const avgScore = sentiments.reduce((sum, s) => sum + s.score, 0) / sentiments.length;
+  const ratings = reviews.map((r) => r.rating).filter((r) => r !== void 0);
+  const avgRating = ratings.length > 0 ? ratings.reduce((a, b) => a + b, 0) / ratings.length : 0;
+  const ratingDistribution = {};
+  for (const r of ratings) {
+    ratingDistribution[r] = (ratingDistribution[r] ?? 0) + 1;
+  }
+  return {
+    totalReviews: reviews.length,
+    avgRating: Math.round(avgRating * 100) / 100,
+    sentiment: {
+      positive,
+      negative,
+      neutral,
+      avgScore: Math.round(avgScore * 100) / 100
+    },
+    topics: clusterTopics(texts),
+    keywords: keywordFrequency(texts),
+    ratingDistribution
+  };
+}
+
+// src/commands/reviews.ts
 async function listReviews(client, packageName, options) {
   const apiOptions = {};
   if (options?.translationLanguage) apiOptions.translationLanguage = options.translationLanguage;
@@ -2007,163 +2443,16 @@ function csvEscape(value) {
   }
   return value;
 }
-
-// src/commands/vitals.ts
-var METRIC_SET_METRICS = {
-  crashRateMetricSet: ["crashRate", "userPerceivedCrashRate", "distinctUsers"],
-  anrRateMetricSet: ["anrRate", "userPerceivedAnrRate", "distinctUsers"],
-  slowStartRateMetricSet: ["slowStartRate", "distinctUsers"],
-  slowRenderingRateMetricSet: ["slowRenderingRate", "distinctUsers"],
-  excessiveWakeupRateMetricSet: ["excessiveWakeupRate", "distinctUsers"],
-  stuckBackgroundWakelockRateMetricSet: ["stuckBackgroundWakelockRate", "distinctUsers"],
-  errorCountMetricSet: ["errorReportCount", "distinctUsers"]
-};
-function buildQuery(metricSet, options) {
-  const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
-  const days = options?.days ?? 30;
-  const DAY_MS = 24 * 60 * 60 * 1e3;
-  const end = new Date(Date.now() - DAY_MS);
-  const start = new Date(Date.now() - DAY_MS - days * DAY_MS);
-  const query = {
-    metrics,
-    timelineSpec: {
-      aggregationPeriod: options?.aggregation ?? "DAILY",
-      startTime: {
-        year: start.getUTCFullYear(),
-        month: start.getUTCMonth() + 1,
-        day: start.getUTCDate()
-      },
-      endTime: {
-        year: end.getUTCFullYear(),
-        month: end.getUTCMonth() + 1,
-        day: end.getUTCDate()
-      }
-    }
-  };
-  if (options?.dimension) {
-    query.dimensions = [options.dimension];
-  }
-  return query;
-}
-async function queryMetric(reporting, packageName, metricSet, options) {
-  const query = buildQuery(metricSet, options);
-  return reporting.queryMetricSet(packageName, metricSet, query);
-}
-async function getVitalsOverview(reporting, packageName) {
-  const metricSets = [
-    ["crashRateMetricSet", "crashRate"],
-    ["anrRateMetricSet", "anrRate"],
-    ["slowStartRateMetricSet", "slowStartRate"],
-    ["slowRenderingRateMetricSet", "slowRenderingRate"],
-    ["excessiveWakeupRateMetricSet", "excessiveWakeupRate"],
-    ["stuckBackgroundWakelockRateMetricSet", "stuckWakelockRate"]
-  ];
-  const results = await Promise.allSettled(
-    metricSets.map(
-      ([metric]) => reporting.queryMetricSet(packageName, metric, buildQuery(metric))
-    )
-  );
-  const overview = {};
-  for (let i = 0; i < metricSets.length; i++) {
-    const entry = metricSets[i];
-    if (!entry) continue;
-    const key = entry[1];
-    const result = results[i];
-    if (!result) continue;
-    if (result.status === "fulfilled") {
-      overview[key] = result.value.rows || [];
-    }
-  }
-  return overview;
-}
-async function getVitalsCrashes(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "crashRateMetricSet", options);
-}
-async function getVitalsAnr(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "anrRateMetricSet", options);
-}
-async function getVitalsStartup(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "slowStartRateMetricSet", options);
-}
-async function getVitalsRendering(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "slowRenderingRateMetricSet", options);
-}
-async function getVitalsBattery(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "excessiveWakeupRateMetricSet", options);
-}
-async function getVitalsMemory(reporting, packageName, options) {
-  return queryMetric(reporting, packageName, "stuckBackgroundWakelockRateMetricSet", options);
-}
-async function getVitalsAnomalies(reporting, packageName) {
-  return reporting.getAnomalies(packageName);
-}
-async function searchVitalsErrors(reporting, packageName, options) {
-  return reporting.searchErrorIssues(packageName, options?.filter, options?.maxResults);
-}
-async function compareVitalsTrend(reporting, packageName, metricSet, days = 7) {
-  const DAY_MS = 24 * 60 * 60 * 1e3;
-  const nowMs = Date.now();
-  const baseMs = nowMs - 2 * DAY_MS;
-  const currentEnd = new Date(baseMs);
-  const currentStart = new Date(baseMs - days * DAY_MS);
-  const previousEnd = new Date(baseMs - days * DAY_MS - DAY_MS);
-  const previousStart = new Date(baseMs - days * DAY_MS - DAY_MS - days * DAY_MS);
-  const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
-  const toApiDate2 = (d) => ({
-    year: d.getUTCFullYear(),
-    month: d.getUTCMonth() + 1,
-    day: d.getUTCDate()
-  });
-  const makeQuery = (start, end) => ({
-    metrics,
-    timelineSpec: {
-      aggregationPeriod: "DAILY",
-      startTime: toApiDate2(start),
-      endTime: toApiDate2(end)
-    }
+async function analyzeReviews2(client, packageName, options) {
+  const reviews = await listReviews(client, packageName, options);
+  const items = reviews.map((r) => {
+    const uc = r.comments?.[0]?.userComment;
+    return {
+      text: uc?.text ?? "",
+      rating: uc?.starRating
+    };
   });
-  const [currentResult, previousResult] = await Promise.all([
-    reporting.queryMetricSet(packageName, metricSet, makeQuery(currentStart, currentEnd)),
-    reporting.queryMetricSet(packageName, metricSet, makeQuery(previousStart, previousEnd))
-  ]);
-  const extractAvg = (rows) => {
-    if (!rows || rows.length === 0) return void 0;
-    const values = rows.map((r) => {
-      const keys = Object.keys(r.metrics);
-      const first = keys[0];
-      return first ? Number(r.metrics[first]?.decimalValue?.value) : NaN;
-    }).filter((v) => !isNaN(v));
-    if (values.length === 0) return void 0;
-    return values.reduce((a, b) => a + b, 0) / values.length;
-  };
-  const current = extractAvg(currentResult.rows);
-  const previous = extractAvg(previousResult.rows);
-  let changePercent;
-  let direction = "unknown";
-  if (current !== void 0 && previous !== void 0 && previous !== 0) {
-    changePercent = (current - previous) / previous * 100;
-    if (Math.abs(changePercent) < 1) {
-      direction = "unchanged";
-    } else if (changePercent < 0) {
-      direction = "improved";
-    } else {
-      direction = "degraded";
-    }
-  }
-  return {
-    metric: metricSet,
-    current,
-    previous,
-    changePercent: changePercent !== void 0 ? Math.round(changePercent * 10) / 10 : void 0,
-    direction
-  };
-}
-function checkThreshold(value, threshold) {
-  return {
-    breached: value !== void 0 && value > threshold,
-    value,
-    threshold
-  };
+  return analyzeReviews(items);
 }
 
 // src/commands/subscriptions.ts
@@ -2180,7 +2469,9 @@ function sanitizeSubscription(data) {
   delete cleaned["archived"];
   if (cleaned.basePlans) {
     cleaned.basePlans = cleaned.basePlans.map((bp) => {
-      const { state: _s, archived: _a, ...cleanBp } = bp;
+      const { state: _state, archived: _archived, ...cleanBp } = bp;
+      void _state;
+      void _archived;
       if (cleanBp.regionalConfigs) {
         cleanBp.regionalConfigs = cleanBp.regionalConfigs.map((rc) => ({
           ...rc,
@@ -2193,7 +2484,8 @@ function sanitizeSubscription(data) {
   return cleaned;
 }
 function sanitizeOffer(data) {
-  const { state: _s, ...cleaned } = data;
+  const { state: _state2, ...cleaned } = data;
+  void _state2;
   delete cleaned["archived"];
   return cleaned;
 }
@@ -2211,7 +2503,8 @@ function autoFixProrationMode(data) {
   for (const bp of data.basePlans) {
     const mode = bp.autoRenewingBasePlanType?.prorationMode;
     if (mode && !mode.startsWith(PRORATION_MODE_PREFIX)) {
-      bp.autoRenewingBasePlanType.prorationMode = `${PRORATION_MODE_PREFIX}${mode}`;
+      if (bp.autoRenewingBasePlanType)
+        bp.autoRenewingBasePlanType.prorationMode = `${PRORATION_MODE_PREFIX}${mode}`;
     }
     if (bp.autoRenewingBasePlanType?.prorationMode) {
       const fullMode = bp.autoRenewingBasePlanType.prorationMode;
@@ -2349,7 +2642,13 @@ async function createOffer(client, packageName, productId, basePlanId, data) {
   validatePackageName(packageName);
   validateSku(productId);
   const sanitized = sanitizeOffer(data);
-  return client.subscriptions.createOffer(packageName, productId, basePlanId, sanitized, data.offerId);
+  return client.subscriptions.createOffer(
+    packageName,
+    productId,
+    basePlanId,
+    sanitized,
+    data.offerId
+  );
 }
 var OFFER_ID_FIELDS = /* @__PURE__ */ new Set(["productId", "basePlanId", "offerId"]);
 function deriveOfferUpdateMask(data) {
@@ -2386,7 +2685,9 @@ async function diffSubscription(client, packageName, productId, localData) {
   const diffs = [];
   const fieldsToCompare = ["listings", "basePlans", "taxAndComplianceSettings"];
   for (const field of fieldsToCompare) {
-    const localVal = JSON.stringify(localData[field] ?? null);
+    const localVal = JSON.stringify(
+      localData[field] ?? null
+    );
     const remoteVal = JSON.stringify(remote[field] ?? null);
     if (localVal !== remoteVal) {
       diffs.push({ field, local: localVal, remote: remoteVal });
@@ -2399,20 +2700,331 @@ async function deactivateOffer(client, packageName, productId, basePlanId, offer
   validateSku(productId);
   return client.subscriptions.deactivateOffer(packageName, productId, basePlanId, offerId);
 }
-
-// src/commands/iap.ts
-import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
-import { join as join4 } from "path";
-import { paginateAll as paginateAll3 } from "@gpc-cli/api";
-async function listInAppProducts(client, packageName, options) {
-  if (options?.limit || options?.nextPage) {
-    const result = await paginateAll3(
-      async (pageToken) => {
-        const resp = await client.inappproducts.list(packageName, {
-          token: pageToken,
-          maxResults: options?.maxResults
-        });
-        return {
+async function getSubscriptionAnalytics(client, packageName) {
+  validatePackageName(packageName);
+  const { items: subs } = await paginateAll2(async (pageToken) => {
+    const response = await client.subscriptions.list(packageName, {
+      pageToken,
+      pageSize: 100
+    });
+    return {
+      items: response.subscriptions || [],
+      nextPageToken: response.nextPageToken
+    };
+  });
+  let activeCount = 0;
+  let activeBasePlans = 0;
+  let trialBasePlans = 0;
+  let pausedBasePlans = 0;
+  let canceledBasePlans = 0;
+  let totalOffers = 0;
+  const byProductId = [];
+  for (const sub of subs) {
+    const state = sub["state"];
+    if (state === "ACTIVE") activeCount++;
+    const basePlans = sub.basePlans ?? [];
+    let subOfferCount = 0;
+    for (const bp of basePlans) {
+      const bpState = bp["state"];
+      if (bpState === "ACTIVE") activeBasePlans++;
+      else if (bpState === "DRAFT") trialBasePlans++;
+      else if (bpState === "INACTIVE") pausedBasePlans++;
+      else if (bpState === "PREPUBLISHED") canceledBasePlans++;
+    }
+    for (const bp of basePlans) {
+      try {
+        const offersResp = await client.subscriptions.listOffers(
+          packageName,
+          sub.productId,
+          bp.basePlanId
+        );
+        const offers = offersResp.subscriptionOffers ?? [];
+        subOfferCount += offers.length;
+        totalOffers += offers.length;
+      } catch {
+      }
+    }
+    byProductId.push({
+      productId: sub.productId,
+      state: sub["state"] ?? "UNKNOWN",
+      basePlanCount: basePlans.length,
+      offerCount: subOfferCount
+    });
+  }
+  return {
+    totalSubscriptions: subs.length,
+    activeCount,
+    activeBasePlans,
+    trialBasePlans,
+    pausedBasePlans,
+    canceledBasePlans,
+    offerCount: totalOffers,
+    byProductId
+  };
+}
+
+// src/commands/vitals.ts
+var METRIC_SET_METRICS = {
+  crashRateMetricSet: ["crashRate", "userPerceivedCrashRate", "distinctUsers"],
+  anrRateMetricSet: ["anrRate", "userPerceivedAnrRate", "distinctUsers"],
+  slowStartRateMetricSet: ["slowStartRate", "distinctUsers"],
+  slowRenderingRateMetricSet: ["slowRenderingRate", "distinctUsers"],
+  excessiveWakeupRateMetricSet: ["excessiveWakeupRate", "distinctUsers"],
+  // API requires the weighted variants — base `stuckBackgroundWakelockRate` is not a valid metric
+  stuckBackgroundWakelockRateMetricSet: [
+    "stuckBackgroundWakelockRate7dUserWeighted",
+    "stuckBackgroundWakelockRate28dUserWeighted",
+    "distinctUsers"
+  ],
+  errorCountMetricSet: ["errorReportCount", "distinctUsers"]
+};
+function buildQuery(metricSet, options) {
+  const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
+  const days = options?.days ?? 30;
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const end = new Date(Date.now() - DAY_MS);
+  const start = new Date(Date.now() - DAY_MS - days * DAY_MS);
+  const query = {
+    metrics,
+    timelineSpec: {
+      aggregationPeriod: options?.aggregation ?? "DAILY",
+      startTime: {
+        year: start.getUTCFullYear(),
+        month: start.getUTCMonth() + 1,
+        day: start.getUTCDate()
+      },
+      endTime: {
+        year: end.getUTCFullYear(),
+        month: end.getUTCMonth() + 1,
+        day: end.getUTCDate()
+      }
+    }
+  };
+  if (options?.dimension) {
+    query.dimensions = [options.dimension];
+  }
+  return query;
+}
+async function queryMetric(reporting, packageName, metricSet, options) {
+  const query = buildQuery(metricSet, options);
+  return reporting.queryMetricSet(packageName, metricSet, query);
+}
+async function getVitalsOverview(reporting, packageName) {
+  const metricSets = [
+    ["crashRateMetricSet", "crashRate"],
+    ["anrRateMetricSet", "anrRate"],
+    ["slowStartRateMetricSet", "slowStartRate"],
+    ["slowRenderingRateMetricSet", "slowRenderingRate"],
+    ["excessiveWakeupRateMetricSet", "excessiveWakeupRate"],
+    ["stuckBackgroundWakelockRateMetricSet", "stuckWakelockRate"]
+  ];
+  const results = await Promise.allSettled(
+    metricSets.map(([metric]) => reporting.queryMetricSet(packageName, metric, buildQuery(metric)))
+  );
+  const overview = {};
+  for (let i = 0; i < metricSets.length; i++) {
+    const entry = metricSets[i];
+    if (!entry) continue;
+    const key = entry[1];
+    const result = results[i];
+    if (!result) continue;
+    if (result.status === "fulfilled") {
+      overview[key] = result.value.rows || [];
+    }
+  }
+  return overview;
+}
+async function getVitalsCrashes(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "crashRateMetricSet", options);
+}
+async function getVitalsAnr(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "anrRateMetricSet", options);
+}
+async function getVitalsStartup(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "slowStartRateMetricSet", options);
+}
+async function getVitalsRendering(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "slowRenderingRateMetricSet", options);
+}
+async function getVitalsBattery(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "excessiveWakeupRateMetricSet", options);
+}
+async function getVitalsMemory(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "stuckBackgroundWakelockRateMetricSet", options);
+}
+async function getVitalsLmk(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "stuckBackgroundWakelockRateMetricSet", {
+    ...options,
+    aggregation: "DAILY"
+  });
+}
+async function getVitalsAnomalies(reporting, packageName) {
+  return reporting.getAnomalies(packageName);
+}
+async function searchVitalsErrors(reporting, packageName, options) {
+  return reporting.searchErrorIssues(packageName, options?.filter, options?.maxResults);
+}
+async function compareVitalsTrend(reporting, packageName, metricSet, days = 7) {
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const nowMs = Date.now();
+  const baseMs = nowMs - 2 * DAY_MS;
+  const currentEnd = new Date(baseMs);
+  const currentStart = new Date(baseMs - days * DAY_MS);
+  const previousEnd = new Date(baseMs - days * DAY_MS - DAY_MS);
+  const previousStart = new Date(baseMs - days * DAY_MS - DAY_MS - days * DAY_MS);
+  const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
+  const toApiDate2 = (d) => ({
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate()
+  });
+  const makeQuery = (start, end) => ({
+    metrics,
+    timelineSpec: {
+      aggregationPeriod: "DAILY",
+      startTime: toApiDate2(start),
+      endTime: toApiDate2(end)
+    }
+  });
+  const [currentResult, previousResult] = await Promise.all([
+    reporting.queryMetricSet(packageName, metricSet, makeQuery(currentStart, currentEnd)),
+    reporting.queryMetricSet(packageName, metricSet, makeQuery(previousStart, previousEnd))
+  ]);
+  const extractAvg = (rows) => {
+    if (!rows || rows.length === 0) return void 0;
+    const values = rows.map((r) => {
+      const keys = Object.keys(r.metrics);
+      const first = keys[0];
+      return first ? Number(r.metrics[first]?.decimalValue?.value) : NaN;
+    }).filter((v) => !isNaN(v));
+    if (values.length === 0) return void 0;
+    return values.reduce((a, b) => a + b, 0) / values.length;
+  };
+  const current = extractAvg(currentResult.rows);
+  const previous = extractAvg(previousResult.rows);
+  let changePercent;
+  let direction = "unknown";
+  if (current !== void 0 && previous !== void 0 && previous !== 0) {
+    changePercent = (current - previous) / previous * 100;
+    if (Math.abs(changePercent) < 1) {
+      direction = "unchanged";
+    } else if (changePercent < 0) {
+      direction = "improved";
+    } else {
+      direction = "degraded";
+    }
+  }
+  return {
+    metric: metricSet,
+    current,
+    previous,
+    changePercent: changePercent !== void 0 ? Math.round(changePercent * 10) / 10 : void 0,
+    direction
+  };
+}
+function checkThreshold(value, threshold) {
+  return {
+    breached: value !== void 0 && value > threshold,
+    value,
+    threshold
+  };
+}
+async function compareVersionVitals(reporting, packageName, v1, v2, options) {
+  const days = options?.days ?? 30;
+  const metricSets = [
+    ["crashRateMetricSet", "crashRate"],
+    ["anrRateMetricSet", "anrRate"],
+    ["slowStartRateMetricSet", "slowStartRate"],
+    ["slowRenderingRateMetricSet", "slowRenderingRate"]
+  ];
+  const results = await Promise.allSettled(
+    metricSets.map(
+      ([ms]) => queryMetric(reporting, packageName, ms, { dimension: "versionCode", days })
+    )
+  );
+  const row1 = { versionCode: v1 };
+  const row2 = { versionCode: v2 };
+  for (let i = 0; i < metricSets.length; i++) {
+    const entry = metricSets[i];
+    const result = results[i];
+    if (!entry || !result || result.status !== "fulfilled") continue;
+    const key = entry[1];
+    const rows = result.value.rows ?? [];
+    const extractAvgForVersion = (vc) => {
+      const matching = rows.filter((r) => {
+        const dims = r.dimensions;
+        return dims?.some((d) => d["stringValue"] === vc) ?? false;
+      });
+      if (matching.length === 0) return void 0;
+      const values = matching.map((r) => {
+        const firstKey = Object.keys(r.metrics)[0];
+        return firstKey ? Number(r.metrics[firstKey]?.decimalValue?.value) : NaN;
+      }).filter((v) => !isNaN(v));
+      if (values.length === 0) return void 0;
+      return values.reduce((a, b) => a + b, 0) / values.length;
+    };
+    row1[key] = extractAvgForVersion(v1);
+    row2[key] = extractAvgForVersion(v2);
+  }
+  const regressions = [];
+  for (const [, key] of metricSets) {
+    const val1 = row1[key];
+    const val2 = row2[key];
+    if (val1 !== void 0 && val2 !== void 0 && val2 > val1 * 1.05) {
+      regressions.push(key);
+    }
+  }
+  return { v1: row1, v2: row2, regressions };
+}
+function watchVitalsWithAutoHalt(reporting, packageName, options) {
+  const {
+    intervalMs = 5 * 60 * 1e3,
+    threshold,
+    metricSet = "crashRateMetricSet",
+    onHalt,
+    onPoll
+  } = options;
+  let stopped = false;
+  let haltTriggered = false;
+  const poll = async () => {
+    if (stopped) return;
+    try {
+      const result = await queryMetric(reporting, packageName, metricSet, { days: 1 });
+      const latestRow = result.rows?.[result.rows.length - 1];
+      const firstMetric = latestRow?.metrics ? Object.keys(latestRow.metrics)[0] : void 0;
+      const value = firstMetric ? Number(latestRow?.metrics[firstMetric]?.decimalValue?.value) : void 0;
+      const breached = value !== void 0 && value > threshold;
+      onPoll?.(value, breached);
+      if (breached && !haltTriggered && onHalt) {
+        haltTriggered = true;
+        await onHalt(value);
+      }
+    } catch {
+    }
+    if (!stopped) {
+      timerId = setTimeout(poll, intervalMs);
+    }
+  };
+  let timerId = setTimeout(poll, 0);
+  return () => {
+    stopped = true;
+    clearTimeout(timerId);
+  };
+}
+
+// src/commands/iap.ts
+import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
+import { join as join4 } from "path";
+import { paginateAll as paginateAll3 } from "@gpc-cli/api";
+async function listInAppProducts(client, packageName, options) {
+  if (options?.limit || options?.nextPage) {
+    const result = await paginateAll3(
+      async (pageToken) => {
+        const resp = await client.inappproducts.list(packageName, {
+          token: pageToken,
+          maxResults: options?.maxResults
+        });
+        return {
           items: resp.inappproduct || [],
           nextPageToken: resp.tokenPagination?.nextPageToken
         };
@@ -2592,6 +3204,10 @@ async function revokeSubscriptionPurchase(client, packageName, token) {
   validatePackageName(packageName);
   return client.purchases.revokeSubscriptionV2(packageName, token);
 }
+async function refundSubscriptionV2(client, packageName, token) {
+  validatePackageName(packageName);
+  return client.purchases.refundSubscriptionV2(packageName, token);
+}
 async function listVoidedPurchases(client, packageName, options) {
   validatePackageName(packageName);
   if (options?.limit || options?.nextPage) {
@@ -2666,8 +3282,8 @@ function isStatsReportType(type) {
 function isValidReportType(type) {
   return FINANCIAL_REPORT_TYPES.has(type) || STATS_REPORT_TYPES.has(type);
 }
-function isValidStatsDimension(dim) {
-  return VALID_DIMENSIONS.has(dim);
+function isValidStatsDimension(dim2) {
+  return VALID_DIMENSIONS.has(dim2);
 }
 function parseMonth(monthStr) {
   const match = /^(\d{4})-(\d{2})$/.exec(monthStr);
@@ -2766,6 +3382,32 @@ function parseGrantArg(grantStr) {
   return { packageName, appLevelPermissions: perms };
 }
 
+// src/commands/grants.ts
+async function listGrants(client, developerId, email) {
+  const result = await client.grants.list(developerId, email);
+  return result.grants || [];
+}
+async function createGrant(client, developerId, email, packageName, permissions) {
+  return client.grants.create(developerId, email, {
+    packageName,
+    appLevelPermissions: permissions
+  });
+}
+async function updateGrant(client, developerId, email, packageName, permissions) {
+  return client.grants.patch(
+    developerId,
+    email,
+    packageName,
+    {
+      appLevelPermissions: permissions
+    },
+    "appLevelPermissions"
+  );
+}
+async function deleteGrant(client, developerId, email, packageName) {
+  return client.grants.delete(developerId, email, packageName);
+}
+
 // src/commands/testers.ts
 import { readFile as readFile6 } from "fs/promises";
 async function listTesters(client, packageName, track) {
@@ -2843,7 +3485,7 @@ var DEFAULT_MAX_LENGTH = 500;
 function parseConventionalCommit(subject) {
   const match = subject.match(/^(\w+)(?:\([^)]*\))?:\s*(.+)$/);
   if (match) {
-    return { type: match[1], message: match[2].trim() };
+    return { type: match[1] ?? "other", message: (match[2] ?? "").trim() };
   }
   return { type: "other", message: subject.trim() };
 }
@@ -2854,7 +3496,7 @@ function formatNotes(commits, maxLength) {
     if (!groups.has(header)) {
       groups.set(header, []);
     }
-    groups.get(header).push(commit.message);
+    groups.get(header)?.push(commit.message);
   }
   const order = ["New", "Fixed", "Improved", "Changes"];
   const sections = [];
@@ -3173,96 +3815,447 @@ async function diffOneTimeProduct(client, packageName, productId, localData) {
   const diffs = [];
   const fieldsToCompare = ["listings", "purchaseType", "taxAndComplianceSettings"];
   for (const field of fieldsToCompare) {
-    const localVal = JSON.stringify(localData[field] ?? null);
+    const localVal = JSON.stringify(
+      localData[field] ?? null
+    );
     const remoteVal = JSON.stringify(remote[field] ?? null);
     if (localVal !== remoteVal) {
       diffs.push({ field, local: localVal, remote: remoteVal });
     }
   }
-  return diffs;
-}
-async function deleteOneTimeOffer(client, packageName, productId, offerId) {
-  try {
-    await client.oneTimeProducts.deleteOffer(packageName, productId, offerId);
-  } catch (error) {
-    throw new GpcError(
-      `Failed to delete offer "${offerId}" for product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
-      "OTP_OFFER_DELETE_FAILED",
-      4,
-      "Check that the product and offer IDs exist."
-    );
+  return diffs;
+}
+async function deleteOneTimeOffer(client, packageName, productId, offerId) {
+  try {
+    await client.oneTimeProducts.deleteOffer(packageName, productId, offerId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to delete offer "${offerId}" for product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_OFFER_DELETE_FAILED",
+      4,
+      "Check that the product and offer IDs exist."
+    );
+  }
+}
+
+// src/utils/spinner.ts
+import process3 from "process";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var INTERVAL_MS = 80;
+function createSpinner(message) {
+  const isTTY = process3.stderr.isTTY === true;
+  let frameIndex = 0;
+  let timer;
+  let currentMessage = message;
+  let started = false;
+  function clearLine() {
+    if (isTTY) {
+      process3.stderr.write("\r\x1B[K");
+    }
+  }
+  function renderFrame() {
+    const frame = FRAMES[frameIndex % FRAMES.length];
+    process3.stderr.write(`\r\x1B[K${frame} ${currentMessage}`);
+    frameIndex++;
+  }
+  return {
+    start() {
+      if (started) return;
+      started = true;
+      if (!isTTY) {
+        process3.stderr.write(`${currentMessage}
+`);
+        return;
+      }
+      renderFrame();
+      timer = setInterval(renderFrame, INTERVAL_MS);
+    },
+    stop(msg) {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      const text = msg ?? currentMessage;
+      if (isTTY) {
+        clearLine();
+        process3.stderr.write(`\u2714 ${text}
+`);
+      } else if (!started) {
+        process3.stderr.write(`${text}
+`);
+      }
+      started = false;
+    },
+    fail(msg) {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      const text = msg ?? currentMessage;
+      if (isTTY) {
+        clearLine();
+        process3.stderr.write(`\u2718 ${text}
+`);
+      } else if (!started) {
+        process3.stderr.write(`${text}
+`);
+      }
+      started = false;
+    },
+    update(msg) {
+      currentMessage = msg;
+      if (!isTTY || !started) return;
+      renderFrame();
+    }
+  };
+}
+
+// src/utils/train-state.ts
+import { mkdir as mkdir3, readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
+import { getCacheDir } from "@gpc-cli/config";
+function stateFile(packageName) {
+  return join5(getCacheDir(), `train-${packageName}.json`);
+}
+async function readTrainState(packageName) {
+  const path = stateFile(packageName);
+  try {
+    const raw = await readFile8(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeTrainState(packageName, state) {
+  const path = stateFile(packageName);
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  await mkdir3(dir, { recursive: true });
+  await writeFile4(path, JSON.stringify(state, null, 2), "utf-8");
+}
+async function clearTrainState(packageName) {
+  const { unlink } = await import("fs/promises");
+  const path = stateFile(packageName);
+  await unlink(path).catch(() => {
+  });
+}
+function parseDuration2(s) {
+  const match = /^(\d+)(d|h|m)$/.exec(s.trim());
+  if (!match) return 0;
+  const n = parseInt(match[1] ?? "0", 10);
+  switch (match[2]) {
+    case "d":
+      return n * 24 * 60 * 60 * 1e3;
+    case "h":
+      return n * 60 * 60 * 1e3;
+    case "m":
+      return n * 60 * 1e3;
+    default:
+      return 0;
+  }
+}
+
+// src/commands/train.ts
+async function startTrain(apiClient, packageName, config, options) {
+  const existing = await readTrainState(packageName);
+  if (existing && existing.status === "running" && !options?.force) {
+    return existing;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const state = {
+    packageName,
+    status: "running",
+    currentStage: 0,
+    startedAt: now,
+    updatedAt: now,
+    stages: config.stages.map((s, i) => ({
+      ...s,
+      scheduledAt: i === 0 ? now : void 0
+    })),
+    gates: config.gates
+  };
+  await writeTrainState(packageName, state);
+  await executeStage(apiClient, packageName, state, 0);
+  return state;
+}
+async function getTrainStatus(packageName) {
+  return readTrainState(packageName);
+}
+async function pauseTrain(packageName) {
+  const state = await readTrainState(packageName);
+  if (!state || state.status !== "running") return state;
+  state.status = "paused";
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeTrainState(packageName, state);
+  return state;
+}
+async function abortTrain(packageName) {
+  await clearTrainState(packageName);
+}
+async function advanceTrain(apiClient, reportingClient, packageName) {
+  const state = await readTrainState(packageName);
+  if (!state || state.status !== "running") return state;
+  const nextStage = state.currentStage + 1;
+  if (nextStage >= state.stages.length) {
+    state.status = "completed";
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeTrainState(packageName, state);
+    return state;
+  }
+  const nextStageConfig = state.stages[nextStage];
+  if (!nextStageConfig) return state;
+  if (nextStageConfig.after) {
+    const delayMs = parseDuration2(nextStageConfig.after);
+    const currentStageConfig = state.stages[state.currentStage];
+    const executedAt = currentStageConfig?.executedAt;
+    if (executedAt && delayMs > 0) {
+      const elapsed = Date.now() - new Date(executedAt).getTime();
+      if (elapsed < delayMs) {
+        const readyAt = new Date(new Date(executedAt).getTime() + delayMs).toISOString();
+        nextStageConfig.scheduledAt = readyAt;
+        await writeTrainState(packageName, state);
+        return state;
+      }
+    }
+  }
+  if (state.gates) {
+    if (state.gates.crashes?.max !== void 0) {
+      const result = await getVitalsCrashes(reportingClient, packageName, { days: 1 });
+      const latestRow = result.rows?.[result.rows.length - 1];
+      const firstMetric = latestRow?.metrics ? Object.keys(latestRow.metrics)[0] : void 0;
+      const value = firstMetric ? Number(latestRow?.metrics[firstMetric]?.decimalValue?.value) : void 0;
+      if (value !== void 0 && value > state.gates.crashes.max / 100) {
+        state.status = "paused";
+        state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await writeTrainState(packageName, state);
+        throw new Error(
+          `Crash gate failed: ${(value * 100).toFixed(3)}% > max ${state.gates.crashes.max}%. Train paused.`
+        );
+      }
+    }
+    if (state.gates.anr?.max !== void 0) {
+      const result = await getVitalsAnr(reportingClient, packageName, { days: 1 });
+      const latestRow = result.rows?.[result.rows.length - 1];
+      const firstMetric = latestRow?.metrics ? Object.keys(latestRow.metrics)[0] : void 0;
+      const value = firstMetric ? Number(latestRow?.metrics[firstMetric]?.decimalValue?.value) : void 0;
+      if (value !== void 0 && value > state.gates.anr.max / 100) {
+        state.status = "paused";
+        state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await writeTrainState(packageName, state);
+        throw new Error(
+          `ANR gate failed: ${(value * 100).toFixed(3)}% > max ${state.gates.anr.max}%. Train paused.`
+        );
+      }
+    }
+  }
+  await executeStage(apiClient, packageName, state, nextStage);
+  return state;
+}
+async function executeStage(apiClient, packageName, state, stageIndex) {
+  const stage = state.stages[stageIndex];
+  if (!stage) throw new Error(`Stage ${stageIndex} not found`);
+  const rolloutFraction = stage.rollout / 100;
+  await updateRollout(apiClient, packageName, stage.track, "increase", rolloutFraction);
+  stage.executedAt = (/* @__PURE__ */ new Date()).toISOString();
+  state.currentStage = stageIndex;
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeTrainState(packageName, state);
+}
+
+// src/commands/games.ts
+async function listLeaderboards(client, packageName) {
+  const result = await client.leaderboards.list(packageName);
+  return result.items ?? [];
+}
+async function listAchievements(client, packageName) {
+  const result = await client.achievements.list(packageName);
+  return result.items ?? [];
+}
+async function listEvents(client, packageName) {
+  const result = await client.events.list(packageName);
+  return result.items ?? [];
+}
+
+// src/commands/enterprise.ts
+async function listEnterpriseApps(client, organizationId) {
+  const result = await client.apps.list(organizationId);
+  return result.customApps ?? [];
+}
+async function createEnterpriseApp(client, organizationId, app) {
+  return client.apps.create(organizationId, app);
+}
+
+// src/audit.ts
+import { appendFile, chmod, mkdir as mkdir4, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
+import { join as join6 } from "path";
+var auditDir = null;
+function initAudit(configDir) {
+  auditDir = configDir;
+}
+async function writeAuditLog(entry) {
+  if (!auditDir) return;
+  try {
+    await mkdir4(auditDir, { recursive: true, mode: 448 });
+    const logPath = join6(auditDir, "audit.log");
+    const redactedEntry = redactAuditArgs(entry);
+    const line = JSON.stringify(redactedEntry) + "\n";
+    await appendFile(logPath, line, { encoding: "utf-8", mode: 384 });
+    await chmod(logPath, 384).catch(() => {
+    });
+  } catch {
+  }
+}
+var SENSITIVE_ARG_KEYS = /* @__PURE__ */ new Set([
+  "keyFile",
+  "key_file",
+  "serviceAccount",
+  "service-account",
+  "token",
+  "password",
+  "secret",
+  "credentials",
+  "private_key",
+  "privateKey",
+  "private_key_id",
+  "privateKeyId",
+  "client_secret",
+  "clientSecret",
+  "accessToken",
+  "access_token",
+  "refreshToken",
+  "refresh_token",
+  "apiKey",
+  "api_key",
+  "auth_token",
+  "bearer",
+  "jwt",
+  "signing_key",
+  "keystore_password",
+  "store_password",
+  "key_password"
+]);
+function redactAuditArgs(entry) {
+  const redacted = {};
+  for (const [k, v] of Object.entries(entry.args)) {
+    redacted[k] = SENSITIVE_ARG_KEYS.has(k) ? "[REDACTED]" : v;
+  }
+  return { ...entry, args: redacted };
+}
+function createAuditEntry(command, args, app) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    command,
+    app,
+    args
+  };
+}
+async function listAuditEvents(options) {
+  if (!auditDir) return [];
+  const logPath = join6(auditDir, "audit.log");
+  let content;
+  try {
+    content = await readFile9(logPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const lines = content.trim().split("\n").filter(Boolean);
+  let entries = [];
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  if (options?.since) {
+    const sinceDate = new Date(options.since).getTime();
+    entries = entries.filter((e) => new Date(e.timestamp).getTime() >= sinceDate);
+  }
+  if (options?.command) {
+    const cmd = options.command.toLowerCase();
+    entries = entries.filter((e) => e.command.toLowerCase().includes(cmd));
+  }
+  if (options?.limit) {
+    entries = entries.slice(-options.limit);
+  }
+  return entries;
+}
+async function searchAuditEvents(query) {
+  const all = await listAuditEvents();
+  const q = query.toLowerCase();
+  return all.filter((e) => {
+    const text = JSON.stringify(e).toLowerCase();
+    return text.includes(q);
+  });
+}
+async function clearAuditLog(options) {
+  if (!auditDir) return { deleted: 0, remaining: 0 };
+  const logPath = join6(auditDir, "audit.log");
+  let content;
+  try {
+    content = await readFile9(logPath, "utf-8");
+  } catch {
+    return { deleted: 0, remaining: 0 };
+  }
+  const lines = content.trim().split("\n").filter(Boolean);
+  if (!options?.before) {
+    const count = lines.length;
+    if (!options?.dryRun) {
+      await writeFile5(logPath, "", { encoding: "utf-8", mode: 384 });
+    }
+    return { deleted: count, remaining: 0 };
+  }
+  const beforeDate = new Date(options.before).getTime();
+  const keep = [];
+  const remove = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (new Date(entry.timestamp).getTime() < beforeDate) {
+        remove.push(line);
+      } else {
+        keep.push(line);
+      }
+    } catch {
+      keep.push(line);
+    }
+  }
+  if (!options?.dryRun) {
+    await writeFile5(logPath, keep.length > 0 ? keep.join("\n") + "\n" : "", {
+      encoding: "utf-8",
+      mode: 384
+    });
   }
+  return { deleted: remove.length, remaining: keep.length };
 }
 
-// src/utils/spinner.ts
-import process3 from "process";
-var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var INTERVAL_MS = 80;
-function createSpinner(message) {
-  const isTTY = process3.stderr.isTTY === true;
-  let frameIndex = 0;
-  let timer;
-  let currentMessage = message;
-  let started = false;
-  function clearLine() {
-    if (isTTY) {
-      process3.stderr.write("\r\x1B[K");
-    }
-  }
-  function renderFrame() {
-    const frame = FRAMES[frameIndex % FRAMES.length];
-    process3.stderr.write(`\r\x1B[K${frame} ${currentMessage}`);
-    frameIndex++;
+// src/commands/quota.ts
+var DAILY_LIMIT = 2e5;
+var MINUTE_LIMIT = 3e3;
+async function getQuotaUsage() {
+  const now = Date.now();
+  const startOfDay = new Date(now);
+  startOfDay.setUTCHours(0, 0, 0, 0);
+  const startOfMinute = new Date(now - 60 * 1e3);
+  const todayEntries = await listAuditEvents({
+    since: startOfDay.toISOString()
+  });
+  const minuteEntries = todayEntries.filter(
+    (e) => new Date(e.timestamp).getTime() >= startOfMinute.getTime()
+  );
+  const commandCounts = /* @__PURE__ */ new Map();
+  for (const entry of todayEntries) {
+    commandCounts.set(entry.command, (commandCounts.get(entry.command) ?? 0) + 1);
   }
+  const topCommands = Array.from(commandCounts.entries()).map(([command, count]) => ({ command, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+  const dailyCallsUsed = todayEntries.length;
+  const minuteCallsUsed = minuteEntries.length;
   return {
-    start() {
-      if (started) return;
-      started = true;
-      if (!isTTY) {
-        process3.stderr.write(`${currentMessage}
-`);
-        return;
-      }
-      renderFrame();
-      timer = setInterval(renderFrame, INTERVAL_MS);
-    },
-    stop(msg) {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-      const text = msg ?? currentMessage;
-      if (isTTY) {
-        clearLine();
-        process3.stderr.write(`\u2714 ${text}
-`);
-      } else if (!started) {
-        process3.stderr.write(`${text}
-`);
-      }
-      started = false;
-    },
-    fail(msg) {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-      const text = msg ?? currentMessage;
-      if (isTTY) {
-        clearLine();
-        process3.stderr.write(`\u2718 ${text}
-`);
-      } else if (!started) {
-        process3.stderr.write(`${text}
-`);
-      }
-      started = false;
-    },
-    update(msg) {
-      currentMessage = msg;
-      if (!isTTY || !started) return;
-      renderFrame();
-    }
+    dailyCallsUsed,
+    dailyCallsLimit: DAILY_LIMIT,
+    dailyCallsRemaining: Math.max(0, DAILY_LIMIT - dailyCallsUsed),
+    minuteCallsUsed,
+    minuteCallsLimit: MINUTE_LIMIT,
+    minuteCallsRemaining: Math.max(0, MINUTE_LIMIT - minuteCallsUsed),
+    topCommands
   };
 }
 
@@ -3326,16 +4319,16 @@ function sortResults(items, sortSpec) {
 }
 
 // src/commands/plugin-scaffold.ts
-import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
+import { join as join7 } from "path";
 async function scaffoldPlugin(options) {
   const { name, dir, description = `GPC plugin: ${name}` } = options;
   const pluginName = name.startsWith("gpc-plugin-") ? name : `gpc-plugin-${name}`;
   const shortName = pluginName.replace(/^gpc-plugin-/, "");
-  const srcDir = join5(dir, "src");
-  const testDir = join5(dir, "tests");
-  await mkdir3(srcDir, { recursive: true });
-  await mkdir3(testDir, { recursive: true });
+  const srcDir = join7(dir, "src");
+  const testDir = join7(dir, "tests");
+  await mkdir5(srcDir, { recursive: true });
+  await mkdir5(testDir, { recursive: true });
   const files = [];
   const pkg = {
     name: pluginName,
@@ -3369,7 +4362,7 @@ async function scaffoldPlugin(options) {
       vitest: "^3.0.0"
     }
   };
-  await writeFile4(join5(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+  await writeFile6(join7(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
   files.push("package.json");
   const tsconfig = {
     compilerOptions: {
@@ -3385,7 +4378,7 @@ async function scaffoldPlugin(options) {
     },
     include: ["src"]
   };
-  await writeFile4(join5(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+  await writeFile6(join7(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
   files.push("tsconfig.json");
   const srcContent = `import { definePlugin } from "@gpc-cli/plugin-sdk";
 import type { CommandEvent, CommandResult } from "@gpc-cli/plugin-sdk";
@@ -3418,7 +4411,7 @@ export const plugin = definePlugin({
   },
 });
 `;
-  await writeFile4(join5(srcDir, "index.ts"), srcContent);
+  await writeFile6(join7(srcDir, "index.ts"), srcContent);
   files.push("src/index.ts");
   const testContent = `import { describe, it, expect, vi } from "vitest";
 import { plugin } from "../src/index";
@@ -3443,154 +4436,11 @@ describe("${pluginName}", () => {
   });
 });
 `;
-  await writeFile4(join5(testDir, "plugin.test.ts"), testContent);
+  await writeFile6(join7(testDir, "plugin.test.ts"), testContent);
   files.push("tests/plugin.test.ts");
   return { dir, files };
 }
 
-// src/audit.ts
-import { appendFile, chmod, mkdir as mkdir4, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
-import { join as join6 } from "path";
-var auditDir = null;
-function initAudit(configDir) {
-  auditDir = configDir;
-}
-async function writeAuditLog(entry) {
-  if (!auditDir) return;
-  try {
-    await mkdir4(auditDir, { recursive: true, mode: 448 });
-    const logPath = join6(auditDir, "audit.log");
-    const redactedEntry = redactAuditArgs(entry);
-    const line = JSON.stringify(redactedEntry) + "\n";
-    await appendFile(logPath, line, { encoding: "utf-8", mode: 384 });
-    await chmod(logPath, 384).catch(() => {
-    });
-  } catch {
-  }
-}
-var SENSITIVE_ARG_KEYS = /* @__PURE__ */ new Set([
-  "keyFile",
-  "key_file",
-  "serviceAccount",
-  "service-account",
-  "token",
-  "password",
-  "secret",
-  "credentials",
-  "private_key",
-  "privateKey",
-  "private_key_id",
-  "privateKeyId",
-  "client_secret",
-  "clientSecret",
-  "accessToken",
-  "access_token",
-  "refreshToken",
-  "refresh_token",
-  "apiKey",
-  "api_key",
-  "auth_token",
-  "bearer",
-  "jwt",
-  "signing_key",
-  "keystore_password",
-  "store_password",
-  "key_password"
-]);
-function redactAuditArgs(entry) {
-  const redacted = {};
-  for (const [k, v] of Object.entries(entry.args)) {
-    redacted[k] = SENSITIVE_ARG_KEYS.has(k) ? "[REDACTED]" : v;
-  }
-  return { ...entry, args: redacted };
-}
-function createAuditEntry(command, args, app) {
-  return {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    command,
-    app,
-    args
-  };
-}
-async function listAuditEvents(options) {
-  if (!auditDir) return [];
-  const logPath = join6(auditDir, "audit.log");
-  let content;
-  try {
-    content = await readFile8(logPath, "utf-8");
-  } catch {
-    return [];
-  }
-  const lines = content.trim().split("\n").filter(Boolean);
-  let entries = [];
-  for (const line of lines) {
-    try {
-      entries.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  if (options?.since) {
-    const sinceDate = new Date(options.since).getTime();
-    entries = entries.filter((e) => new Date(e.timestamp).getTime() >= sinceDate);
-  }
-  if (options?.command) {
-    const cmd = options.command.toLowerCase();
-    entries = entries.filter((e) => e.command.toLowerCase().includes(cmd));
-  }
-  if (options?.limit) {
-    entries = entries.slice(-options.limit);
-  }
-  return entries;
-}
-async function searchAuditEvents(query) {
-  const all = await listAuditEvents();
-  const q = query.toLowerCase();
-  return all.filter((e) => {
-    const text = JSON.stringify(e).toLowerCase();
-    return text.includes(q);
-  });
-}
-async function clearAuditLog(options) {
-  if (!auditDir) return { deleted: 0, remaining: 0 };
-  const logPath = join6(auditDir, "audit.log");
-  let content;
-  try {
-    content = await readFile8(logPath, "utf-8");
-  } catch {
-    return { deleted: 0, remaining: 0 };
-  }
-  const lines = content.trim().split("\n").filter(Boolean);
-  if (!options?.before) {
-    const count = lines.length;
-    if (!options?.dryRun) {
-      await writeFile5(logPath, "", { encoding: "utf-8", mode: 384 });
-    }
-    return { deleted: count, remaining: 0 };
-  }
-  const beforeDate = new Date(options.before).getTime();
-  const keep = [];
-  const remove = [];
-  for (const line of lines) {
-    try {
-      const entry = JSON.parse(line);
-      if (new Date(entry.timestamp).getTime() < beforeDate) {
-        remove.push(line);
-      } else {
-        keep.push(line);
-      }
-    } catch {
-      keep.push(line);
-    }
-  }
-  if (!options?.dryRun) {
-    await writeFile5(logPath, keep.length > 0 ? keep.join("\n") + "\n" : "", {
-      encoding: "utf-8",
-      mode: 384
-    });
-  }
-  return { deleted: remove.length, remaining: keep.length };
-}
-
 // src/utils/webhooks.ts
 function formatSlackPayload(payload) {
   const status = payload.success ? "\u2713" : "\u2717";
@@ -3736,7 +4586,7 @@ function detectFileType(filePath) {
 }
 
 // src/commands/generated-apks.ts
-import { writeFile as writeFile6 } from "fs/promises";
+import { writeFile as writeFile7 } from "fs/promises";
 async function listGeneratedApks(client, packageName, versionCode) {
   if (!Number.isInteger(versionCode) || versionCode <= 0) {
     throw new GpcError(
@@ -3767,7 +4617,7 @@ async function downloadGeneratedApk(client, packageName, versionCode, apkId, out
   }
   const buffer = await client.generatedApks.download(packageName, versionCode, apkId);
   const bytes = new Uint8Array(buffer);
-  await writeFile6(outputPath, bytes);
+  await writeFile7(outputPath, bytes);
   return { path: outputPath, sizeBytes: bytes.byteLength };
 }
 
@@ -3834,17 +4684,19 @@ async function deactivatePurchaseOption(client, packageName, purchaseOptionId) {
 }
 
 // src/commands/bundle-analysis.ts
-import { readFile as readFile9, stat as stat7 } from "fs/promises";
+import { readFile as readFile10, stat as stat7 } from "fs/promises";
 var EOCD_SIGNATURE = 101010256;
 var CD_SIGNATURE = 33639248;
 var MODULE_SUBDIRS = /* @__PURE__ */ new Set(["dex", "manifest", "res", "assets", "lib", "resources.pb", "root"]);
 function detectCategory(path) {
   const lower = path.toLowerCase();
   if (lower.endsWith(".dex") || /\/dex\/[^/]+\.dex$/.test(lower)) return "dex";
-  if (lower === "resources.arsc" || lower.endsWith("/resources.arsc") || lower.endsWith("/resources.pb") || /^(([^/]+\/)?res\/)/.test(lower)) return "resources";
+  if (lower === "resources.arsc" || lower.endsWith("/resources.arsc") || lower.endsWith("/resources.pb") || /^(([^/]+\/)?res\/)/.test(lower))
+    return "resources";
   if (/^(([^/]+\/)?assets\/)/.test(lower)) return "assets";
   if (/^(([^/]+\/)?lib\/)/.test(lower)) return "native-libs";
-  if (lower === "androidmanifest.xml" || lower.endsWith("/androidmanifest.xml") || /^(([^/]+\/)?manifest\/)/.test(lower)) return "manifest";
+  if (lower === "androidmanifest.xml" || lower.endsWith("/androidmanifest.xml") || /^(([^/]+\/)?manifest\/)/.test(lower))
+    return "manifest";
   if (lower.startsWith("meta-inf/") || lower === "meta-inf") return "signing";
   return "other";
 }
@@ -3912,7 +4764,7 @@ async function analyzeBundle(filePath) {
   if (!fileInfo || !fileInfo.isFile()) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const buf = await readFile9(filePath);
+  const buf = await readFile10(filePath);
   const cdEntries = parseCentralDirectory(buf);
   const fileType = detectFileType2(filePath);
   const isAab = fileType === "aab";
@@ -3925,7 +4777,11 @@ async function analyzeBundle(filePath) {
   }));
   const moduleMap = /* @__PURE__ */ new Map();
   for (const entry of entries) {
-    const existing = moduleMap.get(entry.module) ?? { compressedSize: 0, uncompressedSize: 0, entries: 0 };
+    const existing = moduleMap.get(entry.module) ?? {
+      compressedSize: 0,
+      uncompressedSize: 0,
+      entries: 0
+    };
     existing.compressedSize += entry.compressedSize;
     existing.uncompressedSize += entry.uncompressedSize;
     existing.entries += 1;
@@ -3933,7 +4789,11 @@ async function analyzeBundle(filePath) {
   }
   const categoryMap = /* @__PURE__ */ new Map();
   for (const entry of entries) {
-    const existing = categoryMap.get(entry.category) ?? { compressedSize: 0, uncompressedSize: 0, entries: 0 };
+    const existing = categoryMap.get(entry.category) ?? {
+      compressedSize: 0,
+      uncompressedSize: 0,
+      entries: 0
+    };
     existing.compressedSize += entry.compressedSize;
     existing.uncompressedSize += entry.uncompressedSize;
     existing.entries += 1;
@@ -3984,19 +4844,52 @@ function compareBundles(before, after) {
     categoryDeltas
   };
 }
+function topFiles(analysis, n = 20) {
+  return [...analysis.entries].sort((a, b) => b.compressedSize - a.compressedSize).slice(0, n);
+}
+async function checkBundleSize(analysis, configPath = ".bundlesize.json") {
+  let config;
+  try {
+    const raw = await readFile10(configPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    return { passed: true, violations: [] };
+  }
+  const violations = [];
+  if (config.maxTotalCompressed !== void 0 && analysis.totalCompressed > config.maxTotalCompressed) {
+    violations.push({
+      subject: "total",
+      actual: analysis.totalCompressed,
+      max: config.maxTotalCompressed
+    });
+  }
+  if (config.modules) {
+    for (const [moduleName, threshold] of Object.entries(config.modules)) {
+      const mod = analysis.modules.find((m) => m.name === moduleName);
+      if (mod && mod.compressedSize > threshold.maxCompressed) {
+        violations.push({
+          subject: `module:${moduleName}`,
+          actual: mod.compressedSize,
+          max: threshold.maxCompressed
+        });
+      }
+    }
+  }
+  return { passed: violations.length === 0, violations };
+}
 
 // src/commands/status.ts
-import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
-import { execSync } from "child_process";
-import { join as join7 } from "path";
-import { getCacheDir } from "@gpc-cli/config";
+import { mkdir as mkdir6, readFile as readFile11, writeFile as writeFile8 } from "fs/promises";
+import { execFile as execFile2 } from "child_process";
+import { join as join8 } from "path";
+import { getCacheDir as getCacheDir2 } from "@gpc-cli/config";
 var DEFAULT_TTL_SECONDS = 3600;
 function cacheFilePath(packageName) {
-  return join7(getCacheDir(), `status-${packageName}.json`);
+  return join8(getCacheDir2(), `status-${packageName}.json`);
 }
 async function loadStatusCache(packageName, ttlSeconds = DEFAULT_TTL_SECONDS) {
   try {
-    const raw = await readFile10(cacheFilePath(packageName), "utf-8");
+    const raw = await readFile11(cacheFilePath(packageName), "utf-8");
     const entry = JSON.parse(raw);
     const age = (Date.now() - new Date(entry.fetchedAt).getTime()) / 1e3;
     if (age > (entry.ttl ?? ttlSeconds)) return null;
@@ -4012,10 +4905,10 @@ async function loadStatusCache(packageName, ttlSeconds = DEFAULT_TTL_SECONDS) {
 }
 async function saveStatusCache(packageName, data, ttlSeconds = DEFAULT_TTL_SECONDS) {
   try {
-    const dir = getCacheDir();
-    await mkdir5(dir, { recursive: true });
+    const dir = getCacheDir2();
+    await mkdir6(dir, { recursive: true });
     const entry = { fetchedAt: data.fetchedAt, ttl: ttlSeconds, data };
-    await writeFile7(cacheFilePath(packageName), JSON.stringify(entry, null, 2), {
+    await writeFile8(cacheFilePath(packageName), JSON.stringify(entry, null, 2), {
       encoding: "utf-8",
       mode: 384
     });
@@ -4126,7 +5019,14 @@ async function getAppStatus(client, reporting, packageName, options = {}) {
     slowStartRate: options.vitalThresholds?.slowStartRate ?? DEFAULT_THRESHOLDS.slowStartRate,
     slowRenderingRate: options.vitalThresholds?.slowRenderingRate ?? DEFAULT_THRESHOLDS.slowRenderingRate
   };
-  const [releasesResult, crashesResult, anrResult, slowStartResult, slowRenderResult, reviewsResult] = await Promise.allSettled([
+  const [
+    releasesResult,
+    crashesResult,
+    anrResult,
+    slowStartResult,
+    slowRenderResult,
+    reviewsResult
+  ] = await Promise.allSettled([
     sections.has("releases") ? getReleasesStatus(client, packageName) : Promise.resolve([]),
     sections.has("vitals") ? queryVitalWithTrend(reporting, packageName, "crashRateMetricSet", days) : Promise.resolve(SKIPPED_VITAL),
     sections.has("vitals") ? queryVitalWithTrend(reporting, packageName, "anrRateMetricSet", days) : Promise.resolve(SKIPPED_VITAL),
@@ -4155,7 +5055,12 @@ async function getAppStatus(client, reporting, packageName, options = {}) {
     releases,
     vitals: {
       windowDays: days,
-      crashes: toVitalMetric(crashes.current, thresholds.crashRate, crashes.previous, crashes.trend),
+      crashes: toVitalMetric(
+        crashes.current,
+        thresholds.crashRate,
+        crashes.previous,
+        crashes.trend
+      ),
       anr: toVitalMetric(anr.current, thresholds.anrRate, anr.previous, anr.trend),
       slowStarts: toVitalMetric(
         slowStart.current,
@@ -4380,20 +5285,20 @@ async function runWatchLoop(opts) {
   }
 }
 function breachStateFilePath(packageName) {
-  return join7(getCacheDir(), `breach-state-${packageName}.json`);
+  return join8(getCacheDir2(), `breach-state-${packageName}.json`);
 }
 async function trackBreachState(packageName, isBreaching) {
   const filePath = breachStateFilePath(packageName);
   let prevBreaching = false;
   try {
-    const raw = await readFile10(filePath, "utf-8");
+    const raw = await readFile11(filePath, "utf-8");
     prevBreaching = JSON.parse(raw).breaching;
   } catch {
   }
   if (prevBreaching !== isBreaching) {
     try {
-      await mkdir5(getCacheDir(), { recursive: true });
-      await writeFile7(
+      await mkdir6(getCacheDir2(), { recursive: true });
+      await writeFile8(
         filePath,
         JSON.stringify({ breaching: isBreaching, since: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
         { encoding: "utf-8", mode: 384 }
@@ -4409,20 +5314,20 @@ function sendNotification(title, body) {
   try {
     const p = process.platform;
     if (p === "darwin") {
-      execSync(
-        `osascript -e 'display notification ${JSON.stringify(body)} with title ${JSON.stringify(title)}'`,
-        { stdio: "ignore" }
-      );
+      execFile2("osascript", [
+        "-e",
+        `display notification ${JSON.stringify(body)} with title ${JSON.stringify(title)}`
+      ]);
     } else if (p === "linux") {
-      execSync(`notify-send ${JSON.stringify(title)} ${JSON.stringify(body)}`, {
-        stdio: "ignore"
-      });
+      execFile2("notify-send", [title, body]);
     } else if (p === "win32") {
-      const escaped = (s) => s.replace(/'/g, "''");
-      execSync(
-        `powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('${escaped(body)}', '${escaped(title)}')"`,
-        { stdio: "ignore" }
-      );
+      const psEscape = (s) => s.replace(/'/g, "''").replace(/[\r\n]/g, " ");
+      execFile2("powershell", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show('${psEscape(body)}', '${psEscape(title)}')`
+      ]);
     }
   } catch {
   }
@@ -4433,6 +5338,7 @@ function statusHasBreach(status) {
 export {
   ApiError,
   ConfigError,
+  DEFAULT_LIMITS,
   GOOGLE_PLAY_LANGUAGES,
   GpcError,
   NetworkError,
@@ -4440,26 +5346,34 @@ export {
   PluginManager,
   SENSITIVE_ARG_KEYS,
   SENSITIVE_KEYS,
+  abortTrain,
   acknowledgeProductPurchase,
   activateBasePlan,
   activateOffer,
   activatePurchaseOption,
   addRecoveryTargeting,
   addTesters,
+  advanceTrain,
   analyzeBundle,
+  analyzeRemoteListings,
+  analyzeReviews2 as analyzeReviews,
   batchSyncInAppProducts,
   cancelRecoveryAction,
   cancelSubscriptionPurchase,
+  checkBundleSize,
   checkThreshold,
   clearAuditLog,
   compareBundles,
+  compareVersionVitals,
   compareVitalsTrend,
   computeStatusDiff,
   consumeProductPurchase,
   convertRegionPrices,
   createAuditEntry,
   createDeviceTier,
+  createEnterpriseApp,
   createExternalTransaction,
+  createGrant,
   createInAppProduct,
   createOffer,
   createOneTimeOffer,
@@ -4474,6 +5388,7 @@ export {
   deactivatePurchaseOption,
   deferSubscriptionPurchase,
   deleteBasePlan,
+  deleteGrant,
   deleteImage,
   deleteInAppProduct,
   deleteListing,
@@ -4486,6 +5401,7 @@ export {
   detectOutputFormat,
   diffListings,
   diffListingsCommand,
+  diffListingsEnhanced,
   diffOneTimeProduct,
   diffReleases,
   diffSubscription,
@@ -4503,6 +5419,7 @@ export {
   formatStatusDiff,
   formatStatusSummary,
   formatStatusTable,
+  formatWordDiff,
   generateMigrationPlan,
   generateNotesFromGit,
   getAppInfo,
@@ -4518,15 +5435,19 @@ export {
   getOneTimeProduct,
   getProductPurchase,
   getPurchaseOption,
+  getQuotaUsage,
   getReleasesStatus,
   getReview,
   getSubscription,
+  getSubscriptionAnalytics,
   getSubscriptionPurchase,
+  getTrainStatus,
   getUser,
   getVitalsAnomalies,
   getVitalsAnr,
   getVitalsBattery,
   getVitalsCrashes,
+  getVitalsLmk,
   getVitalsMemory,
   getVitalsOverview,
   getVitalsRendering,
@@ -4540,11 +5461,19 @@ export {
   isValidBcp47,
   isValidReportType,
   isValidStatsDimension,
+  lintListing,
+  lintListings,
+  lintLocalListings,
+  listAchievements,
   listAuditEvents,
   listDeviceTiers,
+  listEnterpriseApps,
+  listEvents,
   listGeneratedApks,
+  listGrants,
   listImages,
   listInAppProducts,
+  listLeaderboards,
   listOffers,
   listOneTimeOffers,
   listOneTimeProducts,
@@ -4558,11 +5487,13 @@ export {
   listUsers,
   listVoidedPurchases,
   loadStatusCache,
+  maybePaginate,
   migratePrices,
   parseAppfile,
   parseFastfile,
   parseGrantArg,
   parseMonth,
+  pauseTrain,
   promoteRelease,
   publish,
   pullListings,
@@ -4573,6 +5504,7 @@ export {
   redactSensitive,
   refundExternalTransaction,
   refundOrder,
+  refundSubscriptionV2,
   removeTesters,
   removeUser,
   replyToReview,
@@ -4587,11 +5519,14 @@ export {
   sendNotification,
   sendWebhook,
   sortResults,
+  startTrain,
   statusHasBreach,
   syncInAppProducts,
+  topFiles,
   trackBreachState,
   updateAppDetails,
   updateDataSafety,
+  updateGrant,
   updateInAppProduct,
   updateListing,
   updateOffer,
@@ -4614,6 +5549,8 @@ export {
   validateTrackName,
   validateUploadFile,
   validateVersionCode,
+  watchVitalsWithAutoHalt,
+  wordDiff,
   writeAuditLog,
   writeListingsToDir,
   writeMigrationOutput