mobile-growth-mcp 2.1.2 → 2.2.4

package/dist/index.js

@@ -23,7 +23,7 @@ async function jsonRpcRequest(apiKey2, method, params) {
       Accept: "application/json, text/event-stream"
     },
     body: JSON.stringify(body),
-    signal: AbortSignal.timeout(15e3)
+    signal: AbortSignal.timeout(3e4)
   });
   if (!res.ok) {
     const text = await res.text();
@@ -39,19 +39,34 @@ async function fetchRemoteTools(apiKey2) {
   return resp.result?.tools ?? [];
 }
 async function callRemoteTool(apiKey2, name, args) {
-  const resp = await jsonRpcRequest(apiKey2, "tools/call", {
-    name,
-    arguments: args
-  });
-  if (resp.error) {
-    return {
-      content: [{ type: "text", text: `Remote error: ${resp.error.message}` }],
-      isError: true
-    };
+  const maxAttempts = 2;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const resp = await jsonRpcRequest(apiKey2, "tools/call", {
+        name,
+        arguments: args
+      });
+      if (resp.error) {
+        return {
+          content: [{ type: "text", text: `Remote error: ${resp.error.message}` }],
+          isError: true
+        };
+      }
+      return {
+        content: resp.result?.content ?? [{ type: "text", text: "No content returned" }],
+        isError: resp.result?.isError
+      };
+    } catch (err) {
+      lastError = err;
+      const isRetryable = lastError.name === "AbortError" || lastError.name === "TimeoutError" || lastError.message?.includes("fetch failed");
+      if (!isRetryable || attempt === maxAttempts) break;
+      await new Promise((r) => setTimeout(r, 2e3));
+    }
   }
   return {
-    content: resp.result?.content ?? [{ type: "text", text: "No content returned" }],
-    isError: resp.result?.isError
+    content: [{ type: "text", text: `Remote call failed after retry: ${lastError?.message ?? "unknown error"}` }],
+    isError: true
   };
 }
 function jsonSchemaToZodShape(inputSchema) {
@@ -222,7 +237,7 @@ async function metaApiGet(options) {
 function activeFilter() {
   return JSON.stringify([
     {
-      field: "effective_status",
+      field: "ad.effective_status",
       operator: "IN",
       value: ["ACTIVE"]
     }
@@ -643,15 +658,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"
           }
         });
@@ -950,37 +972,140 @@ async function googleAdsQuery(customerId, query) {
   return [body];
 }
 
+// src/google/format.ts
+async function resolveCampaignId(customerId, value) {
+  if (/^\d+$/.test(value)) return value;
+  const query = `SELECT campaign.id, campaign.name FROM campaign WHERE campaign.name = '${value.replace(/'/g, "\\'")}' LIMIT 1`;
+  const chunks = await googleAdsQuery(customerId, query);
+  const rows = chunks.flatMap((c) => c.results ?? []);
+  if (rows.length === 0) throw new Error(`Campaign not found by name: "${value}"`);
+  return rows[0].campaign.id;
+}
+async function resolveAdGroupId(customerId, value, campaignId) {
+  if (/^\d+$/.test(value)) return value;
+  let query = `SELECT ad_group.id, ad_group.name FROM ad_group WHERE ad_group.name = '${value.replace(/'/g, "\\'")}' LIMIT 1`;
+  if (campaignId) query = query.replace("LIMIT 1", `AND campaign.id = ${campaignId} LIMIT 1`);
+  const chunks = await googleAdsQuery(customerId, query);
+  const rows = chunks.flatMap((c) => c.results ?? []);
+  if (rows.length === 0) throw new Error(`Ad group not found by name: "${value}"`);
+  return rows[0].adGroup.id;
+}
+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 campaigns from a Google Ads account with key metrics. Requires Google Ads credentials \u2014 run `npx mobile-growth-mcp auth google` to set up.",
+    "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.enum(["ENABLED", "PAUSED", "REMOVED"]).optional().describe("Filter by campaign status. Default: ENABLED"),
-      limit: z7.number().min(1).max(1e3).optional().describe("Max campaigns to return (default 50)")
+      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, limit }) => {
+    async ({ customer_id, status: status2, channel_sub_type, limit }) => {
       try {
-        const statusFilter = status2 ?? "ENABLED";
+        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,
-            metrics.impressions,
-            metrics.clicks,
-            metrics.cost_micros,
-            metrics.conversions,
-            metrics.ctr,
-            metrics.average_cpc
+            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.status = '${statusFilter}'
-            AND segments.date DURING LAST_7_DAYS
-          ORDER BY metrics.cost_micros DESC
+          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);
@@ -990,29 +1115,1048 @@ function registerGetGoogleAdsCampaigns(server2) {
             content: [
               {
                 type: "text",
-                text: `No ${statusFilter.toLowerCase()} campaigns found for customer ${customer_id} in the last 7 days.`
+                text: "No campaigns found matching filters. Try expanding status filter to include PAUSED."
               }
             ]
           };
         }
-        let text = `Found ${rows.length} ${statusFilter.toLowerCase()} campaigns (last 7 days):
+        const header = `## Google Campaigns (${rows.length} found)
 
 `;
+        const tableHeader = "| ID | Campaign | Status | Type | Bid Strategy | Target | Daily Budget | App |\n|---|---|---|---|---|---|---|---|\n";
+        let tableRows = "";
         for (const row of rows) {
           const c = row.campaign;
-          const m = row.metrics;
           if (!c) continue;
-          const cost = m?.costMicros ? `$${(parseInt(m.costMicros) / 1e6).toFixed(2)}` : "$0.00";
-          const impressions = m?.impressions ?? "0";
-          const clicks = m?.clicks ?? "0";
-          const conversions = m?.conversions !== void 0 ? m.conversions.toFixed(1) : "0";
-          const ctr = m?.ctr !== void 0 ? `${(m.ctr * 100).toFixed(2)}%` : "\u2014";
-          const avgCpc = m?.averageCpc ? `$${(parseInt(m.averageCpc) / 1e6).toFixed(2)}` : "\u2014";
-          text += `- **${c.name}** (${c.id})
-  Status: ${c.status}` + (c.advertisingChannelType ? ` | Channel: ${c.advertisingChannelType}` : "") + (c.biddingStrategyType ? ` | Bidding: ${c.biddingStrategyType}` : "") + `
-  Spend: ${cost} | Impr: ${impressions} | Clicks: ${clicks} | CTR: ${ctr} | Avg CPC: ${avgCpc} | Conv: ${conversions}
+          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.id} | ${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) {
+          const resolvedCampaignId = await resolveCampaignId(customer_id, campaign_id);
+          whereClause += `
+  AND campaign.id = ${resolvedCampaignId}`;
+        }
+        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 ID | Ad Group | Status | Type | Campaign ID | Campaign |\n|---|---|---|---|---|---|\n";
+        let tableRows = "";
+        for (const row of rows) {
+          const ag = row.adGroup;
+          const c = row.campaign;
+          if (!ag) continue;
+          tableRows += `| ${ag.id} | ${ag.name} | ${ag.status ?? "\u2014"} | ${ag.type ?? "\u2014"} | ${c?.id ?? "\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) {
+          const resolvedCampaignId = await resolveCampaignId(customer_id, campaign_id);
+          conditions.push(`campaign.id = ${resolvedCampaignId}`);
+        }
+        if (ad_group_id) {
+          const resolvedAdGroupId = await resolveAdGroupId(customer_id, ad_group_id, campaign_id);
+          conditions.push(`ad_group.id = ${resolvedAdGroupId}`);
+        }
+        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) {
+          const resolvedCampaignId = await resolveCampaignId(customer_id, campaign_id);
+          conditions.push(`campaign.id = ${resolvedCampaignId}`);
+        }
+        if (ad_group_id) {
+          const resolvedAdGroupId = await resolveAdGroupId(customer_id, ad_group_id, campaign_id);
+          conditions.push(`ad_group.id = ${resolvedAdGroupId}`);
+        }
+        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) {
+          const resolvedCampaignId = await resolveCampaignId(customer_id, campaign_id);
+          conditions.push(`campaign.id = ${resolvedCampaignId}`);
+        }
+        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 resolvedCampaignId = await resolveCampaignId(customer_id, campaign_id);
+        const conditions = [
+          `campaign.id = ${resolvedCampaignId}`,
+          `segments.date BETWEEN '${dateFmt(startDate)}' AND '${dateFmt(endDate)}'`
+        ];
+        if (ad_group_id) {
+          const resolvedAdGroupId = await resolveAdGroupId(customer_id, ad_group_id, resolvedCampaignId);
+          conditions.push(`ad_group.id = ${resolvedAdGroupId}`);
+        }
+        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 {
@@ -1064,10 +2208,11 @@ function registerConnectionStatus(server2, status2) {
         );
       } else {
         lines.push(
-          "## Meta Marketing API: Not Configured",
-          "- Meta tools will return an error when called",
+          "## Meta Marketing API: Not Connected (Optional)",
+          "- KB, suggestions, and private insights work without it",
+          "- Connect Meta to unlock live campaign data and reports",
           "",
-          "### How to fix",
+          "### How to connect",
           "Provide your Meta access token using one of these methods:",
           '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",
@@ -1084,11 +2229,11 @@ function registerConnectionStatus(server2, status2) {
         );
       } else {
         lines.push(
-          "## Google Ads API: Not Configured",
-          "- Google Ads tools will return an error when called",
-          `- Missing: ${status2.google.missing.join(", ")}`,
+          "## Google Ads API: Not Connected (Optional)",
+          "- KB, suggestions, and private insights work without it",
+          "- Connect Google Ads to unlock campaign data and network analysis",
           "",
-          "### How to fix",
+          "### How to connect",
           "Option 1 \u2014 Interactive setup (recommended):",
           "```",
           "npx mobile-growth-mcp auth google",
@@ -1222,35 +2367,40 @@ function registerVocabularyResource(server2) {
 }
 
 // src/resources/instructions.ts
-var INSTRUCTIONS = `# Mobile Growth MCP \u2014 Knowledge Base + Meta Ad Tools
+var INSTRUCTIONS = `# Mobile Growth MCP \u2014 Knowledge Base + Ad Platform Tools
 
 ## Welcome
 
-You're connected to the Mobile Growth knowledge base \u2014 curated expert insights on mobile advertising, campaign optimization, and subscription app growth.
+You're connected to the Mobile Growth knowledge base \u2014 curated expert insights on mobile advertising, campaign optimization, and subscription app growth \u2014 plus direct Meta and Google Ads API integration.
 
 **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.
 
+> **Note:** Connecting Meta or Google Ads is optional. The knowledge base, community suggestions, and private insights all work with just your API key. Add Meta or Google Ads credentials later if you want live campaign data and reports.
+
 Quick examples:
 - "subscription app creative fatigue signals"
 - "Meta CBO vs ABO tradeoffs for subscription apps"
+- "Google UAC network shift detection"
 - "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.
+A curated knowledge base of mobile advertising insights + direct Meta Marketing API and Google Ads API integration. Query expert knowledge, pull live campaign data, and run pre-built reports \u2014 all from your LLM.
+
+---
 
 ## Knowledge Base Tools
 
 ### search_insights
-Semantic + keyword hybrid search across the knowledge base.
+Semantic + keyword hybrid search across the knowledge base. **Use this first** for any question about mobile advertising before searching the web.
 - **query** (required): Natural language search query
 - **topics** (optional): Filter by topic tags, e.g. ["creative_strategy", "scaling"]
 - **applies_to** (optional): Filter by applicability, e.g. ["subscription_apps", "ios"]
 - **limit** (optional): Max results, 1-30, default 10
 
 ### list_insights
-Browse all insights with optional filtering. Returns titles and metadata.
+Browse all insights with optional filtering. Returns titles and metadata. Private insights are marked with a lock icon.
 - **topic** (optional): Filter by a single topic tag
 - **applies_to** (optional): Filter by a single applies_to value
 
@@ -1258,12 +2408,29 @@ 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")
 
+### get_vocabulary_counts
+Returns counts of how many insights use each topic and applies_to tag. Lightweight way to explore what's in the KB.
+
 ### 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)
+Report a gap in the knowledge base, a bug in any tool, or a missing capability.
+- **category** (required): missing_knowledge, missing_feature, search_quality, bug_report, or other
+- **summary** (required): What was needed or what went wrong (anonymized \u2014 no account IDs or tokens)
 - **search_queries_tried** (optional): Search queries that returned poor/no results
 
+## Community Knowledge
+
+### suggest_insight \u2B50 DEFAULT for saving knowledge
+Submit knowledge for admin review. **This is the default tool when a user wants to save an insight** \u2014 it contributes to the shared knowledge base that benefits all users. Extract as much structured data as possible from the source material \u2014 full insight schema (title, insight text, source metadata, topics, actionable steps). Once approved, it's added to the shared knowledge base.
+- Use this when the user shares an article, post, or discussion with valuable mobile growth knowledge
+- Keep raw_excerpt concise (under 500 chars) for reliability
+
+### save_private_insight
+Save knowledge that is private to your API key. Immediately searchable but only visible to you. **Only use this instead of suggest_insight when** the content contains client-specific data, internal benchmarks, account metrics, or the user explicitly asks for private storage.
+- Same full schema as suggest_insight
+- No admin approval needed \u2014 saved instantly
+
+---
+
 ## 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.
@@ -1307,33 +2474,87 @@ 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.
+**Requires Google Ads credentials** \u2014 run \`npx mobile-growth-mcp auth google\` to set up interactively. Credentials are saved to \`.env\` and never leave the user's machine.
+
+All tools accept campaign and ad group IDs as either **numeric IDs** or **campaign/ad group names** \u2014 names are auto-resolved to numeric IDs internally.
 
 ### get_google_ads_campaigns
-List campaigns from a Google Ads account with key metrics (last 7 days).
+List Google App Campaigns with status, bid strategy, budgets, and app info. Returns **numeric campaign IDs** needed by other tools.
 - **customer_id** (required): Google Ads customer ID (e.g. "123-456-7890")
-- **status** (optional): Filter by status \u2014 ENABLED, PAUSED, or REMOVED (default: ENABLED)
+- **status** (optional): Filter by status \u2014 ENABLED, PAUSED, REMOVED (default: ["ENABLED"])
+- **channel_sub_type** (optional): Filter by campaign type \u2014 APP_CAMPAIGN (ACi), APP_CAMPAIGN_FOR_ENGAGEMENT (ACe)
 - **limit** (optional): Max campaigns to return (default 50)
 
+### get_google_ad_groups
+List ad groups within Google App Campaigns. Returns **numeric ad group IDs** and campaign IDs. In UAC, ad groups represent creative themes \u2014 observe spend distribution to identify winning messaging angles.
+- **customer_id** (required): Google Ads customer ID
+- **campaign_id** (optional): Scope to a specific campaign (name or numeric ID)
+- **status** (optional): Filter by status (default: ["ENABLED"])
+- **limit** (optional): Max results (default 50)
+
+### get_google_insights
+Pull performance metrics 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.
+- **customer_id** (required): Google Ads customer ID
+- **level** (optional): account, campaign, ad_group, asset (default: campaign)
+- **campaign_id** (optional): Scope to specific campaign (name or numeric ID)
+- **ad_group_id** (optional): Scope to specific ad group
+- **breakdown** (optional): network or device (one at a time \u2014 GAQL restriction)
+- **date_range** (optional): {start_date, end_date} in YYYY-MM-DD
+- **date_preset** (optional): LAST_7_DAYS, LAST_14_DAYS, LAST_30_DAYS, THIS_MONTH, LAST_MONTH
+- **time_increment** (optional): daily, weekly, monthly, summary (default: summary)
+- **sort** (optional): cost_desc, conversions_desc, impressions_desc, ctr_desc
+- **limit** (optional): Max results (default 50, max 500)
+
+### get_google_assets
+List creative assets with metadata, performance labels, and slot utilization audit. Checks headlines, descriptions, images, videos against Google's per-slot maximums.
+- **customer_id** (required): Google Ads customer ID
+- **campaign_id** (optional): Scope to a specific campaign (name or numeric ID)
+- **ad_group_id** (optional): Scope to a specific ad group
+- **asset_type** (optional): IMAGE, YOUTUBE_VIDEO, TEXT, MEDIA_BUNDLE
+- **include_slot_audit** (optional): default true
+- **limit** (optional): Max results (default 50)
+
+### get_google_network_mix
+Analyze traffic distribution across Google's ad networks (Search, Display/AdMob, YouTube) over time. Flags significant shifts in spend share \u2014 a sudden shift to Display/MGDN typically tanks CPA.
+- **customer_id** (required): Google Ads customer ID
+- **campaign_id** (optional): Scope to one campaign (name or numeric ID)
+- **date_range** (optional): {start_date, end_date} \u2014 default last 14 days
+- **shift_threshold_pct** (optional): Flag networks with spend share change > this % (default 10)
+
+### get_google_asset_fatigue
+Detect creative asset fatigue by analyzing per-asset impression trends, CTR decline, and CPA deterioration. Checks asset age against Google's 2-week learning minimum and 2-3 month refresh cadence.
+- **customer_id** (required): Google Ads customer ID
+- **campaign_id** (required): Campaign to analyze (name or numeric ID)
+- **ad_group_id** (optional): Scope to specific ad group
+- **lookback_days** (optional): Days of data to analyze, 7-90 (default 14)
+- **ctr_decline_threshold_pct** (optional): CTR decline % to flag (default 30)
+- **impression_decay_threshold_pct** (optional): Impression drop % to flag (default 50)
+- **asset_type** (optional): IMAGE, YOUTUBE_VIDEO, TEXT
+
+---
+
 ## Reports (MCP Prompts)
 
-Pre-built analysis workflows. Select a prompt and provide your ad_account_id to run:
+Pre-built analysis workflows for Meta accounts. Select a prompt and provide your ad_account_id to run:
 
 | Prompt | What it does | API calls |
 |--------|-------------|-----------|
 | ad-fatigue-report | Detect creative fatigue with daily granularity | 1 |
 | weekly-performance | Week-over-week health comparison with diagnosis | 2 |
 | creative-performance | Categorize ads by health status | 1 |
-| placement-efficiency | Identify placement waste and savings | 1 per campaign |
-| audience-composition | Age \xD7 gender heatmap with CPA analysis | 1-2 |
+| audience-composition | Age x gender heatmap with CPA analysis | 1-2 |
 | architecture-review | Campaign structure evaluation | 3 (no insights) |
 | audit-meta-account | Comprehensive account audit | 6+ |
 | campaign-comparison | Side-by-side campaign comparison | 3+ |
 | placement-audit | Detailed placement audit with examples | 1 per campaign |
 | attribution-analysis | Conversion quality validation | 2+ |
 
+---
+
 ## Resources
 
 ### vocabulary://tags
@@ -1343,17 +2564,31 @@ Lists all topic tags, applies_to tags, and platforms with counts.
 
 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
-- Meta tools default to safe parameters (last_7d, active-only) to avoid rate limits
-- Reports reference specific knowledge base insight IDs \u2014 use \`get_insight\` to read the full context
-- For custom date ranges, use time_range instead of date_preset
+- **Tell the user** the information comes from the Mobile Growth knowledge base (e.g. "According to the Mobile Growth KB..." or "The knowledge base recommends...")
+- **Cite source author + slug** for key claims (e.g. "...(source: Eric Seufert, \`mb-li-001\`)")
+- **When multiple insights support a recommendation**, mention the count (e.g. "3 insights in the KB agree that...")
+- **Distinguish KB-sourced advice from your own reasoning** \u2014 if you're adding your own analysis on top of KB results, make that clear
+
+## Workflow Tips
+
+### For Google Ads analysis:
+1. Start with \`get_google_ads_campaigns\` to see campaigns and get numeric IDs
+2. Use \`get_google_insights\` with network breakdown to check traffic distribution
+3. Use \`get_google_network_mix\` if you suspect network shifts
+4. Use \`get_google_assets\` to audit creative slot utilization
+5. Use \`get_google_asset_fatigue\` on specific campaigns to detect creative decay
+
+### For Meta analysis:
+1. Start with \`get_meta_campaigns\` to see account structure
+2. Use reports (MCP prompts) for comprehensive analysis
+3. For custom analysis, use \`get_meta_insights\` with breakdowns
+
+### General:
+- Always \`search_insights\` before making recommendations \u2014 ground advice in expert knowledge
+- Use \`get_insight\` to read full context when reports reference insight IDs
+- Use \`suggest_insight\` (default) when a user shares valuable knowledge from articles or discussions
+- Use \`save_private_insight\` only for client-specific data the user explicitly wants private
+- If a tool errors unexpectedly, call \`submit_feedback\` with category \`bug_report\`
 `;
 function buildStatusSection(status2) {
   if (!status2) return "";
@@ -1374,20 +2609,20 @@ function buildStatusSection(status2) {
     lines.push("- **Meta Marketing API**: Token configured");
   } else {
     lines.push(
-      "- **Meta Marketing API**: Token not configured \u2014 Meta tools will return errors"
+      "- **Meta Marketing API**: Not connected (optional \u2014 KB works without it)"
     );
     lines.push(
-      "  - Fix: provide your token via `--meta-token=...` CLI arg, `META_ACCESS_TOKEN` env var, or `.env` file"
+      "  - To connect: 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"
+      "- **Google Ads API**: Not connected (optional \u2014 KB works without it)"
     );
     lines.push(
-      "  - Fix: run `npx mobile-growth-mcp auth google` to set up credentials"
+      "  - To connect: run `npx mobile-growth-mcp auth google` to set up credentials"
     );
   }
   return lines.join("\n");
@@ -1696,7 +2931,7 @@ async function runGoogleAuthFlow() {
   });
   try {
     console.log("Step 1: Developer token");
-    console.log("  (Found in Google Ads \u2192 Tools \u2192 API Center)\n");
+    console.log("  (Found in Google Ads \u2192 Admin \u2192 API Center, or https://ads.google.com/aw/apicenter)\n");
     const developerToken = await prompt(rl, "  Developer token: ");
     if (!developerToken) {
       console.error("\n  Developer token is required.");
@@ -1784,10 +3019,10 @@ console.error(
   apiKey ? `API key: ${apiKeyResult.source}` : "API key: not configured \u2014 KB tools will not be available"
 );
 console.error(
-  metaTokenResult.value ? `Meta token: ${metaTokenResult.source}` : "Meta token: not configured \u2014 Meta tools will return errors when called"
+  metaTokenResult.value ? `Meta token: ${metaTokenResult.source}` : "Meta token: not configured (optional \u2014 KB works without it)"
 );
 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`
+  googleAdsResult.configured ? `Google Ads: configured` : `Google Ads: not configured (optional \u2014 KB works without it). Run \`npx mobile-growth-mcp auth google\` to set up`
 );
 var server = new McpServer({
   name: "mobile-growth-mcp",
@@ -1824,6 +3059,11 @@ 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);