@aicopycoders/exodus 2026.6.2400

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

@@ -0,0 +1,157 @@
+---
+name: exodus-write
+description: The front door for writing ad copy with Luke's Genesis process inside Exodus. It figures out where the user is (new brand → onboarding, brief in hand → write, want to rerun → exodus-browse), walks the brief → genesis → Google Doc flow end to end, and hands off to the exodus-genesis skill for the actual writing pass; it routes — it doesn't replace the exodus-genesis/exodus-foundation skills, it sequences them. Only invoke when the user has explicitly invoked Exodus and hasn't named a specific pipeline: they said "exodus" in the request ("exodus, write me some ads", "exodus, I have a brief", "exodus, turn this winning ad into copy"), named this skill or /exodus-write, ran an `npx exodus` command, or the `exodus` hub skill routed here. Never claim generic copywriting requests ("write me some ads", "help me write hooks") — 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 — do not hijack it into this flow.
+---
+
+# Write — The Guided Copywriting Flow
+
+This is the single entry point for "write me ad copy the Genesis way." It sequences the existing pieces — brand → foundation → brief → genesis → Google Doc — so the user never has to know which command runs when. You stay in `exodus-strategist` the whole time (persona, operating rules, creative principles). Per that persona: **recommend the strategy, menu the run.** You own the creative calls — the awareness read, the angle, the brief itself — so state those and move; the user owns the run's knobs (how many passes), so present those as a quick menu, the way the `exodus-image` skill does for static images. Reach into `exodus-genesis` and `exodus-foundation` for the heavy lifting, and `exodus-strategist`'s Framework Index for depth; this skill is the conductor.
+
+The job, every awareness level, every brand: **install the mechanism → create desire → bridge to the product.** Only the starting place changes.
+
+---
+
+## First-Message Routing — Figure Out Where They Are
+
+Don't interrogate. Read the opening message + run `npx @aicopycoders/exodus brand current` and `npx @aicopycoders/exodus foundation status`, then route:
+
+| Signal | Route to |
+|---|---|
+| New brand, or `foundation status` shows missing fields | **Onboard** (below), then Write |
+| They pasted a winning ad / gave an idea / have a brief | **Write** (skip onboarding if foundation is ✓ Ready) |
+| "rerun", "tweak that", "make a variant", references a past run | **Rerun** — `npx @aicopycoders/exodus browse`, then the genesis editing menu |
+| Pure question about an angle/hook/awareness call | Answer from `exodus-strategist`'s Framework Index + `references/`; offer to write it |
+
+State your read in one line ("New brand, no foundation yet — setting that up first, then we write") and move. The user redirects if you misread.
+
+---
+
+## Stage A — Onboard (only when the brand isn't ready yet)
+
+A brand needs one thing before any pipeline runs: a ready foundation. The default, fastest on-ramp is the **primer** — a single document built from the brand's winning ads that unlocks every pipeline. Check readiness first:
+
+```bash
+npx @aicopycoders/exodus primer status            # always first — is this brand ready?
+```
+
+**Primer-first (the default).** If the user has winning ads, build the primer — one doc, one pass, every pipeline unlocked. Hand off to the `exodus-primer` skill: it runs a one-pass intake (product facts + winning ads) → build → save → verify. Don't re-implement it here.
+
+**No winning ads, or a legacy 2-track setup?** Fall back to the `exodus-foundation` skill. It extracts audience concerns + the two awareness primers from a brand doc / URL / notes and satisfies the same readiness gate. Fill what's missing via its three paths (paste structured markdown → `foundation save -`; one field → `foundation set <field>`; raw source → interactive walkthrough). The fields:
+
+- `audienceConcerns` — who you're talking to and what keeps them up at night
+- `primerUnawareProblemAware` — the **cold** primer (winning ads for unaware / problem-aware)
+- `primerSolutionProductAware` — the **warm** primer (winning ads for solution / product-aware)
+- `brandVoice` — optional voice guide
+
+### The primer — the highest-leverage input
+
+Winning ads are the highest-leverage input: they teach the bots what "good" looks like for this market (see `references/hook-quality-checklist.md` for what makes an ad primer-worthy). The better the examples, the better every hook and body-copy variant. The **`exodus-primer` skill** is the clean way to turn a brand's winning ads into that document in one pass — prefer it for any brand that has winners to paste.
+
+If a brand instead arrives with **finished primer text already prepared** — a packaged set of winning ads + examples per awareness band — you can paste it straight into the matching foundation field, no rebuild needed:
+
+```bash
+# cold (unaware / problem-aware) winning ads:
+pbpaste | npx @aicopycoders/exodus foundation set primerUnawareProblemAware --stdin
+# warm (solution / product-aware) winning ads:
+pbpaste | npx @aicopycoders/exodus foundation set primerSolutionProductAware --stdin
+```
+
+**Works without it.** If there's no primer prompt yet, don't block — Genesis falls back to sensible defaults and still produces copy. Tell the user plainly: "We can write now; output gets noticeably sharper once you add winning examples to the foundation." Then proceed. Adding the primer later and re-running is cheap.
+
+Confirm `foundation status` shows the fields you set, then move to Write.
+
+---
+
+## Stage B — Write the Brief (Stage 4 of Luke's process)
+
+Genesis takes a **brief**, not raw copy. A brief is a 1–2 paragraph natural-language *description* of the ad — not the ad itself. Most of the time you write this yourself from what the user gave you; 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 interesting / what makes it vicious.
+
+**A brief is NOT:** the actual copy · a hook list · a format spec (don't say "video/static") · over-specified (leave the bots room).
+
+Format:
+
+```
+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 — a winning ad, a comment, an angle]
+[1–2 paragraphs describing the ad: scenario, emotional core, mechanism bridge, tone, why it works]
+```
+
+See `references/awareness-framework.md` for the brief→primer mapping and worked brief examples. For hook direction and the vicious standard, see `references/hook-quality-checklist.md`.
+
+### Extract seeds when there's a source ad
+
+If the user pasted a winning ad, mine it for **seeds** — creative angles to carry into the run (a ritual to transfer, a "it's not X, it's Y" reframe, a buried line worth promoting to the hook). One per line:
+
+```
+Coffee = morning ritual — swap to gym, sex, alcohol tolerance
+"It's not low T..." — reframe to "too high cortisol"
+Mechanism-heavy structure — replicate it
+```
+
+Save to `/tmp/genesis-seeds.txt` or pass inline via `--seeds`. Skip seeds when there's no source ad — the brief carries it.
+
+### Classify awareness
+
+Pick ONE level — don't ask the user to choose, state your read:
+
+| Level | Starting place |
+|---|---|
+| **Unaware** | symptom / curiosity / hidden problem |
+| **Problem-aware** | known problem, reframe the cause (default when unsure) |
+| **Solution-aware** | solution category, comparison, skepticism |
+| **Product-aware** | product comparison, "why you over them" |
+
+Awareness picks the primer; never mix buckets in one run. Detail in `references/awareness-framework.md`.
+
+---
+
+## Stage C — Pick the pass count, then run Genesis
+
+Genesis writes in two voices — **MarioBot** and the **Infeed VSL bot**. The default is **one pass per bot = 2 variants** (1 Mario × Brand + 1 Infeed × Brand): the fastest read on both voices against the same brief. More passes widen coverage and bring in the Top-Ads-Biased primer.
+
+How many passes is the user's call, not yours — so **menu it** (one AskUserQuestion call) rather than assuming. Lead with the recommended default:
+
+- **1 pass — 2 variants (recommended)** — one Mario, one Infeed, on the brand primer. Fast.
+- **2 passes — 4 variants** — adds a Mario + Infeed pair on the brand's top-performers primer.
+- **3+ passes — 6+ variants** — a wider sprint; "Other" takes a custom number.
+
+Skip the menu only if the user already said how many ("just give me two", "run a big batch"). Awareness you do *not* menu — that's your strategist call from Stage B; state it and move.
+
+Hand off to the `exodus-genesis` skill — it owns the run (double-pass hooks, the built-in 15-point QA, the editing menu). Always background it; even the default run is ~12–15 min, past the 10-min foreground cap.
+
+```bash
+# Default — 1 pass per bot = 2 variants:
+npx @aicopycoders/exodus genesis run --brief "<brief>" --awareness <level>
+# More coverage — 2 passes = 4 variants:
+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
+```
+
+> "Genesis run started at problem-aware — 1 pass per bot (2 variants: Mario × Brand + Infeed × Brand). I'll surface the Doc when it lands."
+
+Quality is enforced inside the pipeline (Cleanup + QA — see the `exodus-genesis` skill): markdown stripped, bot commentary removed, body copy 700–1500 words, no hook repetition, clean 14pt Google Doc. You don't hand-clean output.
+
+---
+
+## Stage D — Deliver + Next Move
+
+Per the **Default Post-Run Reporting** rule in `exodus-strategist`: surface the Doc URL + the variant breakdown + 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**. Flag the Genesis-specific gotcha: if a 2nd pass was requested and the top-ads primer was empty, that pass's two variants silently fall back to the brand primer.
+
+Don't auto-`read-doc` every variant. Pull the Doc (`npx @aicopycoders/exodus read-doc <runId>`) only to critique hooks, pick a winner for a follow-up, or diagnose a failure.
+
+Then offer the fitting next moves (a short menu is fine here):
+- Apply an edit pass to the strongest variant (Natural Language / Shorten / Cut / Simplify / Make Better — on the dashboard run page)
+- Run more passes, or another Genesis pass at a different awareness level / with different seeds (creative diversity)
+- Render statics from the winning variant via the `exodus-image` skill
+
+---
+
+## What This Skill Does NOT Do
+
+- It doesn't replace `exodus-genesis` or `exodus-foundation` — it sequences them. Drop into those skills, or `exodus-strategist`'s Framework Index, for depth.
+- It doesn't add a CLI command. The flow runs the existing `npx @aicopycoders/exodus foundation` / `genesis` / `browse` / `read-doc` commands.
+- It doesn't do analysis or ideation pipelines — those stay strategist-driven via `exodus-strategist` and its `references/` (STORMING, CASH, the diversity matrix). This skill is the path from "I want to write" to a finished Doc.

package/assets/skills/genesis-bots/.env.example

@@ -0,0 +1,12 @@
+# Genesis Bots credentials. Keep this file private — never commit or share it.
+# Easiest: replace this ENTIRE file with what the portal's "Copy .env" button
+# gives you (https://genesis.copycoders.ai/portal), then add your provider key.
+
+GENESIS_BASE_URL=https://gas.copycoders.ai/api/v1
+GENESIS_API_KEY=gen_your_key_here
+
+# Your provider key (you pay usage). Use ONE of these — match the name to your key:
+#   Anthropic  → ANTHROPIC_API_KEY=sk-ant-...
+#   OpenRouter → OPENROUTER_API_KEY=sk-or-...
+# (`npx @aicopycoders/exodus keys pull` writes these names for you from the dashboard.)
+ANTHROPIC_API_KEY=sk-ant-your_provider_key_here

package/assets/skills/genesis-bots/README.txt

@@ -0,0 +1,29 @@
+Genesis Bots — Claude Code / OpenClaw skill
+
+INSTALL (matches the setup steps on the portal — downloading this zip was
+step 2):
+  1. Get a provider key: create an API key with Anthropic (sk-ant-) or
+     OpenRouter (sk-or-) and add $10-20 in credits. Genesis auto-detects
+     which one you use.
+  2. Move this "genesis-bots" folder into your agent's skills directory.
+     For Claude Code that's:  .claude/skills/genesis-bots
+  3. Paste your .env: on the portal (https://genesis.copycoders.ai/portal),
+     click "Copy .env to clipboard" — it already contains your Genesis key
+     and the server address. Paste it into a NEW file named .env inside this
+     genesis-bots folder or the root of your project (either works), then
+     replace the last line with your provider key from step 1.
+  4. Start a NEW agent session (skills only load at session start — in
+     Claude Code, /clear also works), then ask your agent to run a Genesis
+     bot. Done — no other configuration needed. Try: "Use the genesis-bots
+     skill and ask MarioBot for three ad hooks."
+
+The helper runs on Node (bundled as scripts/genesis-stream.mjs — Claude Code
+always has Node). A Python version (scripts/genesis-stream.py) ships alongside
+it as a fallback; both take the same arguments.
+
+Tip: create and edit the .env file in an editor like Cursor, VS Code, or
+Obsidian — files starting with a dot are hidden by default in Finder (press
+Cmd+Shift+. to show them). There's also a .env.example template in this
+folder if you'd rather fill one in by hand.
+
+See SKILL.md for full usage. Get your keys at https://genesis.copycoders.ai/portal

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

@@ -0,0 +1,219 @@
+---
+name: genesis-bots
+description: Call Genesis (OpenClaw) copywriting, research, strategy, and image-prompt bots DIRECTLY over the Genesis API with the member's own `gen_` key. Genesis is the manual, hands-on way to use the bots — you pick a bot and call it yourself, chaining bots by hand (buyer profile → creative brief → ad hooks → ads). Use this skill whenever the user wants the Genesis bots directly: they say "genesis", "openclaw", "run the bots", "genesis copy", name a bot slug, or want a buyer profile / creative brief / ad hooks generated by calling the bots themselves. There is also a done-for-you sibling, Exodus — pre-built `npx @aicopycoders/exodus` pipelines that drive these same bots automatically — which MAY also be installed in this folder (look for `exodus-*` skills); it often is NOT. If `exodus-*` skills are present AND the user said "exodus" or invoked one, that's the automatic system — hand off to the exodus-* skills, not this one. If the user clearly wants ads and seems unsure whether they're driving Genesis directly or running an Exodus pipeline, ASK which they have rather than guessing. Covers discovering bots and calling them (OpenAI-compatible API where the model field is a bot slug, optionally `slug@model` to override which LLM the bot runs on).
+---
+
+# Genesis Bots
+
+**Skill version: 2026.06.23** · [how to update](#updating-this-skill)
+
+Call the Genesis (OpenClaw) bot API. The bots are OpenAI-compatible chat models where the
+`model` field is a **bot slug**. Each bot carries its own server-side system prompt — you send
+user messages, the bot does the rest.
+
+## Genesis vs Exodus — am I the right skill?
+
+You're looking at **Genesis**: the manual, hands-on way to use the copywriting server. You call
+individual bots directly with the member's own `gen_` key and your own prompts, and you drive
+every step yourself.
+
+There's a done-for-you sibling called **Exodus** — pre-built `npx @aicopycoders/exodus` pipelines (the
+`exodus-*` skills) that drive these *same* Genesis bots automatically against the member's brand.
+Think of it as a car: **Genesis is the manual transmission** (you shift every gear yourself),
+**Exodus is the automatic** (same engine underneath, it does the driving). Most people who don't
+know the internals just want their ads — your job is to get them into the right one.
+
+**Exodus may or may not be installed here** — plenty of members run Genesis on its own. So check
+`.claude/skills/` for `exodus-*` skills before assuming:
+
+- **No `exodus-*` skills present** → there's only one system and you're it. Carry on; ignore the
+  rest of this section.
+- **`exodus-*` skills present** → both are installed. Route by what the user said: bare
+  **"genesis" / "run the bots" / "openclaw" / a bot slug** → this skill; **"exodus …"** → the
+  `exodus-*` skills (hand off, don't do their pipeline work here). If the user just wants "ads"
+  and clearly doesn't know the difference, ask one question — *"Do you want to drive the Genesis
+  bots directly, or run an Exodus pipeline?"* — rather than guessing, because the two go down
+  completely different paths.
+
+## Setup (one time, ~1 minute)
+
+You need two keys. Get them from the member portal — it walks you through it:
+
+- **Portal:** https://genesis.copycoders.ai/portal — your Genesis key (`gen_...`) is already there
+- **Setup Guide:** https://genesis.copycoders.ai/setup — how to get your Anthropic key (`sk-ant-...`)
+
+Then put both keys in a local `.env` file — never paste them into code or chat:
+
+```bash
+cp .env.example .env      # 1. make your private copy
+# 2. open .env, paste your two keys, save
+```
+
+You only fill in two values (the API address is pre-filled — leave it alone):
+
+| In `.env` | What it is | Where to get it |
+|-----------|------------|-----------------|
+| `GENESIS_API_KEY` | Your Genesis access key (`gen_...`) | the portal (already generated for you) |
+| `ANTHROPIC_API_KEY` *or* `OPENROUTER_API_KEY` | Your own provider key — how you pay for usage | the Setup Guide |
+
+Your provider key can be an Anthropic key (`sk-ant-...`, from console.anthropic.com) **or** an
+OpenRouter key (`sk-or-...`, from openrouter.ai):
+
+- **Want every model** — Claude *and* GPT-5, Gemini, etc.? Use an **OpenRouter key** (one key
+  serves them all) and put it in `OPENROUTER_API_KEY`.
+- **Only need Claude?** An Anthropic key is enough — put it in `ANTHROPIC_API_KEY`.
+
+You can set **both**: the helper automatically picks the right key per request — Claude bills
+direct to Anthropic (cheaper), while GPT-5/Gemini route via OpenRouter. Keys are detected by
+their `sk-ant-`/`sk-or-` prefix, so it still works even if you paste one into the other field.
+
+The bundled helper at `.claude/skills/genesis-bots/scripts/genesis-stream.mjs` (Node — works everywhere, no Python needed; a `genesis-stream.py` is also bundled as a fallback) **reads `.env`
+automatically** — you don't need to know what an environment variable is or run any
+`export`/`source` commands. Just edit `.env` once.
+
+> These same names (`GENESIS_API_KEY`, `ANTHROPIC_API_KEY`) and base URL match the portal exactly,
+> so if you're configuring this inside OpenClaw instead of a `.env` file, use the identical values.
+> Keep `.env` private. Add it to `.gitignore`; commit only `.env.example`.
+
+For the raw `curl` commands below (optional), load the file into your shell first:
+`set -a && source .env && set +a`
+
+## Updating this skill
+
+Genesis adds features to this skill over time (the version is at the top of this file).
+Updating an existing install needs **no portal login**:
+
+- **Easiest — ask your agent:** *"update the genesis-bots skill."* It downloads the latest
+  bundle and replaces this `SKILL.md` and the helper script in place, leaving your `.env`
+  untouched.
+- **By hand (docs only, one line)** — overwrites just `SKILL.md`, never your `.env`:
+  ```bash
+  curl -fsSL https://genesis.copycoders.ai/downloads/genesis-bots-SKILL.md \
+    -o .claude/skills/genesis-bots/SKILL.md
+  ```
+  For a full update including the helper script, re-download
+  `https://genesis.copycoders.ai/downloads/genesis-bots-skill.zip` instead.
+
+Either way, **start a new session** afterward (skills load only at session start; `/clear` works).
+
+## Discover bots (never hardcode slugs)
+
+The catalog changes — always pull the live list. Categories include Copywriting, Research,
+Strategy, Creative, Image Prompts, Pages & Funnels, Video Pipelines, and Other.
+
+```bash
+curl -s -H "Authorization: Bearer $GENESIS_API_KEY" \
+  "$GENESIS_BASE_URL/models" \
+  | jq -r '.data[] | "\(.id)\t\(._genesis.category)\t\(._genesis.name)"'
+```
+
+Filter by category: append `?category=Copywriting`. Each entry's `id` is the slug you pass as
+`model`; `_genesis` holds `{name, description, category, provider, model}`.
+
+## Call a bot (streaming helper)
+
+The bundled helper streams the response, accumulates it, and writes it to a file. Use the Node
+helper (`genesis-stream.mjs`) — Claude Code always has Node, and it needs nothing installed. It
+lives inside this skill folder — call it with its full path from your project root (the relative
+`scripts/...` form only works if you've `cd`'d into the skill folder first):
+
+```bash
+# 1. write the prompt
+cat > prompt.txt << 'EOF'
+{your context + ask}
+EOF
+
+# 2. call: <bot-slug> <prompt-file> <output-file> [temperature]
+node .claude/skills/genesis-bots/scripts/genesis-stream.mjs BOT_SLUG prompt.txt out.md
+
+# (No Node? A Python fallback ships alongside it — identical arguments:)
+# python3 .claude/skills/genesis-bots/scripts/genesis-stream.py BOT_SLUG prompt.txt out.md
+```
+
+Request fields:
+
+| Field | Notes |
+|-------|-------|
+| `model` | the **bot slug**, not an LLM model name. Append `@<model>` to run the bot on a different LLM — see [Choose the model and temperature](#choose-the-model-and-temperature-optional). |
+| `messages` | `role` must be `user` or `assistant`. **`system` messages are dropped** — the bot's prompt is server-side. |
+| `stream` | default `true`; SSE in OpenAI format. Set `false` for a complete JSON body. |
+| `temperature` | optional creativity dial; omit to use the bot's default. Ignored by Opus 4.7+/Fable — see [Choose the model and temperature](#choose-the-model-and-temperature-optional). |
+| `max_tokens` | optional; bot has a default. |
+
+### Choose the model and temperature (optional)
+
+Two optional, per-request dials. Set them when the user wants them; otherwise leave the bot's
+defaults alone (the normal case — nothing to do).
+
+**Model** — set `model` to `<bot-slug>@<model>` (everything after the first `@` is the model;
+no `@` = the bot's default). Which models you can pick depends on the provider key in `.env`:
+
+| Your key | Models you can request | Examples |
+|----------|------------------------|----------|
+| Anthropic (`sk-ant-…`) | Claude only (`claude-*`, no `/`) | `claude-opus-4-8` (smartest), `claude-sonnet-4-6`, `claude-haiku-4-5` (fast/cheap) |
+| OpenRouter (`sk-or-…`) | any model | `openai/gpt-5`, `google/gemini-2.5-pro`, plus all Claude models |
+
+A non-Claude model on an Anthropic key returns `400`. A bot's current default is the
+`_genesis.model` field in the `/models` list.
+
+**Temperature** — the creativity dial: higher (e.g. `0.9`) = more varied/creative, lower
+(e.g. `0.2`) = more focused/consistent. Pass it as the helper's 4th argument (or the
+`temperature` field). Omit it to use the bot's tuned default.
+
+**Handle model/temperature compatibility for the user — don't make them think about it.**
+Temperature works on Opus 4.6 and earlier, Sonnet, Haiku, and OpenRouter models. The newest
+reasoning models — **Opus 4.7+ and Fable — ignore temperature** (that control was removed). So:
+
+- User wants a custom temperature → use a model that supports it (the bot's default already
+  does); don't pair it with a model that can't.
+- User wants the most powerful model (Opus 4.8) → just switch the model; don't set a temperature.
+- User asks for both at once → tell them briefly they can have a custom temperature **or** the
+  newest model, and pick whichever better fits their goal. Never make them debug a silent no-op.
+
+```bash
+# model + temperature (4th arg = temperature) — opus-4-6 supports it:
+node .claude/skills/genesis-bots/scripts/genesis-stream.mjs BOT_SLUG@claude-opus-4-6 prompt.txt out.md 0.9
+
+# most powerful model, no temperature (ignored there anyway):
+node .claude/skills/genesis-bots/scripts/genesis-stream.mjs BOT_SLUG@claude-opus-4-8 prompt.txt out.md
+
+# raw curl with both fields:
+curl -s -X POST "$GENESIS_BASE_URL/chat/completions" \
+  -H "Authorization: Bearer $GENESIS_API_KEY" \
+  -H "X-Provider-Key: $ANTHROPIC_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"model":"BOT_SLUG@claude-opus-4-6","temperature":0.9,"messages":[{"role":"user","content":"..."}],"stream":false}'
+```
+
+### Chaining bots
+
+Feed one bot's output into the next as context in the user message (e.g. buyer profile →
+creative brief → hooks → ads). The API injects each bot's system prompt for you; you only pass
+messages. Use the slugs from the live models list.
+
+## Limits
+
+- **1 concurrent stream per key** — a 2nd parallel stream on the same key returns
+  `429 connection_limit_error`. Call sequentially per key.
+- **60 requests/min per key** (sliding window) — over the limit returns `429` with `Retry-After`.
+- Long generations are fine: the server sends SSE heartbeats (~every 5s) to prevent proxy timeouts.
+
+## Minimal call without the helper
+
+```bash
+curl -s -X POST "$GENESIS_BASE_URL/chat/completions" \
+  -H "Authorization: Bearer $GENESIS_API_KEY" \
+  -H "X-Provider-Key: $ANTHROPIC_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"model":"BOT_SLUG","messages":[{"role":"user","content":"..."}],"stream":false}' \
+  | jq -r '.choices[0].message.content'
+```
+
+## Error codes
+
+- `400` — missing `X-Provider-Key` or malformed request; also returned when a `@<model>` override
+  isn't allowed for your key (e.g. a non-Claude model with an `sk-ant-…` key) — the message says so
+- `401` — invalid/revoked Genesis key
+- `404` — bot slug not found (re-check the models list)
+- `429` — rate limit or concurrent-stream limit hit
+- `500` — provider error (usually a bad/over-quota provider key)