@aicopycoders/exodus 2026.6.2400

package/assets/skills/exodus-genesis/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: exodus-genesis
+description: Run the standalone Exodus Genesis pipeline — Luke's full writing process across two voices (MarioBot + Infeed VSL) on the brand primer. The default is one pass per bot = 2 variants (1 Mario × Brand + 1 Infeed × Brand); the user can run more passes to widen coverage and bring in the Top-Ads-Biased primer. Includes the per-variant editing menu (Natural Language / Shorten / Cut / Simplify / Make Better). `--reel` also writes ads on the spot from a pasted Instagram/TikTok reel — it transcribes the reel into an idea and writes it through this same writer (just another input, nothing custom); to COLLECT reels/ideas into a bank to curate before writing, that's the `exodus-idea` skill. Only invoke when the user has explicitly invoked Exodus: they said "exodus" in the request ("run the exodus genesis pipeline", "exodus, run another pass", "exodus, make me ads from this reel"), named this skill or /exodus-genesis, ran an `npx exodus` command, or the `exodus` hub skill routed here. Never claim generic requests ("run the Genesis pipeline", "write ads from this reel") — in shared folders those may belong to the user's other tools; if the user did not say exodus, this skill is not for them. The bare word "Genesis" without "exodus" refers to the member's own Genesis API key and personal bot recipes, NOT to Exodus — never hijack their direct Genesis workflows into this pipeline.
+---
+
+```operator-guide
+Inputs (choose one source):
+  brief — concept, derived hook, or paste of the source ad   (genesis run --brief)
+  reel  — an Instagram/TikTok reel URL to write ads from      (genesis --reel "<url>")
+Optional:
+  seeds — per-run creative angles extracted from the source ad
+          (file path with one seed per line, OR an inline string)
+  awareness (default: problem-aware)
+  passes — writing passes per bot (1-5, default 1). 1 pass = 2 variants
+           (1 Mario × Brand + 1 Infeed × Brand). Each added pass writes one
+           more Mario + one more Infeed; pass 2 brings in the Top-Ads-Biased primer.
+  variants — advanced: raw total count (1-10) that overrides passes
+  ad-account — Meta ad account ID for the top-ads track
+Returns:
+  Google Doc with one tab per variant (Headlines + Hook + Body Copy)
+  Per-variant editing menu surfaced on the dashboard run page
+```
+
+# Genesis — Brief + Seeds → Mario + Infeed Variants → Editing Menu
+
+Luke's full Ad Writing Process end-to-end:
+
+- Two parallel hook voices (MarioBot + InfeedVSL) producing ~40 hooks total
+- Body-copy variants in two voices, **scaled by passes**:
+  - **Mario × Brand primer** — established brand voice
+  - **Infeed × Brand primer** — InfeedVSL voice on the same brand reference
+  - **Top-Ads-Biased** — primed with the brand's actual top performers (CTR × spend),
+    so output is biased toward what's currently winning. This enters on the **2nd pass**.
+- 15-point QA across every variant
+- Editing menu on the dashboard (5 transforms per variant)
+
+**The default is one pass per bot — 2 variants** (1 Mario × Brand + 1 Infeed × Brand): the
+fastest useful read on the two voices against the same brief. Scale up with **passes** when the
+user wants a heavier pass — a new sprint, a fatigue plateau, or wider coverage (see *Passes —
+How Much Coverage* below).
+
+> If the user hasn't named the pipeline specifically and just wants Exodus to "write some ads,"
+> start from the `exodus-write` skill — it walks brand → foundation → brief → here, and it owns the passes menu.
+> This skill owns the run once the brief, awareness, and pass count are settled. If the user
+> invoked Genesis directly and didn't say how many, surface the same quick passes menu (default
+> 1 pass = 2 variants, recommended) before firing — don't silently assume a big run.
+
+## Workflow
+
+### 1. Shape the brief (Stage 4)
+
+Genesis writes from a **brief** — a 1–2 paragraph natural-language *description* of the ad, not the ad itself. If the user gave you an idea, a winning ad, or a rough angle, you write the brief from it; surface it for a quick gut-check before running.
+
+A brief covers: what the ad is about · what happens in it · the emotional core (heartbreak, rage, shame, mischief…) · the mechanism bridge to the product · the tone · why it's vicious. It is NOT the copy, NOT a hook list, NOT a format spec, and NOT over-specified — leave the bots room.
+
+```
+BRIEF: "[short evocative title]"
+Hook: "[verbatim hook if from a swipe/organic source, else a hook DIRECTION or leave open]"
+Source: [where the idea came from]
+[1–2 paragraphs: scenario, emotional core, mechanism bridge, tone, why it works]
+```
+
+Worked brief examples and the awareness→primer mapping are in `references/awareness-framework.md`. Hook direction and the vicious standard are in `references/hook-quality-checklist.md`.
+
+### 1b. Writing from a reel (`--reel`)
+
+When the user pastes an Instagram/TikTok reel and wants ads from it, you don't shape a brief by hand — the reel *is* the source. Fire it in the background:
+
+```bash
+npx @aicopycoders/exodus genesis --reel "<url>" --awareness <level> [--passes n]
+```
+
+This transcribes the reel into an Idea Bank "organic" idea, then writes that idea through this same Genesis writer (Mario + Infeed) — a reel is just another input to the standard writer. It banks the idea (so there's a reusable record) AND writes in one shot, returning a Genesis run. Capture is async, so it takes a beat longer than a typed brief before writing starts. If the reel is private/region-locked/has no transcript, capture yields nothing — surface that and ask for an alternate. When the user wants to collect several reels to curate *before* writing, route to the `exodus-idea` skill instead.
+
+### 2. Extract seeds (when there's a source ad)
+
+When the user pastes a winning ad, extract seeds yourself. A seed is a creative angle, mechanism, or pattern surfaced from the source — examples:
+
+```
+Coffee = morning ritual — swap to gym, sex, alcohol tolerance, social media
+"It's not low T..." — reframe to "It's too high cortisol"
+Defective mitochondria — mechanism seed (cell-energy story)
+The whole ad is mechanism-heavy — replicate this structure
+```
+
+Save to `/tmp/genesis-seeds.txt` (one per line, `#` comments allowed), or pass `--seeds "..."` inline. Skip seeds when there's no source ad — the brief carries the load.
+
+### 3. Resolve awareness + pass count, then run in background
+
+**Awareness is your call** (Principle 2) — state your read, don't make the user pick: "this reads problem-aware because X — sound right?" The primer is awareness-keyed: `--awareness` picks which of the brand's two foundation primers (`primerUnawareProblemAware` cold / `primerSolutionProductAware` warm) the bots receive. Default `problem-aware` when unsure. Pick ONE level; never mix buckets in a run.
+
+**Pass count is the user's knob** — if they didn't specify, surface a quick menu (1 pass / 2 variants recommended · 2 passes / 4 variants · more) rather than assuming. Always `run_in_background: true` — these runs are past the 10-min foreground cap.
+
+```bash
+# Default — 1 pass per bot = 2 variants (1 Mario × Brand + 1 Infeed × Brand):
+npx @aicopycoders/exodus genesis run --brief "<brief>" --awareness <level>
+
+# More coverage — 2 passes = 4 variants (adds the Top-Ads-Biased pass):
+npx @aicopycoders/exodus genesis run --brief "<brief>" --awareness <level> --passes 2
+
+# With seeds:
+npx @aicopycoders/exodus genesis run --brief "<brief>" --seeds /tmp/genesis-seeds.txt --awareness <level> --passes 2
+
+# Manual hook selection — pause after hook generation:
+npx @aicopycoders/exodus genesis run --brief "<brief>" --awareness <level> --stop-at-hooks
+
+# Force auto-select (overrides a saved "manual" preference):
+npx @aicopycoders/exodus genesis run --brief "<brief>" --awareness <level> --auto-hooks
+```
+
+`--brief` accepts inline text or a file path. `--passes <n>` (1–5) is the friendly knob; `--variants <n>` (1–10) is an advanced raw-total override that wins if both are given.
+
+**Hook Selection Mode:**
+The pipeline can pause after Genesis generates hooks, allowing the user to pick which hooks to keep before writing body copy. This is controlled by a persisted per-user preference (manual or auto-select).
+
+- **`--stop-at-hooks`** — pause after hook generation. The run lands in `awaiting_hook_selection` status and the CLI prints a dashboard URL. The user reviews and picks hooks on the run-detail page; the pipeline then continues automatically to body-copy generation.
+- **`--auto-hooks`** — force auto-select for this run (overrides a saved "manual" default). The pipeline auto-computes the strongest hooks and runs straight through without pausing.
+- **Saved preference** — the first time a user runs Genesis (or when no preference is saved), you should ask once: *"Want to choose the hooks yourself, or have me auto-pick and write straight through?"* Then run with `--stop-at-hooks` (manual mode) or `--auto-hooks` (auto mode), and after reporting the result, offer to save the choice with `npx @aicopycoders/exodus genesis hook-pref <manual|auto>` so you don't ask again. If the user has already set a preference via `hook-pref`, skip the question and just run with the saved default.
+
+> "Genesis run started at problem-aware — 1 pass per bot (2 variants: Mario × Brand + Infeed × Brand). I'll surface the Doc when it lands."
+
+Status check (only if user asks): `npx @aicopycoders/exodus status --id <runId> --type genesis` — `--type genesis` required.
+
+### 4. Report
+
+Per the **Default Post-Run Reporting** rule in `exodus-strategist`: surface the Doc URL and the variant breakdown plus a 2-line take. At the default that's **V1 Mario × Brand, V2 Infeed × Brand**; with more passes, each added pass is another Mario + Infeed pair, and **pass 2 uses the Top-Ads-Biased primer**. **Plus one Genesis-specific check**: if a 2nd pass was requested and the top-ads primer was empty (account has no qualifying ads, or lookup failed), that pass's two variants silently fall back to the brand primer — surface it so the user knows they got brand-primer variants instead of top-ads-biased ones.
+
+Mention the **editing menu** on the run-detail page (5 buttons per variant: Natural Language, Shorten, Cut, Simplify, Make Better — each appends a new tab with the edited version, originals stay).
+
+Don't auto-`read-doc` every variant. Pull the Doc only if the user wants vicious-hook critique, or you're picking the strongest variant for a follow-up.
+
+Then propose 1-2 fitting next moves: apply Shorten/Make Better to a specific variant, run another Genesis pass with different seeds or awareness, or pair with the `exodus-image` skill to render statics from the winning variant.
+
+## Cleanup & QA (Stage 6 — built into the pipeline)
+
+You do **not** hand-clean Genesis output. The pipeline runs Luke's cleanup + a 15-point QA pass on every variant before the Google Doc is written, so the Doc lands as a clean deliverable:
+
+- Bot commentary stripped — emotional-excavation notes, STEP/TEST labels, quality-gate/viciousness checks, hook-analysis paragraphs, category labels.
+- Markdown artifacts stripped — `**`, `*`, `##`, `---`, backticks.
+- Body copy continues from the hook (never repeats it), runs 700–1500 words — a design target of the writing process, not a hard limit of the bots (use the editing menu's Shorten/Cut if the user wants tighter) — and reads at a 3rd–5th-grade level.
+- Google Doc formatting: 14pt throughout, bold only on section/item labels (HEADLINES:, HOOKS:, BODY COPY 1/2:, H1:, Hook 1:), clean spacing.
+
+What still needs *your* judgment after the run: **verify any statistics, studies, or claims** — Genesis bots fabricate proof points (Principle 14). Fact-check before anything ships. If you spot junk that slipped past cleanup, that's a Tool Feedback item (see `exodus-strategist`).
+
+## Passes — How Much Coverage
+
+`--passes` is the friendly knob: one pass = one Mario + one Infeed. The user owns this number — menu it when unspecified, don't assume.
+
+- **1 pass = 2 variants (default)** — one Mario × Brand + one Infeed × Brand. The fastest two-voice read.
+- **2 passes = 4 variants** — adds a Mario + Infeed pair on the **Top-Ads-Biased** primer (falls back to brand if the account has no qualifying winners).
+- **3–5 passes = 6–10 variants** — wider net for a sprint; the extra passes repeat the Mario × Brand + Infeed × Brand pairing.
+- **Advanced — `--variants <n>` (1–10)** — a raw total that overrides `--passes`. Odd counts alternate Mario → Infeed (e.g. `--variants 3` = Mario, Infeed, Mario), with the top-ads primer entering on the 3rd variant.
+
+## Common Failure Modes
+
+- **In-feed-vsl-bot fails** — InfeedVSL hook generation degrades to Mario-only; the Infeed variant still runs if recovered. Note in report.
+- **Top-ads primer empty (2+ passes)** — the 2nd pass's two variants fall back to the brand primer. Pipeline completes; flag it.
+- **Pipeline timeout** — rare, and only realistic on a large pass count. Check run-detail for partial variants; trigger an editing pass from the UI to recover usable output.
+- **`status` 400 "Invalid generation ID format"** — missing `--type genesis`.

package/assets/skills/exodus-idea/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: exodus-idea
+description: Capture, curate, and write from the Exodus Idea Bank — the brand's home for formed ideas (a hook + a short concept) you collect now and write later, living in the Exodus dashboard. The Organic capture path transcribes a pasted Instagram/TikTok reel into a reusable idea; `idea write` (or `organic --write`) escalates a banked idea to the Genesis writer. If the user instead wants ads written from a reel RIGHT NOW in one shot — "exodus, make me ads from this reel" — that's the `exodus-genesis` skill (`--reel`); use this skill when the bank itself is the point (collect, curate, then write). Only invoke when the user has explicitly invoked Exodus — they said "exodus" in the request ("exodus, add this to my idea bank", "save these reels to the exodus idea bank", "exodus, write idea O3"), named this skill or /exodus-idea, ran an `npx @aicopycoders/exodus idea` command, referenced Exodus idea-bank keys from a prior run (O3, G1, S4), or the exodus hub skill routed here — gate "idea bank" mentions to Exodus context. Never claim generic idea or note-taking requests ("save this idea for later", "show me my ideas") — in shared folders those may belong to the user's other tools. The bare word "Genesis" without "exodus" refers to the member's own Genesis API key and personal bot recipes, NOT to Exodus.
+---
+
+```operator-guide
+Idea Bank = formed ideas (hook + 1-2 line concept), brand-agnostic, written later.
+Capture (three sources):
+  gambit  "<brain-dump>"        split a freeform dump into discrete ideas
+  organic "<url> ..." [--write] pull ONE idea from each IG/TikTok reel (transcribe → extract)
+  swipe   [--limit n]           extract concepts from the saved swipe library
+Curate:
+  list [--source ..] [--status raw|writing|written|archived] [--limit n]
+  note <KEY> "<steering>"   ·   edit <KEY> "<new concept>"   ·   add "<hook>" [--desc ..]   ·   rm <KEY> [--hard]
+Write:
+  write <KEYS> [--awareness <level>] [--passes n]   one Genesis run per key (brief-mode)
+Keys look like G1 (gambit) · O2 (organic) · S4 (swipe). Capture is fire-and-forget on Trigger.
+Returns: banked ideas appear in `idea list`; writes return a Genesis run + Google Doc per key.
+```
+
+# Idea Bank — Collect Now, Write Later
+
+The Idea Bank is where formed ideas live between "I saw something worth using" and "write it." An idea is a **hook + a short concept** — not the finished ad. Capture cheaply, curate the keepers, then escalate the ones you like to the Genesis writer. The analysis happens at capture; writing is a plain brief-mode Genesis run, so the brand's voice/steering is applied by the writers (Mario + Infeed), not baked into the idea — banked ideas stay reusable across runs.
+
+> **Reel → ads, one shot vs. bank-first.** Both this skill and `exodus-genesis` can write from a pasted reel. Use **the `exodus-genesis` skill (`--reel`)** when the user wants ads *now* from one reel and doesn't care about the bank. Use **`exodus-idea`** when the bank is the point — they're collecting several reels/angles, want to review before writing, or are working through a list. `idea organic --write` is the middle path: capture to the bank AND write in one shot.
+
+## Workflow
+
+### 1. Capture — get ideas into the bank
+
+Pick the source from what the user handed you:
+
+```bash
+# Reels — transcribe each IG/TikTok link into one reusable idea:
+npx @aicopycoders/exodus idea organic "https://www.instagram.com/reel/abc https://www.tiktok.com/@x/video/123"
+
+# Brain-dump — split a freeform stream into discrete ideas:
+npx @aicopycoders/exodus idea gambit "joint pain at 40, sleep angle, grounding vs pills"
+
+# Swipes — mine concepts from the saved competitor-ad library:
+npx @aicopycoders/exodus idea swipe --limit 10
+```
+
+Capture is **fire-and-forget** (it scrapes/transcribes/extracts on the queue). Don't poll — tell the user the ideas will land in the bank, and that `idea list` shows them as they arrive. A reel that's private, region-locked, or has no transcript just won't produce an idea; surface that if the user expected one.
+
+### 2. Curate — make the keepers writable
+
+```bash
+npx @aicopycoders/exodus idea list --source organic --status raw    # review what landed
+npx @aicopycoders/exodus idea note O2 "lean harder on the cortisol angle, never mention sleep meds"
+npx @aicopycoders/exodus idea edit O2 "A 40-something realizes their 'bad sleep' is actually high cortisol…"
+npx @aicopycoders/exodus idea add "It's not low T — it's too high cortisol" --desc "reframe hook" --source gambit
+npx @aicopycoders/exodus idea rm O5            # archive a dud (--hard to delete)
+```
+
+`note` attaches persistent steering that rides along into the Genesis run as a Direction block. `edit` rewrites the concept itself. Keys are stable (`O2`, `G1`, `S4`).
+
+### 3. Write — escalate to Genesis
+
+```bash
+# Write the ones the user picked — one Genesis run per key:
+npx @aicopycoders/exodus idea write O2,G1 --awareness solution-aware
+
+# Or capture a reel AND write it immediately (bank-and-write in one shot):
+npx @aicopycoders/exodus idea organic "https://www.instagram.com/reel/abc" --write --awareness problem-aware
+```
+
+`write` is fire-and-forget — it dispatches a brief-mode Genesis run per key (Mario + Infeed, default 1 pass = 2 variants; `--passes`/`--variants` scale it) and links each idea to its run. **Awareness is your call** (state your read; default `problem-aware`). The idea flips to `writing`, then `written` with a Doc link once the run lands.
+
+### 4. Report
+
+Per the **Default Post-Run Reporting** rule in `exodus-strategist`: for a capture, confirm what's being pulled and where it'll show up (`idea list`). For a write, surface the dispatched run(s) and that status flips to `written` with a Doc link — then propose a next move (curate the rest, write a second batch, or pair a strong result with the `exodus-image` skill).
+
+## Notes
+
+- **Banked ideas are brand-agnostic and reusable** — the same idea can be written for different awareness levels or re-run later. Don't re-capture a reel you've already banked; `idea list --source organic` first.
+- **Reel capture reuses the same transcription as the `exodus-genesis` skill's `--reel` path** — both go reel → transcribe → organic idea → Genesis writer (the standard writer, nothing custom).
+- A reel write models the reel's *angle*; the Genesis writers apply the brand's primer, hook bank, and steering, so the output is on-brand without the idea itself being brand-specific.

package/assets/skills/exodus-image/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: exodus-image
+description: The front door for making static image ads with Exodus — and the skill that WALKS THE USER THROUGH the setup instead of guessing. When the user hands over one or more finished ads and wants statics, it presents clean menus (which ads, which engines, aspect, count, steering, template formats), confirms a final render count, and fires nothing until the user says go. Only invoke when the user has explicitly invoked Exodus: they said "exodus" in the request ("exodus, turn this copy into images", "exodus, make me some statics", "exodus, render this ad"), named this skill or /exodus-image, ran an `npx exodus` command, or the `exodus` hub skill routed here — then use it FIRST when the user wants Exodus images and hasn't already nailed down every detail. Never claim generic image requests ("make images", "I need visuals for this ad") — in shared folders those may belong to the user's other tools; if the user did not say exodus, this skill is not for them. For meme formats specifically, use `exodus-meme`. Do not jump straight to running a render — the whole point of this skill is to ask first.
+---
+
+# Image — The Guided Static-Image Flow
+
+This skill turns "here are some ads, make me images" into a short, menu-driven
+setup, then fires the right render runs. The failure it exists to kill is the
+old behavior: reading one line, guessing an engine, skipping the steering
+question, and firing a batch the user never got to shape. **You ask first. You
+fire nothing until the user has confirmed the full spec — including steering.**
+
+The work runs through two base commands underneath you:
+
+- **`exodus image`** — engine-direct renders from copy (`native`, `copy-derived`).
+- **`exodus template run`** — spreads copy across structured ad-type formats
+  (testimonial, hero, UGC, infographic, +29). This is the command that exposes
+  manual format picking, per-format counts, and the realism enhancer.
+
+You compose those commands *after* the user has answered the menus — not before.
+
+## How to ask: menus, not walls of text
+
+Use the **AskUserQuestion** tool for every choice. That renders a clean picker
+the user can click through — which is exactly what makes this feel guided
+instead of like a wall of text they have to read and reply to in prose. Two
+practical limits to design around:
+
+- **Max 4 options per question, max 4 questions per call.** When a list is
+  longer (the 33 formats, or more than 4 ads), don't dump it as prose — group it
+  into buckets, or offer "all / a subset" and collect the subset as a follow-up.
+- Every question auto-includes an **"Other"** free-text choice, so users can
+  always type their own answer (a custom count, their own steering line, a
+  specific format slug). Lean on that instead of trying to enumerate everything.
+
+## Be adaptive — start where the user already is
+
+Read the request before asking anything. Whatever the user already specified,
+**pre-fill it and skip that question.** Only ask for what's genuinely still open.
+
+- "Here's a bunch of ads, make me some images" → wide open. Walk the full flow.
+- "Make me native ads from these" → engine is decided. Skip the engine question;
+  confirm the ads, aspect, count, and steering, then go.
+- "10 copy-derived statics of this ad, 1:1" → almost everything is set. You still
+  owe them the steering question (see below), then confirm and fire.
+- "Just make a dramatic woman-in-red image" — no copy, a pure visual direction →
+  this is the light path. Run native straight from the direction (steering *is*
+  the brief), no menu needed:
+  `npx @aicopycoders/exodus image --type native --steer "<direction>"`.
+
+The rule of thumb: the menus exist to capture decisions the user hasn't made
+yet. Don't re-ask what they've already told you, and don't make a one-off
+visual-direction render sit through a four-wave setup.
+
+## Steering is always on the table
+
+Whenever a Native engine (Native or Copy-Derived) is in the run, **always ask
+the steering question.** This is the step that used to get skipped, and it's the
+single biggest lever the user has over how the images come out — a direction
+that every image leans into ("make it aggressive and intense", "moody, clinical",
+"nasty toenail fungus, unfiltered"). Never decide steering for them and never
+quietly skip it. Steering applies to the Native engines; Template gets its own
+configuration (formats + realism) instead.
+
+---
+
+## The flow
+
+Think of it as waves. Collapse or skip any wave whose answers the user already
+gave; the order is the spine, not a script to read aloud.
+
+### Wave 0 — Read the ads, set the frame
+
+If the user dropped ad copy, parse it into a numbered list and give each ad a
+2–4 word descriptor so the menus are legible — e.g. "Ad #1 — wife/relational",
+"Ad #2 — free-T science". State a one-line read and that nothing fires until they
+confirm. Stage long copy to temp files if you need to (e.g. `/tmp/exodus-ad1.txt`)
+so the commands stay clean.
+
+### Wave 1 — The basics (one AskUserQuestion call)
+
+Ask only the still-open ones of these:
+
+- **Which ads?** Default option "All N ads" (recommended), plus "a subset" → let
+  them name which in Other. (Don't try to list more than ~3 ads as individual
+  options — the 4-option cap will truncate them; all-or-subset scales.)
+- **Which engines?** multiSelect — **Native** · **Copy-Derived** · **Template**.
+  (Native = a straight render of the ad; Copy-Derived = variations worked off the
+  copy; Template = a spread across ad-type formats.)
+- **Aspect ratio(s)?** **1:1** (feed) · **4:5** · **9:16**. Note in the option
+  text that Template only supports 1:1 and 9:16, so if they pick 4:5 it applies to
+  the Native engines only.
+- **How many per Native engine** (per ad, per aspect)? e.g. **4** (test batch) ·
+  **10** · Other. Only ask if a Native engine is selected.
+
+### Wave 2 — Configuration (branch on the engines chosen)
+
+- If **Native and/or Copy-Derived** is in the run → ask **steering** (always):
+  how do they want to provide it? Options: **one direction for all** · **per-ad
+  steering** (you'll menu each ad next) · **none**. The words are theirs — if they
+  pick "one direction" or "per-ad", collect the actual text in Other or in Wave 3.
+- If **Template** is in the run → ask **mode** (**Auto** = you spread the formats,
+  they give a total count per ad · **Manual** = they pick the formats and the
+  count per format), and the **realism enhancer** (**On** pushes photoreal output ·
+  **Off**). In Auto, the count question means "total images per ad"; in Manual it
+  means "per format" — say which in the option text so it isn't ambiguous.
+
+### Wave 3 — Per-ad steering (only if they chose "per-ad")
+
+One AskUserQuestion question per ad (batch into multiple calls if more than 4
+ads). For each ad, read it and offer **2–3 suggested steering directions you
+derive from that ad's angle** plus Other so they can type their own. You're a
+strategist here — propose real angles ("lean into the relational stakes",
+"clinical, data-forward", "visceral before/after"), don't offer generic filler.
+
+### Wave 4 — Template formats (only if Template + Manual)
+
+Present the 33 formats as a **menu grouped into purpose buckets**, never as a
+prose dump. Offer these top-level choices first:
+
+- **Smart pick (recommended)** — you choose the high-converting DR set that fits
+  these ads (e.g. testimonial · founder-note · before-after · comparison ·
+  scientific · statistics · cost-of-inaction · problem-solution). Fastest path,
+  and usually the right one.
+- **Pick categories** — multiSelect over the 8 buckets below.
+- **Specific formats** — they name slugs in Other.
+- **All 33** — the full spread (watch the cap; see Wave 5).
+
+The 8 buckets (slugs the `--quantities` flag expects):
+
+| Bucket | Formats |
+|---|---|
+| Social proof | testimonial · multi-testimonial · ugc · comment · happy-avatar |
+| Authority / story | founder-note · handwritten · holding-sign · writing-on-body |
+| News | native-news · breaking-news · screenshot |
+| Data / science | scientific · statistics · infographic · comparison · before-after |
+| Listicle / steps | step-by-step · carousel · quiz-interactive · post-it-notes |
+| Problem framing | problem-solution · cost-of-inaction |
+| Product | product-breakdown · hero · receipt |
+| Bold / graphic | bold · headline · meme · collage · lofi · animation · sale-promotional-offer |
+
+(For the full named list, `npx @aicopycoders/exodus template ad-types` prints all 33.)
+
+### Wave 5 — Confirm the math, then fire
+
+Before running anything, show a compact **render-count summary** so the user sees
+exactly what they're about to get:
+
+```
+Engine          Per ad   × N ads   Total
+Native (steered)   10        4        40
+Copy-Derived       10        4        40
+Template (8 fmt×2) 16        4        64
+                                  ─────────
+                                   144 images
+```
+
+**The 50-image cap:** a single Template run tops out at 50 images. If the manual
+counts or auto target for an ad would exceed 50, say so plainly and either trim
+or split across runs — don't let it fail silently at the backend. Auto mode also
+caps at 50 per run.
+
+Then wait for a clear "go" and fire the commands.
+
+---
+
+## Building the commands
+
+Compose these only after the confirm. Use `npx @aicopycoders/exodus`.
+
+**Native / Copy-Derived** — one invocation per selected ad (the single `--ad`
+slot is why per-ad steering works), repeated per aspect:
+
+```bash
+npx @aicopycoders/exodus image --type native --ad "<ad copy>" --variations 10 --aspect 1:1 --steer "<direction>"
+npx @aicopycoders/exodus image --type copy-derived --ad "<ad copy>" --variations 10 --aspect 1:1 --steer "<direction>"
+```
+
+Flags: `--type native|copy-derived`, `--ad "<copy>"`, `--variations N`,
+`--aspect 1:1|4:5|9:16`, `--steer "<direction>"` (drop `--steer` if they chose
+"none"), `--name "<label>"` (optional).
+
+**Template** — drive `exodus template run` (not `image --type template`), because
+it's the path that exposes mode, per-format counts, and realism. One run per ad,
+or pass a numbered list of ads in one `--input`:
+
+```bash
+# Manual: pick formats + per-format counts
+npx @aicopycoders/exodus template run --input "<ad copy>" --mode manual \
+  --quantities "testimonial:2,founder-note:2,before-after:2,comparison:2" \
+  --aspect 1:1 --realism realistic
+
+# Auto: you spread formats, --requested-count is the total per ad
+npx @aicopycoders/exodus template run --input "<ad copy>" --mode auto --requested-count 16 --aspect 1:1
+```
+
+Flags: `--input "<copy or numbered list>"`, `--mode auto|manual`,
+`--quantities "slug:N,slug:N"` (manual), `--requested-count N` (auto),
+`--aspect 1:1|9:16`, `--realism off|realistic`. Slugs must come from the 33
+above; `--quantities` rejects unknown ones.
+
+During long batches, surface progress as runs kick off rather than going silent.
+
+## Report
+
+When the runs are enqueued, the CLI prints a dashboard URL and runId per run.
+Report that plus a 1–2 line take, then stop — the kickoff confirms the run
+*started*, not that renders are done. Native/Copy-Derived poll with
+`npx @aicopycoders/exodus creative status --id <runId>`; Template progress shows live on the
+dashboard (no CLI status endpoint). Everything lands in the creative-suite
+library.
+
+## What this skill does NOT do
+
+- It doesn't fire before the user confirms the spec. Guessing the run and
+  skipping steering is the exact failure this skill replaces.
+- It doesn't mine image concepts from a bare idea with no copy. If there's no
+  copy and no clear visual direction, route to the `exodus-write` skill to produce
+  copy first, then come back here.
+- It doesn't write ad copy. Native/Copy-Derived/Template all render *from* copy
+  you already have (or a pure visual direction for the light native path).
+- It is not for memes. Meme ads ride familiar meme formats — use the
+  `exodus-meme` skill for those.

package/assets/skills/exodus-meme/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: exodus-meme
+description: Generate meme-style ad creative for the active brand — recommends meme formats for a brief (classic Imgflip templates + AI-image formats), then renders the whole batch server-side in ONE run; finished memes land in the dashboard's creative-suite library. Use it for both modes of meme work — "just make me memes" (auto-pick a strong diverse set and fire) and "walk me through it" (present the recommended formats by description and let the user choose). Only invoke when the user has explicitly invoked Exodus — they said "exodus" in the request (e.g. "exodus, make me meme ads", "exodus meme this offer"), named this skill or /exodus-meme, ran an `npx @aicopycoders/exodus meme` command, or the `exodus` hub skill routed here. Never claim generic meme requests ("make me a meme", "meme this", "imgflip meme") without exodus context — in shared folders those may belong to the user's other tools.
+---
+
+```operator-guide
+Subcommands (three; the batch renders server-side via Trigger.dev):
+  exodus meme recommend --brief "<text>" [--avatar "<text>"]
+  exodus meme run --brief "<text>" --formats '<json>' [--formats-file <path>] [--avatar "<text>"] [--name "<label>"]
+  exodus meme regenerate --brief "<text>" --layer 1 --template-id <id> --template-name "<name>" --boxes <N> [--id <runId>]
+  exodus meme regenerate --brief "<text>" --layer 2|3 --format <formatId> [--hint "<text>"] [--id <runId>]
+
+Flow:
+  1. recommend → { recommendations: [...] } — 15 picks (5 per layer), each with
+     name, layer, reasoning, ad_angle. Layer 1 = classic Imgflip templates;
+     layers 2/3 = AI-image formats.
+  2. run → pass the picked recommendation objects straight into --formats (JSON
+     array, 1–50; the CLI normalizes them). Returns { runId }. One enqueue —
+     closing the session does NOT kill the batch.
+  3. Poll: exodus status --id <runId> --type creative
+     Terminal statuses: complete | partial-error | error (also failed/cancelled).
+  4. regenerate → re-render one miss, synchronously (returns image_url).
+
+Keys (strict BYOK, refused server-side before anything starts):
+  layer 1 needs the member's Imgflip login · layers 2/3 need their Kie.ai key ·
+  captions always need their LLM key. `npx @aicopycoders/exodus doctor` checks all three.
+Returns: runId + dashboard URL /creative-suite/runs/<runId> (the visual review surface).
+```
+
+# Meme — Meme Ad Generator (Max's pipeline)
+
+Meme ads ride a format the audience already recognizes — a familiar template or
+a relatable AI-generated scene — and land the brand's point inside it. You drive
+the pipeline in three moves: get format recommendations for the brief, pick the
+formats worth rendering, and fire **one batched run**. The server orchestrates
+everything from there (captions + renders via Trigger.dev), so there is no
+per-meme captioning or rendering for you to compose, and a closed laptop no
+longer kills a half-finished batch.
+
+One thing to hold onto: **this is a no-visuals context.** The dashboard shows
+thumbnails; you can't. Your job is to be the user's eyes — describe formats by
+name, layer, and the `reasoning`/`ad_angle` the recommend call returns, and
+point at the dashboard URL when it's time to actually look at rendered memes.
+Never pretend to show an image.
+
+## Two paths — read the request, pick the right one
+
+**Quick batch** — "exodus, meme this offer", "make me some memes for <brief>".
+The user wants memes, not a meeting. Run `recommend`, pick a strong diverse set
+yourself (~6–10: mix classic templates and AI formats, apply the strategist
+bars below), fire `run`, and report. Tell the user which formats you picked and
+why in one or two lines — they can steer the next batch.
+
+**Guided** — "walk me through it", "what formats are there?", or any sign the
+user wants control over the picks. Run `recommend`, then present the
+recommendations with **AskUserQuestion** (max 4 options per question — group
+into the three layers or offer "my picks / classics only / AI only / let me
+choose" buckets rather than dumping 15 raw entries). Describe each option by
+its name + one-line reasoning, e.g. "Group Chat (AI) — lands the claim as a
+screenshot conversation, good for skeptical audiences". Collect the picks,
+confirm the count, then fire `run`.
+
+In both paths, picking is where the strategist work happens:
+
+- **Relatable beats clever.** A meme the audience has to decode is a scroll-past.
+- **The format should fit the audience's actual feed.** A 55+ supplement buyer
+  and a 22-year-old skincare buyer do not share meme literacy.
+- **Diversity over three flavors of one joke.** Spread across layers and angles;
+  a batch of near-duplicates wastes renders.
+
+## Workflow
+
+### 1. Recommend
+
+```bash
+npx @aicopycoders/exodus meme recommend --brief "<the offer / angle, in the brand's terms>"
+```
+
+Returns `{ recommendations: [...] }` — 15 picks, 5 per layer, each carrying
+`format_id`, `layer`, `name`, `reasoning`, and `ad_angle` (layer-1 entries also
+carry `imgflip_template_id` + `imgflip_box_count`). Layer 1 = classic Imgflip
+templates; layers 2/3 = AI-image formats. Optional `--avatar "<text>"`
+describes a recurring character/persona to thread through the batch.
+
+Keep the JSON in your context — the picked entries go straight into `run`, and
+the per-format fields are what `regenerate` needs later. Don't paste the raw
+JSON at the user.
+
+If the user asks for a specific template by name ("do a Drake one"), put that
+in the brief — recommend reads it and will surface the template if it fits.
+There's no separate catalog browse; recommend **is** the selection surface.
+
+### 2. Run the batch
+
+Pass the picked recommendation objects straight in — the CLI maps them onto the
+run payload itself (don't restructure them):
+
+```bash
+npx @aicopycoders/exodus meme run --brief "<same brief>" --formats '[<picked recommendation objects>]'
+```
+
+For bigger selections, write the array to a file and use `--formats-file
+/tmp/meme-formats.json` — long JSON in shell quoting breaks easily. 1–50
+formats per run; `--name "<label>"` labels the run; pass the same `--avatar`
+you gave recommend, if any.
+
+Returns `runId` + the dashboard URL. The whole batch renders server-side — tell
+the user this explicitly, because it changes their behavior: they can close the
+session and the run finishes anyway.
+
+### 3. Poll
+
+```bash
+npx @aicopycoders/exodus status --id <runId> --type creative
+```
+
+Poll roughly every 45 seconds while the user is waiting (or just hand them the
+dashboard URL if they'd rather watch it live). Treat these statuses as
+terminal: `complete`, `partial-error`, `error` — plus `failed`/`cancelled`. The
+status output includes `completedImages / totalImages` and, on failures, an
+`errorMessage` naming what missed.
+
+### 4. Regenerate the misses
+
+`partial-error` means some renders failed and the rest landed. Name the misses
+to the user and offer to re-render them — the format fields come from the
+recommend output you're still holding:
+
+```bash
+# Classic (layer 1) miss:
+npx @aicopycoders/exodus meme regenerate --brief "<brief>" --layer 1 \
+  --template-id <imgflip_template_id> --template-name "<name>" --boxes <imgflip_box_count> --id <runId>
+
+# AI (layer 2/3) miss — --hint steers the re-roll:
+npx @aicopycoders/exodus meme regenerate --brief "<brief>" --layer 2 --format <format_id> \
+  --hint "make the punchline land the product" --id <runId>
+```
+
+Regenerate is synchronous (caption + render server-side) and
+returns the new `image_url` directly. Passing `--id <runId>` attaches the fresh
+meme to the run so it shows up in the same library entry.
+
+### 5. Report
+
+Surface the dashboard URL (`/creative-suite/runs/<runId>`) + a 2-line
+strategist take ("the classics carry the relatability, the Group Chat one is
+the sleeper — review them in the library"). The dashboard is where the user
+actually evaluates memes visually; your report gets them there with a point of
+view, not a data dump. Don't paste recommend JSON, prompts, or caption
+internals into chat.
+
+## Failure Handling
+
+- **400 "Missing required key(s)"** — the strict-BYOK preflight refused before
+  anything started. The message names the missing key: Imgflip login (classic
+  memes), Kie.ai key (AI memes), or an LLM key (captions, always). Run
+  `npx @aicopycoders/exodus doctor` to confirm, then send the user to **Settings → Keys** on
+  the dashboard. A batch with no layer-1 picks doesn't need Imgflip at all — if
+  the user lacks an Imgflip login, an AI-only batch is a legitimate fallback.
+- **`partial-error`** — not a failed run; some memes landed. Report the
+  successes, name the misses from `errorMessage`, regenerate per step 4.
+- **`error` / `failed`** — the batch died; the status `errorMessage` says why.
+  Fix the cause (usually a key issue mid-run) before re-firing, don't just retry.
+- **No progress for 15+ minutes** — presume the run dead and say so rather than
+  polling forever; the dashboard run page shows the same stall.
+- **Bearer/auth failure** — run `npx @aicopycoders/exodus doctor`; confirm `EXODUS_API_KEY`.
+
+## What this skill does NOT do
+
+- It doesn't compose per-meme caption/render steps — that surface is gone. One
+  `run` call is the whole batch.
+- It doesn't browse a full format catalog. Recommend returns the working set;
+  steer it through the brief.
+- It doesn't write ad copy — the brief is an offer/angle, not finished copy. For
+  copy, that's the `exodus-write` skill; for non-meme statics, `exodus-image`.
+
+## Admin
+
+- Backend: `/api/meme/{recommend,run,regenerate}` (Bearer-auth). `run` enqueues
+  the `meme-batch` Trigger.dev task; meme runs ride `creativeSuiteRuns` with
+  engine `meme`, which is why `exodus status --type creative` and
+  `exodus browse --agent meme` cover them.
+- Finished runs appear in the creative-suite library alongside other engines.