MCP App Store
by KeenEthics
WorkMagic icon

WorkMagic MCP Server for ChatGPT

By WorkMagic

Overview

Ask questions about your WorkMagic attribution data, diagnose swings, compare attribution models, read lift test results, and plan media budgets — using your own WorkMagic account through the WorkMagic MCP server.

How to connect

  1. ChatGPT: Open the WorkMagic listing in the ChatGPT app directory and choose Connect. ChatGPT listing WorkMagic exposes 68 tools here.

Tools

budget-optimizer-compare

ChatGPT
Compare 2–5 saved MBO scenarios side-by-side. Returns a structured diff report you should turn into a comparison TABLE for the user (not paragraphs of one scenario followed by another). Returns: • scenarios[] — per-scenario summary card (name + recommendedSpend + recommendedSales + recommendedRoas + status) • byChannel[] — every channel/tactic that appears in any scenario, with per-scenario recommendedSpend so a side-by-side table is one map • keyDifferences[] — channels sorted by the spread between scenarios (largest dollar differences first). Use this to write 'the biggest moves' narrative without invented ranking. • skipped[] — scenario ids whose forecast wasn't ready (status reported) 🗣️ COMMUNICATION RULES: • Refer to scenarios by name, never by numeric id. • Use business language ('more aggressive on Meta', 'concentrated on Google'), not internal field names ('strategy=aggressive', 'budgetDetail[0].spendBound'). • Lead with the comparison and the key differences. Mention shared behaviour briefly. • Quote each delta with absolute dollar AND percent change (e.g. '$50k → $80k (+60%)'). • Do NOT pick a winner unless the user asks 'which one is better'. Instead, frame each option in decision terms ('this one is for X user, that one for Y'). Requires every scenario to be on the same tenantId.

budget-optimizer-create

ChatGPT
Create a new MBO scenario AND wait for the forecast result inline (up to ~90s). Most calls return {scenario, forecast:{status:'ready', summary, rows, ...}} — the full forecast embedded in the same response. Slow/timed-out runs return forecast:{status:'running'} and the agent should fall back to budget-optimizer-forecast ~30s later; failed runs return forecast:{status:'error'}. 🗣️ When `forecast.status === 'ready'`, you MUST summarize the result to the user in the same turn — cite top reallocations, delta vs baseline, excluded / insufficient-data channels. Do NOT just say 'click the link to see results' — the data is right there in `forecast.summary` + `forecast.rows`. 🔗 Scenario URL — the response includes a scenarioUrl field with the canonical URL where the user can view this scenario in the UI. When you DO want to give the user a link (e.g. 'open it in the optimizer UI'), quote scenarioUrl VERBATIM. NEVER construct a URL yourself (no app.workmagic.io/..., no guessed paths). If scenarioUrl is absent from the response, do NOT mention any link — say only 'scenario id <id>'. 📋 MINIMAL INTAKE — four things require the user (MCP will NOT default them): 1. period (week/month/quarter + start+end dates) 2. goal + sales-platform scope — the goal ('roas' or 'sales' — map intent: 'maximize ROAS' → roas+maximum, 'hit 4x ROAS' → roas+target+goalTarget=4, 'maximize sales' → sales), AND whether to optimize across all sales platforms (Halo outcome, e.g. totalSalesHalo) or DTC only (non-Halo, e.g. totalSales — excludes Amazon). These are two separate questions; ASK the all-vs-DTC one explicitly (it's the UI's Sales-platform selector), don't just pick the metric. 3. budget (skip ONLY when goal='roas' + goalMethod='target' — that's the single goal type where a target ROAS replaces a budget constraint; every other case needs a budget, including goalMethod='maximum') 4. reference window (modelReferenceStartDate / modelReferenceEndDate) — the MMM baseline window. There is NO default — both create AND budget-optimizer-reference-data HARD-ERROR if you omit it. Call budget-optimizer-reference-data (same scope) WITHOUT a window to get the allowed model window from the error, PRESENT that range to the user, ASK them to choose a reference period, THEN call again with explicit dates. Do NOT propose, default, invent ('last 7 days', 'prior month'), or reuse a previous window. (modelRefreshDate is exempt — it auto-defaults to the latest model and need not be asked.) Everything else has a UI-equivalent default. Every default MCP fills is returned in appliedDefaults — you MUST echo them to the user for confirmation (e.g. "I'll optimize next week, maximize sales, keep budget flat (100%), aggressive strategy, all tactics — say if you want to change any of these") before treating the scenario as final. 📐 SCALES AND UNITS: • budgetChangeType='amount': budget is the absolute TOTAL spend for the whole period in the tenant's currency. '$100k' → 100000, '$1.5M' → 1500000, '$300k for the quarter' with period='quarter' → 300000. NEVER pass 100 for $100k. • budgetChangeType='percentage' (the DEFAULT): budget is a PERCENT OF the baseline spend, NOT a signed delta. 100 = keep current spend, 200 = double, 50 = half, 120 = '+20% more', 75 = 'cut 25%', 0 would mean spend nothing (rejected). So 'keep budget the same' → budget=100 (NOT 0); 'increase 20%' → 120 (NOT 20); 'cut spend 10%' → 90 (NOT -10). 🎚️ STRATEGY — defaults to 'aggressive' (do NOT ask unless the user signals risk appetite). 'aggressive' = wide bounds (the most actionable default for the optimizer to find meaningful reallocations). 'conservative' = tight bounds, 'moderate' = mid-range bounds. Strategy applies uniformly when no per-channel locks. For mixed per-tactic strategies or hard locks, pass budgetDetail[] explicitly. 🔒 CHANNEL LOCKS / CONSTRAINTS — express via budgetDetail entries with strategy='manual' and explicit spendBound. ALWAYS give the lock in DOLLARS (absolute spend for the period) — MCP converts it to the scenario's unit…

budget-optimizer-forecast

ChatGPT
Read the optimizer's recommendation rows for a saved scenario. Returns the summary card (current vs recommended overall spend + sales + ROAS) plus per-channel/tactic rows (currentSpend, recommendedSpend, deltaPct, sales, marginalRoas, calibration tag). 🔗 `summary.currentSpend` (overall) and `rows[].currentSpend` (per-channel) are the SAME data the UI's 'Reference' column shows on the scenario allocation table — both come from the forecast worker's baseline_1 array (stored in ods_mmm_result_prod_v2 per forecast run). When the user asks 'what's my reference spend' or 'what's the current spend on Meta for this scenario', answer with these fields. NEVER answer reference-spend questions from budget-optimizer-reference-data — that tool reads a different layer (MMM training hyper-params) and the numbers will diverge. Two flag arrays you MUST surface to the user before interpreting the rest of the forecast: • excludedChannels: [{channel, tactic}] — currentSpend=0 in the reference period; the channel is NOT part of this budget plan. • insufficientDataChannels: [{channel, tactic}] — calibration=InsufficientData; the model left this channel's spend unchanged (noChange). Status semantics: - 'ready': forecast complete, summary + rows populated - 'running': forecast started but not finished; retry in ~30s. Do NOT interpret stale rows when status≠'ready'. - 'not_started': no result row exists for this scenario yet (recently created? model not calibrated? lift test missing?) - 'error': forecast finished but returned no valid result Options: - onlyChanged=true: filter rows where currentSpend ≈ recommendedSpend - includeSaturation=true: include downsampled (~20 pts) saturation curve per row - saturationDetail='full': the unsampled UI curve per row as parallel arrays, with the indices of the current / recommended spend — for charts and exports only (large; pair with focus) - focus='<channel>': restrict to one channel (also limits saturation curve) 🗣️ EXPLAINING THE FORECAST — when the user asks 'why does it recommend X?', answer with all four of: 1. Direction: more spend or less, by how many dollars and as a % of current spend (use deltaPct). 2. Reason: pick from marginalRoas (return per extra dollar) and saturation (channel approaching diminishing returns). Use the tool's numbers, not invented ones. 3. Magnitude: dollar change and % of current spend. 4. Impact: sales/ROAS delta from the summary. First time you use a term like 'marginal ROAS' or 'saturation curve', give a one-line plain-English gloss (e.g. 'marginal ROAS = sales each extra dollar produces') — don't drop jargon without explaining it once. 🔀 vs OTHER PRODUCTS — when the user compares MBO to attribution dashboards or lift tests, don't dodge and don't pick sides. MBO marginal ROAS answers 'where does the NEXT dollar go best' (forward-looking, incremental). Attribution last-click / multi-touch answers 'who got credit for past sales' (backward-looking, share-of-credit). Lift tests measure incremental ROAS in a single window and are used to CALIBRATE MBO — they're meant to agree on incrementality, not on per-channel attribution numbers. Quote specific values from both sides when explaining.

budget-optimizer-list

ChatGPT
List all SAVED Media Budget Optimizer (MBO) scenarios for the current tenant. An MBO scenario is a user-configured forecast request (level, outcome, period, budget, channels, goal). Returns each scenario's inputs + numeric id used by forecast / update / delete operations. Follow up with budget-optimizer-forecast (id=<n>) to read the actual recommendation rows for a saved scenario. ⚠️ DO NOT use this tool for: • Historical ad spend or sales (use dashboard-* / database-query-run) • Current/baseline spend per channel (use budget-optimizer-reference-data) • Feasible spend ranges or ROAS bounds (use budget-optimizer-reference-data) • 'How much should I spend on X?' — that's an optimal-allocation question; guide the user to budget-optimizer-create + -forecast instead. Do NOT scrape numbers out of a returned scenario's budgetDetail as if it were a recommendation for a different period/scope. When the user says vague things like 'show me my budget data' / 'show my budget' / 'how is my budget?' / 'check my budget for Q3' — ASK FIRST whether they want: (a) historical actual spend / performance (dashboard tools), or (b) the list of saved optimization scenarios (this tool), or (c) a new optimal allocation (guide them to budget-optimizer-create). Offer 2–4 options that fit their phrasing (don't dump all four every time). Do not silently default to one. 🗣️ TALKING ABOUT SCENARIOS — always refer to scenarios by their name, never by numeric id, when speaking to the user. When the list has multiple scenarios and the user's request is ambiguous, present them by name with key attributes (time window, strategy, goal) so the user can pick. If the list is empty, do NOT just say 'no scenarios found' — guide the user into budget-optimizer-create. ⚠️ The budgetDetail field on returned scenarios reflects user-set strategy locks — NOT model-derived feasible spend. Use budget-optimizer-reference-data for model bounds. 🔗 Each scenario in the returned list includes a url field with the canonical UI link. When the user asks for a link to a specific scenario, quote scenario.url VERBATIM — NEVER construct a URL yourself.

budget-optimizer-reference-data

ChatGPT
Return the MMM model's reference data for a scope: the baseline spend / ROAS / sales the model was calibrated on, plus the feasible spend bounds (per-channel + overall) the optimizer can move within. ✅ Use this for: • 'What's the feasible spend range for Meta next month?' • 'What's the baseline / reference spend the model is using?' (read spendBase overall or perChannel[].spendBase) • Picking a sensible total budget BEFORE calling budget-optimizer-create (and translating a user's '+20%' into the right budget number — baseline × 1.2). Returns {modelReferenceData: {spendBase, spendBound:[min,max], roasBase, roasBound, salesBase, salesBound, referencePeriod?, perChannel:[{channel, tactic?, spendBase, conservativeSpendBound, moderateSpendBound, aggressiveSpendBound}]}}. Bounds nest conservative ⊆ moderate ⊆ aggressive — wider strategies allow bigger reallocations. 📊 *Base fields are the model's BASELINE (the reference-period level the optimizer starts from), NOT a recommendation. Quote them as 'your current/baseline spend is $X' — never as 'you should spend $X'. For the optimal allocation, run budget-optimizer-create + -forecast. ⚠️ DELIBERATELY NOT returned (model-internal diagnostics the UI doesn't show): overall confidence / backtest*, per-channel confidence / rawCoefficients. ⚠️ DO NOT extract spend ranges from saved scenarios via budget-optimizer-list's budgetDetail field — those reflect user-set strategy locks on that specific scenario, NOT the model's natural bounds. Always call this tool for forward-looking ranges. ⚠️ All channels[].channel must be integrated on this tenant. Pass empty channels=[] to fetch overall (all-platform) bounds. ⚠️ modelReferenceStartDate / modelReferenceEndDate (the baseline window) are USER-CHOSEN — there is NO default. Omit them and this tool HARD-ERRORS, returning the allowed model window so you can ASK the user to pick a reference period (never propose / default / invent one — not even 'last 7 days'). Call again with the user's explicit window. modelRefreshDate is the only model date that auto-defaults (latest model for the outcome).

budget-optimizer-update-or-delete

ChatGPT
Update / rename / delete an existing scenario by numeric id (get ids from budget-optimizer-list). Actions: - action='update': modify any scenario field. PUT requires the FULL entity; this tool fetches the existing scenario, deep-merges your fields, sends the merged result. Re-triggers async forecast (call budget-optimizer-forecast to read). - action='rename': change only name. Does NOT trigger re-forecast. - action='delete': permanently remove the scenario. ⚠️ REQUIRES confirm:true — without it the tool errors and echoes the scenario name so you can quote it back to the user for a second confirmation before retrying. On update, the same cross-field validation as budget-optimizer-create applies. 🔗 Update / rename responses include a scenarioUrl field with the canonical UI link. Quote it VERBATIM when telling the user where to view the scenario — NEVER construct a URL yourself.

cs-task-create

ChatGPT
Hand a problem to the WorkMagic team: creates a CS task on the account CSM's work board (owner = the customer's CSM) and a Lark discussion group; default group members are added server-side by category. Use it ONLY where a skill says to hand off (e.g. lift-test-creation when the design cannot be solved, or the ask is outside what it builds) — not for product limits the user can fix (unsupported country, past start date). ⛔ CONFIRM FIRST: before calling, show the user what will be created — title, responsible team, priority, tenant (name + id), the description summary, and the group members (the defaults the calling skill lists, plus any extras) — and call only after the user explicitly agrees. If the user changes anything, show the updated preview and confirm again. Call it at most once per hand-off; on failure tell the user the error and retry only if they ask (the backend is idempotent on the same content, so a retry never files a second task). tenantId = the customer account the problem is about (for lift-test-creation: the same tenantId used for lift-test-scan / prepare), not the requester's own tenant. Group: with liftTestGroupId of a test that already has an experiment group, the task is posted into that group and no new group is opened (groupReused: true, chatName = the experiment group). Otherwise a new CS Task group is opened and returned as taskGroup: { id, name } — a later lift-test-create for this problem reuses that group as the test's experiment group by default (its larkGroupId), unless the user declines. Result: duplicate: true → someone is already handling the same problem (duplicateOf names it when returned); tell the user, nothing new was created. groupError set → the task was created but the group was not; say so. chatShareUrl / todoId are returned only to WorkMagic employees — never invent a link for a customer.

custom-metric-create

ChatGPT
Create a custom metric with a formula composed of existing metrics, operators, numbers, and brackets. ⚠️ IMPORTANT: There are TWO types of custom metrics with completely different formula formats. You MUST ask the user which page this metric is for BEFORE calling this tool. Do NOT infer from metric naming patterns — the same business metric may exist in both systems with different names. Based on the user's answer: - Overview 首页 → call custom-metric-sections first, formula needs cascaderValue - 其他看板页面 → call dashboard-metrics-list first, formula uses field name only (no cascaderValue) The tool auto-detects the type from formula structure. Common rules - type='operator': value is one of: +, -, *, / - type='number': value is a numeric string (e.g. '100', '0.5') - type='bracket': value is ( or ) - Limit: max 50 custom metrics per tenant. - metricType: decimalPlaces|0, decimalPlaces|2, percentage, currency - increasing: 1 = higher is better (default), -1 = lower is better - belongToSections: only for overview metrics (which overview sections to display in)

custom-metric-list

ChatGPT
List all custom metrics for the current tenant. Returns metrics with their formulas, types, and sections. Each metric has a numeric id used for update/delete operations.

custom-metric-sections

ChatGPT
List all sections and the metrics available in each, for building OVERVIEW custom-metric formulas. ALWAYS call this tool FIRST before custom-metric-create (with useFor='overview') to discover the exact section name and metric name for each cascaderValue. Includes both static platform metrics and tenant-specific extended metrics from backend config. The user may describe metrics using business aliases (e.g. 'attr_sales', 'ad_spend', 'POAS') — use the returned sections to map those to the correct internal names. For DASHBOARD custom metrics (useFor='dashboard'), use dashboard-metrics-list instead — dashboard formulas use metrics-library field names without cascaderValue.

custom-metric-update-or-delete

ChatGPT
Update or delete an existing custom metric by its numeric id (get IDs from custom-metric-list). - action='update': modify name, description, formula, metricType, belongToSections, increasing, or useFor - action='delete': permanently remove a metric by id

data-health-check

ChatGPT
Get per-platform data-health checks for a tenant. Returns every check item (Pass or Fail) with actual values, human title, and human description sourced from the warehouse view data_health_validate. Health states per platform: error (any urgent Fail), warning (any non-urgent Fail), healthy (all Pass). Prerequisite: tenant must have a Data Scope configured (see data-scope-get). When no scope is configured the tool returns dataScopeConfigured: false and asks the agent to call data-scope-get.

data-scope-get

ChatGPT
Get the current Data Scope for a tenant. Data Scope is the onboarding configuration of which Sales Channels (DTC / Online Marketplace) and Marketing Channels (Paid Ads / Email / Other) the tenant has opted into. It is the prerequisite for integration_list, onboarding_manager, measurement_readiness, etc. Returns: - exists: true with dataScope (full channel list) and summary when configured. - exists: false with availableChannels listing every platform identifier the agent can pass to data-scope-set when not yet configured. Channel item shape: { type, value, category, displayName, isImported, version, isDel, regions? }. Note: this tool returns configured scope only — for actual integration connection status use integration_list (planned).

data-scope-set

ChatGPT
Write the tenant's Data Scope — the client account's channel configuration (it drives onboarding tasks, integrations and which platforms a lift test can use). Two modes: mode: "add" — add channels and keep everything else exactly as it is. Pass only what to add: marketingPlatforms / salesPlatforms (canonical ids) and/or importedMarketing / importedSales (by name). Nothing is removed and existing items keep all their fields (regions, hasUtm, …). An id already present is skipped. Use this to add one platform, e.g. when lift-test-scan doesn't list a platform the user wants to test. mode: "replace" (default) — salesPlatforms and marketingPlatforms are both required and are the COMPLETE canonical set: any canonical platform left out is REMOVED. Imported items are kept unless you pass importedSales / importedMarketing (then those lists are replaced). Items you keep keep their existing fields. Only use replace to remove channels or rewrite the whole scope. Before calling, tell the user what will change and get their yes — this edits the client account's configuration. Effects: onboarding steps are recalculated (a new platform appears as a pending integration); removing affiliateAndInfluencer triggers async cleanup of affiliate attribution rules. Canonical ids are validated against the allowed list (the error lists them); category / displayName are derived. Platforms outside that list (e.g. openaiAds) can't be added here yet.

data-upload-direct-ads

ChatGPT
Upload an ad-spend CSV file directly to WorkMagic — alternative to setting up a Google Sheet or client cloud bucket. Agent passes the full CSV content as text; MCP gzips + posts multipart to SOA /api/spend/upload (store-api). Use this for imported ad-platform spend uploads (e.g. platforms without OAuth integration). SOA validates rows against the tenant's Data Scope adsPlatform allowlist — rows outside scope are rejected with per-row errors.

data-upload-direct-orders

ChatGPT
Upload an orders CSV file directly to WorkMagic — alternative to setting up a Google Sheet or client cloud bucket. Agent passes the full CSV content as text; MCP gzips + posts multipart to SOA /api/orders/upload. Use this for imported / custom DTC order data uploads (e.g. Custom Site tenants pre-Shopify migration, retail order backfills).

data-upload-get

ChatGPT
Get the tenant's data-upload configuration — which Sales/Marketing data sources are pointed at WorkMagic and their sync status. Returns a per-mode summary covering bucket modes (s3, gcs, snowflakeS3, bigQuery) and Google Sheet modes (googleSheet for orders/extras, googleSheetAds for ads). Each mode reports configured: true|false plus the fields the agent needs to display status to the user. Note: this tool reads only storeDataSetting; other TenantSetting fields (cost setting, CAPI, pixel, etc.) are out of scope. googleSheetAffiliate is preserved on write but not surfaced in this summary — manage it via the affiliate flow.

data-upload-set-bucket

ChatGPT
Configure an external cloud storage bucket / database as a data source for this tenant. Writes the upload-mode setting via WorkMagic's API; WorkMagic's backend (ExternalBucketOrderService.prepareStorage) then provisions the IAM roles / GCS connections to that external storage. Required fields per bucketType: - s3 / snowflakeS3: userArn + externalID - gcs / bigQuery: serviceAccount (1–2 GCP service account emails) - s3 also accepts use (workmagicBucket | clientBucket; default workmagicBucket) - gcs also accepts use (workmagicBucket only; default workmagicBucket) - snowflakeS3 / bigQuery do NOT accept use. Other upload modes (other bucket types + googleSheet + googleSheetAds + googleSheetAffiliate) are preserved verbatim.

data-upload-set-google-sheet

ChatGPT
Configure an external Google Sheet as a data source for this tenant. Writes the Sheet URL via WorkMagic's API; WorkMagic's backend reads the external Sheet on its own schedule. - sheetType=orders_extras → writes uploadMethod.googleSheet (orders + extras data) - sheetType=ads → writes uploadMethod.googleSheetAds (marketing data) - mode=production (default) writes the live url - mode=test writes a separate testUrl slot for trial runs Backend automatically validates the URL after save (runs googleSheetOrderService.testSheetUrl) and updates status. Use data-upload-get to read back status / lastSyncTime / summary. Other upload modes (all bucket types, the other sheet slot, googleSheetAffiliate) are preserved verbatim.

database-query-ask

ChatGPT
Ask natural-language questions about the Cube.dev data schema, measures, dimensions, joins, and SQL patterns. This is the grounding source for constructing database-query-run queries — always consult it before writing SQL. DO NOT use for UI/product configuration questions (e.g. which custom-metric sections exist, which ad platforms are supported, tactic rule semantics) — those belong to their respective management tools (custom-metric-, tactic-).

database-query-run

ChatGPT
Query the analytic database via Cube.dev SQL. For AI: You should first ask database-query-ask for information. PRE-FLIGHT — single-row shape: a SELECT with no GROUP BY and no explicit aggregate that comes back with exactly ONE row is REJECTED as a suspected silent Cube collapse (Cube runs such a query as ONE global aggregate whose dimension values are arbitrary). Decide BEFORE sending: GROUP BY every dimension you select (compute ratios like ROAS client-side), or wrap the measures in SUM(...)/COUNT(...) for a deliberate global total, or append LIMIT 1 when the table genuinely holds a single row. Do NOT append LIMIT 1 merely to clear the rejection — on a truly collapsed query it returns the same fabricated row. PRE-FLIGHT — response size: results over ~200KB are REJECTED rather than truncated (a partial row set is indistinguishable from a complete one, so any total computed from it would be silently wrong). Aggregate server-side with GROUP BY + SUM(...), keep the date range and dimension count to what you actually need, and add LIMIT with an ORDER BY when you want a row listing. Re-sending the same query unchanged returns the same rejection. RENDERING CONTRACT — when presenting query results to the user: 1. Column headers MUST come from meta.field_labels[col] verbatim. Do NOT shorten, paraphrase, or invent synonyms (e.g. if the dict says "Ad spend", do NOT render as "Spend" / "AdSpend" / "Cost"; if the dict says "Attributed ROAS", do NOT render as "ROAS"). 2. For src_channel values, swap with meta.channel_value_labels[value] (e.g. shopify_app → "Other order sources"). 3. For attr_model_name values, swap with meta.attr_model_value_labels[value] (e.g. data_driven → "Data-driven attribution", last_paid_click → "Last paid click"). Use the dictionary value verbatim — do NOT shorten to "Data-driven" or "DDA". 4. NEVER surface a raw table / cube identifier (e.g. dws_view_..._latest) in narrative to the user. Raw table names belong inside ```sql blocks only; in prose, name the data source in plain business terms. These dictionaries are AUTHORITATIVE — treat them as constraints, not suggestions.

database-query-sql

ChatGPT
⚠️ DEPRECATED (sunset 2026-09-30) — do not call. Use database-query-run instead: same arguments, same result.

goal-get

ChatGPT
Read the tenant's performance goals (Goal Setting & Tracking). A tenant can have SEVERAL goals (each its own metric / track-against cadre / duration and version history). - No args: { goal, versions, goals, activeGoalCount } — goals[] summarizes every effective-active goal (goalId, metric, metricType, trackAgainst, durationType/startDate/endDate, levels, state, itemCount; no items); goal + versions = the most recently updated active goal in full (null when none — empty state). includeArchived: true also lists archived / expired goals. - goalId: that goal in full + its version history. - versionId (+ optional goalId): a historical snapshot (read-only). A goal carries: goalId, versionId (optimistic-lock base for goal-set), metric, metricType (attribution | financial; financial goals also carry financialTarget and per-item impliedMaxBudget), trackAgainst ({ kind, modelId, model, modelLabel }), dateType / window (only when kind='model'), durationType (ongoing | fixed_period) + startDate / endDate, levels (platform → platform|tactic granularity), state (active | expired | archived) and items[] (rows with goalValue=null are scope placeholders).

goal-observed

ChatGPT
Fetch OBSERVED metric values per platform/tactic and attribution cadre (口径), over a reference period. Use this to feed goal-set's calibrated methods: set_from_test needs the observed value in the track-against cadre over EACH row's own lift-test period (pass referencePeriodByKey); set_from_model needs it in BOTH the convert-from and track-against cadres. Returns { [breakdownKey]: { [observeKey]: { value, sales, orders, spend } } } where observeKey is model:<modelId> | ad_platform_reported (custom_3p is never fetched — the user supplies that value). value is the metric-derived observed figure (ROAS = sales/spend, CostPerOrder/CAC = spend/orders); null when the denominator is 0 OR the platform doesn't report the metric (sales / orders null = not reported, which is NOT 0 — ask the user for the value instead of using 0). breakdownKey = the ad-platform id (platform level) or <adsPlatform>::<tacticName> (tactic level; the untagged bucket is <adsPlatform>::Others or <adsPlatform>::Default). Omit breakdownBy to mix platform and tactic keys (per-platform levels). Same warehouse view + column mapping the WorkMagic UI uses for goal calibration.

goal-set

ChatGPT
Create or modify a performance goal (Goal Setting & Tracking). Every save appends a new version. Which goal is written: - goalId → modify that goal (its current versionId is the optimistic-lock base unless you pass baseVersionId). - createNew: true (or replaceGoalId without goalId) → create a NEW goal. - neither (the usual case — customers don't know goal ids) → the goal key metric + trackAgainst (kind + model) + dateType + window identifies the goal: the active goal with the same key is modified, if there is none a new goal is created. Goals with a different key are never modified. If several same-key goals exist on different fixed periods, pass startDate/endDate of the one to modify. When modifying, two item modes: - DEFAULT (merge / upsert) — items are added or overwritten BY KEY; every other platform/tactic already in the goal is KEPT. Merge requires the goal's metric / trackAgainst / dateType / window to match (old targets aren't comparable across cadres). - replace: true — items become the ENTIRE goal; omitted rows are DROPPED. If that drops existing rows you MUST pass confirmDropKeys listing exactly the keys being removed. Duration: durationType ongoing (default for new goals) | fixed_period with startDate / endDate (inclusive YYYY-MM-DD). When modifying, omitted duration fields keep the goal's current duration. Two active goals with the same metric + cadre can't overlap in time: pass replaceGoalId to archive the conflicting goal in the same save (works for create and modify). Granularity: item keys are a platform id (platform level) or <platform>::<tactic> (tactic level); each platform's level is inferred from its keys — pass levels to set it explicitly. breakdownBy is the legacy single granularity and optional. Each item picks a method: - fixed — target entered directly (goalValue). - set_from_test — calibrate an incrementality goal to the reporting cadre via a completed lift test's incremental result: goalValue = goalIncrementality × (observedTrackAgainst / observedTestResult). observedTrackAgainst comes from goal-observed over that lift test's test period. - set_from_model — convert a goal from another attribution model: goalValue = goalConvertFrom × (observedTrackAgainst / observedConvertFrom), both observed over referencePeriod (from goal-observed). Calibration guards: observedBase 0 → treated as 1; observedBase < 0 → cannot calibrate (errors naming the item). Track-against: kind='model' requires model (+ dateType/window, default event/30D). NOT supported: financial goals (metric mer / nc_mer / total_cac) — their targets come from an MMM solve; create/edit them in the WorkMagic Goals page (goal-get can read them). Concurrent edit → optimistic-lock conflict; re-run goal-get and retry. The response reports operation (created | updated), goalId, mode and droppedKeys.

idda-calibration-settings-get

ChatGPT
Read the tenant's iDDA (incrementality-adjusted attribution) calibration mode — the tenant-wide setting behind the Forward / Historical choice in the WorkMagic attribution-model dropdown. - forward (model 33): history stable — a finished lift test only calibrates future data; past iDDA numbers stay as reported. - historical (model 32): recalculates history with the latest calibration back to the test start date. Returns calibrationMode, modelId, meaning, and isDefault (true = the tenant never saved a choice, so the default historical applies). To change it use idda-calibration-settings-set. Batch calibration settings are not exposed.

idda-calibration-settings-set

ChatGPT
Change the tenant's iDDA calibration mode (historical or forward). ⚠️ This changes the iDDA numbers the customer sees for PAST date ranges (dashboards, reports, anything read on incrementality-adjusted attribution), so previously shared or exported figures will stop matching. Explain the difference to the customer and get their explicit confirmation BEFORE calling this; DO NOT switch on your own initiative or as a side step of another task. - forward (model 33): history stable — only future data is calibrated after each lift test. - historical (model 32): history is recalibrated back to each test's start date. Only calibrationMode is changed; all other fields of the stored calibration config (e.g. DS batch-calibration settings) are kept as-is. Setting the mode it already has is a no-op. Call idda-calibration-settings-get first to see the current mode.

integration-list

ChatGPT
List the tenant's connected ad / sales platform accounts with health, and the platforms still pending connection (drawn from Data Scope) with Settings deep links. Prereq: tenant must have a Data Scope configured. When the scope is empty the tool returns dataScopeConfigured: false and points the agent at data-scope-get / data-scope-set. Health states: healthy (connected + accounts ok), warning (connected but some account access was revoked or backend errors observed), error (connection disconnected / never initialized). Counts: quote summary instead of counting connected yourself. summary.paidAdPlatforms = paid ad platforms (what "ad platforms" means; excludes email / SMS such as Klaviyo); summary.byType splits ads (paid + email/SMS) / sales / other (non-channel tools such as ShipStation). A channel in a connection's includes (e.g. TikTok GMV Max via TikTok) reports through that connection and is not counted separately. Read-only: this tool does NOT trigger OAuth flows. The setupUrl field is a deep link into the WorkMagic Settings page where the user completes the connection.

knowledge-base-ask

ChatGPT
⚠️ DEPRECATED (sunset 2026-09-30) — do not call. Use database-query-ask instead: same arguments, same result.

lift-test-create

ChatGPT
Create a lift test draft from fully resolved parameters. Use this ONLY after lift-test-design-analyze confirms the user's final method and start time choice. After a successful call, display the summary field from the response verbatim — do not translate, reformat, or summarize it. Parameter sources — use exactly these, do not improvise: - adPlatform → user confirmed in earlier steps (raw IDs: facebookMarketing / googleAds / tiktokMarketing / pinterest / snapchatMarketing / amazonAds / applovin / etc.) - salesChannel → lift-test-scan: salesChannel - primaryMetric → lift-test-design-prepare input (orders | new_customers) - country → lift-test-scan: country (or user override) - testLevel → user confirmed (tactic / platform / campaign) - approach → lift-test-design-analyze: recommendedApproach by default; user may override (e.g. automatic → manual) - method → user confirmed after lift-test-design-analyze (PTM or LTM) - numberOfCells → lift-test-design-prepare output: create_params.numberOfCells (= test cells + 1 shared reference) - testStartTime → user's start date in their local timezone (YYYY-MM-DD). Pass exactly what the user said. Tool converts to UTC. - testEndTime → OMIT. Auto-calculated by the tool as testStartTime + geoGroup.test_length + geoGroup.cooling_length (default 7) − 1 days (same as the UI). - restrictStartTime → the startTime passed to the lift-test-design-prepare call that produced the CHOSEN design (YYYY-MM-DD, user's local timezone); omit when that call had no startTime. If the user changed the date and prepare was re-run, use the date of the run whose design is being saved. Stored on the draft so the schedule cannot be set earlier and later sessions can read it back (extraInfo.restrictStartTime). - geoGroup → lift-test-design-analyze output: chosen_method.designs[0].geo_group — pass the ENTIRE object; MUST include estimator.channel; you MAY set test_length (and estimator.custom_test_length if days ∉ [14,21,28]) if user requested a different test period - testChannel → lift-test-design-prepare output: create_params.testChannel (pass as-is) - timezone → lift-test-scan: timezone field; if it does not already contain '(GMT', append the GMT offset (e.g. 'Eastern Time (US & Canada), Bogota, Lima (GMT-5:00)') - ianaTimezone → IANA equivalent of timezone (e.g. 'America/New_York'), derive from the timezone string - holdout_pct → lift-test-scan: suggested.holdout_pct - locationSetting → lift-test-design-prepare: create_params.locationSetting Geo conflict safety net: the tool asks platform-api (concurrentConflictCheck — the same judgement the launch-time apply runs) whether the start date + the design's two groups conflict with a scheduled/active/executing test, and if so returns { geoConflict: { conflictingTests, excludeGeos, latestEndTime, conflictEndTime, message } } instead of creating the test. A conflict needs BOTH an overlapping time window (start ~ end incl. cooling) and a geo clash by group, so a test that only starts after this one ends never conflicts. Present the message and let the user choose: start after latestEndTime (empty when a conflicting test has no end date), or re-run lift-test-design-prepare with that startTime and regenerate the design. Account-level geo limitation gate: the account may carry a geo limitation configured by the customer (product UI: Lift Test list page → Geo limitation settings) that constrains every new test in the account. lift-test-design-prepare already applies it, so a design built through the normal flow complies; this tool re-checks the chosen design (both groups) as a last gate and REFUSES to create the draft when it breaks the limitation. The error names the offending geo codes — re-run lift-test-design-prepare → lift-test-design → lift-test-design-analyze and create from the new design, or ask the user to relax the setting. When the limitation applies, the summary shows an Account geo limitation row. Design saved for CCMS: after the draft is created the tool also writes the design to platform.ads_order_dma_design_budget_manual_v2 (same row…

lift-test-create-or-update

ChatGPT
Create or update a lift test group. - If body.id is absent → POST (create a new group) - If body.id is present → PUT (update the existing group) On the update path the stored group is loaded first and the body is layered onto it, so a field you omit keeps its saved value instead of being blanked, and id / tenantId / createTime always stay the stored group's (passing different ones has no effect). extraInfo / additionalInfo merge key by key. To clear a field, pass it explicitly as null. additionalInfo.additionalRequests is never a place for notes: a non-empty value files a manual-design request and pauses the workflow, so this tool refuses to set a new one (it may keep or clear a stored one). Notes belong in your reply to the user. Derived fields are recomputed on every save, like the product UI does: each cell's testChannel[i][j].geoGroup.estimator (expect_cpa, minimum_daily_budget_required) from the shared geoGroup.estimator.channel (matched by platform), the group's method and geoGroup.test_length; estimator.custom_test_length is set for a custom length and cleared for 14 / 21 / 28. To change the period, method or a CPA, change only those inputs — never hand-edit the derived fields. A test_length outside 14–60 days, or a cell platform without exactly one shared estimator entry, is refused. Before saving, the body passes the same gates as lift-test-create: geoGroup shape, testChannel shape, the account-level geo limitation, and a geo-conflict check against this account's scheduled/active/executing tests (platform-api concurrentConflictCheck — the same judgement the launch-time apply runs; the group's own id and its sibling cells are excluded so it never conflicts with itself). A conflict returns { geoConflict: {...} } instead of saving; a shape or limitation violation returns an error naming what to fix. Otherwise the body is forwarded to the backend. When the body carries an online geoGroup (control ids online-<design_id>), the design is reloaded by design_id and its geo codes + geoLevel, order & sales rates, minimum_detectable_lift, factor and experiment_days must match (numbers compared at 2 decimals; method may change) — a tampered or unknown design is rejected. geoGroup: null cannot clear a stored design. A NON-online geoGroup (manual-… / auto_calc-…) has no backup to verify: on create it is refused outright; on update it must equal the stored geoGroup verbatim (bodies without a geoGroup skip all of this). On CREATE with an online geoGroup, after the group is saved its verified design rows are also written to platform.ads_order_dma_design_budget_manual_v2 (CCMS-readable; a design_id + method already saved for the test is skipped) and the result carries designPush; a failed write leaves the group saved with designPush.error set. Updates never write design rows. Key fields: - salesChannel: e.g. ['shopify'] - adPlatform: raw platform IDs e.g. ['facebookMarketing', 'googleAds', 'tiktokMarketing'] - primaryMetric: 'orders' | 'new_customers' (nothing else — the UI retired 'sales'; every testChannel cell must carry the group's value) - country: 'US' - geoLevel: 'dma' | 'state' - ⚠️ status (required): 'draft' to save, 'scheduled' to activate the test - testStartTime / testEndTime: ISO datetime strings (UTC). testEndTime is recomputed by this tool (UI rule: start + geoGroup.test_length + geoGroup.cooling_length − 1 days, customer-local dates) when testStartTime, test_length or cooling_length changes and the body has no testEndTime key — omit it unless the user named a specific end date (an explicit value, null included, is kept) - restrictStartTime (top-level arg, not in body): only with a NEW design in body.geoGroup — the startTime of the lift-test-design-prepare call that produced it (YYYY-MM-DD, customer-local); omit if that call had none. A new design saved without it clears the stored restriction (extraInfo.restrictStartDate / restrictStartTime); other updates keep it, and a testStartTime earlier than it is refused — regenerate the design for the earlier date instead. - testCha…

lift-test-delete

ChatGPT
Delete a lift test group by id. Use lift-test-list to discover IDs. This action is irreversible.

lift-test-design

ChatGPT
When to use — the design step inside the guided 'create a lift test' flow. Use this when the user is creating a lift test end-to-end and you are walking them through it (intake → design → analyze → create a draft). When NOT to use — a direct, standalone design request ('generate a design', 'do a 5% PTM for this test', 'run the design at 10% holdout'): there the user just wants a design computed and handed back, so use lift-test-design-generate instead (a single tool that returns the design INLINE when the solve is fast, or a resume_task_id to keep polling in-place; same solver, one experiment_type per call). The boundary is the entry intent (guided create flow vs one-shot design), not the mechanism. Submit a lift test design task to the internal design API. Returns a task_id immediately without waiting for completion. The task takes approximately 3-4 minutes to complete. After submitting, use lift-test-design-result with the returned task_id to retrieve the result — { ptmDesignId, ltmDesignId } for lift-test-design-analyze. Do NOT resubmit the same task while one is already running. Complete 8-step flow — follow all steps in order: Step 1: Extract info from user's message, then ask only for what is still missing First scan the user's message for any of these fields they may have already provided: - adPlatform(s) — e.g. 'Meta', 'Google', 'TikTok' → map to raw IDs: facebookMarketing / googleAds / tiktokMarketing / tiktokGMVMax / pinterest / snapchatMarketing / reddit / applovin / openaiAds / vibe / walmartConnectDisplay / mntn / roku / universalAds / other (manual 'Other' platform) - testLevel — platform / tactic / campaign (default if not mentioned: tactic) - country — e.g. 'US', 'UK', 'Australia' - testStartTime — parse the user's time intent (three types): • Start date ('start June 1', 'begin July 10') → use directly as testStartTime A date without a year ('May 1', '6/15') → current year (customer-local). If that is already past, treat it as a past date (ask the user) — never roll it to next year silently. Echo the full YYYY-MM-DD back. • Duration ('run for 4 weeks', '28-day test') → note as test period preference; testStartTime still TBD, ask in Step 7 • Hard deadline ('finish before July 15', 'done by end of Q3', 'wrap up before the board meeting') → infer testStartTime = deadline − (geoGroup.test_length + geoGroup.cooling_length (default 7) − 1) days (the start day counts as day 1) Tell user: 'To finish by [deadline], the test needs to start by [date]. Does that work?' If the inferred start date is already in the past → tell user the deadline is too tight, offer options: shorten test period or push the deadline - primaryMetric — 'orders' (default), 'new_customers' - locationSetting exclusions/inclusions — e.g. 'exclude Texas and California', 'only run in NY and FL' In the guided flow lift-test-design-prepare already resolved locationSetting to engine codes — pass its lift_test_group unchanged. The table below is ONLY for building locationSetting by hand on the direct (no-prepare) path. When geoLevel='state', resolve each geo name or abbreviation to its wm_code using this table and build locationSetting: { locationType: 'exclude'|'include', locations: [{ value: <wm_code as integer>, label: <full state name> }] } State lookup (full name / 2-letter abbrev → wm_code): Alabama/AL=1, Alaska/AK=2, Arizona/AZ=3, Arkansas/AR=4, California/CA=5, Colorado/CO=6, Connecticut/CT=7, Delaware/DE=8, District of Columbia/DC=9, Florida/FL=10, Georgia/GA=11, Hawaii/HI=12, Idaho/ID=13, Illinois/IL=14, Indiana/IN=15, Iowa/IA=16, Kansas/KS=17, Kentucky/KY=18, Louisiana/LA=19, Maine/ME=20, Maryland/MD=21, Massachusetts/MA=22, Michigan/MI=23, Minnesota/MN=24, Mississippi/MS=25, Missouri/MO=26, Montana/MT=27, Nebraska/NE=28, Nevada/NV=29, New Hampshire/NH=30, New Jersey/NJ=31, New Mexico/NM=32, New York/NY=33, North Carolina/NC=34, North Dakota/ND=35, Ohio/OH=36, Oklahoma/OK=37, Oregon/OR=38, Pennsylvania/PA=39, Rhode Island/RI=40, South Carolina/SC=41, South Dakota/SD=42, Tennessee/TN=43, Texas/TX=44, Utah/UT=45, Vermon…

lift-test-design-analyze

ChatGPT
Compute estimator (expected daily spend per platform) and recommend PTM or LTM. ⚠️ REQUIRES a completed design task — call lift-test-design, then poll lift-test-design-result until status='success' first. Call this AFTER lift-test-design-result returns success. Pass: - ptmDesignId / ltmDesignId: from the lift-test-design-result success result - geoLevel: from lift-test-design-prepare output (e.g. 'dma') - testChannel: from lift-test-design-prepare output - country + adPlatform: from the test setup - platformSpend (optional): user-provided daily_spend and/or cpa per platform. If omitted or partial, missing values are auto-queried from analytics. Returns: - recommended: 'PTM' | 'LTM' (matches frontend recommendTestMethodAndTestLength logic) - ptm / ltm: designs enriched with estimator.channel per platform - Each design.estimator.channel[i][j] (cell i, platform j): { ad_platform, ads_daily_reported_spend, origin_ads_daily_reported_spend, cpa, origin_cpa, minimum_daily_budget_required, sufficient, threshold_at_floor, expected_daily_spend } · minimum_daily_budget_required = this platform's feasibility threshold ($/day) at the design's own length D = geo_group.estimator.experiment_days. Any other length N: threshold(N) = minimum_daily_budget_required × √(D / N). sufficient = ads_daily_reported_spend ≥ threshold × 0.95 (true when cpa / spend is missing, as in the product UI). Thresholds are per platform — show each one; never add them up or show only [0][0]. A design is sufficient only when EVERY platform is. · expected_daily_spend is DEPRECATED (kept only for the draft shape) — never read it for a threshold or a decision. · cpa / ads_daily_reported_spend = the values used (a platformSpend override if passed, else the platform's); origin_ = the platform's own 30-day CPA / 7-day daily spend. null = no data. · cpa or ads_daily_reported_spend null ⇒ feasibility was NOT actually checked for that platform (the design still counts as sufficient, as in the product UI) — say so; never present it as 'sufficient'. · threshold_at_floor: true ⇒ minimum_daily_budget_required is the platform minimum ($200 LTM, 200 ÷ order share PTM), not CPA-driven — because CPA is missing or CPA × MDL is below it. Say so; don't read it as a cheap test. Recommendation rules (same as frontend): PTM: ptm designs exist AND at least one design is budget-sufficient AND all platforms support PTM for the country LTM: designs exist but PTM conditions not met PTM (default): no designs returned from design API After receiving results, ALWAYS do the following in order: Step A: Present design comparison table* Show PTM and LTM side-by-side. For each method, show the first design (designs[0]): | | PTM | LTM | | Method | PTM (Pause-to-Measure) | LTM (Launch-to-Measure) | | Test period | estimator.experiment_days days | same | | Treatment geos | Holdout group: {designs[0].cell_order_share_pct[0]}% of orders | Exposed group: {designs[0].cell_order_share_pct[0]}% of orders | With more than one test cell, list each cell on its own line inside that cell instead, numbered like the product UI: PTM 'Holdout group 1: {cell_order_share_pct[0]}% · Holdout group 2: {cell_order_share_pct[1]}% …', LTM 'Exposed group 1: … · Exposed group 2: …' — one entry per cell, never summed. ⚠️ Use the tool-computed cell_order_share_pct field VERBATIM (cell_order_share_pct[i] = test cell i's treatment-side order share, %). Do NOT read geo_group.test.orders / geo_group.control[i].orders or compute the percentage yourself. If a value is null, write 'n/a'. | Feasibility threshold | estimator.channel[i][j].minimum_daily_budget_required /day — one line per platform (and per cell) | same | | Budget sufficient | sufficient (Yes/No) | same | Mark the recommended method with ★. DO NOT show MDL in this table. ⚠️ Treatment-side labels are method-specific (matches product UI): PTM column says 'Holdout group' (ads paused there), LTM column says 'Exposed group' (new spend introduced there); the baseline side for any method is 'Reference group'. NEVER label the LTM side 'Holdout group' and NEVER invent a…

lift-test-design-prepare

ChatGPT
Assemble lift test design parameters from lift-test-scan result + user inputs. Call this AFTER lift-test-scan and BEFORE lift-test-design. Requires no DB queries. `testChannel` IS the cell structure (2-D) — read its parameter description. Outer = test cells (impact groups), inner = the platform(s) tested in that cell, each bound to its own targets. You bind platforms to cells; this tool guesses nothing — it only derives numberOfCells (= cells + 1 shared reference), each entry's testChannelIndex and extraInfo (completed=true; skipForNow=true when a platform has no selectable target, i.e. impactCampaignInfos: []). One cell = ONE lift result. Things the user wants a separate result for → separate cells; things explicitly measured together → the same cell; several things named with no grouping stated → one cell EACH (default — do not ask). Max 4 test cells. Geo constraints (matches the product UI — computed by platform-api, you pass inputs only): This tool asks platform-api (geoConstraints) to combine three inputs and hands the design engine the result as per-group exclusion lists in lift_test_group (treatmentExclusion / controlExclusion + locationSetting) — pass lift_test_group to lift-test-design verbatim. - Concurrent scheduled/executing/active tests: a region held by another test's treatment group (holdout / exposed) is kept out of BOTH groups of this test; a region held only by another test's reference group is kept out of this test's treatment group only (two reference groups may overlap). Occupying tests release their regions in batches as they end, so only what is still occupied ON startTime counts — omit startTime when unknown (then today is used, the safe default). geoConstraints.occupancy lists what is still occupied and rangeEndTime (when everything is released); the summary already explains it — relay it, and offer a later start when the user wants more geo. - Account-level geo limitation (customer setting, product UI: Lift Test list page → Geo limitation settings): Allowed / Restricted locations bind BOTH groups of every test in the account. When it applies, the output carries geoExclusion and the summary shows an Account geo limitation row — relay it, the user may not know the setting exists. Account state + test dma is converted automatically. - The test's own locationSetting (include / exclude) binds the treatment group only. - When re-designing an EXISTING group, pass liftTestGroupId so the group and its sibling cells are not counted as concurrent occupancy, and pass its stored start restriction as startTime (extraInfo.restrictStartTime, converted to the customer's local date) when that date is later than today, unless the user is choosing a new date; a passed date is no restriction — omit startTime then. - If a group would be left with no geo, this tool errors (naming the causes and the release date) instead of designing. If platform-api could not be reached, the summary warns that only the test's own location setting was applied — warn the user; lift-test-create re-checks conflicts and the account limitation once platform-api is reachable (with no start date the conflict check runs open-ended from restrictStartTime when given, else today); the launch-time check always enforces them. Geo location codes — you do NOT pre-convert: Pass locationSetting.locations[].value and this tool resolves each to the design engine's numeric code automatically (the engine silently ignores anything outside its code space). PREFERRED form: for geoLevel='state' the 2-letter USPS code (e.g. 'TX'); for geoLevel='dma' the numeric DMA code (e.g. '501'). The full state name / exact DMA name also resolve. A value that cannot be resolved is a HARD ERROR (the error lists the valid options) — the exclusion is never silently dropped, so fix it and retry rather than assuming it was applied. Workflow: 1. Call lift-test-scan → show user platformMetrics, running tests, suggested params 2. Derive the cell structure from what the user asked using the rule above (ask only when more than 4 cells would be …

lift-test-design-result

ChatGPT
Poll the result of a previously submitted lift-test-design task. This tool uses long-polling: it holds the request for up to 30 seconds waiting for completion. A full design takes ~3-4 minutes, so one submit normally needs 6-8 of these polls. ⛔ AUTONOMOUS POLLING — when status='running' you MUST call this tool again YOURSELF, in the SAME turn, right away. Do NOT end your turn, and do NOT ask the user to reply / say 'check' / 'done?' / prompt you again to continue — making the user drive the polling is a regression. Keep calling in a loop until status is 'success' or 'failed'. A one-line progress note to the user between polls is fine, but you must always fire the next poll yourself without waiting for user input. - status='success' → result contains { ptmDesignId, ltmDesignId }; pass them to lift-test-design-analyze (and later lift-test-create). If one side is null (see note), that experiment type produced no usable design — proceed with the other side only. - status='running' → call this tool again with the same task_id immediately (do NOT yield to the user; do NOT resubmit lift-test-design). progress_message shows the per-side stage (e.g. 'PTM ready, LTM solving'). - status='failed' → { reason, user_message, error }. Tell the user user_message (the product UI's text for that reason) and act on reason (no_orders / order_data_issue / no_overlap / insufficient_60d / system_error / no_feasible_design). NEVER show error — it is the raw design-service message (often Chinese), for debugging only. Resubmit lift-test-design only after the inputs changed, or for reason 'system_error'. Existing design (design_id instead of task_id). When the user names a design id (a geo pair card shows online-<id>_<n>; <id>_<n> and a bare <id> also work), pass it as design_id (plus tenantId) — exactly one of task_id / design_id. One lookup, no polling, no solve: - status='success' → same result as a finished task (the design's method side set, the other null), plus selected_design_id (the exact design the user named, or null for any design of that solve), part_date and design_params (country / geo level / sales platforms / metric / cells / holdout_pct — the lower bound of its treatment_pct_min–max band — it was generated with). Continue to lift-test-design-analyze; skip lift-test-design. - status='not_found' → no such design in this account. Tell the user user_message. - status='expired' → generated more than 33 days ago (the product UI no longer offers it). Tell the user user_message. Do not analyze either of these.

lift-test-get

ChatGPT
Get the full details of a lift test group by id. Returns the complete object including geoGroup, testChannel, extraInfo, and additionalInfo. Use lift-test-list to discover IDs. Feasibility threshold of a saved draft: read each cell's testChannel[i][j].geoGroup.estimator.minimum_daily_budget_required ($/day at the group's test_length, computed from the current method and CPA on every save). Do NOT read geoGroup.estimator.channel[][].expected_daily_spend — a snapshot taken at geo pairing that is not updated when the CPA or period changes. MDL — never show the customer: a design's MDL, in any form, is an internal parameter, not a customer-facing number. The raw fields minimum_detectable_lift and factor are internal plumbing (they feed the budget math and are passed back into lift-test-create): NEVER expose, show, quote, mention, or convert either field to the customer in ANY form — and in particular NEVER treat minimum_detectable_lift as the MDL (its name is misleading). If the user asks about the MDL, say it is an internal design detail and answer in business terms (the test's expected outcome and required budget) instead.

lift-test-impact-campaigns

ChatGPT
List ad accounts or campaigns for building impactCampaignInfos. The backend API only requires platform. accountId is optional client-side filtering. Recommended flow: Step 1: Call with level='account' (no accountId) → returns unique accounts Step 2: Call with level='campaign', optionally with accountId to filter by account (Omitting accountId returns all campaigns across all accounts.) Note: tactic-level grouping is NOT available here — use the tactic MCP tool instead. Returns { list: [{accountId, accountName, campaignId?, campaignName?, campaignType?}], total }.

lift-test-list

ChatGPT
List lift test groups for the current tenant. Returns a paginated list of lift test groups with their status, platforms, dates, and metrics. Each row's testChannel entries are trimmed to a summary (identity, status, impactCampaignInfos, test/control geo codes, extraInfo flags); extraInfo.campaigns (group and channel level), per-channel geoGroup, holdout execution records and row bookkeeping (workflowId, dmaExclusion, extraInfo.startTime / useWorkflow / revertBeforeCooling) are omitted here. Use lift-test-get to fetch the full object including geoGroup and the complete testChannel — a list row has NO feasibility threshold (it lives on the per-channel geoGroup); use list to find ids only. Status values: draft, scheduled, active, completed, executionFailed, executing, removing, terminated. MDL — never show the customer: a design's MDL, in any form, is an internal parameter, not a customer-facing number. The raw fields minimum_detectable_lift and factor are internal plumbing (they feed the budget math and are passed back into lift-test-create): NEVER expose, show, quote, mention, or convert either field to the customer in ANY form — and in particular NEVER treat minimum_detectable_lift as the MDL (its name is misleading). If the user asks about the MDL, say it is an internal design detail and answer in business terms (the test's expected outcome and required budget) instead.

lift-test-readout

ChatGPT
Read and interpret a COMPLETED lift test's results for the current tenant. Use AFTER the test is resolved to a concrete id (resolve 'my last Meta test' etc. via lift-test-list/lift-test-get first; this tool only accepts a concrete testId). Returns per-sales-platform rows: ad_spend, incremental_orders, incremental_sales, lift_pct, confidence_score, significant, significance_basis, iroas, icpa, nc_iorders, nc_isales, nc_iroas, nc_icpa, iaov, nc_iaov, nc_lift_pct, test_orders, test_start, test_end; plus resultReady. resultReady = at least one result row was returned (a row existing in the result report IS an experiment result). If resultReady=false there are simply no result rows for this test (or for the requested salesPlatformScope) — tell the user there is no result to read; DO NOT fabricate numbers. Significance comes from the confidence score, and ONLY from it. confidence_score is a fraction in [0,1] per sales platform (1 - p_value; higher = the observed lift is less likely to be random chance) and is ALWAYS a number — render it as an integer % (0.98 → 98%, 0.65 → 65%). significant=true means the row is at or above 90% (UI badge 'Significant'); significant=false means below 90% (UI badge 'Not significant' — the data cannot rule out zero or negative lift, so do NOT read lift_pct as directional). Use the significant flag the tool returns; never compute your own threshold. There is no confidence interval in this tool's output and none in its significance logic — do NOT ask for, infer, or render a CI, and do NOT describe the confidence level as fixed at 95%: it varies per row and you must report the row's own number. ALWAYS show the actual confidence score for every row — including the ones that are NOT significant. A below-threshold score is the whole explanation of why the row is not significant, so it must be visible, not hidden: write 'Amazon: 1.6% lift, 68% confidence — Not significant', never a bare 'Not significant'. Same for significant rows: state the score next to the lift % it qualifies, never tucked at the end. `significance_basis` distinguishes a measured score from a filled-in one: - confidence_score — the score was computed for this row; report it plainly. - default — no score was stored, so it was filled with 95% (the level lift tests are designed at) and the row therefore reads as Significant. Still report 95%, but if the user asks how confident the result is or leans on it for a decision, say plainly that this row has no computed confidence score and 95% is the assumed design level. Interpretation rubric (apply to every output): - Connect every metric to an implication; never report a bare number. - ALWAYS pair lift_pct with its confidence_score AND significance — never report lift % alone. Same point estimate, different confidence, opposite conclusion: 13.5% at 98% is a confirmed result; 13.5% at 68% is not. Summary-table columns are 'Lift %' and 'Confidence score' — there is NO CI column. - lift_pct is a raw fraction: render it as a percentage with 1 decimal (0.0329 → 3.3%, 0.002 → 0.2%). - Comparative framing ONLY when the reference is in the data (user-stated target, prior period, or another channel in the same test). Never invent a baseline/benchmark. With no reference, state the magnitude as a fact and let it stand. - Frame stakes in dollars where it fits ('$11k incremental sales on $11k ad spend' beats '13.5% lift'). - Acknowledge what was NOT measured (Meta-only test → don't speculate about Google/TikTok). - nc_iroas < $1.00 is NORMAL (first-purchase revenue rarely covers full CAC) — don't flag it as a problem unprompted. - Render sales_platform: shopify→DTC (never 'Shopify' — the store may be a custom site), amazon→Amazon, tiktok→TikTok Shop, combined→Combined. - UI labels for metrics: incremental_orders→'Incr. orders', incremental_sales→'Incr. sales', icpa→'Cost per incr. order', iroas→'Incr. ROAS'; nc_iorders→'Incr. new customer orders', nc_isales→'Incr. new customer sales', nc_icpa→'Incr. CAC' (not bare 'CAC'), nc_iroas→'Incr. new customer ROAS'. - ad_spend …

lift-test-replace-platform

ChatGPT
Replace one ad platform of a DRAFT or SCHEDULED lift test with another, keeping its design (same geos, same cells). Changes only: the platform id (adPlatform, testChannel entries — with adPlatformName for an imported platform — geoGroup estimator channel entries), the platform name inside the test name and cell names, and geoGroup.designHash. Leaves CPA, spend, feasibility thresholds, geos, method and setup approach unchanged — say so to the user; re-estimating them is a separate request. to must be one of lift-test-scan's adPlatforms for this tenant and available in the test's country. Refused once the test has started or ended. Targets: the old platform's accounts / tactics / campaigns don't carry over. When the old entry has targets, ask the user to pick the new platform's targets the same way as when building a test (lift-test-impact-campaigns / tactic-list for to, shaped by the test's level) and pass them in targets, or [] when the user wants to set them later. Confirm the change with the user before calling.

lift-test-scan

ChatGPT
Scan tenant data to gather all context needed before creating a lift test. Run this as the FIRST step whenever a user asks to create, design, or plan a lift test. Returns: - country — dominant country from last 90d order data, with confidence - geoLevel — 'dma' (US); 'city' (GB / FR when the requested adPlatform is TikTok only — TikTok has no postcode targeting there, and city is TikTok-only); 'postcode' (others) - salesChannel — active sales channels - timezone — tenant UTC offset - runningTests — current scheduled/executing/active tests (for geo-overlap awareness) - adPlatforms — the ad platforms the user can pick (the product UI's Test channel list): the tenant's Data Scope ad platforms that are lift-test platforms (source: supported) plus every other Data Scope ad platform (source: imported, the UI's 'Others': manual setup, platform level). Each carries supportCountry (countries it can be tested in), automaticCountry (automatic setup; manual elsewhere), ptmCountry (PTM available), supportTestLevel, geoLevels (geo levels it can be tested at in the scanned country — platforms in one test must share a level, e.g. TikTok in GB / FR is ['city'] while Meta there is ['postcode'], so they can't be one test), and 28-day daily_spend / daily_orders (0 = no data, still pickable). AppLovin without a Campaign Management Key carries managementKeyMissing: true, an empty automaticCountry, managementKeyNotice and settingsUrl (the platform's AppLovin integration settings): tell the user once, when AppLovin is offered or picked, that it can only be set up manually and that automatic setup or a tactic-level test needs the key, which the client adds at settingsUrl — tactic level can still be chosen; never ask for the key in chat. Offer the user every entry available for the chosen country and test level, never only the ones with spend. A platform the user names that is NOT in this list is not in the tenant's Data Scope: offer to add it (data-scope-set mode 'add', after the user confirms), then scan again. null = the Data Scope couldn't be read. - platformMetrics — per-platform daily spend + orders (last 28d), only platforms with warehouse data; use adPlatforms for what can be picked - suggested — recommended holdout_pct, approach, method, numberOfCells (numberOfCells is only a one-cell-per-requested-platform default; the real cell count comes from the testChannel you pass to lift-test-design-prepare, which ignores this value) - geoExclusion — the account-level geo limitation the customer configured (product UI: Lift Test list page → Geo limitation settings), already converted to this test's geo level: { allowedCodes, restrictedCodes, source }; null when the account has none. geoExclusionSummary is the same as one human-readable line. Relay it in the Step 4 read-back so the user knows the design will be constrained — lift-test-design-prepare applies it to the design and lift-test-create re-checks it. After receiving results, present the key findings to the user, ask them to confirm or adjust (country, platforms), then pass the confirmed data into lift-test-design-prepare.

measurement-readiness

ChatGPT
Get the tenant's measurement-product readiness across MTA, MMM, and Lift Test. Returns per-product overall status (ready / not_ready / not_optimal), per-platform breakdown with failed-rule descriptions ready for display, and a concise recommendation string. Status semantics: - ready — currently meets all readiness rules - not_optimal — was ready at some point but currently failing some rules - not_ready — has never been ready Prerequisite: tenant must have a Data Scope configured (see data-scope-get). When no rows are returned for a tenant, suggest calling data-scope-get to confirm channel configuration.

naming-convention-create

ChatGPT
Create a naming convention rule that extracts a property from ad names. You must specify the extraction method: - position: split by separator, pick Nth segment (requires separator + position). e.g. 'brand_us_summer' with separator='_', position=1 extracts 'brand' - kv: key=value pairs (requires separator + identifier). e.g. 'geo=us_brand=nike' with separator='_', identifier='=' extracts by key name - regex: capture group extraction (requires regexExpression). e.g. regex 'brand_(\w+)_campaign' captures the middle part - segment: classify ad names into categories via rules (requires segments array; segment names must be unique) level='all' applies one rule to campaign, ad set and ad names at once — only the 'segment' method is allowed with it (same as the web UI). Separators: built-in ["-","_","|",">"," "] are always available; any other separator must first be in the tenant's custom list (naming-convention-separators-get / -set). To see real names before choosing a rule, call naming-convention-examples-list. Returns the created config(s) with their IDs. Multiple adPlatforms creates one config per platform in a single call. ⚠️ Each value in adPlatforms must be one of the tenant's integrated ad platforms that carries campaign/adset/ad names. Platforms without usable names (e.g. Tatari, Tatari Linear) are rejected. If you pass an invalid value the tool returns an error listing valid values; you can also discover them up-front via database-query-ask or database-query-run. Limit: max 100 configs per platform+level combination.

naming-convention-examples-list

ChatGPT
List real campaign / ad set / ad names for the given ad platform(s) and level (read-only) — the same samples the web UI shows as a preview while you design a naming convention rule. Only active entities are returned, ordered by ad spend (highest first); entities without spend are omitted. level='all' returns samples for all three levels. Use it to pick separator / position / regex / segment rules before calling naming-convention-create. It does not evaluate a rule.

naming-convention-list

ChatGPT
List naming convention configs for the current tenant. Returns configs with property names, extraction methods (1=position, 2=kv, 3=regex, 4=segment), and matching status. Each config has a numeric id used for update/delete operations. Supports filtering by adPlatform and level (level 'all' = rules applied to every level). Segment rules list only their segment names + rule counts by default; pass includeValueConditions: true (ideally with adPlatform / level) for the full matching rules — needed before updating a rule's segments. Use this tool first to see existing rules before creating new ones.

naming-convention-separators

ChatGPT
⚠️ DEPRECATED (sunset 2026-12-07) — do not call. Use naming-convention-separators-get to read or naming-convention-separators-set to change separators.

naming-convention-separators-get

ChatGPT
Get the tenant's current separator config for naming conventions (read-only). Separators are the characters used to split ad names in position/kv extraction methods (e.g. '_' in 'US_Prospecting_Video'). Call this before proposing a position/kv rule.

naming-convention-separators-set

ChatGPT
Replace the tenant's separator config for naming conventions with the given list (e.g. ['/', '+']). This overwrites the whole config — call naming-convention-separators-get first and include every separator that existing rules still rely on. Each separator must be symbols only (no letters, digits or whitespace — same rule as the web UI); the built-in ["-","_","|",">"," "] are always available and need not be stored.

naming-convention-update-or-delete

ChatGPT
Update or delete an existing naming convention config by its numeric id (get IDs from naming-convention-list). - action='update': modify propertyName, separator, position, identifier, regex, or segments (segments replaces the whole list — read the current ones via naming-convention-list with includeValueConditions: true first) (adPlatform, level, and method cannot be changed). A new propertyName must be unique within the config's ad platform; a separator outside the built-in set must be in the tenant's custom list. - action='delete': permanently remove a config by id

onboarding-invite-team

ChatGPT
Invite teammates to the calling tenant by email. Calls WorkMagic's members API (POST /api/tenant/members), which sends one invitation email to each new external address. Performs a pre-flight check to skip already-joined emails so the agent gets a clean partition between newly-invited and already-existing members. Pair with onboarding-status (the invite_team task flips to done once member count > 1 — pending invitations also count).

onboarding-status

ChatGPT
Read-only snapshot of a tenant's onboarding progress. Returns per-task status (done / pending / not_applicable / blocked / see_pixel_status) computed from Data Scope, integrations, settings, tactics, naming conventions, custom-built store domain, and pixel event activity. Each task carries a detail describing why and an actionTool hint pointing the agent at the right downstream MCP tool. When Data Scope is not configured the response carries dataScopeConfigured: false with an empty tasks list — the agent should call data-scope-set first.

onboarding-update-config

ChatGPT
Update a tenant's onboarding config — backend write for one of: set_currency_timezone, setup_store_domain, configure_tracking. Currency+timezone and storefront domain are set-once: re-calling with a different value returns an err pointing at the locked value; re-calling with the same value returns status: "already-set". Tracking flag is freely toggleable. Pair with onboarding-status (call it first to find which config tasks are pending; agent then dispatches this tool with the matching taskId + per-task params).

pixel-status

ChatGPT
Get the WorkMagic Pixel deployment status for a tenant. Returns primary-site pixel health (event counts, page coverage, 7-day trend) and 3rd-party landing-page status, plus install instructions when problems are found. Prerequisites: tenant must have a Data Scope configured (see data-scope-get). If the primary site type is shopify, you MUST first ask the user whether the store is headless (custom frontend on Shopify backend) and pass isHeadless accordingly. Without it the tool returns an actionable requiresInput error. Note: this tool does NOT report whether 3rd-party landing-page domains are registered in Settings — only whether the pixel is receiving events on them.

product-article-search

ChatGPT
Search the product's official documentation / help articles. Use when the user asks how to use a feature, requests product documentation, or asks what something in the platform means. Returns the most relevant excerpts with source URLs.

saved-view-create

ChatGPT
Create a saved view on an attribution dashboard (Ads Channel / All Channels / Email & SMS), e.g. a view for the customer's chosen use case and attribution model. The view starts from the page's WM view settings and applies what you pass (model, attribution window, date type, comparison period, columns, trendline, breakdown, filters). Shared with the whole team by default (same as the page). Optional setAsDefault makes it YOUR default view on that page. Saved views do not store a date range — the page's date picker always decides it (the comparison period IS stored, see comparison). The default view is per user: it applies only to the account calling this tool. Teammates (including the customer) keep their own default — new users land on the WM view.

saved-view-list

ChatGPT
List the saved views of the attribution dashboards — the 'View' dropdown on the Ads Channel (page='ads'), All Channels ('all-channels') and Email & SMS ('email') pages. Returns views visible to you: the WM view (type='preset', read-only), your own views and teammates' shared views, in the page's order (your default first). settings summarises each view (model, window, date type, columns, breakdown, filters). Omit page to list all three pages. DO NOT use for custom dashboards (use dashboard-list).

saved-view-update-or-delete

ChatGPT
Change, delete, or set as default an existing saved view (ids from saved-view-list). - action='update': rename, change sharing, and/or change settings. Settings merge onto the view: parameters you omit keep their current value; passing any filter parameter replaces all the view's filters. - action='delete': permanently delete the view (for everyone it was shared with; users who had it as default fall back to the WM view). - action='set-default': make the view (WM view included) your default on its page. The default view is per user: it applies only to the account calling this tool. Teammates (including the customer) keep their own default — new users land on the WM view. WM views (type='preset') cannot be updated or deleted.

skills-list

ChatGPT
List the available WorkMagic skill playbooks — each skill's name, description, category, risk, and version. This is the routing index: read the descriptions, pick the skill whose description matches the task, then call skills-read with its name to load the playbook. Optionally pass category to filter (e.g. attribution, lift-test, mbo).

skills-read

ChatGPT
Read one file from a WorkMagic skill playbook. Call with just name to get its SKILL.md (the playbook body + its list of reference / template / example files). Then call again with a path from that list to load a specific detail file. Discover skill names with skills-list first.

tactic-create

ChatGPT
Create an ad tactic that classifies campaigns into groups based on naming patterns. Matching rule fields: - field: what to match against — 'campaign_name' or 'campaign_type'. Imported platforms and Vibe / Tatari Streaming / LinkedIn / Roku / WalmartSearchAds / WalmartDisplayAds / AmazonAds support 'campaign_name' only. 'adset_name' cannot be used for new tactics. - operator: 'contain' (include matches) or 'notContain' (exclude matches) - logic: 'anyOf' (match if ANY value found) or 'allOf' (match if ALL values found) - value: array of strings to match The regex pattern is auto-generated from field/logic/value. After creation, tactic→campaign matching is asynchronous: it can take up to 3 hours to take effect and applies retroactively to the past 40 days of data. To verify matches later, query tactic_name on dws_view_copilot_attr_ads_ad_level_daily_latest via database-query-run. Example: field='campaign_name', operator='contain', logic='anyOf', value=['brand', 'Brand'] → matches campaigns whose name contains 'brand' or 'Brand'. ⚠️ adsPlatform must be one of the tenant's integrated ad platforms If you pass an unintegrated value the tool returns an error that lists the valid values for this tenant — you can also discover them up-front via database-query-ask or database-query-run. ⚠️ For field='campaign_type': matching is CASE-SENSITIVE (e.g. 'SEARCH' ≠ 'Search'). Use database-query-run to query actual values first: SELECT campaign_type, MEASURE(ad_spend) FROM dws_view_copilot_attr_ads_ad_level_daily_latest WHERE attr_model_name='data_driven' GROUP BY 1 Limits: max 20 tactics per platform per tenant; name max 30 characters. New tactics are appended at the lowest priority — use tactic-update-or-delete action='reorder' to change the order.

tactic-list

ChatGPT
List all ad tactics for the current tenant. Returns tactics with their matching rules (field, operator, logic, value) and priority (per platform; a campaign goes to the first matching tactic in ascending priority). Each tactic has a numeric id used for update/delete operations. To see which campaigns each tactic matches (with spend / orders / etc.), query tactic_name on dws_view_copilot_attr_ads_ad_level_daily_latest via database-query-run — the name returned here equals tactic_name there.

tactic-update-or-delete

ChatGPT
Update, delete or reorder existing ad tactics (get IDs from tactic-list). - action='update' (needs id): modify field, operator, logic, or value. name and adsPlatform CANNOT be changed after creation (delete + recreate to change either). Field rules match tactic-create; an existing 'adset_name' rule may keep that field but cannot switch back to it. - action='delete' (needs id): permanently remove a tactic. - action='reorder' (needs sortedIds): set the priority order of ALL tactics of one ad platform. A campaign is assigned to the FIRST tactic (top of the list) whose rule matches it, so order decides which tactic wins when rules overlap. ⚠️ Lift tests reference tactics by name (campaign scope + calibration). Before a delete, a rule change or a reorder that moves a tactic, this tool checks the tenant's lift tests and REFUSES if any non-terminated lift test uses an affected tactic (or if the check itself fails). Tell the user which lift tests are affected; only after they agree, retry with confirmAffectsLiftTest: true.

tenant-list

ChatGPT
List all tenants the current user has access to. Returns tenant ids, names, and a 'kind' field: 'owned' for tenants the user belongs to, 'possession' for tenants an internal employee can act on behalf of. Use this to discover which tenant id to pass to other tools. Optionally pass tenantId to return only that one tenant (filter).

tenant-member-list

ChatGPT
List the team members of a WorkMagic tenant — each member's email, role (admin | member | viewer | customerSupport), and isCreator flag. Wraps GET /tenant/members. Read-only. Use to enumerate a workspace's full roster (e.g. to mirror team membership elsewhere). NOTE: WM has no 'owner' role — the workspace creator is marked by isCreator=true and the highest manageable role is 'admin'. 'customerSupport' rows are transient WM-support accounts, not real teammates — exclude them when syncing.

tracking-log

ChatGPT
Per-ad outcomes of past tracking-URL updates — the same rows as the 'Update logs' tab on the tracking settings page. This is the RIGHT tool for 'did my update work?': it reflects the run within minutes, whereas tracking-status only moves hours later, once the ad platform serves the new URLs back to us. One row is ONE AD, not one campaign: a campaign with three failing ads gives three rows, exactly as the page shows it. message is the ad platform's own wording, passed through untouched — quote it rather than paraphrasing, and do not turn it into a diagnosis it does not support. Covers both manual runs and the automatic nightly update, newest first. ORDER matches the page exactly: newest day first, that day's failures above its successes, newest first within each group. Report the rows in the order they arrive rather than re-sorting them — a re-sort only reorders the page you are holding and hides where the failures really sit. DO NOT use for: how many ads currently lack tracking (tracking-status), or performance numbers (database-query-run).

tracking-status

ChatGPT
Report which of a tenant's ACTIVE ads are missing correct WorkMagic tracking parameters on their landing URL, split into the two groups that need different actions: • auto_fixable — WorkMagic can rewrite these landing URLs through the ad platform's API. In Justin, tracking-update runs it for the campaigns the customer confirms; everywhere else there is NO tool that performs the update and the customer runs it themselves from the tracking settings page, whose link is returned as settings_url. Give them that link verbatim; never construct one yourself. • manual_only — the platform (or that campaign type) has no update API, so that page cannot fix these either; the customer must paste the returned suggested_params onto the landing URL in that platform's own ads manager. Ads without correct tracking still run — what breaks is attribution: their orders cannot be matched back to the ad, so the platform's spend shows up with missing or wrong revenue. FRESHNESS — read this before reporting a number as 'current'. data_as_of is when this data was last refreshed, computed the same way as the 'Data refreshed at' line on the tracking settings page, so quote it rather than saying 'now' — and it will match what the customer sees on screen. 🔴 LEAVE realtime ALONE unless the customer asked for live numbers in so many words. The default precomputed view is what the tracking settings page shows, so it is the answer they can check against their screen. The live view is minutes fresher at best and routinely times out on a large tenant — reaching for it on a plain 'is my tracking ok?' turns a working answer into a failed call. 🔴 DO NOT use this to verify an update the customer just ran. A URL changed on that page only reaches this data after the ad platform serves it back to us and it lands in the warehouse — hours, not minutes, and NO view setting shortens that. Unchanged numbers right after an update mean 'not yet', not 'failed'; re-running the update would change the customer's live ads a second time. Use tracking-log to check whether the update itself succeeded. DO NOT use for: whether tracking auto-update is switched on (that is onboarding-update-config), or per-ad attribution numbers (database-query-run).

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/workmagic"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/workmagic)