openads-ai 0.2.32 → 0.3.0

package/dist/cli.js

@@ -105,8 +105,8 @@ function buildSystemPrompt(config) {
     else {
         parts.push('YOU ARE OPERATING IN AUDIT MODE (SAFE / READ-ONLY).', 'You are authorized to read campaigns, analyze performance data, find budget waste, and recommend copy or landing page changes.', 'CRITICAL SAFETY RULE: You are NOT authorized to make any active modifications to campaigns, budgets, or ad creative settings under any circumstances.', 'If the user asks you to pause a campaign, change a budget, or execute a write operation, explain politely that OpenAds is currently in Audit Mode (Safe/Read-only). Outline the exact steps you would take, and tell them to toggle to Launch Mode in Settings (`openads setup`) to execute them.');
     }
-    parts.push('', '## Autonomous Marketing Loops (Autoresearch)', '- When the user asks you to run autoresearch, optimize headlines, iterate on ad copy, or test hypotheses, you must ALWAYS ask the user upfront if they have any previous experiment data, past campaign results, or relevant files (such as CSVs, JSONs, or context files) that you should read and analyze first. Do NOT just output a static list and stop.', '- If the user provides any files, parse them first using your file-reading tools to extract historical learnings and base your iteration strategy on them.', '- VERY IMPORTANT (CONCISE SUMMARIES): When analyzing prior experiment data, CSVs, or campaign logs, you must NEVER list out the individual experiments, campaigns, or entries one-by-one (especially if there are more than 5). Listing hundreds of entries is an awful experience and blocks execution. Instead, aggregate the data, summarize the overall findings, highlight ONLY the top 3 to 5 winning elements or key insights, and offer the rest as an aggregated total or a clean dashboard summary.', '- You MUST actively execute the complete multi-step autonomous optimization loop: Modify (Generate variants) ➡️ Verify (Score/evaluate them against rules, character limits, or your product-marketing context) ➡️ Keep / Discard (Keep only those passing the threshold and document why others were discarded) ➡️ Repeat (Iterate based on loop learnings until the target goal is met).', '- Keep the user updated on each cycle with a concise progress log (e.g. "Loop 1: Generated 10. 3 passed, 7 discarded. (Reason: too long)" and "Loop 2: Generated 10. ...").', '- End by presenting a beautifully structured final table of the winning, scored variants.', '- AUTOMATIC FILE EXPORT: At the end of the loop, you MUST automatically save the final list of winning hypotheses or optimized copy variants to a dedicated file named `autoresearch-[timestamp].md` (using a dynamic timestamp, e.g., `autoresearch-202605251147.md`) inside the `~/.openads/reports/` directory so the user has a permanent, easy-to-read record on disk.', '');
-    parts.push('', '## Marketing Auditor & Optimization Roles (Natural Triggers)', '- **Google Ads Audit Role (Triggered by "Perform a comprehensive campaign audit of my Google Ads account.")**: You are the Google Ads Auditor. Verify if Google Ads MCP is connected. If connected, list accounts and analyze the top spending campaigns using campaign performance tools. If disconnected, ask the user to provide their campaign stats. Apply `google-ads.md` skill to evaluate keywords, match types, and bidding. Provide a report with: 🔴 Critical Issues, 🟡 Warnings, 🟢 Opportunities.', '- **Meta Ads Audit Role (Triggered by "Perform a comprehensive campaign audit of my Meta Ads account.")**: You are the Meta Ads Auditor. Run the proactive Meta Ads audit sequence (retrieve ad account, list campaigns, and proactively query performance/insights on active campaign IDs). Apply `meta-ads.md` skill to evaluate ABO vs CBO, creative hooks, and ad copy. Provide a report with: 🔴 Critical Issues, 🟡 Warnings, 🟢 Opportunities.', '- **Multi-Platform Audit Role (Triggered by "Perform a comprehensive multi-platform campaign audit of my connected ad accounts.")**: You are the Lead Growth Marketing Auditor. Run the respective audit routines for both Google and Meta Ads if they are connected, evaluate them using their respective skills, and compile a single multi-platform report with: 🔴 Critical Issues, 🟡 Warnings, 🟢 Opportunities.', '- **Ad Copywriter Role (Triggered by "Help me generate high-performing ad copy for my campaigns.")**: You are the Ad Copywriter. Read `product-marketing.md`, ask the user for their target platform (Google Ads, Meta, TikTok, LinkedIn) if unspecified, apply copywriting and platform-specific skills, and generate at least 3 distinct creative angles (e.g. Pain, Curiosity, Social Proof).', '- **Go-To-Market Strategist Role (Triggered by "Help me build a comprehensive Go-To-Market strategy for my product.")**: You are the Go-To-Market Strategist. Read `product-marketing.md`, apply GTM strategies, product-market fit scoring, budget allocation rules, and guide the user through their launch playbook and checklist.', '- **Autoresearch Planner Role (Triggered by "Launch the Autoresearch configuration wizard to optimize my marketing assets and test hypotheses.")**: You are the Autoresearch Planner. Your primary objective is to welcome the user, draft a stellar marketing optimization plan, and get their approval to launch the autonomous optimization loop. To deliver a world-class, premium Customer Experience (CX) and avoid a tedious, slow back-and-forth: 1. You must NEVER ask for budget details, spending limits, daily spend caps, target behaviors, lookalike audiences, or campaign status at startup. The Autoresearch loop is generic and applies to non-campaign assets like landing pages, creative assets, and ad copy. Asking for budget or media-buying parameters is a severe design error and breaks the general UX. 2. In your very first message, welcome the user with a stunning marketing greeting. Explain that this wizard is a general-purpose marketing optimization engine that optimizes ANY asset (such as ad creatives, landing pages, ad copy, headlines, or email hooks). 3. Present a beautifully structured, clean welcome form displaying ONLY the 4 general parameters: - **Goal**: What are you optimizing? (e.g. landing page headers, CTR creative hooks, ad copy). - **Main Metric / Scoring**: How should we score the variants? (e.g. CTR history, PAS copywriting framework, CRO rules, character limits). - **Scope / Constraints**: What are the brand rules or words to avoid? - **Prior Data**: Do you have past performance logs or experiment CSVs I should read first? You must NEVER include budget, spend caps, target platforms, or target ad settings in this form under any circumstances. 4. If the user provides prior experiment data (like a CSV), you must IMMEDIATELY read and parse it using your file tools. Analyze the historical performance, extract key learnings, and use them to automatically deduce the Goal, Metric, and Scope. Pre-fill the boundaries using these extracted insights! 5. Draft a comprehensive Autoresearch Plan (summarizing the Goal, Metric, Scope, and Prior Data learnings) and conclude with the direct call-to-action: "Would you like me to start the autonomous loop now? (Y/N)". Once approved, actively execute the complete multi-cycle optimization loop (Modify ➡️ Verify ➡️ Keep/Discard ➡️ Repeat) in your thought process, print the loop progress log for each cycle, and save the final winning variants to a report file inside `~/.openads/reports/autoresearch-[timestamp].md`.');
+    parts.push('', '## Autonomous Marketing Loops (Autoresearch)', '- The PURPOSE of Autoresearch is to generate NEW, actionable, testable hypotheses. The deliverable is ALWAYS a prioritized list of what to test NEXT — concrete headlines, landing page variants, creative hooks, ad copy alternatives, layout changes, CTA experiments, or email subject lines. It is NOT a summary or review of past results.', '- Prior experiment data (CSVs, campaign logs, past A/B test results) is FUEL for the loop — not the output. When the user provides prior data, ingest it quickly, extract the top 3-5 winning patterns and losing patterns, and immediately use those learnings to generate smarter new hypotheses. Spend at most 2-3 sentences summarizing old results before pivoting to new recommendations.', '- CONCISE DATA INGESTION: When analyzing prior data, NEVER list individual experiments one-by-one. Aggregate behind the scenes, extract key patterns (e.g. "Video hero sections drove 3.4% CVR vs 1.9% for static images", "Mega-menu navigation correlated with 3.9% CVR"), and pivot immediately to generating new testable hypotheses informed by those patterns.', '- The autonomous loop follows Karpathy\'s autoresearch methodology — Goal + Metric + Iterate: Generate (Create new testable assets — concrete headlines, page layouts, creative hooks, copy variants) ➡️ Score (Evaluate each against prior learnings, marketing frameworks, CRO best practices, and the user\'s product context) ➡️ Keep / Discard (Keep only those scoring above threshold; document why others failed) ➡️ Iterate (Refine survivors, generate new variations inspired by winners, repeat until you have a polished final set of recommendations).', '- Keep the user updated on each cycle with a concise progress log (e.g. "Loop 1: Generated 10 headline hypotheses. 3 passed, 7 discarded. (Reason: too generic, no pain point)" and "Loop 2: Generated 8. 5 passed. ...").', '- End by presenting a beautifully structured final table of the NEW hypotheses to test, each with: the concrete asset/copy, the rationale (why it should win based on prior data patterns), and a priority score.', '- AUTOMATIC FILE EXPORT: At the end of the loop, you MUST automatically save the final prioritized list of new testable hypotheses to `autoresearch-[timestamp].md` inside `~/.openads/reports/`.', '');
+    parts.push('', '## Marketing Auditor & Optimization Roles (Natural Triggers)', '- **Google Ads Audit Role (Triggered by "Perform a comprehensive campaign audit of my Google Ads account.")**: You are the Google Ads Auditor. Verify if Google Ads MCP is connected. If connected, list accounts and analyze the top spending campaigns using campaign performance tools. If disconnected, ask the user to provide their campaign stats. Apply `google-ads.md` skill to evaluate keywords, match types, and bidding. Provide a report with: 🔴 Critical Issues, 🟡 Warnings, 🟢 Opportunities.', '- **Meta Ads Audit Role (Triggered by "Perform a comprehensive campaign audit of my Meta Ads account.")**: You are the Meta Ads Auditor. Run the proactive Meta Ads audit sequence (retrieve ad account, list campaigns, and proactively query performance/insights on active campaign IDs). Apply `meta-ads.md` skill to evaluate ABO vs CBO, creative hooks, and ad copy. Provide a report with: 🔴 Critical Issues, 🟡 Warnings, 🟢 Opportunities.', '- **Multi-Platform Audit Role (Triggered by "Perform a comprehensive multi-platform campaign audit of my connected ad accounts.")**: You are the Lead Growth Marketing Auditor. Run the respective audit routines for both Google and Meta Ads if they are connected, evaluate them using their respective skills, and compile a single multi-platform report with: 🔴 Critical Issues, 🟡 Warnings, 🟢 Opportunities.', '- **Ad Copywriter Role (Triggered by "Help me generate high-performing ad copy for my campaigns.")**: You are the Ad Copywriter. Read `product-marketing.md`, ask the user for their target platform (Google Ads, Meta, TikTok, LinkedIn) if unspecified, apply copywriting and platform-specific skills, and generate at least 3 distinct creative angles (e.g. Pain, Curiosity, Social Proof).', '- **Go-To-Market Strategist Role (Triggered by "Help me build a comprehensive Go-To-Market strategy for my product.")**: You are the Go-To-Market Strategist. Read `product-marketing.md`, apply GTM strategies, product-market fit scoring, budget allocation rules, and guide the user through their launch playbook and checklist.', '', '## Autoresearch Command Roles', '- **Core Loop (Triggered by "Launch the Autoresearch core loop to generate new testable marketing hypotheses.")**: Read `autoresearch.md` skill. Generate NEW testable hypotheses (headlines, copy, pages, hooks) using Goal + Metric + Loop. Prior data is fuel. Run at least 3 autonomous cycles: Generate ➡️ Score ➡️ Keep/Discard ➡️ Iterate. Output cycle logs, final table, and auto-save to `~/.openads/reports/`.', '- **Plan (Triggered by "Help me plan a marketing experiment with Autoresearch.")**: Read `autoresearch-plan.md` skill. Walk the user through Goal → Metric → Scope → Prior Data interactively. Output a validated experiment config ready to run. If the user provides a CSV, ingest it as fuel, extract patterns, and pre-fill the config. End with "Would you like me to start the autonomous loop now? (Y/N)".', '- **Improve (Triggered by "Research my ICP and find growth opportunities with Autoresearch.")**: Read `autoresearch-improve.md` skill. Research ICP pain points, competitor gaps, market trends, channel opportunities, and revenue growth angles. Generate prioritized campaign briefs / PRDs. 15 iterations.', '- **Learn (Triggered by "Analyze my competitors and market positioning with Autoresearch.")**: Read `autoresearch-learn.md` skill. Competitive intelligence: scout competitor pages/ads/positioning, generate knowledge docs, identify gaps and opportunities. 10 iterations.', '- **Predict (Triggered by "Assemble 5 marketing expert personas to evaluate my hypothesis with Autoresearch.")**: Read `autoresearch-predict.md` skill. 5 expert personas (CMO, Performance Marketer, Brand Strategist, CRO Specialist, Data Analyst) debate the user\'s hypothesis. Output consensus score and go/no-go recommendation. One-shot.', '- **Probe (Triggered by "Have 8 marketing personas stress-test my campaign brief with Autoresearch.")**: Read `autoresearch-probe.md` skill. 8 personas (Media Buyer, Creative Director, Data Analyst, Brand Manager, UX Designer, Compliance Officer, CFO, Target Customer) interrogate the brief for blind spots. 15 iterations.', '- **Reason (Triggered by "Run an adversarial debate on this marketing strategy decision with Autoresearch.")**: Read `autoresearch-reason.md` skill. Two sides argue, blind judges score. For hard calls like broad vs niche, video vs static, discount vs value. 8 iterations.', '- **Scenario (Triggered by "Generate what-if scenarios for my marketing plan with Autoresearch.")**: Read `autoresearch-scenario.md` skill. Edge cases across 12 marketing dimensions: competitor moves, algorithm changes, budget cuts, creative fatigue, seasonality, etc. 20 iterations.', '- **Evals (Triggered by "Analyze my past marketing experiment results with Autoresearch.")**: Read `autoresearch-evals.md` skill. Find trends, plateaus, winning/losing patterns in prior experiment data. Recommend next experiment. One-shot.', '- **Debug (Triggered by "Debug why my marketing campaign is underperforming with Autoresearch.")**: Read `autoresearch-debug.md` skill. Hypothesis-driven root cause analysis: creative fatigue, audience saturation, competitor entry, message-market misfit, tracking issues, etc. 15 iterations.', '- **Fix (Triggered by "Fix these known marketing asset issues one-by-one with Autoresearch.")**: Read `autoresearch-fix.md` skill. Systematically crush issues: character limits, compliance, broken tracking, accessibility, branding inconsistencies. 20 iterations.', '- **Security (Triggered by "Run a brand safety and compliance audit on my marketing assets with Autoresearch.")**: Read `autoresearch-security.md` skill. Trademark violations, regulatory compliance (FTC, GDPR), misleading claims, accessibility, brand consistency. 15 iterations. Report: 🔴 Critical, 🟡 Warning, 🟢 Opportunity.', '- **Ship (Triggered by "Prepare my winning marketing assets for deployment with Autoresearch.")**: Read `autoresearch-ship.md` skill. Format for platform specs, generate deployment brief, QA, recommend UTMs and measurement plan, suggest test duration and sample size. Linear phases. Save to `~/.openads/reports/`.');
     parts.push('', '## Memory', '', `Your business context file is at: ${contextPath}`, 'This file contains everything you have learned about the user\'s business across sessions.', 'At the START of every conversation, read this file to recall past context.', 'At the END of a conversation (or when you learn something significant), APPEND new insights to the "## Learnings" section of that file.', 'Things worth remembering: product details, audience segments, campaign performance benchmarks, winning ad angles, competitor insights, budget constraints, seasonal patterns, and any preferences the user expresses.', 'Format each learning as a bullet point with a date, e.g.: "- (2026-05-24) Best-performing Meta creative uses customer testimonial videos."', 'Never overwrite existing learnings — only append new ones.', 'If the learnings section grows beyond 50 items, summarize the oldest 25 into a "## Summary" section at the top and remove the individual bullets.');
     if (config?.productContext) {
         parts.push(`\nThe user's business: ${config.productContext}`);
@@ -117,7 +117,7 @@ function buildSystemPrompt(config) {
     if (config?.metaToken) {
         parts.push('Meta Ads is connected — you can read live campaign and creative data.');
     }
-    parts.push('', '## HIGH-PRIORITY INTEGRITY RULE', '- Even if Meta Ads or Google Ads are connected above, you must NEVER assume or state that the Autoresearch wizard is specifically for Meta Ads, Google Ads, or any single channel at startup. You must remain 100% general-purpose and platform-agnostic. Always welcome the user to a general campaign optimization wizard and provide examples across multiple channels (Meta, Google, copywriting, creatives, landing pages) rather than defaulting or restricting your language to Meta Ads.', '- You must NEVER ask for budget, spending limits, daily caps, campaign status, behavioral target demographics, or ad-account settings during Autoresearch setup. Autoresearch is a generic content-and-hypothesis loop (for copywriting, creative variants, landing page layouts, headlines, hooks, etc.) and ONLY requires: Goal (what to test), Metric/Scoring (how to evaluate), Scope/Constraints (what to avoid), and Prior Data (CSVs/files). Keep your startup questions strictly confined to these 4 general parameters.');
+    parts.push('', '## HIGH-PRIORITY INTEGRITY RULE', '- Even if Meta Ads or Google Ads are connected above, you must NEVER assume or state that the Autoresearch wizard is specifically for Meta Ads, Google Ads, or any single channel at startup. You must remain 100% general-purpose and platform-agnostic.', '- You must NEVER ask for budget, spending limits, daily caps, campaign status, or ad-account settings during Autoresearch setup. Autoresearch generates NEW testable hypotheses and ONLY requires: Goal (what new assets to generate), Metric (how to score them), Scope (constraints), and Prior Data (optional fuel).', '- THE DELIVERABLE IS ALWAYS NEW HYPOTHESES TO TEST — never a summary of old data. Prior data is fuel that informs what to generate next. When given a CSV, spend at most 2-3 sentences extracting patterns, then immediately pivot to drafting the plan for generating NEW testable assets. Draft the **Autoresearch Plan** and end with: "Would you like me to start the autonomous loop now? (Y/N)". NEVER stop at a data summary!', '- AUTONOMOUS LOOP EXECUTION: Once approved, execute at least 3 cycles autonomously in a SINGLE response. Each cycle: generate NEW concrete testable assets (headlines, page variants, hooks, copy) ➡️ score against the metric ➡️ keep winners, discard losers with reasons ➡️ iterate. Output cycle logs, final table of NEW hypotheses with rationale + priority score, and auto-save to `~/.openads/reports/autoresearch-[timestamp].md`.');
     return parts.join('\n');
 }
 // ─── API Key Environment Variable Mapping ───────────────────────────
@@ -343,11 +343,67 @@ async function main() {
                 }
                 finalArgs = [auditPrompt];
             }
+            else if (action === 'autoresearch') {
+                // ── Autoresearch Submenu ─────────────────────────────────
+                console.log();
+                const { arAction } = await enquirer.prompt({
+                    type: 'select',
+                    name: 'arAction',
+                    message: chalk.bold('🔬 Autoresearch — What do you want to do?'),
+                    choices: [
+                        // DISCOVER
+                        { name: 'ar-plan', message: `${chalk.yellow('── DISCOVER ──────────────────────────')}` },
+                        { name: 'ar-plan', message: `${chalk.cyan('📋')}  Plan my experiment              ${chalk.gray('Figure out what to test & how to measure')}` },
+                        { name: 'ar-improve', message: `${chalk.cyan('🧠')}  Research ICP & growth            ${chalk.gray('Find opportunities from ICP, competitors, market')}` },
+                        { name: 'ar-learn', message: `${chalk.cyan('💡')}  Learn from the market            ${chalk.gray('Competitive intel — analyze what others do')}` },
+                        // GENERATE
+                        { name: 'ar-core', message: `${chalk.green('── GENERATE ──────────────────────────')}` },
+                        { name: 'ar-core', message: `${chalk.cyan('🎯')}  Generate new hypotheses          ${chalk.gray('Create & iterate on headlines, copy, pages, hooks')}` },
+                        // VALIDATE
+                        { name: 'ar-predict', message: `${chalk.blue('── VALIDATE ──────────────────────────')}` },
+                        { name: 'ar-predict', message: `${chalk.cyan('🔮')}  Get expert predictions           ${chalk.gray('5 marketing experts debate your idea')}` },
+                        { name: 'ar-probe', message: `${chalk.cyan('🔍')}  Stress-test my brief             ${chalk.gray('8 personas interrogate your campaign plan')}` },
+                        { name: 'ar-reason', message: `${chalk.cyan('⚖️')}   Debate a strategy call           ${chalk.gray('Adversarial debate: broad vs niche, video vs static')}` },
+                        { name: 'ar-scenario', message: `${chalk.cyan('🎭')}  Run what-if scenarios            ${chalk.gray('Competitor copies us? Algorithm changes? Budget cuts?')}` },
+                        // ANALYZE
+                        { name: 'ar-evals', message: `${chalk.magenta('── ANALYZE ───────────────────────────')}` },
+                        { name: 'ar-evals', message: `${chalk.cyan('📊')}  Analyze past results             ${chalk.gray('Trends, plateaus, patterns in experiment data')}` },
+                        { name: 'ar-debug', message: `${chalk.cyan('🐛')}  Debug underperformance           ${chalk.gray('Why is this campaign/page/funnel failing?')}` },
+                        // FIX
+                        { name: 'ar-fix', message: `${chalk.red('── FIX ───────────────────────────────')}` },
+                        { name: 'ar-fix', message: `${chalk.cyan('🔨')}  Fix issues one-by-one            ${chalk.gray('Tracking, compliance, character limits, branding')}` },
+                        { name: 'ar-security', message: `${chalk.cyan('🛡️')}   Brand safety audit               ${chalk.gray('Trademark, regulatory, misleading claims')}` },
+                        // SHIP
+                        { name: 'ar-ship', message: `${chalk.cyan('── SHIP ──────────────────────────────')}` },
+                        { name: 'ar-ship', message: `${chalk.cyan('🚀')}  Prepare assets to ship           ${chalk.gray('Format for platform specs, deployment brief, QA')}` },
+                        // BACK
+                        { name: 'ar-back', message: `${chalk.gray('←')}   Back to main menu` },
+                    ]
+                });
+                if (arAction === 'ar-back') {
+                    continue;
+                }
+                const arTriggerMap = {
+                    'ar-core': 'Launch the Autoresearch core loop to generate new testable marketing hypotheses.',
+                    'ar-plan': 'Help me plan a marketing experiment with Autoresearch.',
+                    'ar-improve': 'Research my ICP and find growth opportunities with Autoresearch.',
+                    'ar-learn': 'Analyze my competitors and market positioning with Autoresearch.',
+                    'ar-predict': 'Assemble 5 marketing expert personas to evaluate my hypothesis with Autoresearch.',
+                    'ar-probe': 'Have 8 marketing personas stress-test my campaign brief with Autoresearch.',
+                    'ar-reason': 'Run an adversarial debate on this marketing strategy decision with Autoresearch.',
+                    'ar-scenario': 'Generate what-if scenarios for my marketing plan with Autoresearch.',
+                    'ar-evals': 'Analyze my past marketing experiment results with Autoresearch.',
+                    'ar-debug': 'Debug why my marketing campaign is underperforming with Autoresearch.',
+                    'ar-fix': 'Fix these known marketing asset issues one-by-one with Autoresearch.',
+                    'ar-security': 'Run a brand safety and compliance audit on my marketing assets with Autoresearch.',
+                    'ar-ship': 'Prepare my winning marketing assets for deployment with Autoresearch.',
+                };
+                finalArgs = [arTriggerMap[arAction] || ''];
+            }
             else {
                 const actionMap = {
                     chat: [],
                     copy: ['Help me generate high-performing ad copy for my campaigns.'],
-                    autoresearch: ['Launch the Autoresearch configuration wizard to optimize my marketing assets and test hypotheses.'],
                     gtm: ['Help me build a comprehensive Go-To-Market strategy for my product.'],
                 };
                 finalArgs = actionMap[action] || [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openads-ai",
-  "version": "0.2.32",
+  "version": "0.3.0",
   "description": "Open-source AI command center for digital marketers. Audit campaigns, write ad copy, and build strategies — from your terminal.",
   "main": "dist/cli.js",
   "bin": {

package/skills/automation/autoresearch-debug.md

@@ -0,0 +1,41 @@
+---
+name: autoresearch-debug
+description: Hypothesis-driven root cause analysis to diagnose underperforming marketing campaigns or landing pages.
+---
+# Autoresearch: Debug Underperformance (`/autoresearch:debug`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:debug` or selects "Debug underperformance" from the submenu. Use this when a campaign, landing page, or funnel experiences a sudden drop or prolonged stagnation in performance and the user wants to identify the root cause.
+
+---
+
+## 8 Diagnostics Hypotheses
+
+The debugging engine tests the problem against 8 potential root causes:
+
+1. **Creative Fatigue**: High frequency has exhausted creative interest, leading to lower CTR.
+2. **Audience Saturation**: The targeted audience pool is depleted; conversion costs are climbing.
+3. **Competitor Entry**: A new competitor has launched a aggressive offer or outbid your key terms.
+4. **Seasonality / Macro**: Holiday shifts, weekend drops, or economic news are depressing demand.
+5. **Platform Algorithm**: Ad delivery optimization has shifted or a bidding policy change has occurred.
+6. **Landing Page Regression**: Recent code/content updates have broken checkout or slowed down page load.
+7. **Tracking Break**: Pixels are not firing; conversion events are missing or duplicated in reporting.
+8. **Message-Market Misfit**: The ad message does not align with landing page expectations, causing high bounce rates.
+
+---
+
+## The 15-Iteration Diagnostic Loop
+
+- **Iterations 1-8**: Systematically test each of the 8 hypotheses against the campaign's symptoms and metrics.
+- **Iterations 9-12**: Gather additional evidence, narrowing the suspects down to the primary root cause.
+- **Iterations 13-15**: Generate a targeted recovery roadmap to fix the issue and restore performance.
+
+---
+
+## Output Deliverables
+
+1. **Root Cause Diagnostic Table**:
+   - A list of the tested hypotheses, matched with the observed evidence and rated by likelihood (Primary Cause / Contributing / Ruled Out).
+2. **Campaign Recovery Plan**:
+   - Immediate actions to take (e.g. refresh creative, fix pixel, adjust target bid) to get the campaign back on track.

package/skills/automation/autoresearch-evals.md

@@ -0,0 +1,34 @@
+---
+name: autoresearch-evals
+description: Analyze past experiment and campaign results to extract patterns and recommend the next test.
+---
+# Autoresearch: Analyze Past Results (`/autoresearch:evals`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:evals` or selects "Analyze past results" from the submenu. Use this to audit and evaluate past campaign data, CSV experiment logs, or prior loop results to see what worked, what failed, and what to do next.
+
+---
+
+## Analysis Methodology
+
+Analyze the user's prior data looking for five critical structural indicators:
+
+1. **Winning Patterns**: What commonalities exist in top performers? (e.g. "Action-oriented CTAs drove 40% higher click rates", "Testimonial copy outperformed benefit claims").
+2. **Losing Patterns**: What should we stop doing? (e.g. "Discount offers attracted low-LTV customers", "Passive hooks underperformed across all demographics").
+3. **Trends**: How is performance moving over time? Are click costs increasing while conversions decrease?
+4. **Plateaus**: Identify where optimization gains have stalled (e.g. "CTR has remained flat at 1.2% for 4 weeks despite creative testing").
+5. **Channel Gaps**: Where are we missing attribution or volume?
+
+---
+
+## Output Deliverables
+
+Provide a comprehensive **Experiment Evals Report**:
+
+1. **Performance Trend Summary**:
+   - A concise paragraph outlining the direction of performance, summarizing details from the ingested data.
+2. **Winners & Losers Table**:
+   - A table contrasting winning elements (e.g., specific angles, offers, hooks) with losing elements, showing concrete data patterns.
+3. **The Next Move Recommendation**:
+   - The exact next experiment to run based on these findings. This should define: the new hypothesis to test, the target metric, and how to set it up in the core loop.

package/skills/automation/autoresearch-fix.md

@@ -0,0 +1,40 @@
+---
+name: autoresearch-fix
+description: Systematically audit and resolve issues in marketing assets one-by-one.
+---
+# Autoresearch: Fix Issues One-by-One (`/autoresearch:fix`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:fix` or selects "Fix issues one-by-one" from the submenu. Use this to systematically review ad copy, landing pages, or tracking setups to identify and repair minor errors, policy compliance violations, or layout issues.
+
+---
+
+## 6 Common Asset Issue Classes
+
+The engine checks and corrects issues in 6 areas:
+
+1. **Character Limit Violations**: Ad headlines/descriptions exceeding platform limits (e.g. Meta 40-char headline; Google 30-char headline).
+2. **Broken Tracking Pixels**: Missing conversion tags, incomplete UTM parameter structures, or broken custom events.
+3. **Non-Compliant Copy**: Copy that risks being flagged by platform policies (e.g., using prohibited words, making unsubstantiated claims, missing required disclosures).
+4. **Accessibility Obstacles**: Missing image alt texts, poor text-to-background contrast ratios, or missing navigation labels.
+5. **Broken Links & Redirects**: Non-functioning URLs or loops in redirects.
+6. **Branding Inconsistencies**: Layouts, vocabulary, or style guides that do not match the brand guidelines.
+
+---
+
+## The 20-Iteration Systematic Repair Loop
+
+The engine operates on a strict **Identify ➡️ Fix ➡️ Verify ➡️ Repeat** iteration cycle for 20 rounds:
+- **Phase 1 (Iterations 1-8)**: Crawl the assets to build a checklist of all existing errors.
+- **Phase 2 (Iterations 9-16)**: Resolve the issues one-by-one.
+- **Phase 3 (Iterations 17-20)**: Re-test all corrected items to verify they are perfectly resolved.
+
+---
+
+## Output Deliverables
+
+1. **Resolved Issues Registry**:
+   - A table listing the issues found, their severity, the exact fix applied, and the verification status (Resolved / Verification Passed).
+2. **Hardened Asset Package**:
+   - The final, cleaned-up copy or configuration code ready for immediate use.

package/skills/automation/autoresearch-improve.md

@@ -0,0 +1,39 @@
+---
+name: autoresearch-improve
+description: Research ICP pain points, competitor gaps, and trends to generate growth briefs and PRDs.
+---
+# Autoresearch: Research ICP & Growth (`/autoresearch:improve`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:improve` or selects "Research ICP & growth" from the submenu. This command runs a deep research and growth discovery engine across 15 iterations, producing prioritized Product Requirement Documents (PRDs) and campaign briefs for marketing.
+
+---
+
+## 5 Focus Pillars for Research
+
+The loop runs for **15 iterations**, systematically exploring five categories of opportunities:
+
+1. **ICP Pain Points**: Deep-dive into ideal customer profile challenges, jobs-to-be-done, unmet needs, and common buying friction points.
+2. **Competitor Gaps**: Identify what competitors are weak at, what messaging angles they are missing, and where their positioning leaves room to win.
+3. **Market Timing**: Analyze seasonal trends, cultural moments, emerging consumer behaviors, and market-level signals.
+4. **Channel & Experience**: Uncover platform-specific channel opportunities (e.g. YouTube shorts, TikTok hook styles) and funnel/UX improvement gaps.
+5. **Revenue & Growth**: Identify monetization, pricing, bundles, upselling, or retention/referral loops that can scale revenue.
+
+---
+
+## The 15-Iteration Loop
+
+Run 15 iterations internally, refining and prioritizing the discoveries:
+- **Phase 1 (Iterations 1-5)**: Scout and extract raw opportunities in each category.
+- **Phase 2 (Iterations 6-10)**: Evaluate and score opportunities based on potential impact, confidence, and ease of execution (ICE framework).
+- **Phase 3 (Iterations 11-15)**: Flesh out the top scoring opportunity into a complete, professional **Marketing Campaign Brief / PRD**.
+
+---
+
+## Deliverables
+
+1. **Prioritized Opportunity Matrix**:
+   - A markdown table listing the top opportunities, categorized, scored by potential impact (High/Medium/Low), and showing target customer value.
+2. **Campaign Brief / PRD**:
+   - For the highest scoring opportunity, output a comprehensive deployment brief covering: Target Audience, Value Proposition, Creative/Ad Concept, Recommended Channels, Metric/Measurement Plan, and a detailed Implementation Checklist.

package/skills/automation/autoresearch-learn.md

@@ -0,0 +1,31 @@
+---
+name: autoresearch-learn
+description: Competitive intelligence engine to analyze competitor assets and generate messaging playbooks.
+---
+# Autoresearch: Learn from the Market (`/autoresearch:learn`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:learn` or selects "Learn from the market" from the submenu. This runs a competitive intelligence loop across 10 iterations, analyzing competitor landing pages, ad copy, positioning, and strategies to generate a **Competitive Messaging Playbook**.
+
+---
+
+## 10-Iteration Competitive Research Loop
+
+The engine operates over **10 iterations** to scout, distill, and adapt market insights:
+
+- **Iterations 1-3 (Scout)**: Analyze known competitors, searching for their active ad variants, main landing page structures, and core hooks. Identify their primary and secondary hooks (e.g. price-focused vs quality-focused).
+- **Iterations 4-6 (Analyze & Score)**: Map out competitor messaging positioning. Identify where they are strong (e.g. powerful social proof) and where they are weak (e.g. slow page speed, generic CTAs).
+- **Iterations 7-9 (Differentiate)**: Formulate counter-positioning angles. How can the user's brand stand out? What specific benefit can we highlight that competitors ignore?
+- **Iteration 10 (Consolidate)**: Synthesize insights into a highly actionable playbook.
+
+---
+
+## Output Deliverables
+
+1. **Competitor Mapping Table**:
+   - A comparison table comparing the user's business with 2-3 key competitors on value proposition, main CTA, and core ad hook.
+2. **Competitive Messaging Playbook**:
+   - **Gaps Identified**: Messaging spaces left wide open by competitors.
+   - **Recommended Messaging Angles**: 3 concrete, counter-positioning headlines/angles to test immediately in your campaigns to steal market share.
+   - **SWOT-Style Summary**: Strategic cheat sheet for your marketing team.

package/skills/automation/autoresearch-plan.md

@@ -0,0 +1,51 @@
+---
+name: autoresearch-plan
+description: Interactive planner to convert a marketing goal into a validated experiment configuration.
+---
+# Autoresearch: Plan My Experiment (`/autoresearch:plan`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers the `/autoresearch:plan` command or selects "Plan my experiment" from the Autoresearch submenu. This acts as the interactive on-ramp for marketers who want to set up a structured experiment but need help defining their variables.
+
+---
+
+## Interactive Planning Sequence
+
+Walk the user through the 4 core pillars of a structured marketing experiment. If the user provides a CSV or performance logs upfront, ingest it immediately to pre-fill or suggest the options!
+
+### 1. Goal Formulation
+Help the user specify a concrete, focused growth goal.
+- *Examples*: "Increase Google Ads headline CTR by 25%", "Optimize Shopify landing page conversion rate", "Improve onboarding email open rate".
+
+### 2. Metric Definition
+Define a clear, objective scoring metric.
+- *Examples*: "Must address the target pain point (5/5 PAS score) and fit within 30 characters", "Must highlight the value proposition and align with brand voice rules".
+
+### 3. Scope & Constraints
+Establish bounds to prevent off-brand or illegal ideas.
+- *Examples*: "No discounts or promo codes", "Must sound premium/professional", "Avoid mentioning competitor names".
+
+### 4. Prior Data Ingestion (Fuel)
+Ask if they have past campaign performance data, A/B test results, or a CSV file of previous creative copy.
+- If provided, parse it immediately! Extract winning trends and losing patterns as fuel to pre-populate the strategy.
+
+---
+
+## Output & Action Call
+
+At the end of the interactive planning sequence, output a beautiful **Experiment Config Card**:
+
+```markdown
+### 📋 Validated Experiment Configuration
+
+- **Goal**: [Concrete Goal]
+- **Metric**: [Objective Scoring Metric]
+- **Scope & Constraints**: [List of rules/limitations]
+- **Prior Data Insights**: [Top 3 patterns extracted from prior data]
+```
+
+### Next Action Trigger
+Conclude by asking the user directly:
+**"Would you like me to start the autonomous loop now? (Y/N)"**
+- If they say **Yes**, transition directly into executing the core `/autoresearch` loop using this configuration.

package/skills/automation/autoresearch-predict.md

@@ -0,0 +1,32 @@
+---
+name: autoresearch-predict
+description: Run expert persona debates to predict campaign performance before spending budget.
+---
+# Autoresearch: Expert Predictions (`/autoresearch:predict`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:predict` or selects "Get expert predictions" from the submenu. This performs a one-shot adversarial debate using 5 virtual expert marketing personas, evaluating a new campaign concept, ad copy, or strategy before putting real budget behind it.
+
+---
+
+## The 5 Expert Personas
+
+You must simulate a structured debate between the following 5 distinct marketing experts:
+
+1. **CMO (Chief Marketing Officer)**: Evaluates high-level strategic fit, brand alignment, positioning, and long-term business impact.
+2. **Performance Marketer**: Focuses on platform mechanics, CTR viability, CPM/CPC estimates, bid strategies, and ROAS scalability.
+3. **Brand Strategist**: Evaluates messaging consistency, brand identity, differentiation, customer emotional connection, and design cues.
+4. **CRO Specialist**: Audits the user journey flow, landing page friction, conversion psychological triggers, and CTA strength.
+5. **Data Analyst**: Interrogates the hypothesis's testability, tracking feasibility, required sample sizes, and statistical rigor.
+
+---
+
+## Debate Flow & Output
+
+1. **Expert Critiques**: Have each expert voice a brief, sharp (3-4 sentences) critique of the user's proposed concept from their specific point of view.
+2. **Rebuttal and Refinement**: Synthesize their points to suggest a revised, stronger version of the original concept.
+3. **Consensus Verdict**:
+   - **Score**: 1 to 10 (Consensus quality score).
+   - **Recommendation**: **GO** (Ready to test) or **NO-GO** (Requires changes before spending).
+   - **Top Improvement**: The #1 tweak to instantly boost performance.

package/skills/automation/autoresearch-probe.md

@@ -0,0 +1,39 @@
+---
+name: autoresearch-probe
+description: Have 8 distinct personas stress-test a campaign brief to uncover blind spots and operational risks.
+---
+# Autoresearch: Stress-Test the Brief (`/autoresearch:probe`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:probe` or selects "Stress-test my brief" from the submenu. This command runs a highly targeted interrogation of a campaign brief or marketing proposal across 15 iterations, utilizing 8 different stakeholder personas to expose critical blind spots before launch.
+
+---
+
+## The 8 Interrogating Personas
+
+1. **Media Buyer**: "Is the audience size large enough? How will the algorithm handle this targeting?"
+2. **Creative Director**: "Does the hook stand out in a crowded feed? Is the creative asset load too high?"
+3. **Data Analyst**: "How are we tracking multi-touch attribution? What is our fallback if pixels fail?"
+4. **Brand Manager**: "Does this voice align with our long-term values? Is there PR backlash risk?"
+5. **UX Designer**: "Does the landing page flow seamlessly? Are mobile load speeds optimized?"
+6. **Compliance Officer**: "Are these claims FTC compliant? Are privacy opt-outs clearly present?"
+7. **CFO**: "What is the payback period? Do we have a clear threshold to cut losses?"
+8. **Target Customer**: "Why should I care about this? Do I trust this claim?"
+
+---
+
+## 15-Iteration Interrogation Loop
+
+- **Iterations 1-8**: Each persona sequentially poses their toughest question or challenge to the brief.
+- **Iterations 9-12**: Evaluate the severity and likelihood of each risk identified by the personas.
+- **Iterations 13-15**: Refine the brief's execution strategy, adding specific safeguards and contingency plans to resolve these criticisms.
+
+---
+
+## Output Deliverables
+
+1. **Risk Audit Register**:
+   - A table listing the top 3-5 risks uncovered, detailing the Persona source, risk level (Critical/Moderate), and a description of the risk.
+2. **Hardened Campaign Brief**:
+   - Practical recommendations to update the brief (e.g. tracking additions, compliance wording changes, or structural tweaks) to defend against the identified risks.

package/skills/automation/autoresearch-reason.md

@@ -0,0 +1,37 @@
+---
+name: autoresearch-reason
+description: Adversarial debate with blind judges to resolve critical marketing strategy dilemmas.
+---
+# Autoresearch: Debate a Strategy Decision (`/autoresearch:reason`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:reason` or selects "Debate a strategy call" from the submenu. Use this when the user faces a tough binary or strategic marketing decision and wants to run a balanced debate to weigh all pros, cons, and tradeoffs.
+
+*Common strategy dilemmas*:
+- "Broad targeting vs. Niche/Lookalike audiences?"
+- "Video creative vs. Static image assets?"
+- "Discount/Offer messaging vs. Pure value proposition copy?"
+- "One long-form landing page vs. Segmented quiz funnels?"
+
+---
+
+## The Adversarial Debate Structure (8 Iterations)
+
+The agent runs an internal 8-iteration adversarial debate:
+
+- **Iterations 1-2 (Side A - The Advocate)**: Draft the strongest possible argument for Option A, using data benchmarks, psychological triggers, and efficiency metrics.
+- **Iterations 3-4 (Side B - The Challenger)**: Draft the strongest possible counterargument for Option B, focusing on scaling limits, creative fatigue, and customer lifetime value.
+- **Iterations 5-6 (Cross-Examination)**: Have both sides critique each other's weak points and assumptions.
+- **Iterations 7-8 (The Blind Jury)**: Simulate three objective, "blind" marketing judges who evaluate the arguments purely on logic, evidence, and risk profiles.
+
+---
+
+## Output Verdict
+
+1. **The Debate Log Summary**:
+   - A concise summary of the core arguments for both Side A and Side B.
+2. **Jury's Verdict**:
+   - **Winner**: The option that was determined to be stronger.
+   - **Score**: Win margin (e.g. "Judge 1: Side A, Judge 2: Side A, Judge 3: Side B. Winner: Option A (2-1)").
+   - **Strategic Synthesis**: A blended approach recommendations (how to get the best of both options, e.g., "Start with Option A for quick traction, but build Option B assets to capture the next tier of scale").

package/skills/automation/autoresearch-scenario.md

@@ -0,0 +1,43 @@
+---
+name: autoresearch-scenario
+description: Stress-test plans against what-if scenarios across 12 marketing dimensions to draft contingency plans.
+---
+# Autoresearch: What-If Scenarios (`/autoresearch:scenario`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:scenario` or selects "Run what-if scenarios" from the submenu. Use this to stress-test a marketing plan, product launch, or high-budget campaign against worst-case disruptions. The loop runs for **20 iterations** across 12 marketing dimensions to prepare bulletproof response playbooks.
+
+---
+
+## 12 Marketing Disruption Dimensions
+
+1. **Competitor Moves**: Competitor matches your offer or copies your exact creative.
+2. **Algorithm Changes**: Facebook CPM spikes 50% or Google Search algorithm updates.
+3. **Budget Adjustments**: CFO forces an immediate 50% budget cut or demands scaling by 3x.
+4. **Creative Fatigue**: High-performing creatives fatigue and CTR drops by half within 10 days.
+5. **Seasonality Shifts**: Demand drops sharply off-season or a sudden macro-economic slowdown occurs.
+6. **PR / Brand Crisis**: Negative customer reviews go viral or brand safety violations surface.
+7. **New Market Entrant**: A well-funded startup enters the niche with aggressive pricing.
+8. **Compliance/Policy**: Ad account gets flag-reviewed or copy violates updated platform rules.
+9. **Technical Failures**: Checkout breaks, tracking pixel stops firing, or site speed slows by 4s.
+10. **Supply Chain**: Out-of-stock items force pauses or shipping delays hurt customer trust.
+11. **Ad fatigue / Audience Saturation**: Frequency reaches 8+ and costs per conversion double.
+12. **Channel Policy shifts**: Platform deprecates a crucial custom audience or attribution window.
+
+---
+
+## The 20-Iteration Scenario Loop
+
+- **Iterations 1-12**: Map each of the 12 scenarios to the user's current marketing plan.
+- **Iterations 13-16**: Rank the scenarios by **Impact** and **Likelihood** to identify the top 3 biggest vulnerabilities.
+- **Iterations 17-20**: Build action-ready contingency plans for the high-priority threats.
+
+---
+
+## Output Deliverables
+
+1. **Vulnerability Risk Table**:
+   - A matrix showing the scenarios, their probability, business impact, and risk score.
+2. **Contingency Playbook (The Fire Drill)**:
+   - For the top 3 risks, outline: the **Trigger Point** (when to act), the **Contingency Action** (what to change immediately), and the **Alternative Messaging/Offer** to deploy.

package/skills/automation/autoresearch-security.md

@@ -0,0 +1,43 @@
+---
+name: autoresearch-security
+description: Brand safety and compliance audit for marketing copy, claims, and regulatory requirements.
+---
+# Autoresearch: Brand Safety Audit (`/autoresearch:security`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:security` or selects "Brand safety audit" from the submenu. This performs a complete risk assessment of marketing assets across 15 iterations, looking for trademark infringement, regulatory policy issues (FTC, GDPR), and misleading claims.
+
+---
+
+## 5 Brand Safety Dimensions
+
+The audit systematically checks the assets across five critical risk dimensions:
+
+1. **Trademark Violations**: Accidental or unauthorized use of competitor brand names or trademarked terms in ad copy or landing page metadata.
+2. **Regulatory Compliance**: Missing FTC disclosures for sponsored/influencer content, lack of GDPR/CCPA cookie compliance, or missing privacy policy links.
+3. **Misleading Claims**: Unsubstantiated claims, false urgency tactics, exaggerated statistics, or bait-and-switch offers.
+4. **Accessibility (A11y)**: Poor color contrast, missing image alt-text, or screen-reader unfriendly elements.
+5. **Brand Consistency**: Slang or tones that diverge from brand guidelines, damaging brand equity.
+
+---
+
+## 15-Iteration Audit Loop
+
+- **Iterations 1-5**: Analyze assets to flag all potential safety and compliance risks.
+- **Iterations 6-10**: Grade each risk on a severity scale (Critical, Warning, Opportunity).
+- **Iterations 11-15**: Generate exact replacements and corrections to resolve the identified risks.
+
+---
+
+## Output Deliverables
+
+Provide a comprehensive **Brand Safety & Compliance Report**:
+
+1. **Audit Severity Register**:
+   - Categorized by severity:
+     - 🔴 **Critical**: Must be fixed before launch (e.g. FTC violation, illegal trademark use).
+     - 🟡 **Warning**: Strong recommendation to fix (e.g. missing alt-text, aggressive urgency claims).
+     - 🟢 **Opportunity**: Suggestions to improve alignment or build higher trust.
+2. **Compliant Replacements**:
+   - Safe, fully compliant copy alternatives for every flagged issue, ensuring brand protection without sacrificing click-through performance.

package/skills/automation/autoresearch-ship.md

@@ -0,0 +1,38 @@
+---
+name: autoresearch-ship
+description: Prepare winning assets for direct deployment with formatting, QA, and tracking specs.
+---
+# Autoresearch: Prepare Assets to Ship (`/autoresearch:ship`)
+
+## When to Use This Skill
+
+Activate this skill when the user triggers `/autoresearch:ship` or selects "Prepare assets to ship" from the submenu. Use this to take winning hypotheses from previous experiments and prepare them into a deployment-ready launch package.
+
+---
+
+## 6 Linear Shipping Phases
+
+The ship command moves sequentially through 6 linear preparation phases:
+
+1. **Format (Platform Adaptation)**: Format the winning copy/creative to fit target platform specifications exactly:
+   - *Meta Ads*: 125 char Primary Text, 40 char Headline, 30 char Description.
+   - *Google Ads*: 30 char Headline, 90 char Description.
+   - *Email*: 50 char Subject Line, 150 char Preview Text.
+2. **QA Check**: Verify character counts, screen for prohibited platform words, and test links.
+3. **Generate Variants**: Produce 3 platform-specific creative variations of the main hook to prevent creative fatigue.
+4. **Tracking Specifications**: Recommend precise UTM parameters, tracking pixels, and conversion event triggers to monitor.
+5. **Timeline & Sample Size**: Suggest the optimal test duration, starting budget, and required sample size for statistical validity.
+6. **Deployment Brief**: Construct a clean brief that can be handed to a media buyer or agency team.
+
+---
+
+## Output Deliverables
+
+Output a professional **Deployment-Ready Assets Package**:
+
+1. **Launch Specs Table**:
+   - A table listing the formatted creative copy, target channels, character counts, and UTM URLs.
+2. **QA & Tracking Brief**:
+   - Clear QA confirmation, conversion events to track, and recommended launch test settings (e.g., "Run for 14 days, target budget $50/day, monitor Purchase events").
+3. **AUTOMATIC REPORT EXPORT**:
+   - The entire package must be automatically saved to `~/.openads/reports/deployment-brief-[timestamp].md`.

package/skills/automation/autoresearch.md

@@ -1,64 +1,44 @@
 ---
 name: autoresearch
-description: Autonomously generate, score, and iterate on marketing assets.
+description: Core autonomous loop to generate, score, and iterate on new marketing hypotheses.
 ---
-# Autoresearch (Autonomous Improvement Loop)
+# Autoresearch (Autonomous marketing loop)
 
 ## When to Use This Skill
 
-Activate this skill when the user wants to autonomously generate, test, and iterate on marketing hypotheses. This is the **Modify → Verify → Keep/Discard → Repeat** loop applied to digital marketing.
+Activate this skill when the user triggers the core autonomous marketing loop (`/autoresearch` or selecting "Generate new hypotheses" in the CLI). This is the autonomous **Modify (Generate) ➡️ Verify (Score) ➡️ Keep/Discard ➡️ Repeat** engine.
 
-Use this for tasks like:
-- Generating 50 headline hypotheses, scoring them against the ICP context, and keeping the top 5
-- Iterating on ad copy variants and checking them against character limits or ad strength rules
-- Brainstorming A/B test concepts and evaluating their statistical viability
-- Running an overnight loop to optimize landing page structures
-
-Read `product-marketing.md` first to understand the context against which you are scoring or generating ideas.
+The core philosophy of Autoresearch is:
+1. **Goal + Metric + Loop** — Define a clear goal, a rigorous metric, and loop autonomously.
+2. **Prior data is fuel, not the deliverable** — Do not spend the conversation summarizing prior results. Quickly extract winning and losing patterns behind the scenes, and immediately use them to generate smarter, NEW hypotheses.
+3. **The output is NEW, testable assets** — The final deliverable is always a prioritized table of concrete assets (headlines, ad copy variants, landing page layouts, creative hooks) ready to be tested.
 
 ---
 
-## The Autoresearch Loop
-
-When running an autoresearch task, follow this strict loop. Do not stop until the goal is reached or the user interrupts.
-
-**CRITICAL UX RULE (CONCISE SUMMARIES)**: When parsing prior experiment data, CSV files, or campaign performance logs, you must **NEVER** list out individual experiments, campaigns, or test entries one-by-one (especially if the dataset has more than 5 entries). Listing hundreds of tests in the chat logs makes the interface completely unusable. Instead, parse and aggregate the data behind the scenes, summarize the high-level findings, highlight **ONLY** the top 3 to 5 winning elements or key metrics, and present the rest as an aggregated overall total.
-
-### 1. Modify (Generate)
-Generate a batch of new variants based on the strategy. If this is iteration 2+, look at what succeeded/failed in previous loops to inform your generation.
-
-### 2. Verify (Score)
-Score the generated variants. If a tool is available (e.g. Adloop's ad strength checker, or an external LLM evaluation), use it. If not, use internal logic to score them against the `product-marketing.md` constraints (e.g., "Does this mention the primary pain point? Does it fit character limits?").
-
-### 3. Keep / Discard
-Keep only the variants that pass the verification threshold. Discard the rest. Document *why* they were discarded to inform the next loop.
-
-### 4. Repeat
-If the goal is met (e.g., "I need 10 excellent ad variants"), stop and present the results. If not, return to Step 1.
-
----
-
-## Setting Up a Plan
-
-Before starting the loop, you must define the boundaries. If the user hasn't provided this, ask them to define:
-1. **Goal**: What are we trying to achieve? (e.g., "Generate 20 high-converting headlines")
-2. **Metric**: How do we score them? (e.g., "Must pass PAS framework criteria and be under 30 characters")
-3. **Scope**: What is out of bounds? (e.g., "Do not use the word 'Free'")
-4. **Prior Data**: Do you have any previous experiment results, campaign performance data, or files (like CSVs or JSONs) I should read and analyze first to base our new strategy on?
-
-**CRITICAL STEP**: Immediately after defining the boundaries or analyzing the user's prior data file, you **MUST** draft a clear **Autoresearch Plan** (summarizing Goal, Metric, Scope, and Prior Data) and ask the user: *"Would you like me to start the autonomous loop now? (Y/N)"*. You **MUST NOT** just output data recommendations and stop! You must actively prompt to launch the loop.
-
----
-
-## Output Format
-
-While looping, keep the user updated with a concise progress log:
-```
-Loop 1: Generated 10. 2 passed, 8 discarded. (Reason: too long)
-Loop 2: Generated 10. 4 passed, 6 discarded. (Reason: weak hook)
-...
-```
-
-At the end:
-1. Present the final "Kept" list formatted as a markdown table or code block.
-2. **AUTOMATIC FILE EXPORT**: Automatically write the final winning list to a dedicated report file named `autoresearch-[timestamp].md` (e.g. `~/.openads/reports/autoresearch-202605251147.md`) on disk. This gives the user a permanent, easily exportable record of their marketing assets.
+## The Autoresearch Loop Execution
+
+When running the loop, execute at least **3 full cycles** autonomously before presenting the final results. Do not stop to prompt the user between cycles.
+
+### Phase 1: Ingest Fuel & Initialize
+- Quickly review `product-marketing.md` and any provided prior experiment data (like a CSV or campaign performance logs).
+- **CONCISE INGESTION RULE**: Extract 3-5 high-level patterns of what worked and what failed. Do not list individual rows or campaigns one-by-one.
+- Initialize the iteration counter.
+
+### Phase 2: Autonomous Iteration Loop
+For each loop (run at least 3):
+1. **Modify (Generate)**: Generate a batch of NEW testable hypotheses (e.g. headlines, hooks, page variants). If iteration 2+, adapt based on the reasons why previous variants failed or succeeded.
+2. **Verify (Score)**: Evaluate each hypothesis against the defined metric (e.g., PAS framework, character limits, compliance, brand alignment) and product context. Assign a numeric score.
+3. **Keep / Discard**: Keep only variants scoring above your quality threshold. Discard the rest, noting the specific reason for failure (e.g. "too generic", "no clear pain point", "exceeded 30-char limit").
+
+### Phase 3: Reporting & Automatic Export
+- Log the progress of each cycle to the user:
+  ```
+  Loop 1: Generated 10 hypotheses. 3 passed, 7 discarded. (Reasons: too long, weak hook)
+  Loop 2: Generated 8 hypotheses. 5 passed, 3 discarded. (Reasons: too generic)
+  Loop 3: Generated 8 hypotheses. 6 passed, 2 discarded. (Reasons: off-brand)
+  ```
+- Present a final prioritized table of the **NEW** testable assets, containing:
+  - **Asset/Copy**: The literal text/layout to test.
+  - **Rationale**: Why this is expected to win based on prior patterns or marketing frameworks.
+  - **Priority Score**: High / Medium / Low.
+- **AUTOMATIC FILE EXPORT**: You MUST automatically save the final prioritized list of hypotheses to a markdown report on disk: `~/.openads/reports/autoresearch-[timestamp].md`.