mobile-growth-mcp 2.0.8 → 2.2.1

package/dist/index.js

@@ -116,9 +116,9 @@ async function getRemotePrompt(apiKey2, name, args) {
   return resp.result?.messages ?? [];
 }
 function registerFetchedPrompts(server2, apiKey2, prompts) {
-  for (const prompt of prompts) {
+  for (const prompt2 of prompts) {
     const zodShape = {};
-    for (const arg of prompt.arguments) {
+    for (const arg of prompt2.arguments) {
       let field = z.string().describe(arg.description);
       if (!arg.required) {
         field = field.optional();
@@ -126,13 +126,13 @@ function registerFetchedPrompts(server2, apiKey2, prompts) {
       zodShape[arg.name] = field;
     }
     server2.prompt(
-      prompt.name,
-      prompt.description,
+      prompt2.name,
+      prompt2.description,
       zodShape,
       async (args) => {
         const messages = await getRemotePrompt(
           apiKey2,
-          prompt.name,
+          prompt2.name,
           args
         );
         return {
@@ -160,7 +160,7 @@ function getMetaAccessToken() {
   const token = process.env.META_ACCESS_TOKEN;
   if (!token) {
     throw new Error(
-      "Missing META_ACCESS_TOKEN environment variable. Provide a Meta Marketing API access token to use Meta tools."
+      'Missing META_ACCESS_TOKEN. To fix, add it to your MCP config:\n  \u2022 Claude Code / Cursor: add "META_ACCESS_TOKEN": "..." to the "env" block in .mcp.json\n  \u2022 Claude Desktop: add "META_ACCESS_TOKEN": "..." to the "env" block in claude_desktop_config.json\n  \u2022 CLI: add META_ACCESS_TOKEN=... to a .env file in your working directory\nThen restart your MCP client.'
     );
   }
   return token;
@@ -643,15 +643,22 @@ function registerGetMetaAdFatigue(server2) {
         const freqWarn = frequency_warning ?? 3;
         const freqCrit = frequency_critical ?? 5;
         const ctrThreshold = ctr_decline_threshold ?? 30;
-        const parentPath = campaign_id ? `/${campaign_id}/insights` : `/${ad_account_id}/insights`;
+        const filtering = JSON.parse(activeFilter());
+        if (campaign_id) {
+          filtering.push({
+            field: "campaign.id",
+            operator: "EQUAL",
+            value: campaign_id
+          });
+        }
         const result = await metaApiGet({
-          path: parentPath,
+          path: `/${ad_account_id}/insights`,
           params: {
             level: "ad",
             time_increment: "1",
             fields: "ad_id,ad_name,spend,impressions,clicks,ctr,cpm,frequency,actions,cost_per_action_type",
             date_preset: "last_7d",
-            filtering: activeFilter(),
+            filtering: JSON.stringify(filtering),
             limit: "500"
           }
         });
@@ -819,6 +826,1301 @@ ${text}`;
   );
 }
 
+// src/tools/google-campaigns.ts
+import { z as z7 } from "zod";
+
+// src/google/oauth.ts
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var EXPIRY_SAFETY_MARGIN_MS = 6e4;
+function createGoogleAdsAuth(config) {
+  let cached;
+  async function refreshAccessToken() {
+    const body = new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      refresh_token: config.refreshToken
+    });
+    const response = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(
+        `Google OAuth token refresh failed (${response.status}): ${text}. Your refresh token may be expired \u2014 run \`npx mobile-growth-mcp auth google\` to re-authorize.`
+      );
+    }
+    const data = await response.json();
+    return {
+      accessToken: data.access_token,
+      expiresAt: Date.now() + data.expires_in * 1e3 - EXPIRY_SAFETY_MARGIN_MS
+    };
+  }
+  async function getAccessToken() {
+    if (!cached || Date.now() >= cached.expiresAt) {
+      cached = await refreshAccessToken();
+    }
+    return cached.accessToken;
+  }
+  async function getHeaders(customerId) {
+    const token = await getAccessToken();
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      "developer-token": config.developerToken
+    };
+    if (config.loginCustomerId) {
+      headers["login-customer-id"] = config.loginCustomerId.replace(/-/g, "");
+    }
+    return headers;
+  }
+  return { getAccessToken, getHeaders };
+}
+
+// src/google/client.ts
+var API_VERSION = "v19";
+var BASE_URL = `https://googleads.googleapis.com/${API_VERSION}`;
+var authSingleton;
+function getGoogleAdsAuth() {
+  if (authSingleton) return authSingleton;
+  const developerToken = process.env.GOOGLE_ADS_DEVELOPER_TOKEN;
+  const clientId = process.env.GOOGLE_ADS_CLIENT_ID;
+  const clientSecret = process.env.GOOGLE_ADS_CLIENT_SECRET;
+  const refreshToken = process.env.GOOGLE_ADS_REFRESH_TOKEN;
+  const loginCustomerId = process.env.GOOGLE_ADS_LOGIN_CUSTOMER_ID;
+  if (!developerToken || !clientId || !clientSecret || !refreshToken) {
+    throw new Error(
+      'Google Ads is not configured. To fix:\n  1. Run `npx mobile-growth-mcp auth google` to set up credentials (saves to .env)\n  2. Or add GOOGLE_ADS_* vars to the "env" block in your MCP config (.mcp.json or claude_desktop_config.json)\nThen restart your MCP client.'
+    );
+  }
+  const config = {
+    developerToken,
+    clientId,
+    clientSecret,
+    refreshToken,
+    loginCustomerId
+  };
+  authSingleton = createGoogleAdsAuth(config);
+  return authSingleton;
+}
+function normalizeCustomerId(customerId) {
+  return customerId.replace(/-/g, "");
+}
+function isGoogleAdsError(body) {
+  return typeof body === "object" && body !== null && "error" in body && typeof body.error?.message === "string";
+}
+function formatGoogleAdsError(err) {
+  const code = err.code;
+  if (code === 401) {
+    return "Authentication error: Your Google Ads credentials are invalid or expired. Run `npx mobile-growth-mcp auth google` to re-authorize.";
+  }
+  if (code === 403) {
+    return `Permission denied: ${err.message}. Check that your developer token is approved and the account ID is correct.`;
+  }
+  if (code === 429) {
+    return `Rate limit hit: ${err.message}. Wait a few minutes before retrying.`;
+  }
+  if (code === 400 && err.details?.length) {
+    const gaqlErrors = err.details.flatMap((d) => d.errors ?? []).map((e) => e.message).join("; ");
+    if (gaqlErrors) {
+      return `Invalid query: ${gaqlErrors}`;
+    }
+  }
+  return `Google Ads API error (${code}): ${err.message}`;
+}
+async function googleAdsQuery(customerId, query) {
+  const auth = getGoogleAdsAuth();
+  const normalizedId = normalizeCustomerId(customerId);
+  const headers = await auth.getHeaders(normalizedId);
+  const url = `${BASE_URL}/customers/${normalizedId}/googleAds:searchStream`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      ...headers,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ query })
+  });
+  const body = await response.json();
+  if (!response.ok) {
+    if (isGoogleAdsError(body)) {
+      throw new Error(formatGoogleAdsError(body.error));
+    }
+    throw new Error(
+      `Google Ads API returned ${response.status}: ${JSON.stringify(body)}`
+    );
+  }
+  if (Array.isArray(body)) {
+    return body;
+  }
+  return [body];
+}
+
+// src/google/format.ts
+function formatMicros(micros) {
+  if (!micros) return "\u2014";
+  const val = parseInt(micros, 10);
+  if (isNaN(val)) return "\u2014";
+  return `$${(val / 1e6).toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function formatPct(value) {
+  return `${value.toFixed(2)}%`;
+}
+function formatCompact(value) {
+  if (value >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  if (value >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
+  return value.toString();
+}
+function datePresetToRange(preset) {
+  const now = /* @__PURE__ */ new Date();
+  const fmt = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+  switch (preset) {
+    case "LAST_7_DAYS": {
+      const end = new Date(now);
+      end.setDate(end.getDate() - 1);
+      const start = new Date(end);
+      start.setDate(start.getDate() - 6);
+      return { start: fmt(start), end: fmt(end) };
+    }
+    case "LAST_14_DAYS": {
+      const end = new Date(now);
+      end.setDate(end.getDate() - 1);
+      const start = new Date(end);
+      start.setDate(start.getDate() - 13);
+      return { start: fmt(start), end: fmt(end) };
+    }
+    case "LAST_30_DAYS": {
+      const end = new Date(now);
+      end.setDate(end.getDate() - 1);
+      const start = new Date(end);
+      start.setDate(start.getDate() - 29);
+      return { start: fmt(start), end: fmt(end) };
+    }
+    case "THIS_MONTH": {
+      const start = new Date(now.getFullYear(), now.getMonth(), 1);
+      const end = new Date(now);
+      end.setDate(end.getDate() - 1);
+      return { start: fmt(start), end: fmt(end) };
+    }
+    case "LAST_MONTH": {
+      const start = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+      const end = new Date(now.getFullYear(), now.getMonth(), 0);
+      return { start: fmt(start), end: fmt(end) };
+    }
+    default:
+      return datePresetToRange("LAST_7_DAYS");
+  }
+}
+
+// src/tools/google-campaigns.ts
+function channelSubTypeLabel(subType) {
+  if (subType === "APP_CAMPAIGN") return "ACi";
+  if (subType === "APP_CAMPAIGN_FOR_ENGAGEMENT") return "ACe";
+  return subType ?? "\u2014";
+}
+function appStoreLabel(appStore) {
+  if (appStore === "APPLE_APP_STORE") return "iOS";
+  if (appStore === "GOOGLE_APP_STORE") return "Android";
+  return appStore ?? "";
+}
+function formatTarget(row) {
+  const c = row.campaign;
+  if (!c) return "\u2014";
+  if (c.targetCpa?.targetCpaMicros) {
+    return formatMicros(c.targetCpa.targetCpaMicros);
+  }
+  if (c.targetRoas?.targetRoas !== void 0) {
+    return `${(c.targetRoas.targetRoas * 100).toFixed(0)}%`;
+  }
+  return "\u2014";
+}
+function registerGetGoogleAdsCampaigns(server2) {
+  server2.tool(
+    "get_google_ads_campaigns",
+    "List Google App Campaigns with status, bid strategy, budgets, and app info. Campaign naming conventions encode dimensions (app, event, country, OS) \u2014 surface the raw name for parsing. Requires Google Ads credentials \u2014 run `npx mobile-growth-mcp auth google` to set up.",
+    {
+      customer_id: z7.string().describe("Google Ads customer ID (e.g. 123-456-7890 or 1234567890)"),
+      status: z7.array(z7.enum(["ENABLED", "PAUSED", "REMOVED"])).optional().describe('Filter by campaign status. Default: ["ENABLED"]'),
+      channel_sub_type: z7.array(z7.enum(["APP_CAMPAIGN", "APP_CAMPAIGN_FOR_ENGAGEMENT"])).optional().describe('Filter by sub-type. Default: ["APP_CAMPAIGN", "APP_CAMPAIGN_FOR_ENGAGEMENT"]. Set to include all app campaign types'),
+      limit: z7.number().min(1).max(100).optional().describe("Max campaigns to return (default 50)")
+    },
+    async ({ customer_id, status: status2, channel_sub_type, limit }) => {
+      try {
+        const statuses = status2 ?? ["ENABLED"];
+        const subTypes = channel_sub_type ?? ["APP_CAMPAIGN", "APP_CAMPAIGN_FOR_ENGAGEMENT"];
+        const rowLimit = limit ?? 50;
+        const statusList = statuses.map((s) => `'${s}'`).join(", ");
+        const subTypeList = subTypes.map((s) => `'${s}'`).join(", ");
+        const query = `
+          SELECT
+            campaign.id,
+            campaign.name,
+            campaign.status,
+            campaign.advertising_channel_type,
+            campaign.advertising_channel_sub_type,
+            campaign.bidding_strategy_type,
+            campaign.target_cpa.target_cpa_micros,
+            campaign.target_roas.target_roas,
+            campaign.campaign_budget,
+            campaign_budget.amount_micros,
+            campaign_budget.type,
+            campaign.app_campaign_setting.app_id,
+            campaign.app_campaign_setting.app_store,
+            campaign.app_campaign_setting.bidding_strategy_goal_type,
+            campaign.start_date,
+            campaign.end_date
+          FROM campaign
+          WHERE campaign.advertising_channel_type = 'MULTI_CHANNEL'
+            AND campaign.advertising_channel_sub_type IN (${subTypeList})
+            AND campaign.status IN (${statusList})
+          LIMIT ${rowLimit}
+        `;
+        const chunks = await googleAdsQuery(customer_id, query);
+        const rows = chunks.flatMap((c) => c.results ?? []);
+        if (rows.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No campaigns found matching filters. Try expanding status filter to include PAUSED."
+              }
+            ]
+          };
+        }
+        const header = `## Google Campaigns (${rows.length} found)
+
+`;
+        const tableHeader = "| Campaign | Status | Type | Bid Strategy | Target | Daily Budget | App |\n|---|---|---|---|---|---|---|\n";
+        let tableRows = "";
+        for (const row of rows) {
+          const c = row.campaign;
+          if (!c) continue;
+          const budget = row.campaignBudget?.amountMicros ? formatMicros(row.campaignBudget.amountMicros) : "\u2014";
+          const budgetType = row.campaignBudget?.type;
+          const budgetDisplay = budgetType === "TOTAL" ? `${budget} (lifetime)` : budget;
+          const appId = c.appCampaignSetting?.appId ?? "";
+          const store = appStoreLabel(c.appCampaignSetting?.appStore);
+          const appDisplay = appId ? `${appId} (${store})` : "\u2014";
+          tableRows += `| ${c.name} | ${c.status} | ${channelSubTypeLabel(c.advertisingChannelSubType)} | ${c.biddingStrategyType ?? "\u2014"} | ${formatTarget(row)} | ${budgetDisplay} | ${appDisplay} |
+`;
+        }
+        return {
+          content: [{ type: "text", text: header + tableHeader + tableRows }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/google-ad-groups.ts
+import { z as z8 } from "zod";
+function registerGetGoogleAdsAdGroups(server2) {
+  server2.tool(
+    "get_google_ad_groups",
+    "List ad groups within Google App Campaigns. In UAC, ad groups represent creative themes (e.g. 'at_home_workouts'). The algorithm allocates spend across ad groups based on which themes resonate \u2014 observe spend distribution to identify winning messaging angles. To scale, add new ad groups with different text-asset strategies rather than aggressively increasing bids (ab-pt-006).",
+    {
+      customer_id: z8.string().describe("Google Ads customer ID (e.g. 123-456-7890 or 1234567890)"),
+      campaign_id: z8.string().optional().describe("Scope to a specific campaign. If omitted, returns ad groups across all app campaigns"),
+      status: z8.array(z8.enum(["ENABLED", "PAUSED", "REMOVED"])).optional().describe('Filter by ad group status. Default: ["ENABLED"]'),
+      limit: z8.number().min(1).max(100).optional().describe("Max results to return (default 50)")
+    },
+    async ({ customer_id, campaign_id, status: status2, limit }) => {
+      try {
+        const statuses = status2 ?? ["ENABLED"];
+        const rowLimit = limit ?? 50;
+        const statusList = statuses.map((s) => `'${s}'`).join(", ");
+        let whereClause = `WHERE campaign.advertising_channel_sub_type IN ('APP_CAMPAIGN', 'APP_CAMPAIGN_FOR_ENGAGEMENT')
+  AND ad_group.status IN (${statusList})`;
+        if (campaign_id) {
+          whereClause += `
+  AND campaign.id = ${campaign_id}`;
+        }
+        const query = `
+          SELECT
+            ad_group.id,
+            ad_group.name,
+            ad_group.status,
+            ad_group.type,
+            campaign.id,
+            campaign.name,
+            campaign.status
+          FROM ad_group
+          ${whereClause}
+          LIMIT ${rowLimit}
+        `;
+        const chunks = await googleAdsQuery(customer_id, query);
+        const rows = chunks.flatMap((c) => c.results ?? []);
+        if (rows.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No ad groups found matching filters. Try expanding status filter to include PAUSED."
+              }
+            ]
+          };
+        }
+        const campaignName = campaign_id && rows[0]?.campaign?.name ? ` for "${rows[0].campaign.name}"` : "";
+        const header = `## Ad Groups${campaignName} (${rows.length} found)
+
+`;
+        const tableHeader = "| Ad Group | Status | Type | Campaign |\n|---|---|---|---|\n";
+        let tableRows = "";
+        for (const row of rows) {
+          const ag = row.adGroup;
+          const c = row.campaign;
+          if (!ag) continue;
+          tableRows += `| ${ag.name} | ${ag.status ?? "\u2014"} | ${ag.type ?? "\u2014"} | ${c?.name ?? "\u2014"} |
+`;
+        }
+        return {
+          content: [{ type: "text", text: header + tableHeader + tableRows }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/google-assets.ts
+import { z as z9 } from "zod";
+var SLOT_LIMITS = {
+  HEADLINE: 5,
+  DESCRIPTION: 5,
+  IMAGE: 20,
+  YOUTUBE_VIDEO: 20,
+  MEDIA_BUNDLE: 20
+};
+function classifyOrientation(w, h) {
+  if (!w || !h) return "unknown";
+  if (w > h * 1.05) return "landscape";
+  if (h > w * 1.05) return "portrait";
+  return "square";
+}
+function registerGetGoogleAdsAssets(server2) {
+  server2.tool(
+    "get_google_assets",
+    "List creative assets linked to a campaign or ad group with metadata, performance labels, and slot utilization audit. Google allows up to 5 headlines, 5 descriptions, 20 images, 20 videos, 20 HTML5 per ad group. Missing asset types mean missing inventory channels. Google's built-in asset ratings (Low/Good/Best) measure scalability, not conversion value \u2014 evaluate by your own CPA/ROAS (ab-pt-008).",
+    {
+      customer_id: z9.string().describe("Google Ads customer ID"),
+      campaign_id: z9.string().optional().describe("Scope to a specific campaign"),
+      ad_group_id: z9.string().optional().describe("Scope to a specific ad group"),
+      asset_type: z9.array(z9.enum(["IMAGE", "YOUTUBE_VIDEO", "TEXT", "MEDIA_BUNDLE"])).optional().describe("Filter by asset type"),
+      include_slot_audit: z9.boolean().optional().describe("Include slot utilization audit (default true)"),
+      limit: z9.number().min(1).max(500).optional().describe("Max results to return (default 50)")
+    },
+    async ({ customer_id, campaign_id, ad_group_id, asset_type, include_slot_audit, limit }) => {
+      try {
+        const rowLimit = limit ?? 50;
+        const showAudit = include_slot_audit !== false;
+        const conditions = [
+          "campaign.status = 'ENABLED'"
+        ];
+        if (campaign_id) conditions.push(`campaign.id = ${campaign_id}`);
+        if (ad_group_id) conditions.push(`ad_group.id = ${ad_group_id}`);
+        if (asset_type?.length) {
+          const typeList = asset_type.map((t) => `'${t}'`).join(", ");
+          conditions.push(`asset.type IN (${typeList})`);
+        }
+        const query = `
+          SELECT
+            asset.id,
+            asset.name,
+            asset.type,
+            asset.text_asset.text,
+            asset.image_asset.full_size.url,
+            asset.image_asset.full_size.width_pixels,
+            asset.image_asset.full_size.height_pixels,
+            asset.youtube_video_asset.youtube_video_id,
+            asset.youtube_video_asset.youtube_video_title,
+            ad_group_ad_asset_view.field_type,
+            ad_group_ad_asset_view.performance_label,
+            ad_group.id,
+            ad_group.name,
+            campaign.id,
+            campaign.name
+          FROM ad_group_ad_asset_view
+          WHERE ${conditions.join("\n  AND ")}
+          LIMIT ${rowLimit}
+        `;
+        const chunks = await googleAdsQuery(customer_id, query);
+        const rows = chunks.flatMap((c) => c.results ?? []);
+        if (rows.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: "No assets found matching filters."
+            }]
+          };
+        }
+        const assets = rows.filter((r) => r.asset).map((r) => ({
+          asset: r.asset,
+          fieldType: r.adGroupAdAssetView?.fieldType ?? "\u2014",
+          performanceLabel: r.adGroupAdAssetView?.performanceLabel ?? "\u2014",
+          adGroupName: r.adGroup?.name ?? "\u2014"
+        }));
+        const textAssets = assets.filter((a) => a.asset.type === "TEXT");
+        const imageAssets = assets.filter((a) => a.asset.type === "IMAGE");
+        const videoAssets = assets.filter((a) => a.asset.type === "YOUTUBE_VIDEO");
+        const bundleAssets = assets.filter((a) => a.asset.type === "MEDIA_BUNDLE");
+        const campaignName = rows[0]?.campaign?.name ?? "Unknown Campaign";
+        const adGroupName = ad_group_id && rows[0]?.adGroup?.name ? ` / "${rows[0].adGroup.name}"` : "";
+        let text = `## Assets for "${campaignName}"${adGroupName} (${assets.length} found)
+
+`;
+        if (textAssets.length > 0) {
+          text += "### Text Assets\n";
+          text += "| Asset | Field | Content | Label |\n|---|---|---|---|\n";
+          for (const a of textAssets) {
+            const content = a.asset.textAsset?.text ?? "\u2014";
+            text += `| ${a.asset.name} | ${a.fieldType} | ${content} | ${a.performanceLabel} |
+`;
+          }
+          text += "\n";
+        }
+        if (imageAssets.length > 0) {
+          text += "### Image Assets\n";
+          text += "| Asset | Dimensions | Ratio | Label |\n|---|---|---|---|\n";
+          for (const a of imageAssets) {
+            const img = a.asset.imageAsset?.fullSize;
+            const w = img?.widthPixels;
+            const h = img?.heightPixels;
+            const dims = w && h ? `${w}x${h}` : "\u2014";
+            const ratio = w && h ? `${(w / h).toFixed(2)}:1` : "\u2014";
+            text += `| ${a.asset.name} | ${dims} | ${ratio} | ${a.performanceLabel} |
+`;
+          }
+          text += "\n";
+        }
+        if (videoAssets.length > 0) {
+          text += "### Video Assets\n";
+          text += "| Asset | YouTube ID | Title | Label |\n|---|---|---|---|\n";
+          for (const a of videoAssets) {
+            const yt = a.asset.youtubeVideoAsset;
+            text += `| ${a.asset.name} | ${yt?.youtubeVideoId ?? "\u2014"} | ${yt?.youtubeVideoTitle ?? "\u2014"} | ${a.performanceLabel} |
+`;
+          }
+          text += "\n";
+        }
+        if (bundleAssets.length > 0) {
+          text += "### HTML5 Assets\n";
+          text += "| Asset | Field | Label |\n|---|---|---|\n";
+          for (const a of bundleAssets) {
+            text += `| ${a.asset.name} | ${a.fieldType} | ${a.performanceLabel} |
+`;
+          }
+          text += "\n";
+        }
+        if (showAudit) {
+          const adGroups = /* @__PURE__ */ new Map();
+          for (const a of assets) {
+            const key = a.adGroupName;
+            if (!adGroups.has(key)) adGroups.set(key, []);
+            adGroups.get(key).push(a);
+          }
+          for (const [agName, agAssets] of adGroups) {
+            const headlines = agAssets.filter((a) => a.fieldType === "HEADLINE");
+            const descriptions = agAssets.filter((a) => a.fieldType === "DESCRIPTION");
+            const images = agAssets.filter((a) => a.asset.type === "IMAGE");
+            const videos = agAssets.filter((a) => a.asset.type === "YOUTUBE_VIDEO");
+            const html5 = agAssets.filter((a) => a.asset.type === "MEDIA_BUNDLE");
+            const orientations = /* @__PURE__ */ new Set();
+            for (const v of videos) {
+              orientations.add("unknown");
+            }
+            const hasLandscape = images.some((a) => classifyOrientation(a.asset.imageAsset?.fullSize?.widthPixels, a.asset.imageAsset?.fullSize?.heightPixels) === "landscape");
+            const hasPortrait = images.some((a) => classifyOrientation(a.asset.imageAsset?.fullSize?.widthPixels, a.asset.imageAsset?.fullSize?.heightPixels) === "portrait");
+            const hasSquare = images.some((a) => classifyOrientation(a.asset.imageAsset?.fullSize?.widthPixels, a.asset.imageAsset?.fullSize?.heightPixels) === "square");
+            text += `### Slot Utilization \u2014 "${agName}"
+`;
+            text += "| Asset Type | Filled | Max | Status |\n|---|---|---|---|\n";
+            const slotRow = (label, count, max, extra) => {
+              const pct = count >= max ? "\u2705 Full" : count >= Math.ceil(max * 0.6) ? "\u2705 OK" : `\u26A0\uFE0F Below Excellent (need ${max})`;
+              return `| ${label} | ${count} | ${max} | ${extra ?? pct} |
+`;
+            };
+            text += slotRow("Headlines", headlines.length, SLOT_LIMITS.HEADLINE);
+            text += slotRow("Descriptions", descriptions.length, SLOT_LIMITS.DESCRIPTION);
+            text += slotRow(
+              "Images",
+              images.length,
+              SLOT_LIMITS.IMAGE,
+              images.length > 0 ? hasLandscape && hasPortrait && hasSquare ? "\u2705 OK (has landscape + portrait + square)" : `\u26A0\uFE0F Missing orientations: ${[!hasLandscape && "landscape", !hasPortrait && "portrait", !hasSquare && "square"].filter(Boolean).join(", ")}` : "\u26A0\uFE0F No images"
+            );
+            text += slotRow(
+              "Videos",
+              videos.length,
+              SLOT_LIMITS.YOUTUBE_VIDEO,
+              videos.length > 0 ? "\u2705 OK" : "\u26A0\uFE0F No videos \u2014 missing YouTube inventory"
+            );
+            text += `| HTML5 | ${html5.length} | ${SLOT_LIMITS.MEDIA_BUNDLE} | ${html5.length > 0 ? "\u2705 OK" : "\u2014 Not required"} |
+`;
+            const issues = [];
+            if (headlines.length < 5) issues.push(`${5 - headlines.length} headlines`);
+            if (descriptions.length < 5) issues.push(`${5 - descriptions.length} descriptions`);
+            if (!hasLandscape) issues.push("landscape image");
+            const strength = issues.length === 0 ? "Excellent" : issues.length <= 2 ? "Good" : "Poor";
+            text += `
+**Ad Strength: ${strength}**`;
+            if (issues.length > 0) {
+              text += ` (missing ${issues.join(" and ")} for Excellent)`;
+            }
+            text += "\n\n";
+          }
+        }
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/google-insights.ts
+import { z as z10 } from "zod";
+function parseNum(v) {
+  if (v === void 0 || v === null) return 0;
+  if (typeof v === "number") return v;
+  const n = parseFloat(v);
+  return isNaN(n) ? 0 : n;
+}
+function buildAggKey(row, level, breakdown) {
+  const parts = [];
+  if (level === "campaign" || level === "ad_group" || level === "asset") {
+    parts.push(row.campaign?.id ?? "?");
+  }
+  if (level === "ad_group" || level === "asset") {
+    parts.push(row.adGroup?.id ?? "?");
+  }
+  if (level === "asset") {
+    parts.push(row.asset?.id ?? "?");
+  }
+  if (breakdown) {
+    const seg = row.segments;
+    if (breakdown === "network") parts.push(seg?.adNetworkType ?? "?");
+    if (breakdown === "device") parts.push(seg?.device ?? "?");
+  }
+  return parts.join("|");
+}
+function getLabel(row, level) {
+  if (level === "asset") return row.asset?.name ?? row.asset?.id ?? "\u2014";
+  if (level === "ad_group") return row.adGroup?.name ?? row.adGroup?.id ?? "\u2014";
+  if (level === "campaign") return row.campaign?.name ?? row.campaign?.id ?? "\u2014";
+  return "Account";
+}
+function getBreakdownValue(row, breakdown) {
+  if (!breakdown) return void 0;
+  const seg = row.segments;
+  if (breakdown === "network") return seg?.adNetworkType;
+  if (breakdown === "device") return seg?.device;
+  return void 0;
+}
+function sortKeyForEnum(sort) {
+  switch (sort) {
+    case "cost_desc":
+      return "metrics.cost_micros";
+    case "conversions_desc":
+      return "metrics.conversions";
+    case "impressions_desc":
+      return "metrics.impressions";
+    case "ctr_desc":
+      return "metrics.ctr";
+    default:
+      return "metrics.cost_micros";
+  }
+}
+function registerGetGoogleAdsInsights(server2) {
+  server2.tool(
+    "get_google_insights",
+    "Pull performance metrics from Google Ads with configurable level, breakdowns, date ranges, and time granularity. Use network breakdown to detect traffic shifts between Search, Display/AdMob, and YouTube \u2014 the #1 diagnostic lever for Google campaigns (ab-pt-005). Supports campaign, ad_group, asset, and account levels.",
+    {
+      customer_id: z10.string().describe("Google Ads customer ID"),
+      level: z10.enum(["account", "campaign", "ad_group", "asset"]).optional().describe("Aggregation level (default: campaign)"),
+      campaign_id: z10.string().optional().describe("Scope to specific campaign"),
+      ad_group_id: z10.string().optional().describe("Scope to specific ad group"),
+      breakdown: z10.enum(["network", "device"]).optional().describe("Segmentation dimension. Only one at a time (GAQL restriction)"),
+      date_range: z10.object({
+        start_date: z10.string().describe("YYYY-MM-DD"),
+        end_date: z10.string().describe("YYYY-MM-DD")
+      }).optional().describe("Custom date range. Overrides date_preset"),
+      date_preset: z10.enum(["LAST_7_DAYS", "LAST_14_DAYS", "LAST_30_DAYS", "THIS_MONTH", "LAST_MONTH"]).optional().describe("Predefined date range (default: LAST_7_DAYS)"),
+      time_increment: z10.enum(["daily", "weekly", "monthly", "summary"]).optional().describe("Time granularity (default: summary)"),
+      sort: z10.enum(["cost_desc", "conversions_desc", "impressions_desc", "ctr_desc"]).optional().describe("Sort order (default: cost_desc)"),
+      limit: z10.number().min(1).max(500).optional().describe("Max results (default 50)")
+    },
+    async ({ customer_id, level, campaign_id, ad_group_id, breakdown, date_range, date_preset, time_increment, sort, limit }) => {
+      try {
+        const lvl = level ?? "campaign";
+        const ti = time_increment ?? "summary";
+        const sortField = sort ?? "cost_desc";
+        const rowLimit = limit ?? 50;
+        const dr = date_range ?? datePresetToRange(date_preset ?? "LAST_7_DAYS");
+        const dateLabel = date_range ? `${dr.start_date ?? dr.start} to ${dr.end_date ?? dr.end}` : date_preset ?? "Last 7 Days";
+        const startDate = dr.start_date ?? dr.start;
+        const endDate = dr.end_date ?? dr.end;
+        const selectFields = [];
+        if (lvl !== "account") {
+          selectFields.push("campaign.id", "campaign.name");
+        }
+        if (lvl === "ad_group" || lvl === "asset") {
+          selectFields.push("ad_group.id", "ad_group.name");
+        }
+        if (lvl === "asset") {
+          selectFields.push(
+            "asset.id",
+            "asset.name",
+            "asset.type",
+            "ad_group_ad_asset_view.field_type",
+            "ad_group_ad_asset_view.performance_label"
+          );
+        }
+        if (breakdown === "network") selectFields.push("segments.ad_network_type");
+        if (breakdown === "device") selectFields.push("segments.device");
+        if (ti === "daily" || ti === "weekly" || ti === "monthly") {
+          selectFields.push("segments.date");
+        }
+        selectFields.push(
+          "metrics.impressions",
+          "metrics.clicks",
+          "metrics.ctr",
+          "metrics.cost_micros",
+          "metrics.conversions",
+          "metrics.conversions_value",
+          "metrics.all_conversions",
+          "metrics.video_views",
+          "metrics.interactions",
+          "metrics.average_cpm",
+          "metrics.average_cpc",
+          "metrics.biddable_app_install_conversions",
+          "metrics.biddable_app_post_install_conversions"
+        );
+        let fromClause;
+        if (lvl === "asset") fromClause = "ad_group_ad_asset_view";
+        else if (lvl === "ad_group") fromClause = "ad_group";
+        else fromClause = "campaign";
+        const conditions = [
+          "campaign.advertising_channel_sub_type IN ('APP_CAMPAIGN', 'APP_CAMPAIGN_FOR_ENGAGEMENT')",
+          "campaign.status = 'ENABLED'",
+          `segments.date BETWEEN '${startDate}' AND '${endDate}'`
+        ];
+        if (campaign_id) conditions.push(`campaign.id = ${campaign_id}`);
+        if (ad_group_id) conditions.push(`ad_group.id = ${ad_group_id}`);
+        const orderBy = `ORDER BY ${sortKeyForEnum(sortField)} DESC`;
+        const query = `
+          SELECT ${selectFields.join(", ")}
+          FROM ${fromClause}
+          WHERE ${conditions.join("\n  AND ")}
+          ${orderBy}
+          LIMIT ${rowLimit}
+        `;
+        const chunks = await googleAdsQuery(customer_id, query);
+        const rows = chunks.flatMap((c) => c.results ?? []);
+        if (rows.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: "No data found for the specified filters and date range."
+            }]
+          };
+        }
+        const aggMap = /* @__PURE__ */ new Map();
+        for (const row of rows) {
+          const key = lvl === "account" ? (breakdown ? getBreakdownValue(row, breakdown) ?? "all" : "all") + (row.segments?.date ? `|${row.segments.date}` : "") : buildAggKey(row, lvl, breakdown) + (row.segments?.date && ti !== "summary" ? `|${row.segments.date}` : "");
+          if (!aggMap.has(key)) {
+            aggMap.set(key, {
+              label: getLabel(row, lvl),
+              breakdown: getBreakdownValue(row, breakdown),
+              date: row.segments?.date,
+              impressions: 0,
+              clicks: 0,
+              costMicros: 0,
+              conversions: 0,
+              conversionsValue: 0,
+              installs: 0,
+              postInstalls: 0,
+              videoViews: 0,
+              averageCpmMicros: 0,
+              averageCpcMicros: 0,
+              rowCount: 0
+            });
+          }
+          const agg = aggMap.get(key);
+          const m = row.metrics;
+          agg.impressions += parseNum(m?.impressions);
+          agg.clicks += parseNum(m?.clicks);
+          agg.costMicros += parseNum(m?.costMicros);
+          agg.conversions += parseNum(m?.conversions);
+          agg.conversionsValue += parseNum(m?.conversionsValue);
+          agg.installs += parseNum(m?.biddableAppInstallConversions);
+          agg.postInstalls += parseNum(m?.biddableAppPostInstallConversions);
+          agg.videoViews += parseNum(m?.videoViews);
+          agg.averageCpmMicros += parseNum(m?.averageCpm);
+          agg.averageCpcMicros += parseNum(m?.averageCpc);
+          agg.rowCount += 1;
+        }
+        const aggRows = Array.from(aggMap.values());
+        const levelLabel = lvl.charAt(0).toUpperCase() + lvl.slice(1);
+        const breakdownLabel = breakdown ? ` \u2014 By ${breakdown.charAt(0).toUpperCase() + breakdown.slice(1)}` : "";
+        let text = `## Google Ads Performance \u2014 ${dateLabel}${breakdownLabel} (${aggRows.length} ${levelLabel}s)
+
+`;
+        const cols = [];
+        if (ti === "daily") cols.push("Date");
+        cols.push(levelLabel);
+        if (breakdown) cols.push(breakdown.charAt(0).toUpperCase() + breakdown.slice(1));
+        cols.push("Spend", "Impr", "Clicks", "CTR", "CPM", "CPC", "Installs", "CPI", "Post-Install", "CPA", "ROAS");
+        text += `| ${cols.join(" | ")} |
+`;
+        text += `|${cols.map(() => "---").join("|")}|
+`;
+        for (const agg of aggRows) {
+          const spend = agg.costMicros / 1e6;
+          const ctr = agg.impressions > 0 ? agg.clicks / agg.impressions * 100 : 0;
+          const cpm = agg.rowCount > 0 ? agg.averageCpmMicros / agg.rowCount / 1e6 : 0;
+          const cpc = agg.rowCount > 0 ? agg.averageCpcMicros / agg.rowCount / 1e6 : 0;
+          const cpi = agg.installs > 0 ? spend / agg.installs : 0;
+          const cpa = agg.postInstalls > 0 ? spend / agg.postInstalls : 0;
+          const roas = spend > 0 ? agg.conversionsValue / spend * 100 : 0;
+          const vals = [];
+          if (ti === "daily") vals.push(agg.date ?? "\u2014");
+          vals.push(agg.label);
+          if (breakdown) vals.push(agg.breakdown ?? "\u2014");
+          vals.push(
+            `$${spend.toLocaleString("en-US", { minimumFractionDigits: 0, maximumFractionDigits: 0 })}`,
+            formatCompact(agg.impressions),
+            formatCompact(agg.clicks),
+            formatPct(ctr),
+            `$${cpm.toFixed(2)}`,
+            `$${cpc.toFixed(2)}`,
+            agg.installs > 0 ? formatCompact(agg.installs) : "\u2014",
+            cpi > 0 ? `$${cpi.toFixed(2)}` : "\u2014",
+            agg.postInstalls > 0 ? formatCompact(agg.postInstalls) : "\u2014",
+            cpa > 0 ? `$${cpa.toFixed(2)}` : "\u2014",
+            roas > 0 ? formatPct(roas) : "\u2014"
+          );
+          text += `| ${vals.join(" | ")} |
+`;
+        }
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/google-network-mix.ts
+import { z as z11 } from "zod";
+function parseNum2(v) {
+  if (v === void 0 || v === null) return 0;
+  if (typeof v === "number") return v;
+  const n = parseFloat(v);
+  return isNaN(n) ? 0 : n;
+}
+function registerGetGoogleAdsNetworkMix(server2) {
+  server2.tool(
+    "get_google_network_mix",
+    "Analyze traffic distribution across Google's ad networks (Search, Display/AdMob, YouTube) over time. Computes spend share % per network per day and flags significant shifts. Traffic shifts signal performance problems \u2014 a sudden shift to Display/MGDN tanks CPA. Google optimizes for Google's revenue alongside yours; use this to detect shifts to low-quality inventory (ab-pt-005, ab-pt-017).",
+    {
+      customer_id: z11.string().describe("Google Ads customer ID"),
+      campaign_id: z11.string().optional().describe("Scope to one campaign. If omitted, aggregates across all app campaigns"),
+      date_range: z11.object({
+        start_date: z11.string().describe("YYYY-MM-DD"),
+        end_date: z11.string().describe("YYYY-MM-DD")
+      }).optional().describe("Custom date range. Default: last 14 days"),
+      shift_threshold_pct: z11.number().optional().describe("Flag networks whose spend share changed by more than this % (default 10)")
+    },
+    async ({ customer_id, campaign_id, date_range, shift_threshold_pct }) => {
+      try {
+        const threshold = shift_threshold_pct ?? 10;
+        const dr = date_range ?? datePresetToRange("LAST_14_DAYS");
+        const startDate = dr.start_date ?? dr.start;
+        const endDate = dr.end_date ?? dr.end;
+        const conditions = [
+          "campaign.advertising_channel_sub_type IN ('APP_CAMPAIGN', 'APP_CAMPAIGN_FOR_ENGAGEMENT')",
+          "campaign.status = 'ENABLED'",
+          `segments.date BETWEEN '${startDate}' AND '${endDate}'`
+        ];
+        if (campaign_id) conditions.push(`campaign.id = ${campaign_id}`);
+        const query = `
+          SELECT
+            campaign.id,
+            campaign.name,
+            segments.ad_network_type,
+            segments.date,
+            metrics.impressions,
+            metrics.clicks,
+            metrics.cost_micros,
+            metrics.conversions,
+            metrics.conversions_value,
+            metrics.average_cpm,
+            metrics.biddable_app_install_conversions,
+            metrics.biddable_app_post_install_conversions
+          FROM campaign
+          WHERE ${conditions.join("\n  AND ")}
+          ORDER BY segments.date ASC
+        `;
+        const chunks = await googleAdsQuery(customer_id, query);
+        const rows = chunks.flatMap((c) => c.results ?? []);
+        if (rows.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: "No network data found for the specified filters and date range."
+            }]
+          };
+        }
+        const dayNetMap = /* @__PURE__ */ new Map();
+        for (const row of rows) {
+          const date = row.segments?.date ?? "unknown";
+          const network = row.segments?.adNetworkType ?? "UNKNOWN";
+          const key = `${date}|${network}`;
+          if (!dayNetMap.has(key)) {
+            dayNetMap.set(key, { date, network, costMicros: 0, impressions: 0, clicks: 0, installs: 0 });
+          }
+          const dn = dayNetMap.get(key);
+          dn.costMicros += parseNum2(row.metrics?.costMicros);
+          dn.impressions += parseNum2(row.metrics?.impressions);
+          dn.clicks += parseNum2(row.metrics?.clicks);
+          dn.installs += parseNum2(row.metrics?.biddableAppInstallConversions);
+        }
+        const dayNets = Array.from(dayNetMap.values());
+        const dates = [...new Set(dayNets.map((d) => d.date))].sort();
+        const networks = [...new Set(dayNets.map((d) => d.network))].sort();
+        const dailyTotals = /* @__PURE__ */ new Map();
+        for (const dn of dayNets) {
+          dailyTotals.set(dn.date, (dailyTotals.get(dn.date) ?? 0) + dn.costMicros);
+        }
+        const campaignLabel = campaign_id && rows[0]?.campaign?.name ? ` \u2014 ${rows[0].campaign.name}` : "";
+        let text = `## Network Mix${campaignLabel} \u2014 ${startDate} to ${endDate}
+
+`;
+        const headerCols = ["Date"];
+        for (const net of networks) {
+          headerCols.push(net, `${net} %`);
+        }
+        headerCols.push("Total");
+        text += `| ${headerCols.join(" | ")} |
+`;
+        text += `|${headerCols.map(() => "---").join("|")}|
+`;
+        const networkDatePct = /* @__PURE__ */ new Map();
+        for (const net of networks) {
+          networkDatePct.set(net, /* @__PURE__ */ new Map());
+        }
+        for (const date of dates) {
+          const total = dailyTotals.get(date) ?? 1;
+          const vals = [date];
+          for (const net of networks) {
+            const dn = dayNets.find((d) => d.date === date && d.network === net);
+            const cost = dn?.costMicros ?? 0;
+            const pct = total > 0 ? cost / total * 100 : 0;
+            networkDatePct.get(net).set(date, pct);
+            vals.push(
+              `$${(cost / 1e6).toLocaleString("en-US", { minimumFractionDigits: 0, maximumFractionDigits: 0 })}`,
+              `${pct.toFixed(0)}%`
+            );
+          }
+          vals.push(`$${(total / 1e6).toLocaleString("en-US", { minimumFractionDigits: 0, maximumFractionDigits: 0 })}`);
+          text += `| ${vals.join(" | ")} |
+`;
+        }
+        const midIdx = Math.floor(dates.length / 2);
+        const firstHalfDates = dates.slice(0, midIdx);
+        const secondHalfDates = dates.slice(midIdx);
+        text += `
+### Network Shift Analysis (first ${firstHalfDates.length} days vs. last ${secondHalfDates.length} days)
+
+`;
+        text += "| Network | First Half | Second Half | Shift | Status |\n|---|---|---|---|---|\n";
+        const flagged = [];
+        for (const net of networks) {
+          const pctMap = networkDatePct.get(net);
+          const firstAvg = firstHalfDates.length > 0 ? firstHalfDates.reduce((s, d) => s + (pctMap.get(d) ?? 0), 0) / firstHalfDates.length : 0;
+          const secondAvg = secondHalfDates.length > 0 ? secondHalfDates.reduce((s, d) => s + (pctMap.get(d) ?? 0), 0) / secondHalfDates.length : 0;
+          const shift = secondAvg - firstAvg;
+          const isFlagged = Math.abs(shift) > threshold;
+          if (isFlagged) {
+            flagged.push({
+              network: net,
+              shift,
+              direction: shift > 0 ? "increasing" : "declining"
+            });
+          }
+          text += `| ${net} | ${firstAvg.toFixed(0)}% | ${secondAvg.toFixed(0)}% | ${shift > 0 ? "+" : ""}${shift.toFixed(0)}% | ${isFlagged ? `\u26A0\uFE0F FLAGGED \u2014 ${net} share ${shift > 0 ? "increasing" : "declining"}` : "\u2705 Stable"} |
+`;
+        }
+        if (flagged.length > 0) {
+          const increasing = flagged.filter((f) => f.shift > 0);
+          const declining = flagged.filter((f) => f.shift < 0);
+          text += "\n";
+          const parts = [];
+          for (const f of increasing) {
+            parts.push(`${f.network} spend share increased by ${Math.abs(f.shift).toFixed(0)}%`);
+          }
+          for (const f of declining) {
+            parts.push(`${f.network} decreased by ${Math.abs(f.shift).toFixed(0)}%`);
+          }
+          text += `\u26A0\uFE0F Significant network shift detected: ${parts.join(" while ")}.
+`;
+          const hasDisplayIncrease = increasing.some(
+            (f) => f.network.includes("DISPLAY") || f.network.includes("CONTENT")
+          );
+          if (hasDisplayIncrease) {
+            text += "This may indicate the algorithm is shifting to lower-quality Display/MGDN inventory.\n";
+          }
+          text += "\nRecommended actions:\n";
+          text += "- Check the placement report for underperforming apps/sites\n";
+          text += "- Cross-reference with MMP data to verify conversion quality per network\n";
+          text += "- If CPA has risen, the network shift is likely the cause\n";
+          text += "\nSources: ab-pt-005, ab-pt-017, gg135-005\n";
+        }
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/google-asset-fatigue.ts
+import { z as z12 } from "zod";
+function parseNum3(v) {
+  if (v === void 0 || v === null) return 0;
+  if (typeof v === "number") return v;
+  const n = parseFloat(v);
+  return isNaN(n) ? 0 : n;
+}
+function rolling3DayAvg(values) {
+  if (values.length === 0) return 0;
+  if (values.length <= 3) return values.reduce((a, b) => a + b, 0) / values.length;
+  let best = 0;
+  for (let i = 0; i <= values.length - 3; i++) {
+    const avg = (values[i] + values[i + 1] + values[i + 2]) / 3;
+    if (avg > best) best = avg;
+  }
+  return best;
+}
+function rolling3DayMin(values) {
+  if (values.length === 0) return 0;
+  if (values.length <= 3) return values.reduce((a, b) => a + b, 0) / values.length;
+  let best = Infinity;
+  for (let i = 0; i <= values.length - 3; i++) {
+    const avg = (values[i] + values[i + 1] + values[i + 2]) / 3;
+    if (avg < best) best = avg;
+  }
+  return best;
+}
+function last3Avg(values) {
+  if (values.length === 0) return 0;
+  const slice = values.slice(-3);
+  return slice.reduce((a, b) => a + b, 0) / slice.length;
+}
+function dateFmt(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function registerGetGoogleAdsAssetFatigue(server2) {
+  server2.tool(
+    "get_google_asset_fatigue",
+    "Detect creative asset fatigue in Google UAC campaigns by analyzing per-asset impression trends, CTR decline, and CPA deterioration. Also checks asset age against Google's 2-week learning minimum and 2-3 month refresh cadence. Google doesn't expose per-asset frequency \u2014 uses impression volume decay as the primary fatigue signal. Never remove assets within first 2 weeks (goog-pdf-018). Google's performance label measures scalability, not fatigue (ab-pt-008).",
+    {
+      customer_id: z12.string().describe("Google Ads customer ID"),
+      campaign_id: z12.string().describe("Campaign to analyze"),
+      ad_group_id: z12.string().optional().describe("Scope to specific ad group"),
+      lookback_days: z12.number().min(7).max(90).optional().describe("Days of daily data to analyze (default 14)"),
+      ctr_decline_threshold_pct: z12.number().optional().describe("CTR decline % from peak to flag fatigue (default 30)"),
+      impression_decay_threshold_pct: z12.number().optional().describe("Impression volume drop % from peak to flag (default 50)"),
+      asset_type: z12.array(z12.enum(["IMAGE", "YOUTUBE_VIDEO", "TEXT"])).optional().describe("Filter by asset type")
+    },
+    async ({ customer_id, campaign_id, ad_group_id, lookback_days, ctr_decline_threshold_pct, impression_decay_threshold_pct, asset_type }) => {
+      try {
+        const lookback = lookback_days ?? 14;
+        const ctrThreshold = ctr_decline_threshold_pct ?? 30;
+        const imprThreshold = impression_decay_threshold_pct ?? 50;
+        const endDate = /* @__PURE__ */ new Date();
+        endDate.setDate(endDate.getDate() - 1);
+        const startDate = new Date(endDate);
+        startDate.setDate(startDate.getDate() - lookback + 1);
+        const ageStartDate = new Date(endDate);
+        ageStartDate.setDate(ageStartDate.getDate() - 89);
+        const conditions = [
+          `campaign.id = ${campaign_id}`,
+          `segments.date BETWEEN '${dateFmt(startDate)}' AND '${dateFmt(endDate)}'`
+        ];
+        if (ad_group_id) conditions.push(`ad_group.id = ${ad_group_id}`);
+        if (asset_type?.length) {
+          const typeList = asset_type.map((t) => `'${t}'`).join(", ");
+          conditions.push(`asset.type IN (${typeList})`);
+        }
+        const query = `
+          SELECT
+            asset.id,
+            asset.name,
+            asset.type,
+            ad_group_ad_asset_view.field_type,
+            ad_group_ad_asset_view.performance_label,
+            ad_group.id,
+            ad_group.name,
+            segments.date,
+            metrics.impressions,
+            metrics.clicks,
+            metrics.cost_micros,
+            metrics.conversions,
+            metrics.biddable_app_install_conversions
+          FROM ad_group_ad_asset_view
+          WHERE ${conditions.join("\n  AND ")}
+          ORDER BY segments.date ASC
+        `;
+        const chunks = await googleAdsQuery(customer_id, query);
+        const rows = chunks.flatMap((c) => c.results ?? []);
+        if (rows.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: "No asset performance data found for the specified campaign and date range."
+            }]
+          };
+        }
+        const assetDaily = /* @__PURE__ */ new Map();
+        for (const row of rows) {
+          const assetId = row.asset?.id ?? "?";
+          if (!assetDaily.has(assetId)) {
+            assetDaily.set(assetId, {
+              name: row.asset?.name ?? "\u2014",
+              type: row.asset?.type ?? "\u2014",
+              fieldType: row.adGroupAdAssetView?.fieldType ?? "\u2014",
+              performanceLabel: row.adGroupAdAssetView?.performanceLabel ?? "\u2014",
+              days: /* @__PURE__ */ new Map()
+            });
+          }
+          const entry = assetDaily.get(assetId);
+          const date = row.segments?.date ?? "unknown";
+          if (!entry.days.has(date)) {
+            entry.days.set(date, { date, impressions: 0, clicks: 0, costMicros: 0, installs: 0 });
+          }
+          const dm = entry.days.get(date);
+          dm.impressions += parseNum3(row.metrics?.impressions);
+          dm.clicks += parseNum3(row.metrics?.clicks);
+          dm.costMicros += parseNum3(row.metrics?.costMicros);
+          dm.installs += parseNum3(row.metrics?.biddableAppInstallConversions);
+        }
+        const analyses = [];
+        for (const [assetId, data] of assetDaily) {
+          const sortedDays = [...data.days.values()].sort((a, b) => a.date.localeCompare(b.date));
+          const daysWithImpressions = sortedDays.filter((d) => d.impressions > 0);
+          if (daysWithImpressions.length < 3) continue;
+          const firstDate = new Date(daysWithImpressions[0].date);
+          const ageDays = Math.floor((endDate.getTime() - firstDate.getTime()) / (1e3 * 60 * 60 * 24));
+          const dailyImpr = sortedDays.map((d) => d.impressions);
+          const peakImpr = rolling3DayAvg(dailyImpr);
+          const recentImpr = last3Avg(dailyImpr);
+          const imprDecay = peakImpr > 0 ? (peakImpr - recentImpr) / peakImpr * 100 : 0;
+          const dailyCtr = sortedDays.map((d) => d.impressions > 0 ? d.clicks / d.impressions : 0);
+          const peakCtr = rolling3DayAvg(dailyCtr);
+          const recentCtr = last3Avg(dailyCtr);
+          const ctrDecline = peakCtr > 0 ? (peakCtr - recentCtr) / peakCtr * 100 : 0;
+          const dailyCpa = sortedDays.map((d) => d.installs > 0 ? d.costMicros / d.installs / 1e6 : 0);
+          const nonZeroCpa = dailyCpa.filter((c) => c > 0);
+          const peakCpa = nonZeroCpa.length >= 3 ? rolling3DayMin(nonZeroCpa) : nonZeroCpa.length > 0 ? Math.min(...nonZeroCpa) : 0;
+          const recentCpa = last3Avg(dailyCpa.filter((c) => c > 0).length >= 3 ? dailyCpa.slice(-3) : dailyCpa);
+          const cpaChange = peakCpa > 0 ? (recentCpa - peakCpa) / peakCpa * 100 : 0;
+          let status2;
+          let action;
+          if (ageDays < 14) {
+            status2 = "LEARNING";
+            action = `In learning phase \u2014 evaluate after day 14`;
+          } else if (imprDecay > imprThreshold && (ctrDecline > ctrThreshold || cpaChange > 50)) {
+            status2 = "FATIGUED";
+            if (ageDays > 75) {
+              action = "Replace \u2014 past refresh window, declining on all signals";
+            } else {
+              action = "Replace \u2014 impression decay + " + (ctrDecline > ctrThreshold ? "CTR decline" : "CPA deterioration");
+            }
+          } else if (ageDays > 75) {
+            status2 = "NEEDS_REFRESH";
+            action = "Approaching 75+ day age \u2014 evaluate for replacement";
+          } else if (imprDecay > imprThreshold || ctrDecline > ctrThreshold || cpaChange > 30) {
+            status2 = "WARNING";
+            const signals = [];
+            if (imprDecay > imprThreshold) signals.push("impression decay");
+            if (ctrDecline > ctrThreshold) signals.push("CTR decline");
+            if (cpaChange > 30) signals.push("CPA increase");
+            action = `${signals.join(" + ")} beginning \u2014 watch next 7 days`;
+          } else {
+            status2 = "HEALTHY";
+            action = "Stable performance";
+          }
+          analyses.push({
+            assetId,
+            assetName: data.name,
+            assetType: data.type,
+            fieldType: data.fieldType,
+            performanceLabel: data.performanceLabel,
+            status: status2,
+            ageDays,
+            impressionDecayPct: imprDecay,
+            ctrDeclinePct: ctrDecline,
+            cpaChangePct: cpaChange,
+            action
+          });
+        }
+        const priority = {
+          FATIGUED: 0,
+          NEEDS_REFRESH: 1,
+          WARNING: 2,
+          LEARNING: 3,
+          HEALTHY: 4
+        };
+        analyses.sort((a, b) => priority[a.status] - priority[b.status]);
+        const fatigued = analyses.filter((a) => a.status === "FATIGUED");
+        const needsRefresh = analyses.filter((a) => a.status === "NEEDS_REFRESH");
+        const warning = analyses.filter((a) => a.status === "WARNING");
+        const learning = analyses.filter((a) => a.status === "LEARNING");
+        const healthy = analyses.filter((a) => a.status === "HEALTHY");
+        const campaignName = rows[0]?.campaign?.name ?? campaign_id;
+        let text = `## Asset Fatigue Analysis \u2014 ${campaignName} \u2014 Last ${lookback} Days
+
+`;
+        text += `### Summary
+`;
+        text += `- Total assets analyzed: ${analyses.length}
+`;
+        if (fatigued.length > 0) text += `- \u{1F534} FATIGUED: ${fatigued.length} (replace these first)
+`;
+        if (warning.length > 0) text += `- \u{1F7E1} WARNING: ${warning.length} (monitor closely)
+`;
+        if (healthy.length > 0) text += `- \u{1F7E2} HEALTHY: ${healthy.length}
+`;
+        if (learning.length > 0) text += `- \u{1F4D8} LEARNING: ${learning.length} (do not remove \u2014 need more time)
+`;
+        if (needsRefresh.length > 0) text += `- \u{1F504} NEEDS_REFRESH: ${needsRefresh.length} (approaching 75+ day age)
+`;
+        text += "\n";
+        if (fatigued.length > 0) {
+          text += "### Fatigued Assets (Action Required)\n";
+          text += "| Asset | Type | Field | Label | Impr Decay | CTR Decline | CPA Change | Age | Action |\n";
+          text += "|---|---|---|---|---|---|---|---|---|\n";
+          for (const a of fatigued) {
+            text += `| ${a.assetName} | ${a.assetType} | ${a.fieldType} | ${a.performanceLabel} | -${a.impressionDecayPct.toFixed(0)}% | -${a.ctrDeclinePct.toFixed(0)}% | +${a.cpaChangePct.toFixed(0)}% | ${a.ageDays} days | ${a.action} |
+`;
+          }
+          text += "\n";
+        }
+        if (needsRefresh.length > 0) {
+          text += "### Assets Needing Refresh (75+ days)\n";
+          text += "| Asset | Type | Field | Label | Age | Action |\n";
+          text += "|---|---|---|---|---|---|\n";
+          for (const a of needsRefresh) {
+            text += `| ${a.assetName} | ${a.assetType} | ${a.fieldType} | ${a.performanceLabel} | ${a.ageDays} days | ${a.action} |
+`;
+          }
+          text += "\n";
+        }
+        if (warning.length > 0) {
+          text += "### Warning Assets (Monitor)\n";
+          text += "| Asset | Type | Field | Label | Impr Decay | CTR Decline | CPA Change | Age | Note |\n";
+          text += "|---|---|---|---|---|---|---|---|---|\n";
+          for (const a of warning) {
+            text += `| ${a.assetName} | ${a.assetType} | ${a.fieldType} | ${a.performanceLabel} | -${a.impressionDecayPct.toFixed(0)}% | -${a.ctrDeclinePct.toFixed(0)}% | +${a.cpaChangePct.toFixed(0)}% | ${a.ageDays} days | ${a.action} |
+`;
+          }
+          text += "\n";
+        }
+        if (learning.length > 0) {
+          text += "### Learning Assets (Do Not Remove)\n";
+          text += "| Asset | Type | Field | Age | Note |\n";
+          text += "|---|---|---|---|---|\n";
+          for (const a of learning) {
+            text += `| ${a.assetName} | ${a.assetType} | ${a.fieldType} | ${a.ageDays} days | ${a.action} |
+`;
+          }
+          text += "\n";
+        }
+        text += "### Recommendations\n";
+        text += "Based on the analysis and Mobile Growth knowledge base:\n\n";
+        if (fatigued.length > 0) {
+          const pastRefresh = fatigued.filter((a) => a.ageDays > 75).length;
+          text += `1. **Replace ${fatigued.length} fatigued assets**`;
+          if (pastRefresh > 0) text += ` \u2014 prioritize the ${pastRefresh} past the 75-day refresh window`;
+          text += "\n";
+        }
+        if (learning.length > 0) {
+          text += `2. **Do NOT remove the ${learning.length} learning assets** \u2014 they need at least 14 days before evaluation (goog-pdf-018)
+`;
+        }
+        text += `3. **Replace 2-3 assets at a time**, not all at once \u2014 maintain algorithmic stability (goog-pdf-018)
+`;
+        text += `4. **Add variants inspired by your "Best" rated assets** when replacing (goog-pdf-018)
+`;
+        const mislabeled = fatigued.filter((a) => a.performanceLabel === "GOOD" || a.performanceLabel === "BEST");
+        if (mislabeled.length > 0) {
+          const names = mislabeled.map((a) => `"${a.assetName}"`).join(", ");
+          text += `5. Note: ${names} rated "${mislabeled[0].performanceLabel}" by Google but fatigued by actual CTR/CPA metrics \u2014 Google's label measures scalability, not value (ab-pt-008)
+`;
+        }
+        text += `
+Sources: goog-pdf-018, ab-pt-008, goog-pdf-019, ab-pt-007
+`;
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/tools/connection-status.ts
 function registerConnectionStatus(server2, status2) {
   server2.tool(
@@ -859,9 +2161,40 @@ function registerConnectionStatus(server2, status2) {
           "",
           "### How to fix",
           "Provide your Meta access token using one of these methods:",
-          "1. CLI argument: add `--meta-token=...` to the args array",
-          '2. Environment variable: add `"META_ACCESS_TOKEN": "..."` to the env block',
-          "3. `.env` file: add `META_ACCESS_TOKEN=...` to your `.env` file"
+          '1. MCP config: add `"META_ACCESS_TOKEN": "..."` to the `"env"` block in `.mcp.json` (Claude Code/Cursor) or `claude_desktop_config.json` (Claude Desktop)',
+          "2. CLI argument: add `--meta-token=...` to the args array",
+          "3. `.env` file: add `META_ACCESS_TOKEN=...` to a `.env` file in your working directory",
+          "",
+          "Then restart your MCP client."
+        );
+      }
+      lines.push("");
+      if (status2.google.configured) {
+        lines.push(
+          "## Google Ads API: Configured",
+          "- Google Ads tools are available and ready to use"
+        );
+      } else {
+        lines.push(
+          "## Google Ads API: Not Configured",
+          "- Google Ads tools will return an error when called",
+          `- Missing: ${status2.google.missing.join(", ")}`,
+          "",
+          "### How to fix",
+          "Option 1 \u2014 Interactive setup (recommended):",
+          "```",
+          "npx mobile-growth-mcp auth google",
+          "```",
+          "This walks you through developer token, OAuth credentials, and authorization. Saves to `.env`.",
+          "",
+          'Option 2 \u2014 Add credentials manually to the `"env"` block in your MCP config:',
+          "- `GOOGLE_ADS_DEVELOPER_TOKEN`",
+          "- `GOOGLE_ADS_CLIENT_ID`",
+          "- `GOOGLE_ADS_CLIENT_SECRET`",
+          "- `GOOGLE_ADS_REFRESH_TOKEN`",
+          "- `GOOGLE_ADS_LOGIN_CUSTOMER_ID` (optional, for MCC accounts)",
+          "",
+          "Then restart your MCP client."
         );
       }
       return {
@@ -983,6 +2316,19 @@ function registerVocabularyResource(server2) {
 // src/resources/instructions.ts
 var INSTRUCTIONS = `# Mobile Growth MCP \u2014 Knowledge Base + Meta Ad Tools
 
+## Welcome
+
+You're connected to the Mobile Growth knowledge base \u2014 curated expert insights on mobile advertising, campaign optimization, and subscription app growth.
+
+**The knowledge base is always on.** Use \`search_insights\` freely \u2014 before making recommendations, when diagnosing issues, or exploring strategies. The more specific your query, the better the results.
+
+Quick examples:
+- "subscription app creative fatigue signals"
+- "Meta CBO vs ABO tradeoffs for subscription apps"
+- "iOS attribution strategies post-ATT"
+
+If you can't find what you need, call \`submit_feedback\` to report the gap \u2014 it helps us improve the knowledge base.
+
 ## What This Is
 A curated knowledge base of mobile advertising insights + direct Meta Marketing API integration. Query expert knowledge, pull live campaign data, and run pre-built reports \u2014 all from your LLM.
 
@@ -1004,6 +2350,12 @@ Browse all insights with optional filtering. Returns titles and metadata.
 Fetch the full content of a specific insight by ID or slug.
 - **id** (required): Numeric ID or string slug (e.g. "mb-li-001")
 
+### submit_feedback
+Report a gap in the knowledge base or a missing capability. Helps improve the product.
+- **category** (required): missing_knowledge, missing_feature, search_quality, or other
+- **summary** (required): What was needed but not available (anonymized \u2014 no account IDs or tokens)
+- **search_queries_tried** (optional): Search queries that returned poor/no results
+
 ## Meta Marketing API Tools
 
 **Requires META_ACCESS_TOKEN env var** \u2014 without it, these tools return a clear error. Knowledge base tools work with just API_KEY.
@@ -1047,6 +2399,16 @@ Built-in report: detect creative fatigue via frequency, CTR decline, CPA trends.
 - **frequency_critical** (optional): default 5
 - **ctr_decline_threshold** (optional): default 30%
 
+## Google Ads Tools
+
+**Requires Google Ads credentials** \u2014 run \`npx mobile-growth-mcp auth google\` to set up interactively. This walks you through developer token, OAuth app, and authorization. Credentials are saved to \`.env\` and never leave the user's machine.
+
+### get_google_ads_campaigns
+List campaigns from a Google Ads account with key metrics (last 7 days).
+- **customer_id** (required): Google Ads customer ID (e.g. "123-456-7890")
+- **status** (optional): Filter by status \u2014 ENABLED, PAUSED, or REMOVED (default: ENABLED)
+- **limit** (optional): Max campaigns to return (default 50)
+
 ## Reports (MCP Prompts)
 
 Pre-built analysis workflows. Select a prompt and provide your ad_account_id to run:
@@ -1069,6 +2431,15 @@ Pre-built analysis workflows. Select a prompt and provide your ad_account_id to
 ### vocabulary://tags
 Lists all topic tags, applies_to tags, and platforms with counts.
 
+## Presenting Results
+
+When your response draws on knowledge base results, **always attribute visibly** so the user knows the value came from the curated KB, not your general training data:
+
+- **Tell the user** the information comes from the Mobile Growth knowledge base (e.g. "According to the Mobile Growth KB\u2026" or "The knowledge base recommends\u2026")
+- **Cite source author + slug** for key claims (e.g. "\u2026(source: Eric Seufert, \`mb-li-001\`)")
+- **When multiple insights support a recommendation**, mention the count (e.g. "3 insights in the KB agree that\u2026")
+- **Distinguish KB-sourced advice from your own reasoning** \u2014 if you're adding your own analysis on top of KB results, make that clear (e.g. "The KB covers X; based on that, my suggestion is Y")
+
 ## Tips
 - Start with \`list_insights\` to see what's in the knowledge base
 - Use \`search_insights\` to find specific advice grounded in expert knowledge
@@ -1101,6 +2472,16 @@ function buildStatusSection(status2) {
       "  - Fix: provide your token via `--meta-token=...` CLI arg, `META_ACCESS_TOKEN` env var, or `.env` file"
     );
   }
+  if (status2.google.configured) {
+    lines.push("- **Google Ads API**: Configured");
+  } else {
+    lines.push(
+      "- **Google Ads API**: Not configured \u2014 Google Ads tools will return errors"
+    );
+    lines.push(
+      "  - Fix: run `npx mobile-growth-mcp auth google` to set up credentials"
+    );
+  }
   return lines.join("\n");
 }
 function registerInstructionsResource(server2, status2) {
@@ -1180,12 +2561,316 @@ function resolveApiKey() {
 function resolveMetaToken() {
   return resolve("META_ACCESS_TOKEN", "meta-token");
 }
+function resolveGoogleAdsConfig() {
+  const devToken = resolve("GOOGLE_ADS_DEVELOPER_TOKEN", "google-dev-token");
+  const clientId = resolve("GOOGLE_ADS_CLIENT_ID", "google-client-id");
+  const clientSecret = resolve("GOOGLE_ADS_CLIENT_SECRET", "google-client-secret");
+  const refreshToken = resolve("GOOGLE_ADS_REFRESH_TOKEN", "google-refresh-token");
+  const loginCustomerId = resolve("GOOGLE_ADS_LOGIN_CUSTOMER_ID", "google-login-customer-id");
+  const required = [
+    { name: "GOOGLE_ADS_DEVELOPER_TOKEN", result: devToken },
+    { name: "GOOGLE_ADS_CLIENT_ID", result: clientId },
+    { name: "GOOGLE_ADS_CLIENT_SECRET", result: clientSecret },
+    { name: "GOOGLE_ADS_REFRESH_TOKEN", result: refreshToken }
+  ];
+  const missing = required.filter((r) => !r.result.value).map((r) => r.name);
+  const sources = {};
+  for (const r of required) {
+    sources[r.name] = r.result.source;
+  }
+  sources["GOOGLE_ADS_LOGIN_CUSTOMER_ID"] = loginCustomerId.source;
+  return {
+    configured: missing.length === 0,
+    missing,
+    sources,
+    developerToken: devToken.value,
+    clientId: clientId.value,
+    clientSecret: clientSecret.value,
+    refreshToken: refreshToken.value,
+    loginCustomerId: loginCustomerId.value
+  };
+}
+
+// src/google/auth.ts
+import { createInterface } from "readline";
+import { createServer } from "http";
+import { exec } from "child_process";
+import { readFileSync as readFileSync2, appendFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var OAUTH_PORT = 8549;
+var REDIRECT_URI = `http://localhost:${OAUTH_PORT}/callback`;
+var AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var TOKEN_URL2 = "https://oauth2.googleapis.com/token";
+var SCOPE = "https://www.googleapis.com/auth/adwords";
+async function maybeRunAuthCommand() {
+  const args = process.argv.slice(2);
+  if (args[0] !== "auth" || args[1] !== "google") return;
+  await runGoogleAuthFlow();
+  process.exit(0);
+}
+function prompt(rl, question) {
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => resolve2(answer.trim()));
+  });
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? `open "${url}"` : platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, (err) => {
+    if (err) {
+      console.error(`  Could not open browser automatically.`);
+      console.error(`  Open this URL manually:
+  ${url}`);
+    }
+  });
+}
+function getDotEnvPath() {
+  return join2(process.cwd(), ".env");
+}
+function readExistingEnv() {
+  try {
+    const content = readFileSync2(getDotEnvPath(), "utf-8");
+    const vars = {};
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq === -1) continue;
+      vars[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim();
+    }
+    return vars;
+  } catch {
+    return {};
+  }
+}
+function saveToEnv(vars) {
+  const envPath = getDotEnvPath();
+  const existing = readExistingEnv();
+  const overwritten = [];
+  for (const key of Object.keys(vars)) {
+    if (existing[key]) {
+      overwritten.push(key);
+    }
+  }
+  if (overwritten.length > 0) {
+    console.log(`
+  Overwriting existing keys: ${overwritten.join(", ")}`);
+    let content;
+    try {
+      content = readFileSync2(envPath, "utf-8");
+    } catch {
+      content = "";
+    }
+    const lines = content.split("\n");
+    const updated = /* @__PURE__ */ new Set();
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq === -1) continue;
+      const key = trimmed.slice(0, eq).trim();
+      if (key in vars) {
+        lines[i] = `${key}=${vars[key]}`;
+        updated.add(key);
+      }
+    }
+    for (const [key, value] of Object.entries(vars)) {
+      if (!updated.has(key)) {
+        lines.push(`${key}=${value}`);
+      }
+    }
+    writeFileSync(envPath, lines.join("\n"));
+  } else {
+    const block = Object.entries(vars).map(([k, v]) => `${k}=${v}`).join("\n");
+    let prefix = "\n";
+    try {
+      const existing2 = readFileSync2(envPath, "utf-8");
+      if (existing2.length > 0 && !existing2.endsWith("\n")) {
+        prefix = "\n\n";
+      } else if (existing2.endsWith("\n")) {
+        prefix = "";
+      }
+    } catch {
+      prefix = "";
+    }
+    appendFileSync(envPath, `${prefix}${block}
+`);
+  }
+}
+async function waitForOAuthCallback(clientId, clientSecret) {
+  return new Promise((resolve2, reject) => {
+    const server2 = createServer(
+      async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${OAUTH_PORT}`);
+        if (url.pathname !== "/callback") {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const code = url.searchParams.get("code");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h2>Authorization failed</h2><p>You can close this tab.</p></body></html>"
+          );
+          server2.close();
+          reject(new Error(`OAuth authorization denied: ${error}`));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h2>Missing authorization code</h2></body></html>"
+          );
+          return;
+        }
+        try {
+          const tokenBody = new URLSearchParams({
+            code,
+            client_id: clientId,
+            client_secret: clientSecret,
+            redirect_uri: REDIRECT_URI,
+            grant_type: "authorization_code"
+          });
+          const tokenRes = await fetch(TOKEN_URL2, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: tokenBody.toString()
+          });
+          if (!tokenRes.ok) {
+            const text = await tokenRes.text();
+            throw new Error(`Token exchange failed (${tokenRes.status}): ${text}`);
+          }
+          const tokenData = await tokenRes.json();
+          if (!tokenData.refresh_token) {
+            throw new Error(
+              "No refresh token received. Make sure prompt=consent is set and try again."
+            );
+          }
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h2>Success!</h2><p>You can close this tab and return to the terminal.</p></body></html>"
+          );
+          server2.close();
+          resolve2({ refreshToken: tokenData.refresh_token });
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h2>Token exchange failed</h2><p>Check the terminal for details.</p></body></html>"
+          );
+          server2.close();
+          reject(err);
+        }
+      }
+    );
+    server2.listen(OAUTH_PORT, () => {
+    });
+    server2.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${OAUTH_PORT} is already in use. Close the process using it and try again.`
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+async function runGoogleAuthFlow() {
+  console.log("\nGoogle Ads Setup");
+  console.log("================\n");
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log("Step 1: Developer token");
+    console.log("  (Found in Google Ads \u2192 Tools \u2192 API Center)\n");
+    const developerToken = await prompt(rl, "  Developer token: ");
+    if (!developerToken) {
+      console.error("\n  Developer token is required.");
+      return;
+    }
+    const loginCustomerId = await prompt(
+      rl,
+      "  MCC account ID (optional, press Enter to skip): "
+    );
+    console.log("\nStep 2: OAuth credentials");
+    console.log(
+      "  (Create in Google Cloud Console \u2192 APIs & Services \u2192 Credentials)\n"
+    );
+    console.log(`  Redirect URI to register: ${REDIRECT_URI}
+`);
+    const clientId = await prompt(rl, "  Client ID: ");
+    if (!clientId) {
+      console.error("\n  Client ID is required.");
+      return;
+    }
+    const clientSecret = await prompt(rl, "  Client secret: ");
+    if (!clientSecret) {
+      console.error("\n  Client secret is required.");
+      return;
+    }
+    rl.close();
+    console.log("\nStep 3: Authorization");
+    const authParams = new URLSearchParams({
+      client_id: clientId,
+      redirect_uri: REDIRECT_URI,
+      response_type: "code",
+      scope: SCOPE,
+      access_type: "offline",
+      prompt: "consent"
+    });
+    const authUrl = `${AUTH_URL}?${authParams.toString()}`;
+    console.log("  Opening browser...\n");
+    openBrowser(authUrl);
+    console.log(`  If the browser didn't open, visit:
+  ${authUrl}
+`);
+    const { refreshToken } = await waitForOAuthCallback(clientId, clientSecret);
+    const envVars = {
+      GOOGLE_ADS_DEVELOPER_TOKEN: developerToken,
+      GOOGLE_ADS_CLIENT_ID: clientId,
+      GOOGLE_ADS_CLIENT_SECRET: clientSecret,
+      GOOGLE_ADS_REFRESH_TOKEN: refreshToken
+    };
+    if (loginCustomerId) {
+      envVars.GOOGLE_ADS_LOGIN_CUSTOMER_ID = loginCustomerId;
+    }
+    saveToEnv(envVars);
+    console.log(`
+\u2713 Saved to .env. Restart your MCP client to use Google Ads tools.`);
+  } catch (err) {
+    console.error(
+      `
+Error: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
 
 // src/index.ts
+await maybeRunAuthCommand();
 var apiKeyResult = resolveApiKey();
 var metaTokenResult = resolveMetaToken();
+var googleAdsResult = resolveGoogleAdsConfig();
 if (apiKeyResult.value) process.env.API_KEY = apiKeyResult.value;
 if (metaTokenResult.value) process.env.META_ACCESS_TOKEN = metaTokenResult.value;
+if (googleAdsResult.developerToken)
+  process.env.GOOGLE_ADS_DEVELOPER_TOKEN = googleAdsResult.developerToken;
+if (googleAdsResult.clientId)
+  process.env.GOOGLE_ADS_CLIENT_ID = googleAdsResult.clientId;
+if (googleAdsResult.clientSecret)
+  process.env.GOOGLE_ADS_CLIENT_SECRET = googleAdsResult.clientSecret;
+if (googleAdsResult.refreshToken)
+  process.env.GOOGLE_ADS_REFRESH_TOKEN = googleAdsResult.refreshToken;
+if (googleAdsResult.loginCustomerId)
+  process.env.GOOGLE_ADS_LOGIN_CUSTOMER_ID = googleAdsResult.loginCustomerId;
 var apiKey = apiKeyResult.value;
 console.error(
   apiKey ? `API key: ${apiKeyResult.source}` : "API key: not configured \u2014 KB tools will not be available"
@@ -1193,6 +2878,9 @@ console.error(
 console.error(
   metaTokenResult.value ? `Meta token: ${metaTokenResult.source}` : "Meta token: not configured \u2014 Meta tools will return errors when called"
 );
+console.error(
+  googleAdsResult.configured ? `Google Ads: configured` : `Google Ads: not configured (missing: ${googleAdsResult.missing.join(", ")}) \u2014 run \`npx mobile-growth-mcp auth google\` to set up`
+);
 var server = new McpServer({
   name: "mobile-growth-mcp",
   version: "2.0.0"
@@ -1200,6 +2888,10 @@ var server = new McpServer({
 var status = {
   kb: { connected: false, toolCount: 0, promptCount: 0 },
   meta: { tokenConfigured: !!metaTokenResult.value },
+  google: {
+    configured: googleAdsResult.configured,
+    missing: googleAdsResult.missing
+  },
   apiKey: { source: apiKeyResult.source }
 };
 if (apiKey) {
@@ -1223,6 +2915,12 @@ registerGetMetaAdSets(server);
 registerGetMetaAds(server);
 registerGetMetaInsights(server);
 registerGetMetaAdFatigue(server);
+registerGetGoogleAdsCampaigns(server);
+registerGetGoogleAdsAdGroups(server);
+registerGetGoogleAdsAssets(server);
+registerGetGoogleAdsInsights(server);
+registerGetGoogleAdsNetworkMix(server);
+registerGetGoogleAdsAssetFatigue(server);
 registerConnectionStatus(server, status);
 registerVocabularyResource(server);
 registerInstructionsResource(server, status);