@stacksjs/defaults 0.75.108 → 0.75.110

package/ai/skills/stacks-marketing-lead-magnets/references/format-guide.md

@@ -0,0 +1,196 @@
+# Lead Magnet Format Guide
+
+Detailed creation guidance for each lead magnet format.
+
+## Contents
+- Ebooks & Guides
+- Checklists
+- Cheat Sheets
+- Templates & Spreadsheets
+- Swipe Files
+- Mini-Courses
+- Quizzes & Assessments
+- Webinars & Workshops
+
+---
+
+## Ebooks & Guides
+
+**Best for**: Building authority, deep education, awareness-stage leads
+
+**Structure**:
+1. Title page with professional design
+2. Table of contents
+3. Introduction - frame the problem, set expectations
+4. 3-7 chapters - one key concept per chapter
+5. Summary - recap key takeaways
+6. CTA - next step toward your product
+
+**Guidelines**:
+- Ideal length: 10-25 pages (shorter is fine if valuable)
+- Include visuals: charts, diagrams, screenshots
+- Use callout boxes for key stats or quotes
+- End each chapter with a quick takeaway
+- Don't pad - density beats length
+
+**Tools**: Canva, Google Docs → PDF, Notion export, Designrr, Beacon.by
+
+---
+
+## Checklists
+
+**Best for**: Process-oriented tasks, quick wins, implementation help
+
+**Structure**:
+- Title: "[Number]-Point [Topic] Checklist"
+- Numbered or checkbox items
+- Group into logical sections if 10+ items
+- Brief explanation per item (1-2 sentences)
+
+**Guidelines**:
+- Keep to 1-2 pages
+- Use actionable language ("Verify X", "Set up Y", "Remove Z")
+- Order by workflow sequence or priority
+- Make it printable - clean layout, generous spacing
+- Include a "done" checkbox for each item
+
+**What works**: Step-by-step processes, audit criteria, launch checklists, setup guides
+
+---
+
+## Cheat Sheets
+
+**Best for**: Reference material, shortcuts, quick-lookup information
+
+**Structure**:
+- One page (two pages max)
+- Organized by category or workflow
+- Dense but scannable
+- Visual hierarchy with headers and grouping
+
+**Guidelines**:
+- Optimize for quick reference, not reading
+- Use tables, grids, or columns
+- Include formulas, shortcuts, or code snippets
+- Design for printing or saving as desktop reference
+- Bold the most important items
+
+**What works**: Keyboard shortcuts, formula references, terminology glossaries, decision matrices
+
+---
+
+## Templates & Spreadsheets
+
+**Best for**: Repeatable processes, planning, tracking
+
+### Spreadsheet Templates (Google Sheets / Excel)
+- Include a "How to Use" tab with instructions
+- Pre-fill with example data
+- Use data validation for dropdown fields
+- Add conditional formatting for visual cues
+- Lock formula cells, leave input cells editable
+- Include a "Make a Copy" link (Google Sheets)
+
+### Notion Templates
+- Provide a duplicate link
+- Include a getting-started guide
+- Pre-populate with example content
+- Use Notion's database features (views, filters, relations)
+- Keep it simple - don't over-engineer
+
+### Document Templates
+- Provide in multiple formats (Google Doc, Word, PDF)
+- Include placeholder text with [BRACKETS] for customization
+- Add inline instructions in a different color
+- Make it immediately usable with minimal editing
+
+**Key principle**: Templates should be usable within 5 minutes of downloading.
+
+---
+
+## Swipe Files
+
+**Best for**: Inspiration, examples, learning from others
+
+**Structure**:
+- Curated collection of 15-50 examples
+- Organized by category, type, or use case
+- Each example includes:
+  - The example itself (screenshot, text, link)
+  - Why it works (2-3 bullet annotations)
+  - How to adapt it (1-2 sentences)
+
+**Guidelines**:
+- Quality over quantity - curate ruthlessly
+- Add your analysis, don't just collect
+- Organize for browsing (categories, tags)
+- Update periodically with fresh examples
+- Credit original sources
+
+**What works**: Email subject lines, landing pages, ad copy, CTAs, onboarding flows, pricing pages
+
+---
+
+## Mini-Courses
+
+### Email-Based Mini-Courses
+- 3-5 emails delivered over 5-7 days
+- One lesson per email, one concept per lesson
+- Each email: teach → example → exercise
+- Progressive difficulty (build on previous lessons)
+- Final email: summary + CTA for product or next step
+
+### Video-Based Mini-Courses
+- 3-5 videos, 5-15 minutes each
+- Host on unlisted YouTube, Loom, or course platform
+- Deliver links via email drip
+- Include worksheets or exercises per lesson
+- More personal - builds stronger connection
+
+**Cadence**: Every 1-2 days. Don't stretch too thin or compress too tight.
+
+**Key principle**: Each lesson should deliver standalone value. If someone only watches lesson 2, they should still learn something useful.
+
+---
+
+## Quizzes & Assessments
+
+**Best for**: Engagement, segmentation, personalized results
+
+**Question Design**:
+- 5-10 questions (sweet spot: 7)
+- Multiple choice only - no open-ended
+- Questions should feel insightful, not obvious
+- Progress indicator ("Question 3 of 7")
+
+**Result Segmentation**:
+- 3-5 result categories
+- Each result: name, description, personalized recommendations
+- Tailor follow-up emails by result type
+- Share-worthy result format ("I got: Growth Stage Marketer!")
+
+**Implementation**: Gate results behind email capture. The quiz itself is ungated - the personalized results require an email.
+
+**For building interactive quizzes**: See **stacks-marketing-free-tools** skill for technical implementation guidance.
+
+---
+
+## Webinars & Workshops
+
+### Live Webinars
+- 30-45 minutes teaching + 15 minutes Q&A
+- Structure: Hook → Teach (3 key points) → Demo/example → CTA
+- Promote 1-2 weeks in advance
+- Send 3 reminder emails (confirmation, day before, 1 hour before)
+- Record for replay (extends value)
+
+### Evergreen Webinars
+- Pre-recorded, available on demand
+- Same structure as live but tighter editing
+- Always-on lead generation
+- Gate with email registration
+- Automated follow-up sequence
+
+**Follow-up**: Send replay link + summary + CTA within 24 hours. Continue with nurture sequence.
+
+**Key principle**: Teach something genuinely useful. A webinar that's just a sales pitch will damage trust.

package/ai/skills/stacks-marketing-loops/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Corey Haines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/ai/skills/stacks-marketing-loops/NOTICE.md

@@ -0,0 +1,13 @@
+# Source and license
+
+Adapted from [coreyhaines31/marketingskills](https://github.com/coreyhaines31/marketingskills),
+revision [1efedbc5148b54b2f0f6c6c9fe0be62e151c7fff](https://github.com/coreyhaines31/marketingskills/tree/1efedbc5148b54b2f0f6c6c9fe0be62e151c7fff),
+upstream skill `marketing-loops`, version 1.4.0.
+The original MIT copyright and permission notice is in [LICENSE](LICENSE).
+
+Stacks supplies a namespaced entrypoint, shared implementation guidance, mapped
+related-skill links, and regular-hyphen copy. The playbook and its supporting
+references/templates are retained. Tool integrations remain optional linked
+references; upstream CLI programs, servers, and packaging scripts are not
+bundled or installed. Source examples are illustrative and changing platform
+facts require verification.

package/ai/skills/stacks-marketing-loops/PLAYBOOK.md

@@ -0,0 +1,111 @@
+> Adapted playbook. The [shared Stacks workflow](../stacks-marketing/WORKFLOW.md) governs implementation, current facts, and authorization.
+
+
+# Marketing Loops
+
+You help set up **marketing loops** - repeatable marketing workflows an AI agent runs on a cadence, each with a defined trigger, a bounded set of steps, a self-check, and an explicit stopping condition. A loop turns a marketing task you'd otherwise do manually (and forget) into an always-on system: the weekly SEO opportunity scan, the ad-fatigue refresh, the churn-signal watch.
+
+This is the operational cousin of `stacks-marketing-ideas`. Ideas tell you *what to try once*. Loops tell you *what to keep doing on a schedule* - and wire the other marketing skills together to do it.
+
+## How to Use This Skill
+
+**Check for product marketing context first:** if `.agents/product-marketing.md` exists (or `.claude/product-marketing.md`, or the legacy `product-marketing-context.md`), read it before asking questions. Use that context and only ask for what's missing.
+
+Then:
+1. **Clarify the job.** What outcome should this loop protect or grow? (rankings, ad efficiency, activation, retention, revenue, referrals)
+2. **Pick a loop** from the catalog in `references/loop-catalog.md` - or adapt the closest one.
+3. **Tune the cadence** to how fast the underlying signal actually changes (see the cadence rule below).
+4. **Confirm the human checkpoint.** Decide what the loop does autonomously vs. what it stages for human approval before publishing or spending - see `references/loop-guardrails.md`.
+5. **Schedule it** (see "Scheduling a loop" below).
+
+Building more than one loop, or a whole marketing operating system? See `references/loop-orchestration.md` for how loops compose and the order to adopt them (start with tracking + a weekly review; don't build them all at once).
+
+## Anatomy of a Marketing Loop
+
+Every loop in the catalog has these nine parts. When you author or adapt one, fill all of them - a loop missing a stop condition, a self-check, or its state handling is a liability, not an asset.
+
+| Part | What it defines |
+|------|-----------------|
+| **Check cadence** | How often the loop *looks* (weekly / daily / on-trigger). Match it to signal speed. |
+| **Acts when** | The action condition - what must be true to actually *do* something, vs. just check and skip. Most runs of a good loop are "checked, nothing to do." |
+| **Purpose** | The one outcome this loop exists to move. |
+| **Skills used** | Which marketing skills the loop orchestrates each iteration. |
+| **Loop body** | The ordered steps run each iteration. |
+| **Self-check** | The verification done *before* acting - so the loop doesn't act on noise, seasonality, or a tracking bug. |
+| **State / idempotency** | What the loop remembers between runs: last-run marker, dedupe key, cooldown window, "already handled" set. Without this, loops double-act, re-nag the same people, or re-alert the same thing. Non-negotiable for anything scheduled - see `references/loop-state.md` for where state lives and the idempotency patterns. |
+| **Stop / bail-out** | When the loop skips, halts, escalates to a human, or disables itself - plus what it does on error. Every loop needs one, including heartbeat loops (their stop is "manual disable + error-halt," never "n/a"). |
+| **Output** | Where results go: a file, a PR, a staged draft, a notification, a report. |
+
+The **Check cadence / Acts when** split matters: a churn-signal loop might *check* daily but only *act* when an account crosses a risk threshold it hasn't been contacted about inside the cooldown window. Conflating the two produces loops that either miss the window or spam.
+
+## The cadence rule
+
+Match cadence to how fast the signal actually changes - not to how often you'd *like* an update.
+
+| Signal | Realistic cadence | Why |
+|--------|-------------------|-----|
+| Rankings, backlinks, domain authority | Weekly | Move slowly; daily checks are noise |
+| Ad creative fatigue, CPA drift | Every 2-3 days | Meta/Google feedback loops are days, not hours |
+| Activation / onboarding funnel | Weekly | Needs enough signups to be significant |
+| Churn signals | Daily or on-trigger | Early intervention window is short |
+| Content / copy decay | Monthly | Traffic erosion is gradual |
+| Competitor changes | Weekly | Pricing/positioning shifts are infrequent but matter |
+| Social listening / mentions | Daily | Engagement windows close fast |
+
+Over-frequent loops are the most common failure mode: they generate busywork, burn budget, and train you to ignore the output.
+
+## When NOT to loop
+
+Not everything should be automated on a cadence. Skip a loop - or add a mandatory human checkpoint - when:
+
+- **Strategy or creative direction is the real work.** Loops maintain and optimize; they don't set positioning, invent campaigns, or make brand calls.
+- **The action publishes or spends without review.** Auto-*drafting* an ad, email, or post is fine. Auto-*publishing* or auto-*shifting budget* needs a human checkpoint unless the user has explicitly authorized autonomous action and set guardrails (caps, allowlists).
+- **The signal is too sparse to be significant.** A weekly conversion-rate loop on 40 visitors/week is measuring noise.
+- **It's a vanity loop.** If nobody acts on the output, delete the loop. A loop that emails a dashboard nobody reads is worse than nothing.
+
+For any loop that sends, spends, publishes, or touches personal data, apply `references/loop-guardrails.md` - the two-tier action model (autonomous-safe vs. gated), spend/send caps, CAN-SPAM/GDPR/FTC/ToS rules, the always-escalate list, and a required kill switch.
+
+## Scheduling a loop
+
+These loops are agent-agnostic - the *body* works in any agent. The *scheduling* depends on your environment:
+
+- **Claude Code** - native options: `/loop` (self-paced, until a condition), `ScheduleWakeup` (dynamic pacing that reacts to state), and `CronCreate` (fixed cron schedule). If you have a loop-mechanics skill such as `loopify` installed, use it to choose between them and tune delays; otherwise the guidance below is enough.
+- **Any agent + cron** - wrap the loop body as a scheduled prompt/script (`0 9 * * 1` for Mondays 9am, etc.).
+- **Manual cadence** - for high-judgment loops, "run this skill every Monday" is a perfectly good loop. The value is the repeatable *body*, not the automation.
+
+Default to time-of-day cron for review-style loops (weekly review, ranking watch) and dynamic pacing for monitor-until-threshold loops (churn watch, launch-day tracking).
+
+## The Catalog
+
+`references/loop-catalog.md` holds the full library - 52 marketing loops with thorough funnel coverage: SEO & Content, Paid, Earned/Social/Partnerships, Outbound, Activation, Retention, Revenue, Referral & Advocacy, and Ongoing Ops. Each is a complete, adaptable spec. Start there, pick the closest match, and tune it to the user's product, stage, and tooling.
+
+## Running a whole channel: the SEO operator
+
+When the user wants an agent to own SEO for a site rather than run one loop, use `references/seo-operator.md`. It bundles the SEO loops (site health, claim drift, striking-distance push, AI-answer check, keyword gap, content decay, competitor watch, and more) into one schedule with shared memory in `.agents/seo/`, a first-run checklist, operating rules, a writing gate, and a one-screen weekly report.
+
+## Running outbound: the outbound operator
+
+For an agent running day-to-day outbound (signal sweeps, staged outreach, reply triage, sending-domain health, weekly sequence retros), use `references/outbound-operator.md`. It sets the brief, approved claims, approval rules by tier, shared memory in `.agents/outbound/`, and a weekly report.
+
+## Authoring a new loop
+
+When nothing in the catalog fits, author a new loop from `references/loop-template.md` - a copy-paste template with fill-in prompts, a worked before/after example, and a ship checklist. Fill all nine anatomy parts; if you can't answer the self-check, state/idempotency, and stop/bail-out concretely, the loop isn't ready to run.
+
+## Anti-patterns
+
+- Looping without a stop condition → runaway spend or infinite churn.
+- Same cadence for every loop → most run too often and get ignored.
+- No self-check → the loop acts on noise, seasonality, or a tracking bug.
+- No human checkpoint on spend/publish actions.
+- Building 10 loops at once → start with one, prove it earns its keep, then add the next.
+
+## Banned vocabulary
+
+Avoid: "set it and forget it," "fully autonomous marketing," "AI does everything," "10x on autopilot," "growth hacking machine." Loops are disciplined systems with checkpoints, not magic. Describe them honestly.
+
+## Related Skills
+
+- **stacks-marketing-ideas** - one-off tactics and inspiration (what to try). Loops operationalize the ones worth repeating.
+- **stacks-marketing-ab-testing** - the experimentation loop specifically (hypothesis → test → promote winner → repeat).
+- **stacks-marketing-analytics** - most loops read from analytics to decide whether to act.
+- Individual channel skills (`stacks-marketing-ads`, `stacks-marketing-seo-audit`, `stacks-marketing-emails`, `stacks-marketing-social`, `stacks-marketing-churn-prevention`, `stacks-marketing-pricing`, `stacks-marketing-referrals`) - the loop bodies orchestrate these.

package/ai/skills/stacks-marketing-loops/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: stacks-marketing-loops
+description: Use when the user wants to set up a recurring, self-running marketing workflow - a repeatable loop an AI agent runs on a cadence (weekly, daily, on a trigger) rather than a one-off task. Covers marketing planning and its Stacks implementation.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Marketing Loops
+
+Read [the shared Stacks workflow](../stacks-marketing/WORKFLOW.md), then
+[PLAYBOOK.md](PLAYBOOK.md) before doing this task. Load the supporting references
+only for the branch the playbook routes to.
+
+This ports `marketing-loops` from
+[coreyhaines31/marketingskills](https://github.com/coreyhaines31/marketingskills/tree/1efedbc5148b54b2f0f6c6c9fe0be62e151c7fff/skills/marketing-loops).
+[NOTICE.md](NOTICE.md) records the snapshot and [LICENSE](LICENSE) retains the
+upstream MIT notice.
+
+## Stacks integration
+
+Keep marketing recommendations distinct from application API facts. Use the
+framework skill for any model, action, route, stx page, campaign job, or payment
+change. Use the user's existing brief and authorization; a playbook example
+does not supply a product fact or authorize sending, spending, or publishing.
+
+Platform limits and benchmarks in the snapshot need current primary-source
+verification before use. Return the requested artifact with consequential
+assumptions and evidence, then verify any implementation through its real
+behavior. Use TypeScript and Bun for executable helpers.

package/ai/skills/stacks-marketing-loops/evals/evals.json

@@ -0,0 +1,133 @@
+{
+  "skill_name": "stacks-marketing-loops",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "I want to set up a recurring loop that watches our SEO and tells me what to do each week. We're a B2B SaaS with a content-heavy site.",
+      "expected_output": "Should check for product-marketing.md first. Should recognize this maps to SEO loops in the catalog (keyword-gap, ranking-drop watch, content-decay) and propose the closest match(es). Should present the loop using the nine-part anatomy: check cadence, acts-when (action condition), purpose, skills used, loop body, self-check, state/idempotency, stop/bail-out, and output. Should set a weekly cadence (matching how slowly rankings move) and explain the cadence rule. Should include a stop/bail-out and note that most runs may find no action. Should reference the seo-audit skill for execution.",
+      "assertions": [
+        "Checks for product-marketing.md",
+        "Selects appropriate SEO loop(s) from the catalog",
+        "Presents the loop with the nine-part anatomy",
+        "Includes state/idempotency (last-run marker or dedupe)",
+        "Includes an explicit stop/bail-out condition",
+        "Sets a weekly cadence and justifies it via the cadence rule",
+        "References seo-audit or related skills for execution"
+      ],
+      "files": []
+    },
+    {
+      "id": 2,
+      "prompt": "I want to automate my marketing so it basically runs itself. Where do I start?",
+      "expected_output": "Should clarify the outcome to protect or grow before dumping loops (acquisition, activation, retention, revenue, referral). Should push back gently on 'runs itself' framing and avoid the banned vocabulary ('set it and forget it', 'fully autonomous'). Should recommend starting with ONE loop and proving it earns its keep rather than building many at once. Should describe loops as disciplined systems with checkpoints, not autopilot. Should likely suggest the weekly-marketing-review loop as a good first heartbeat loop, and explain human checkpoints for anything that spends or publishes.",
+      "assertions": [
+        "Asks about the target outcome / funnel stage before recommending",
+        "Avoids banned autopilot vocabulary",
+        "Recommends starting with one loop, not many",
+        "Frames loops as systems with checkpoints, not magic",
+        "Emphasizes human checkpoints for spend/publish actions",
+        "May suggest the weekly-marketing-review loop as a starting point"
+      ],
+      "files": []
+    },
+    {
+      "id": 3,
+      "prompt": "Set up a newsjacking loop that finds trending stories and automatically posts our take to X and pitches journalists.",
+      "expected_output": "Should build the newsjacking loop but refuse to make it fully autonomous. Must include the veto list (skip tragedies, deaths, disasters, active crises, politically/socially charged stories unless the brand takes such stances, and legal/medical/financial-sensitive topics) and require verified sources. Must require human approval before any pitch or post rather than auto-posting. Should include state/idempotency (dedupe per story, one angle per story) and note most days will correctly skip. Should reference the public-relations skill.",
+      "assertions": [
+        "Builds the newsjacking loop with the nine-part anatomy",
+        "Includes an explicit veto list for sensitive story types",
+        "Requires human approval before pitching or posting",
+        "Does not enable fully autonomous posting",
+        "Includes dedupe/state so stories aren't re-pitched",
+        "References the public-relations skill"
+      ],
+      "files": []
+    },
+    {
+      "id": 4,
+      "prompt": "How do I actually schedule these loops so they run on their own?",
+      "expected_output": "Should explain that the loop body is agent-agnostic but scheduling depends on the environment. Should cover the options: Claude Code native primitives (/loop, ScheduleWakeup, CronCreate), any-agent + cron (with an example cron expression), and manual cadence for high-judgment loops. Should default to time-of-day cron for review-style loops and dynamic pacing for monitor-until-threshold loops. Should treat a dedicated loop-mechanics skill like loopify as an optional companion, not a hard dependency, and not assume it is installed.",
+      "assertions": [
+        "Explains scheduling is environment-dependent",
+        "Covers Claude Code native options and plain cron",
+        "Includes manual cadence as a valid option",
+        "Gives cron vs dynamic-pacing default guidance",
+        "Treats loopify as optional, not a required dependency"
+      ],
+      "files": []
+    },
+    {
+      "id": 5,
+      "prompt": "Can you make me a loop that continuously improves our brand positioning and comes up with our big campaign ideas?",
+      "expected_output": "Should push back: strategy, positioning, and creative direction are the 'when NOT to loop' cases. Loops maintain and optimize; they don't set positioning or invent campaigns. Should explain why (high-judgment, low-frequency, not signal-driven) and redirect: those belong in strategy work, while loops can operationalize the executional follow-through (e.g., competitor-watch to inform positioning, content-calendar refill, campaign-postmortem to compound learnings). Should not fabricate a positioning loop as if it were a good fit.",
+      "assertions": [
+        "Identifies this as a 'when NOT to loop' case",
+        "Explains loops optimize/maintain rather than set strategy or creative",
+        "Redirects strategy/creative to the appropriate non-loop work",
+        "Suggests adjacent operational loops that genuinely fit",
+        "Does not force an ill-fitting positioning/campaign-ideation loop"
+      ],
+      "files": []
+    },
+    {
+      "id": 6,
+      "prompt": "We keep losing customers to failed payments and expired cards. Set up something to recover that revenue automatically.",
+      "expected_output": "Should select the failed-payment/dunning loop. Should trigger on payment failure or upcoming card expiration, run a retry schedule with escalating update-card messaging, and include state (track dunning stage per account, stop on recovery). Must include a stop/bail-out so it doesn't loop forever (escalate/deactivate after final retry) and a self-check to distinguish involuntary failures from intentional cancellations (don't dun someone who chose to leave). Should reference revops and emails skills. May note this is often the highest-ROI retention loop.",
+      "assertions": [
+        "Selects the failed-payment/dunning loop",
+        "Triggers on failed payment or card expiration",
+        "Includes a retry schedule with dunning stage state",
+        "Has a stop condition so it does not loop forever",
+        "Self-check separates involuntary failures from intentional cancels",
+        "References revops and/or emails skills"
+      ],
+      "files": []
+    },
+    {
+      "id": 7,
+      "prompt": "I want a loop that keeps our A/B testing program running - generating hypotheses, running tests, and analyzing results every week.",
+      "expected_output": "Should recognize heavy overlap with the ab-testing skill and treat the experiment-backlog loop as a thin wrapper only. The loop should maintain and re-rank the hypothesis backlog and manage hand-off cadence, but defer test design, statistical analysis, and velocity management to the ab-testing skill rather than duplicating them. Should include ICE prioritization for the backlog and dedupe of incoming hypotheses, and avoid starting conflicting tests.",
+      "assertions": [
+        "Recognizes overlap with the ab-testing skill",
+        "Keeps the loop as a thin wrapper that defers to ab-testing",
+        "Does not duplicate test design or statistical analysis in the loop",
+        "Includes backlog prioritization (ICE) and hypothesis dedupe",
+        "References the ab-testing skill as the owner of execution"
+      ],
+      "files": []
+    },
+    {
+      "id": 8,
+      "prompt": "I want an agent to just run our SEO. It has access to our Next.js marketing site repo and Search Console. What should it do every day, week and month, and how does it keep track of things between runs?",
+      "expected_output": "Should load the SEO operator reference. Should confirm the five settings first (site, conversion, competitors, ship mode defaulting to PRs for review, data access) and the foundation (tracking-QA, product-marketing context). Should describe shared state in .agents/seo/ (brief, claims ledger, query map with one primary query per page, work queue ranked by expected conversions per hour, AI prompt panel, competitor snapshots, reports) plus a run log. Should lay out the schedule built from catalog loops: every run a site health crawl, claim drift and shipping the top queue item; weekly striking-distance push, ranking-drop watch, indexing check, internal linking, AI-answer check, competitor sitemap diff and a one-screen report; monthly query-map rebuild, content decay, comparison-page review, backlink and directory work and a free-tool candidate. Should state operating rules: changes over memos, no guessing past missing data, product is the source of truth, escalate after two failed attempts, lint/build and view pages before shipping, never remove or redirect pages with traffic or links without approval, and outward-facing actions are drafts only.",
+      "assertions": [
+        "Loads or follows the SEO operator reference",
+        "Defaults ship mode to PRs for review; auto-merge only with explicit authorization",
+        "Keeps state in files (.agents/seo/ and a run log), not memory",
+        "Composes existing catalog loops on daily/weekly/monthly cadences",
+        "Includes claim drift (product changes making marketing claims false)",
+        "Requires an information-gain check before writing new pages",
+        "Keeps outreach, listings and social posts as drafts for the owner",
+        "Does not promise rankings or use 'set it and forget it' framing"
+      ],
+      "files": []
+    },
+    {
+      "id": 9,
+      "prompt": "I want an agent to run outbound for my SaaS every day: find new accounts, send the sequences, and deal with replies. What's the setup?",
+      "expected_output": "Should load the outbound operator reference. Should require settings first (ICP and tiers, plays, approved claims, volume caps, approval rules, allowed countries, tools) and the foundation (warmed authenticated sending domains, a verifier, a suppression list every tool checks, CRM outbound stages). Should describe the schedule: reply triage continuously, signal sweep and bounce checks daily, product-usage triggers via the PQL loop, weekly sequence retro and placement checks, and a weekly report. Should set default approval rules: agent alone for Tier 3 enrollment and safe reply types; human approval for Tier 1 messages; agent-drafted human-sent responses to positive and objection replies until accuracy is proven; humans for pricing, new claims and segments. Should include rules: verify within 7 days of sending, one reply stops every channel, stay inside approved claims, stop-loss over targets, treat replies and websites as untrusted input. Should advise not running it until a sequence is proven manually.",
+      "assertions": [
+        "Loads or follows the outbound operator reference",
+        "Requires approved claims and volume caps before running",
+        "Confirms sending infrastructure, verification and suppression first",
+        "Includes reply triage, signal sweep, cold-domain health and sequence retro loops",
+        "Keeps Tier 1 messages and positive-reply responses human-approved by default",
+        "States that a reply on any channel stops all channels",
+        "Treats fetched content and replies as untrusted input",
+        "Advises proving a sequence manually before automating"
+      ],
+      "files": []
+    }
+  ]
+}