# GoMarble Ecommerce Skills
### 15 skills for ecommerce brands running Meta + Google + Shopify

Built and tested against live accounts. Each skill pulls real data from GoMarble MCP
and returns specific, actionable findings — not generic recommendations.

---

## Prerequisites

Before running any skill, confirm the following are connected in GoMarble:
- Meta Ads account
- Google Ads account (with Shopping or PMax campaigns + product feed)
- Shopify store

To confirm connections, run:
- `shopify_list_shops` → note your SHOPIFY_ID
- `facebook_list_ad_accounts` → note your META_ACT_ID (format: act_XXXXXXXXXX)
- `google_ads_list_accounts` → note your GOOGLE_ID and GOOGLE_MANAGER_ID if applicable

**Default date range for all skills: last 30 days**
To use a custom range, specify dates when triggering the skill.
Format: SINCE YYYY-MM-DD UNTIL YYYY-MM-DD

---

## Skills Index

| Skill | Trigger | Platforms | What it answers |
|---|---|---|---|
| 1 | `true-profit-check` | Meta + Google + Shopify | What your actual ROAS is after using Shopify as truth |
| 2 | `hidden-bestsellers` | Google + Shopify | Which top sellers have no ad coverage and vice versa |
| 3 | `product-scorecard` | Google + Shopify | Scale / Fix / Pause / Investigate per SKU |
| 4 | `new-vs-repeat` | Meta + Shopify | Are your ads acquiring new customers or recycling existing ones |
| 5 | `where-should-my-money-go` | Meta + Google + Shopify | Exactly how much to move between platforms and from where |
| 6 | `what-to-scale` | Google + Shopify | Products with proven ROAS that are underinvested right now |
| 7 | `creative-fatigue` | Meta only | Which active ads are fatiguing and need to be retired |
| 8 | `checkout-dropoff` | Shopify only | Where in your funnel the biggest revenue leak is |
| 9 | `placement-audit` | Meta only | Which Meta placements are quietly burning budget |
| 10 | `search-term-waste` | Google only | Wasted search spend and a ready-to-paste negative keyword list |
| 11 | `top-ad-finder` | Meta only | Which Meta ads are actually working right now |
| 12 | `impression-share-gaps` | Google + Shopify | Search demand you are losing on your own bestsellers |
| 13 | `search-term-opportunity` | Google + Shopify | Converting search terms with no dedicated campaign yet |
| 14 | `landing-page-audit` | Shopify only | Which landing pages are killing conversion and costing you revenue |
| 15 | `are-my-customers-coming-back` | Shopify only | Whether your retention foundation justifies increasing acquisition spend |

**Platform dependency:**
Meta only: Skills 7, 9, 11
Google + Shopify: Skills 2, 3, 6, 12, 13 — require Google Shopping or PMax with product feed
Meta + Shopify: Skill 4
Meta + Google + Shopify: Skills 1, 5
Shopify only: Skills 8, 14, 15

---

## Skill 1: true-profit-check

**Trigger:** `true-profit-check`

**What it answers:**
Meta reports one ROAS. Google reports another. Shopify recorded the actual revenue.
This skill uses Shopify net sales as the source of truth and shows exactly how far
each platform's reported number is from reality.

**Step 1 — Pull Meta account performance:**
```
facebook_get_adaccount_insights(
  act_id = META_ACT_ID,
  fields = ["spend", "purchase_roas", "action_values", "actions"],
  level = "account",
  date_preset = "last_30d",
  filtering = [{"field": "impressions", "operator": "GREATER_THAN", "value": 0}]
)
```
Extract:
- `spend` = Meta total spend
- From `action_values`: find action_type "omni_purchase" value = Meta claimed revenue
- From `purchase_roas`: find action_type "omni_purchase" value = Meta reported ROAS

**Step 2 — Pull Google campaign performance:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,  (omit if not a managed account)
  query = "
    SELECT
      campaign.name,
      campaign.advertising_channel_type,
      metrics.cost_micros,
      metrics.conversions_value,
      metrics.conversions
    FROM campaign
    WHERE segments.date DURING LAST_30_DAYS
      AND campaign.status = 'ENABLED'
    ORDER BY metrics.cost_micros DESC
    LIMIT 50
  "
)
```
Extract:
- Sum all `cost` (already in currency units) = Google total spend
- Sum all `conversionsValue` = Google claimed revenue

**Step 3 — Pull Shopify actual revenue:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["gross_sales", "net_sales", "orders", "average_order_value"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```
Extract:
- `net_sales` = Shopify source of truth (after discounts and returns)
- `gross_sales` = Shopify before discounts
- `orders` = actual order count

**Step 4 — Calculate:**
- Total ad spend = Meta spend + Google spend
- True blended ROAS = Shopify net_sales ÷ Total ad spend
- Platform combined claim = Meta claimed revenue + Google claimed revenue
- Attribution coverage = (Platform combined claim ÷ Shopify net_sales) × 100
  - If > 85%: platforms are claiming credit for nearly all revenue including organic/email/direct
  - If 60–85%: normal range for well-attributed accounts
  - If < 60%: significant untracked revenue or attribution setup issue

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ROAS REALITY CHECK — [period]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

TOTAL AD SPEND
Meta:    $X
Google:  $X
─────────────
Total:   $X

WHAT THE PLATFORMS REPORT
Meta ROAS:    Xx  ($X claimed revenue)
Google ROAS:  Xx  ($X claimed revenue)
Combined:         $X claimed

WHAT SHOPIFY RECORDED
Net revenue:      $X (after discounts + returns)
Gross revenue:    $X

TRUE BLENDED ROAS:  Xx

ATTRIBUTION AUDIT
Platforms claim $X combined on $X actual Shopify revenue
= XX% of all Shopify revenue being credited to ads
[flag if > 85%: platforms are claiming organic/email/direct sales too]

INTERPRETATION
[2–3 sentences: which platform is inflated, which is sandbagging, and what the gap means for budget decisions]
```

---

## Skill 2: hidden-bestsellers

**Trigger:** `hidden-bestsellers`

**What it answers:**
Your #1 Shopify seller may have almost no ad coverage.
Your top-spend Google product may barely sell.
This skill surfaces both mismatches so you can fix the allocation.

**Step 1 — Pull Shopify top 25 products by revenue:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["gross_sales", "net_sales", "orders"],
  dimensions = ["product_title"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```
Sort rows by gross_sales descending. Take top 25.
Exclude: null product_title rows, shipping protection lines, gift cards, $0 rows.

**Step 2 — Pull Google Shopping/PMax product spend:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      campaign.id,
      campaign.advertising_channel_type,
      segments.product_title,
      metrics.cost_micros,
      metrics.conversions,
      metrics.conversions_value,
      metrics.clicks,
      metrics.impressions
    FROM shopping_performance_view
    WHERE segments.date DURING LAST_30_DAYS
    ORDER BY metrics.cost_micros DESC
    LIMIT 100
  "
)
```
Aggregate by product_title (sum across variants and campaigns).

**Step 3 — Cross-reference:**

For each Shopify top-25 product:
- Is it present in Google product data?
- If yes: what is its Google spend rank vs Shopify revenue rank?
- If no: flag as uncovered

Classify each product into one of three buckets:
- **UNCOVERED**: In Shopify top 25 by revenue, not found in Google top 50 spend
- **MISALIGNED**: High Google spend (top 15 by spend) but outside Shopify top 25 by revenue
- **ALIGNED**: Strong in both Shopify revenue and Google spend

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PRODUCT AD GAP — [period]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🔴 TOP SELLERS WITH NO/LOW AD COVERAGE
(These products sell — ads aren't helping them)

→ [Product] | Shopify: $X gross, [N] orders | Google spend: $0 (not found)
→ [Product] | Shopify: $X gross, [N] orders | Google spend: $X (ranked #X in spend)

🟡 HEAVILY ADVERTISED, LOW SHOPIFY RETURN
(You're spending on products that don't move)

→ [Product] | Google spend: $X (rank #X) | Shopify: $X gross (rank #X)
→ [Product] | Google spend: $X (rank #X) | Shopify: $X gross (rank #X)

🟢 ALIGNED — STRONG ON BOTH
→ [Product] | Shopify: $X | Google: $X spend, Xx ROAS

TOP PRIORITY ACTION
[Specific: e.g. "Add [Product] to a dedicated PMax asset group — it's your #1 Shopify
seller at $X/month with zero Google coverage"]
```

---

## Skill 3: product-scorecard

**Trigger:** `product-scorecard`

**What it answers:**
For every product running in Google Shopping or PMax —
should you scale it, fix it, pause it, or investigate a possible feed issue?
One clear verdict per SKU, with exact spend and revenue numbers.

**Step 1 — Pull Google product-level data:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      campaign.id,
      campaign.advertising_channel_type,
      segments.product_title,
      segments.product_item_id,
      metrics.cost_micros,
      metrics.conversions,
      metrics.conversions_value,
      metrics.clicks,
      metrics.impressions
    FROM shopping_performance_view
    WHERE segments.date DURING LAST_30_DAYS
    ORDER BY metrics.cost_micros DESC
    LIMIT 100
  "
)
```
Aggregate by product_title: sum cost, conversions, conversions_value, clicks, impressions across all variants and campaigns.
Calculate per product: ROAS = conversions_value ÷ cost

**Step 2 — Pull Shopify product revenue:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["gross_sales", "net_sales", "orders"],
  dimensions = ["product_title"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```

**Step 3 — Classify each product using these rules (apply in order, first match wins):**

| Verdict | Criteria |
|---|---|
| **SCALE** | ROAS > 2.5x AND cost > $10 AND Shopify gross_sales > $200 |
| **PAUSE** | cost > $15 AND conversions < 0.3 AND impressions > 300 |
| **FIX** | clicks > 15 AND conversions < 0.5 AND cost > $10 (traffic not converting → landing page or price) |
| **INVESTIGATE** | impressions < 100 AND Shopify gross_sales > $200 (sells organically, invisible on Google → feed issue) |
| **MONITOR** | everything else |

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PRODUCT SCORECARD — [period]
[X] products analyzed across Shopping/PMax
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

⬆️  SCALE — increase budget on these
→ [Product] | $X spend → $X revenue (Xx ROAS) | Shopify: $X / [N] orders
  Action: Increase product group bid by 20–40%
→ ...

⏸️  PAUSE — zero return, confirmed wasted spend
→ [Product] | $X spend | [N] clicks | 0 conversions
  Action: Exclude from Shopping/PMax immediately
→ ...
TOTAL CONFIRMED WASTED SPEND: $X

🔧 FIX — traffic arriving, nothing converting
→ [Product] | [N] clicks | [N] conversions | $X spend
  Action: Check product page price, images, and copy vs ad creative
→ ...

🔍 INVESTIGATE — selling organically, invisible on Google
→ [Product] | $X Shopify revenue | [N] Google impressions
  Action: Check product feed — title, GTIN, category, and image may be suppressing
→ ...

SUMMARY
Wasted spend (pause candidates): $X/month
Undertapped ROAS (scale candidates): $X potential revenue at current ROAS
```

---

## Skill 4: new-vs-repeat

**Trigger:** `new-vs-repeat`

**What it answers:**
Meta says X% of your conversions are new customers.
Shopify says the actual new customer rate is Y%.
And your existing customers may be seeing your ads every single day.
This skill surfaces what's actually happening with customer acquisition vs retention.

**Step 1 — Pull Shopify customer metrics:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["orders", "gross_sales", "net_sales", "returning_customer_rate"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```
Extract:
- `returning_customer_rate` (0–1 decimal)
- New customer rate = 1 - returning_customer_rate

**Step 2 — Pull Meta user segment breakdown:**
```
facebook_get_adaccount_insights(
  act_id = META_ACT_ID,
  fields = ["spend", "purchase_roas", "actions", "action_values", "impressions", "frequency"],
  breakdowns = ["user_segment_key"],
  level = "account",
  date_preset = "last_30d",
  filtering = [{"field": "impressions", "operator": "GREATER_THAN", "value": 0}]
)
```
Extract per segment (prospecting / existing / engaged / unknown):
- spend
- purchases: from `actions` find action_type "omni_purchase" value
- revenue: from `action_values` find action_type "omni_purchase" value
- ROAS = revenue ÷ spend
- frequency (existing and engaged segments only)

**Step 3 — Calculate:**
- Meta prospecting spend % = prospecting spend ÷ total Meta spend × 100
- Meta existing + engaged spend % = (existing + engaged spend) ÷ total Meta spend × 100
- Meta implied new customer rate = prospecting purchases ÷ total Meta purchases × 100
- Shopify actual new customer rate = (1 - returning_customer_rate) × 100
- Gap = Meta implied new rate vs Shopify actual new rate
- Frequency flag: existing segment frequency > 15 = WARNING, > 25 = CRITICAL

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
NEW VS REPEAT — [period]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

SHOPIFY TRUTH
New customers:       XX% of orders
Returning customers: XX% of orders

META BUDGET SPLIT
Prospecting (new):   $X (XX% of spend) → Xx ROAS | [N] purchases
Existing customers:  $X (XX% of spend) → Xx ROAS | [N] purchases
Engaged customers:   $X (XX% of spend) → Xx ROAS | [N] purchases

ACQUISITION VS RETENTION GAP
Meta says XX% of its conversions are new customers
Shopify says XX% of all orders are new customers
Gap: [match / X% discrepancy — [explanation]]

FREQUENCY CHECK
Existing audience frequency: Xx/month
[HEALTHY (< 10x) / WARNING (10–20x): consider frequency cap / CRITICAL (> 20x): audience fatigue — reduce or refresh]

Engaged audience frequency: Xx/month
[same flag logic]

KEY FINDING
Retention outperforms acquisition by Xx on ROAS — [or reverse]
[Specific action: "Shift $X/month from prospecting to retention" or "Your existing
audience is saturated — set a 10x/month frequency cap or expand prospecting audiences"]
```

---

## Skill 5: where-should-my-money-go

**Trigger:** `where-should-my-money-go`

**What it answers:**
Based on actual ROAS performance across Meta segments and Google campaigns —
exactly how much should move, from where, and to where, this week.

**Step 1 — Pull Meta segment performance:**
```
facebook_get_adaccount_insights(
  act_id = META_ACT_ID,
  fields = ["spend", "purchase_roas", "action_values", "actions"],
  breakdowns = ["user_segment_key"],
  level = "account",
  date_preset = "last_30d",
  filtering = [{"field": "impressions", "operator": "GREATER_THAN", "value": 0}]
)
```
Extract: spend, ROAS, purchases per segment.

**Step 2 — Pull Google campaign performance:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      campaign.name,
      campaign.advertising_channel_type,
      metrics.cost_micros,
      metrics.conversions_value,
      metrics.conversions,
      metrics.search_impression_share
    FROM campaign
    WHERE segments.date DURING LAST_30_DAYS
      AND campaign.status = 'ENABLED'
    ORDER BY metrics.cost_micros DESC
    LIMIT 20
  "
)
```
Extract: spend, ROAS, campaign type per campaign.
Note: `search_impression_share` only valid for Search campaigns. For PMax it returns 0 — do not use as headroom signal for PMax. For PMax headroom, use ROAS as proxy: if ROAS > 3x, treat as having scale headroom.

**Step 3 — Pull Shopify totals:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["net_sales", "orders"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```

**Step 4 — Calculate reallocation:**
- Rank all channels/segments by ROAS
- Source of reallocation = lowest ROAS segment/campaign with meaningful spend (> $1,000/month)
- Destination = highest ROAS channel with evidence of headroom
- Suggested shift = 15–25% of source budget (conservative to avoid over-correction)
- Expected revenue impact = shift amount × destination ROAS

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
BUDGET REBALANCER — [period]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

CURRENT ALLOCATION
Meta total:   $X (XX%) blended Xx ROAS
  Prospecting:  $X → Xx ROAS
  Existing:     $X → Xx ROAS
  Engaged:      $X → Xx ROAS

Google total: $X (XX%) blended Xx ROAS
  [Campaign]:  $X → Xx ROAS
  [Campaign]:  $X → Xx ROAS

Shopify actual net revenue: $X
True blended ROAS: Xx

REALLOCATION RECOMMENDATION
Move FROM: Meta [segment] — $X/month at Xx ROAS (lowest performer)
Move TO:   Google [campaign type] — currently Xx ROAS [headroom signal]

Suggested shift: $X/month (~XX% of Meta [segment] budget)

Revenue impact:
  Keeping $X in Meta [segment]:  ~$X revenue at Xx ROAS
  Moving $X to Google [campaign]: ~$X revenue at Xx ROAS
  Net improvement: ~$X additional revenue/month

NOTE: Reduce prospecting first. Never cut existing/retention campaigns — they
protect the revenue baseline that makes everything else look profitable.
```

---

## Skill 6: what-to-scale

**Trigger:** `what-to-scale`

**What it answers:**
Which specific products have proven conversion rates and strong Shopify demand
but are barely getting any Google ad spend — your highest-confidence scale bets right now.

**Step 1 — Pull Google product-level performance:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      campaign.id,
      campaign.advertising_channel_type,
      segments.product_title,
      segments.product_item_id,
      metrics.cost_micros,
      metrics.conversions,
      metrics.conversions_value,
      metrics.clicks,
      metrics.impressions
    FROM shopping_performance_view
    WHERE segments.date DURING LAST_30_DAYS
    ORDER BY metrics.cost_micros DESC
    LIMIT 100
  "
)
```
Aggregate by product_title (sum across all variants and campaigns).
Calculate per product: ROAS = conversions_value ÷ cost. CPC = cost ÷ clicks.

**Step 2 — Pull Shopify product revenue:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["gross_sales", "net_sales", "orders"],
  dimensions = ["product_title"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```

**Step 3 — Identify scale signals:**
A product qualifies as a scale signal if ALL THREE conditions are true:
1. Google ROAS > 3x (proven ad conversion rate)
2. Google spend < $150 in 30 days (clearly underinvested)
3. Shopify gross_sales > $300 in same period (total demand exists)

Rank qualifying products by Google ROAS descending. Return top 5.

If fewer than 3 products meet all three criteria, relax condition 2 to < $300 spend.

**Step 4 — Calculate scale potential:**
For each qualifying product:
- Conservative scale target = current Google spend × 3
- Revenue at current ROAS = conservative scale target × ROAS

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
WHAT TO SCALE — [period]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Products with proven ROAS and confirmed Shopify demand — underinvested right now:

#1 [Product name]
   Google:  $X spend → $X revenue (Xx ROAS) | [N] conversions
   Shopify: $X total revenue | [N] orders
   Scale:   Increase to $X/month → ~$X additional revenue at current ROAS

#2 [Product name]
   Google:  $X spend → $X revenue (Xx ROAS) | [N] conversions
   Shopify: $X total revenue | [N] orders
   Scale:   Increase to $X/month → ~$X additional revenue at current ROAS

[#3–5 same format]

HOW TO SCALE THESE IN GOOGLE ADS
For PMax: Create a dedicated asset group for each product with matching headlines,
images, and audience signals. Separate asset groups give the algorithm a cleaner
signal than mixing top performers with low performers in one group.

For Shopping: Create a separate campaign for these SKUs, set manual CPC bids,
and exclude them from the catch-all Shopping campaign to avoid internal competition.

TOTAL SCALE POTENTIAL (conservative):
If top 3 products reach 3x current spend at same ROAS: ~$X additional revenue/month
```

---

## Skill 7: creative-fatigue

**Trigger:** `creative-fatigue`

**What it answers:**
Which of your active Meta ads are fatiguing right now — CPM climbing, CTR falling —
ranked by spend so the highest-investment ads are evaluated first.

**Step 1 — Pull ad-level performance with 7-day time increment:**
```
facebook_get_adaccount_insights(
  act_id = META_ACT_ID,
  fields = ["ad_name", "spend", "ctr", "cpm", "impressions", "purchase_roas", "actions"],
  level = "ad",
  time_increment = 7,
  date_preset = "last_28d",
  filtering = [
    {"field": "impressions", "operator": "GREATER_THAN", "value": 0},
    {"field": "ad.effective_status", "operator": "IN", "value": ["ACTIVE"]}
  ]
)
```
This returns 4 weekly rows per ad. Group rows by ad_id, sort chronologically.

**Step 2 — Calculate week-over-week delta per ad:**
For each ad with at least 2 weekly data points:
- CTR delta = (Week 4 CTR - Week 3 CTR) / Week 3 CTR × 100
- CPM delta = (Week 4 CPM - Week 3 CPM) / Week 3 CPM × 100
- Spend in most recent week = Week 4 spend

**Step 3 — Classify each ad:**

| Verdict | Criteria |
|---|---|
| RETIRE NOW | CPM increased > 15% AND CTR dropped > 20% week-over-week |
| WATCH | CPM increased > 10% OR CTR dropped > 15% (one signal only) |
| HEALTHY | Neither threshold triggered |

**Step 4 — Rank all ads by 28-day total spend descending.**

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CREATIVE FATIGUE REPORT — last 28 days
[X] active ads analyzed
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🔴 RETIRE NOW
→ [Ad name] | $X spend | CTR: -XX% WoW | CPM: +XX% WoW | ROAS: Xx
→ [Ad name] | ...

🟡 WATCH
→ [Ad name] | $X spend | CTR: -XX% WoW | CPM: +XX% WoW
→ ...

🟢 HEALTHY
→ [Ad name] | $X spend | CTR stable | CPM stable
→ ...

SUMMARY
Ads to retire: [N] | Spend at risk: $X/month
Ads to watch: [N]
Recommendation: Replace RETIRE NOW ads before pausing — have new creative live
first to avoid losing campaign learning.
```

---

## Skill 8: checkout-dropoff

**Trigger:** `checkout-dropoff`

**What it answers:**
Where in your Shopify funnel is the biggest revenue leak — and exactly how much
is it costing you per month in missed orders.

**Step 1 — Pull session funnel:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sessions",
  metrics = [
    "sessions",
    "sessions_with_cart_additions",
    "sessions_that_reached_checkout",
    "sessions_that_completed_checkout",
    "conversion_rate"
  ],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```

**Step 2 — Pull average order value:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["average_order_value", "net_sales", "orders"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```

**Step 3 — Calculate funnel stages:**
- Browse-to-cart rate = sessions_with_cart_additions / sessions × 100
- Cart-to-checkout rate = sessions_that_reached_checkout / sessions_with_cart_additions × 100
- Checkout-to-purchase rate = sessions_that_completed_checkout / sessions_that_reached_checkout × 100
- Overall CVR = conversion_rate

For each stage calculate:
- Drop-off count = sessions entering stage - sessions advancing
- Drop-off % = drop-off count / sessions entering stage × 100
- Revenue impact = drop-off count × average_order_value × next-stage conversion rates
  (how much revenue those dropped sessions would have generated if they converted)

**Step 4 — Identify biggest leak stage:**
The stage with the highest revenue impact number is the primary fix target.

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
CHECKOUT DROPOFF — [period]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

FUNNEL
Sessions:              [N]       (100%)
Added to cart:         [N]       (XX% of sessions — [N] dropped here)
Reached checkout:      [N]       (XX% of cart adds — [N] dropped here)
Completed purchase:    [N]       (XX% of checkouts — [N] dropped here)
Overall CVR:           XX%

REVENUE LEAK BY STAGE
Browse → Cart:     [N] sessions lost = ~$X/month in missed revenue
Cart → Checkout:   [N] sessions lost = ~$X/month in missed revenue
Checkout → Purchase: [N] sessions lost = ~$X/month in missed revenue

BIGGEST LEAK: [stage name] — $X/month
Fix: [one specific recommendation based on which stage is worst]
  Browse→Cart: improve product page content, images, and pricing clarity
  Cart→Checkout: reduce friction — guest checkout, trust signals, shipping cost visibility
  Checkout→Purchase: review payment options, address fields, error states
```

---

## Skill 9: placement-audit

**Trigger:** `placement-audit`

**What it answers:**
Which Meta placements are spending real money at ROAS meaningfully below your
account average — and exactly how much to reclaim by excluding them.

**Step 1 — Pull account-level ROAS benchmark:**
```
facebook_get_adaccount_insights(
  act_id = META_ACT_ID,
  fields = ["spend", "purchase_roas", "action_values", "actions"],
  level = "account",
  date_preset = "last_30d",
  filtering = [{"field": "impressions", "operator": "GREATER_THAN", "value": 0}]
)
```
Extract: account-average purchase_roas value = BENCHMARK_ROAS

**Step 2 — Pull placement breakdown:**
```
facebook_get_adaccount_insights(
  act_id = META_ACT_ID,
  fields = ["spend", "purchase_roas", "action_values", "actions", "impressions", "cpm", "ctr"],
  breakdowns = ["publisher_platform", "platform_position"],
  level = "account",
  date_preset = "last_30d",
  filtering = [{"field": "impressions", "operator": "GREATER_THAN", "value": 0}]
)
```

**Step 3 — Classify each placement:**
For each placement row:
- Extract purchase ROAS from action_type "omni_purchase" in purchase_roas array
- Extract purchases from actions array action_type "omni_purchase"
- Flag if: spend > 30 AND placement ROAS < (BENCHMARK_ROAS × 0.80)
- Calculate wasted spend = spend at that placement × (1 - placement_ROAS / BENCHMARK_ROAS)

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
PLACEMENT AUDIT — last 30 days
Account benchmark ROAS: Xx
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

UNDERPERFORMING PLACEMENTS (>$30 spend, >20% below benchmark)
→ [Platform] / [Position] | $X spend | Xx ROAS | ~$X estimated waste
→ [Platform] / [Position] | $X spend | Xx ROAS | ~$X estimated waste

STRONG PLACEMENTS (at or above benchmark)
→ [Platform] / [Position] | $X spend | Xx ROAS
→ ...

TOTAL ESTIMATED WASTE: $X/month from underperforming placements

ACTION
In Meta Ads Manager → Ad Set level → Placements → Manual Placements →
Uncheck: [list each flagged placement]
Apply to all active ad sets above $100/month spend.
```

---

## Skill 10: search-term-waste

**Trigger:** `search-term-waste`

**What it answers:**
Every search term spending above your CPA threshold with no conversions to show for it —
with a ready-to-paste negative keyword list so you can stop the bleed today.

**Step 1 — Get account average CPA:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      metrics.cost_micros,
      metrics.conversions,
      metrics.cost_per_conversion
    FROM customer
    WHERE segments.date DURING LAST_30_DAYS
    LIMIT 1
  "
)
```
Extract: account CPA = cost_per_conversion (in account currency, already converted from micros)
If conversions = 0, use (total spend / 10) as fallback CPA threshold.

**Step 2 — Pull Search campaign search terms:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      search_term_view.search_term,
      campaign.name,
      campaign.advertising_channel_type,
      metrics.cost_micros,
      metrics.conversions,
      metrics.clicks,
      metrics.impressions
    FROM search_term_view
    WHERE segments.date DURING LAST_30_DAYS
      AND metrics.cost_micros > 0
    ORDER BY metrics.cost_micros DESC
    LIMIT 200
  "
)
```

**Step 3 — Pull Shopping search terms (if Shopping campaigns exist):**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      segments.search_term_match_type,
      shopping_performance_view.resource_name,
      campaign.name,
      metrics.cost_micros,
      metrics.conversions,
      metrics.clicks
    FROM shopping_performance_view
    WHERE segments.date DURING LAST_30_DAYS
      AND metrics.cost_micros > 0
    ORDER BY metrics.cost_micros DESC
    LIMIT 100
  "
)
```

**Step 4 — Classify and build negative list:**
Flag any search term where: cost > ACCOUNT_CPA AND conversions < 0.5

For each flagged term, assign match type:
- Exact match: single high-specificity terms with zero conversions and > 2× CPA spend
- Phrase match: terms containing waste patterns (e.g. "free", "how to", "DIY", competitor + review)
- Default to Exact for everything else

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SEARCH TERM WASTE — last 30 days
Account average CPA: $X
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

TOTAL CONFIRMED WASTED SPEND: $X across [N] search terms

TOP WASTED TERMS
→ "[term]" | $X spent | [N] clicks | 0 conversions | Campaign: [name]
→ "[term]" | $X spent | [N] clicks | 0 conversions | Campaign: [name]
[continue for all flagged terms]

NEGATIVE KEYWORD LIST (paste directly into Google Ads)

EXACT MATCH — add at campaign level:
[exact match keyword]
[exact match keyword]

PHRASE MATCH — add at campaign level:
"phrase match keyword"
"phrase match keyword"

HOW TO ADD
Google Ads → Keywords tab → Negative Keywords →
Paste the list above → Select campaign level → Save
```

---

## Skill 11: top-ad-finder

**Trigger:** `top-ad-finder`

**What it answers:**
Which Meta ads are actually working right now — ranked by ROAS with spend,
format, and purchase data so you know what to protect, what to duplicate,
and what to brief next.

**Step 1 — Pull active ad-level performance:**
```
facebook_get_adaccount_insights(
  act_id = META_ACT_ID,
  fields = ["ad_name", "adset_name", "campaign_name", "spend", "purchase_roas",
            "ctr", "cpm", "actions", "action_values", "impressions", "clicks"],
  level = "ad",
  date_preset = "last_30d",
  filtering = [
    {"field": "spend", "operator": "GREATER_THAN", "value": 50},
    {"field": "impressions", "operator": "GREATER_THAN", "value": 0},
    {"field": "ad.effective_status", "operator": "IN", "value": ["ACTIVE"]}
  ],
  sort = "spend_descending",
  limit = 50
)
```

**Step 2 — Extract and sort:**
For each ad:
- Extract purchase ROAS from purchase_roas array (action_type "omni_purchase")
- Extract purchase count from actions array (action_type "omni_purchase")
- Extract revenue from action_values array (action_type "omni_purchase")
- Calculate CPA = spend / purchases (if purchases > 0)

Filter out ads with fewer than 3 purchases (statistically insufficient).
Sort remaining ads by purchase ROAS descending.
Take top 10.

**Step 3 — Identify format pattern:**
Note ad_name patterns that indicate format (video, image, carousel) if naming convention allows.
Flag ads where spend is high but purchases < 3 as "insufficient data" rather than top performers.

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
TOP AD FINDER — last 30 days
[N] active ads with >$50 spend analyzed
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

RANK | AD NAME | SPEND | ROAS | CTR | CPM | PURCHASES | CPA
  1  | [name]  | $X    | Xx   | X%  | $X  | [N]       | $X
  2  | [name]  | $X    | Xx   | X%  | $X  | [N]       | $X
  3  | [name]  | $X    | Xx   | X%  | $X  | [N]       | $X
[continue to #10]

CAMPAIGN BREAKDOWN
Top performers are running in: [campaign names]

WHAT TO DO
Protect: Do not pause or modify top 3 ads — they are in active learning or
  proven delivery. Any edit resets learning.
Duplicate: Take ad #1 hook and copy structure → create 2–3 new variations
  testing different products or audiences.
Kill: Any active ad outside this top 10 with > $100 spend and < 1.0x ROAS
  should be reviewed for immediate pause.
```

---

## Skill 12: impression-share-gaps

**Trigger:** `impression-share-gaps`

**What it answers:**
For your top Shopify bestsellers — what percentage of available Google search
demand are you actually capturing? If impression share is below 60%, you are
handing search traffic for your own products to competitors.

**Step 1 — Pull Shopify top 10 sellers:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["gross_sales", "orders"],
  dimensions = ["product_title"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```
Take top 10 by gross_sales. Exclude null titles and non-product rows.

**Step 2 — Pull Google campaign impression share:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      campaign.name,
      campaign.advertising_channel_type,
      metrics.cost_micros,
      metrics.conversions_value,
      metrics.conversions,
      metrics.impressions,
      metrics.search_impression_share,
      metrics.search_rank_lost_impression_share,
      metrics.search_budget_lost_impression_share
    FROM campaign
    WHERE segments.date DURING LAST_30_DAYS
      AND campaign.status = 'ENABLED'
    ORDER BY metrics.cost_micros DESC
    LIMIT 20
  "
)
```
Note: search_impression_share is only valid for Search campaigns. Returns 0 for PMax.

**Step 3 — Pull product-level impression data:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      campaign.id,
      campaign.advertising_channel_type,
      segments.product_title,
      metrics.impressions,
      metrics.clicks,
      metrics.cost_micros,
      metrics.conversions
    FROM shopping_performance_view
    WHERE segments.date DURING LAST_30_DAYS
    ORDER BY metrics.impressions DESC
    LIMIT 100
  "
)
```

**Step 4 — Cross-reference and flag:**
For each Shopify top-10 product:
- Find matching Google product title (fuzzy match on key words)
- If found in Shopping data: flag impression share if available, or flag if impressions are low relative to spend
- If not found in Shopping data at all: INVESTIGATE flag (feed issue)
- For Search campaigns: use search_impression_share directly

Flag: impression share < 60% = losing > 40% of available demand.
Split loss cause: rank (bid/quality score issue) vs budget (daily budget exhaustion).

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
IMPRESSION SHARE GAPS — last 30 days
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

YOUR TOP SHOPIFY SELLERS VS GOOGLE COVERAGE

Product (Shopify rank) | Shopify Revenue | Google Impressions | Gap | Action
─────────────────────────────────────────────────────────────────
[Product] (#1) | $X | [N] impressions | [IS%] | [action]
[Product] (#2) | $X | [N] impressions | [IS%] | [action]
[continue for top 10]

FLAGGED — IMPRESSION SHARE BELOW 60%
→ [Product]: IS XX% — losing XX% of searches.
   Cause: [rank (increase bid / improve quality score) or budget (increase daily cap)]
   Fix: [specific action]

FLAGGED — NOT FOUND IN GOOGLE AT ALL
→ [Product]: $X Shopify revenue, 0 Google impressions
   Likely cause: product feed missing or suppressed
   Fix: Check Merchant Center for feed errors on this product
```

---

## Skill 13: search-term-opportunity

**Trigger:** `search-term-opportunity`

**What it answers:**
Which search terms are already converting in Google but have no dedicated
campaign or ad group capturing them properly — these are your highest-confidence
expansion bets because demand and conversion are already proven.

**Step 1 — Pull converting search terms:**
```
google_ads_run_gaql(
  customer_id = GOOGLE_ID,
  manager_id = GOOGLE_MANAGER_ID,
  query = "
    SELECT
      search_term_view.search_term,
      campaign.name,
      campaign.advertising_channel_type,
      metrics.conversions,
      metrics.conversions_value,
      metrics.cost_micros,
      metrics.clicks,
      metrics.impressions
    FROM search_term_view
    WHERE segments.date DURING LAST_30_DAYS
      AND metrics.conversions >= 1
    ORDER BY metrics.conversions DESC
    LIMIT 100
  "
)
```

**Step 2 — Pull Shopify top sellers:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["gross_sales", "net_sales", "orders"],
  dimensions = ["product_title"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```
Take top 20 by gross_sales.

**Step 3 — Cross-reference and identify gaps:**
For each converting search term:
- Check if it has a dedicated exact match keyword in a Search campaign
  (Look for the term in keyword data — if only appearing via broad/phrase catch, flag as gap)
- Check if it aligns with a Shopify top-20 product by keyword overlap
- Score each term: conversions + (Shopify product revenue / 1000) = opportunity score

Surface top 5–10 by opportunity score where:
- The term is converting but only caught by broad match or PMax (no dedicated campaign)
- The term matches a Shopify bestseller

**Step 4 — Build campaign recommendation per term:**
For each opportunity term: recommend Exact Match keyword → new ad group → existing campaign
or new Search campaign if no relevant campaign exists.

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
SEARCH TERM OPPORTUNITY — last 30 days
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

TOP OPPORTUNITIES (converting terms with no dedicated capture)

#1 "[search term]"
   Conversions: [N] | Spend: $X | CPA: $X | Currently caught by: [broad/PMax]
   Matches Shopify product: [product name] ($X Shopify revenue)
   Action: Add as [Exact Match] keyword to [Campaign name] → [Ad Group name]

#2 "[search term]"
   [same format]

[#3–10 same]

TOTAL UNTAPPED CONVERSION POTENTIAL
If these terms had dedicated ad groups at current CPA: ~[N] additional conversions/month
Estimated additional revenue: ~$X/month at current conversion value

HOW TO ADD
Google Ads → [Campaign] → Ad Groups → New Ad Group →
Add [term] as Exact Match → Write 3 headlines specific to [product]
```

---

## Skill 14: landing-page-audit

**Trigger:** `landing-page-audit`

**What it answers:**
Which landing pages are receiving meaningful traffic but converting at rates
too low to sustain profitable paid acquisition — and exactly how much revenue
those underperforming pages are costing you each month.

**Step 1 — Pull landing page session data:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sessions",
  metrics = [
    "sessions",
    "sessions_with_cart_additions",
    "sessions_that_reached_checkout",
    "sessions_that_completed_checkout",
    "conversion_rate"
  ],
  dimensions = ["landing_page_path"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```
Sort by sessions descending. Take top 15.

**Step 2 — Pull AOV:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["average_order_value"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```

**Step 3 — Classify each page:**
For each landing page with sessions > 100/month:
- CVR = sessions_that_completed_checkout / sessions × 100
- Flag if CVR < 1%: underperforming
- Revenue impact = sessions × (0.01 - actual_CVR) × average_order_value
  (how much additional revenue if CVR was at the 1% baseline)
- Flag if CVR < 0.5%: critically underperforming

**Step 4 — Rank by revenue impact descending.**

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
LANDING PAGE AUDIT — last 30 days
Store AOV: $X
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🔴 CRITICALLY UNDERPERFORMING (CVR < 0.5%)
→ [Page path] | [N] sessions | X.X% CVR | $X missed revenue/month
→ ...

🟡 UNDERPERFORMING (CVR 0.5%–1.0%)
→ [Page path] | [N] sessions | X.X% CVR | $X missed revenue/month
→ ...

🟢 HEALTHY (CVR > 1%)
→ [Page path] | [N] sessions | X.X% CVR
→ ...

TOTAL MISSED REVENUE FROM UNDERPERFORMING PAGES: $X/month

FIX CHECKLIST (apply to each flagged page)
Check: product images (minimum 5, lifestyle + detail), price vs competitor,
reviews visible above fold, mobile layout, page load speed under 3 seconds,
add-to-cart button prominent without scrolling, shipping cost visible early.
```

---

## Skill 15: are-my-customers-coming-back

**Trigger:** `are-my-customers-coming-back`

**What it answers:**
What percentage of new customers from each of the last 6 months returned
for a second purchase — and whether your retention rate is strong enough
to justify increasing paid acquisition spend.

**Step 1 — Pull monthly customer cohorts:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "customers",
  metrics = ["new_customers", "returning_customers"],
  dimensions = ["month"],
  start_date = [6 months ago],
  end_date = PERIOD_END
)
```
Or using TIMESERIES syntax:
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["orders", "returning_customer_rate"],
  dimensions = ["month"],
  start_date = [6 months ago],
  end_date = PERIOD_END
)
```

**Step 2 — Pull overall retention metrics:**
```
shopify_run_analytics_query(
  account_id = SHOPIFY_ID,
  dataset = "sales",
  metrics = ["orders", "gross_sales", "net_sales", "returning_customer_rate", "average_order_value"],
  start_date = PERIOD_START,
  end_date = PERIOD_END
)
```

**Step 3 — Calculate second-purchase rate:**
For each monthly cohort:
- Second purchase rate = returning_customers in month X+1 through X+3 / new_customers in month X
  (approximation: use returning_customer_rate as proxy if cohort data is unavailable)

Overall second-purchase rate = 1 - returning_customer_rate (as Shopify defines returning customers
as those with > 1 order ever, not necessarily in the current period — use with caveat noted in output)

**Step 4 — Verdict on acquisition readiness:**
- Second-purchase rate > 30%: retention is strong — scaling acquisition is justified
- Second-purchase rate 20–30%: retention is acceptable — scale cautiously
- Second-purchase rate < 20%: retention is weak — fix retention before scaling acquisition spend

**Output:**
```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
REPEAT PURCHASE GAP — last 6 months
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

MONTHLY COHORT RETENTION
Month    | New customers | Returning rate | Trend
[Month]  | [N]           | XX%            | [up/down/flat]
[Month]  | [N]           | XX%            | [up/down/flat]
[6 rows]

OVERALL METRICS (last 30 days)
Returning customer rate:    XX%
New customer rate:          XX%
AOV — new customers:        $X (estimated)
AOV — returning customers:  $X (estimated)

VERDICT: [STRONG / ACCEPTABLE / WEAK RETENTION]

[STRONG]: Your XX% second-purchase rate means each acquired customer generates
  meaningful repeat revenue. Unit economics support increasing acquisition spend.

[ACCEPTABLE]: Retention is functional but not exceptional. Scale acquisition
  conservatively and invest in post-purchase email flows to push above 30%.

[WEAK]: More than 80% of customers never come back. Increasing acquisition spend
  now means paying full CAC for customers with near-zero LTV multiple.
  Fix: Launch a 3-email post-purchase sequence and a 90-day win-back flow
  before increasing Meta or Google budgets.
```

---

## Error handling

**`shopping_performance_view` returns no rows:**
The account is not running Google Shopping or PMax with a product feed.
Skills 2, 3, 6, 12, and 13 will not produce output. All other skills still run fully.
Inform the user and run the platform-independent skills instead.

**`search_term_view` returns no rows:**
The account may have no active Search campaigns, or search terms may be suppressed
by privacy thresholds. Skill 10 and 13 cannot run. Confirm Search campaigns are active.

**Shopify `sessions` dataset returns no data:**
The sessions dataset requires Shopify Analytics to be enabled on the store plan.
Skills 8 and 14 depend on this. If it fails, inform the user and skip to other skills.
Try: narrowing date range to last 14 days as a fallback.

**Shopify `customers` dataset returns no monthly breakdown:**
Skill 15 falls back to overall returning_customer_rate from the `sales` dataset.
Note in output that cohort-level data was unavailable and the figure is a 30-day average.

**Meta `user_segment_key` breakdown returns only 1–2 segments:**
Account may not have enough spend history for Meta to fully segment.
Run Skill 4 using account-level data only. Note in output that segment data is incomplete.

**Meta placement breakdown returns no Audience Network row:**
Audience Network may be disabled in all ad sets. Skip that placement in Skill 9.
No action needed — the exclusion is already in place.

**Shopify analytics query fails:**
1. Run `shopify_list_shops` to confirm store is connected.
2. If connected, try narrowing date range to last 14 days.
3. If still failing, the store may have restricted analytics permissions in GoMarble.

**Google returns `not accessible` error:**
The account is a managed account. Pass `manager_id` parameter.
Run `google_ads_list_accounts` to find the correct manager_id for this account.

**Meta token expiry / permission error:**
Do not retry. Show the user: "Your Meta connection needs to be refreshed.
Go to apps.gomarble.ai → Settings → Integrations → Reconnect Meta."

**`search_impression_share` returns 0 for all campaigns:**
This metric is only valid for Search campaigns. If the account runs PMax only,
impression share data is unavailable. Skill 12 will note this and fall back
to raw impressions and spend as the coverage proxy.

---

## Running multiple skills at once

You can chain skills in a single session. Example:

> "Run true-profit-check then where-should-my-money-go"

Claude will run true-profit-check first to establish the true ROAS baseline,
then use that context to make the where-should-my-money-go recommendation more precise.

Recommended chain for a full account review:
1. `true-profit-check` — establish the truth layer
2. `new-vs-repeat` — understand the customer mix
3. `hidden-bestsellers` — find which top sellers have no ad coverage
4. `product-scorecard` — clean up the catalog SKU by SKU
5. `what-to-scale` — find the growth levers
6. `where-should-my-money-go` — reallocate based on all of the above
7. `creative-fatigue` — retire what is burning out
8. `top-ad-finder` — protect and duplicate what is working
9. `placement-audit` — stop placement waste
10. `search-term-waste` — cut Google waste and build negative list
11. `checkout-dropoff` — find the biggest funnel leak
12. `landing-page-audit` — fix the pages losing paid traffic
13. `are-my-customers-coming-back` — validate retention before scaling spend
14. `impression-share-gaps` — capture demand you are already losing
15. `search-term-opportunity` — build campaigns around proven converters