@aicopycoders/exodus 2026.9.1100-beta.3 → 2026.9.1400-beta.0

package/assets/skills/odf/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: odf
+description: Luke's ODF method (Outcome × Demographic × Facet) for finding who to sell to, one axis at a time, in a recursive think-mode loop. Use it whenever someone wants segments, sub-outcomes, personas, a segment grid or map, "who else is out there", "map the market", "find the pockets", "build personas from the comments", "horizontal scaling", "ODF", or wants to aim an existing winning ad at a new segment. Three entry points: MAP (no winners yet, build the grid and focus order), PERSONAS (turn chosen segments into named humans that live in Exodus), HORIZONTAL (a winner exists, swipe it into each new persona, Mad Libs not rewrites). Trigger even when the user only names one axis ("let's list the outcomes", "what are the facets here", "add menopause as a segment") because the axes change each other. Runs with nothing installed: a conversation, whatever data they have, this file. Pushes into Exodus with `npx @aicopycoders/exodus segment`.
+---
+
+# ODF
+
+There are two ways an ad account grows with creative. Vertical is same people, more to say to them. Horizontal is new people. A segment is not a vibe. It is one outcome, one demographic, and a facet or two: "3AM · women 45 to 60 · on HRT and still". Change any part and it is a different human and usually a different ad. Most accounts slice on outcome and demographic. The gold is in the facets and the sub-outcomes.
+
+The sentence to keep: ads are made of parts, some proven and some cheap to swap, so every launch should be one cheap swap away from something proven. A new segment is the expensive swap. This method makes sure the segment is real before anyone pays for it.
+
+## Think mode, always
+
+This runs as a back-and-forth. One axis per message. Every item one or two words. Propose a list, let the user cut it, move to the next axis. No document until the axis is agreed, and no grid until every axis is agreed. The user makes every call, fast, by name or by number. When they say "stress test", apply the rules and show only what moved. When they say "are we missing anything", check the data for the biggest themes not on the list and name at most three. When they say "note your place", say what is done, what is missing, what is next, then wait.
+
+Research inside an axis (rip these ads, scrape these reviews) is a build burst: say the plan back in two lines, get the go, run it comprehensively, write files early, then come back to the list. Read the `thinking-vs-build` skill if installed.
+
+## The grammar
+
+**Outcome** is the spine. What the buyer wants fixed, one or two words. Each outcome breaks into sub-outcomes through five lenses: type (which kind), location (where it shows), function (what stops working), moment (when it hits), severity (how bad). Function and severity cuts make different humans (dead bedroom versus weak erections). Moment cuts usually make symptom lines, not humans.
+
+**Demographic** is what you could tick from across the room: gender, age band, race or ethnicity, buying for whom, occupation, life stage, medical identity. Include the groups the product is not for yet. Mark exclusions.
+
+**Identity** is who they say they are: the one who holds everyone together, not a pill person, the researcher, gym guy. It is its own axis in the map because the user audits it separately and it is where casting and voice come from. It also lives in Exodus as a demographic row and as a facet family, so on export the same list goes to both.
+
+**Facet** is why they are here, invisible from across the room. Four families in the map: **Belief** (what they think causes it), **State** (a condition, what they are on, what they tried), **Value** (what they prefer), **Occasion** (something that happened; it has a date). Two laws of a good facet: it is self-verifiable in one second ("do you sit six hours a day?"), and it usually carries its mechanism (sitting → blood flow), which half-explains the problem before the ad does. A facet also sets awareness: "just hit menopause" is problem-aware; "tried three cleanses that failed" is solution-aware and needs a failure-explainer, not an intro. Record awareness on the facet; never make it an axis or you count the same human five times.
+
+**Three words that are not the same thing.** A *Belief facet* is the mechanism the market already believes (cortisol, hormones, gut). The *UMP* is the mechanism a competitor sells as its positioning; competitors are grouped by UMP. The *ingredient story* is this product's mechanism per sub-outcome (star ingredient plus at most one partner plus the form factor); it lives in the folder grid and in the copy, not in Exodus. Keep the three apart in every list.
+
+**Persona** is one segment named as a human, with a self-ID line built from their words, a quote bank, and a first transplant.
+
+## Stress-test rules (apply on every axis)
+
+- One or two words per item. If it needs a sentence it is not an item yet.
+- Different human, not a synonym. Merge sub-outcomes that describe the same person.
+- Nothing in two rows. 3AM lives in Sleep, not in Menopause or Cortisol.
+- States and occasions are facets, not outcomes. "On HRT", "doctor shrugged" go under State and Occasion.
+- Mechanisms are not outcomes unless the market adopted the word as the problem (cortisol qualifies; its row holds the visible symptoms).
+- Life stages can be outcomes when buyers name the stage as the problem ("my peri symptoms"), and also stay as a layer over the other rows.
+- **The AI-artifact test.** A phrase in many ads and few human mouths ("2PM crash", "wired but tired", "brain fog") is a copy line, not a segment. Count it in reviews and comments, not in ads. Does it split the market into a different human who needs a different ad? If not, it is copy.
+- Competitor coinage ("stress bloat") is not the market's word. Map the plain word.
+- Formula fit. Drop outcomes the product cannot honestly touch.
+- Refuse new markets in disguise. A sub-outcome that needs new proof is a different account. Keep the outcome, add a facet.
+- Compliance-hot words (anxiety, panic, disease names) can be sub-outcomes, not headline outcomes. Mark them.
+- Exclusions are not segments. A contraindication goes in the medical list marked as an exclusion.
+- Check the other gender and the other ages after every facet list. The user will.
+
+**Evidence when arguing an item:** own winning ad > long-running competitor ad > comment under a running ad > review or Reddit quote > logic. Quote the proof exactly, never summarise it. Mark pure logic HYPOTHESIS. Never hide your own inventions.
+
+## Entry point 1: MAP
+
+Use when there is no agreed grid yet, whether or not winners exist.
+
+1. **Load what they have** and say it back in one paragraph: product and fixed formula, the outcome it sells today, who buys now, what is winning and fatiguing, the sister SKUs it must not collide with, and the market's words (own ads, competitors' longest-running ads, comments, reviews, Reddit). Never edit a quote.
+2. **Outcomes.** Ask for their starting list. Sort each item into outcome, Belief facet, demographic, or copy line. Propose additions from the data. Get to six to ten.
+3. **Sub-outcomes.** Three to five under each, through the five lenses. Stress-test. Then "are we missing anything" against the biggest themes in the data (energy and fatigue is the usual one).
+4. **Focus order.** Two or three lanes with a simple argument from ads, competitors, reviews, and logic. The user decides.
+5. **Demographics.** Gender, age bands, race, buying for, occupation, life stage, medical with exclusions.
+6. **Identity.** From comments, reviews, the brand's own cast, and the ads with the best hold. Include the other gender's versions.
+7. **Facets by family.** Belief, State, Value, Occasion. Sources: reviews ("what I tried", "what I replaced"), Reddit, comments, competitor ads (what they name and disqualify), logic (the conditions the category obviously has: shift worker, on a GLP-1, on an SSRI, postpartum). Each facet gets its one-second self-ID line and the mechanism it carries. Check both genders.
+8. **Ingredient story** per sub-outcome, if the user wants mechanisms in the grid: star ingredient in every one, at most one partner, plus the form factor. Supporting cast never leads.
+9. **Full list**, then the SKU collision check, then write the grid (template below), then the three homes: folder, Exodus, shareable.
+10. **Segments seen.** Keep a running list in the folder of every segment spotted in a competitor ad or the brand's own ads that is not in the grid yet ("that's always a segment too"). Add to it in every session.
+
+When ads exist, tag every ad, theirs and competitors', to one cell by its net impression. Shaded cells are taken, empty cells are gaps. Rank gaps by size, urgency of the outcome, who is already there, and zeitgeist.
+
+## Entry point 2: PERSONAS
+
+Use when the grid is agreed and the user wants humans to write for. Personas live in Exodus; the folder keeps the quote banks.
+
+1. **The tiered list**, as one numbered chat message. Every segment worth a persona in three tiers: Tier 1, you should have these (proven on two sides, or the obvious missing column); Tier 2, recommended (real signal on one side); Tier 3, could do (hypotheses, cheap to test small). Name the human, not the outcome: *HRT-and-Still Helen (Sleep → 3AM · women 45 to 60 · on HRT and still)*. Each line: name, coordinate, proof in a phrase, what changes in the ad. The user answers by number.
+2. **The persona card** for each one picked. Short, because it has to fit the dashboard:
+   - Name (the human)
+   - Coordinate: outcome → sub-outcome · demographic values · identity · one or two facets
+   - Awareness the facet sets
+   - One-second self-ID line, in their words
+   - What they tried that failed, and what they will not hear
+   - Ingredient story for this cell
+   - First transplant: which existing winner to aim at them, and the only things that change
+   - Quote bank: five to ten exact quotes with source, kept in the active brand's folder at `<brand>/state/personas/<slug>.md`, referenced from the card
+3. **Push to Exodus.** Export first, then add personas to the contract, then import.
+
+## Entry point 3: HORIZONTAL
+
+Use when a winner exists and the job is new people. Do not go horizontal too early: if two segments are printing, squeeze them first.
+
+Aim every existing winner at every new persona. Mad Libs, not rewrites. The winner's skeleton transfers word for word: sentence count, line breaks, rhythm, beat order, mechanism, proof, offer, CTA, certainty. Only the segment payload moves: the self-ID line, the symptoms and scenes, what they tried, the words from the quote bank. Most sentences of a good pass are untouched. Never add a beat, an explainer, a risk line, or an urgency line the winner does not have. Never soften a line. Then ten extra hooks per swipe in the persona's own words. A swipe that wins validates the segment. A swipe that loses says the segment is real but needs its own ad, or is not real.
+
+Hand the swipes to the writing pipeline; this skill does not write finished ads.
+
+## Exodus
+
+The dashboard map is Plan → Map. The CLI is the edit surface and the JSON contract is the document:
+
+```
+npx @aicopycoders/exodus brand current                       # right brand first
+npx @aicopycoders/exodus segment export --out segments.json   # pull the current map (empty is fine)
+# edit segments.json
+npx @aicopycoders/exodus segment import segments.json          # dry-runs, prints changes
+npx @aicopycoders/exodus segment import segments.json --yes    # only if it would delete or archive
+npx @aicopycoders/exodus segment show                          # verify
+npx @aicopycoders/exodus segment personas --json               # saved personas
+```
+
+Rules of the contract, learned the hard way:
+
+- Import is a full replace matched by name. Names missing from the file get deleted; personas they orphan get archived. The CLI refuses without `--yes` if anything would be deleted.
+- The dashboard keeps exactly five demographic rows: Buyer, Gender, Age, Race / Ethnicity, Identity. Extra rows are dropped silently. Fold life stage into Age values, occupation into Identity, medical into the State facet family.
+- Facet families in Exodus are Belief, Identity, State, Value, Occasion. Send the Identity axis to both the Identity demo row and the Identity facet family.
+- There is no ingredient-story slot. Mechanisms stay in the folder grid.
+- The persona object shape is not documented in `segment --help` and exports empty on a fresh map. Before the first persona push, export, look for an existing persona object, and if there is none, write one persona with `name`, the coordinate slugs (`outcome`, `sub`, `demos`, `facets`), and a `notes` field holding the self-ID line and first transplant, then let the dry-run tell you what the server accepts. Log the shape in tool feedback once known.
+
+## Grid template (folder copy)
+
+```
+# <Brand> — <Product> — Segment Grid (v<n>, <date>)
+
+## OUTCOMES (spine)
+| # | Outcome | Sub-outcomes |
+
+## DEMOGRAPHICS (tick from across the room)
+| Gender | Age | Race | Buying for | Occupation | Life stage | Medical (exclusions marked) |
+
+## IDENTITY (who they say they are)
+<a> · <b> · <c>
+
+## FACETS (why they're here)
+| Belief | State | Value | Occasion |
+
+## INGREDIENT STORY (star in every one; at most one partner; form factor)
+| Outcome | Sub-outcome | Lead ingredients |
+
+## FOCUS ORDER
+1. <outcome → sub · demographic · facet> — one-line argument
+
+## SEGMENTS SEEN (not in the grid yet)
+<a> · <b>
+
+## COVERAGE GRID (persona names; blank = gap)
+| Outcome | <demo col> | <demo col> | … |
+```
+
+## Worked example: Evenkeel Reset Gummies (fictional)
+
+Saffron, magnesium glycinate, rhodiola, evening gummy. Founder a former ER nurse. Sister SKUs Night Tea and Glow Collagen. Twelve tested ads, best hold on a 3AM-waking ad, "stress" ads fatiguing.
+
+**MAP, pass 1, outcomes.** User's list: stress, sleep, cortisol, menopause, mood, energy. Sorted: stress is a Belief facet and a copy line, not an outcome (three human mouths in 400 posts; "3AM" in 115). Cortisol stays (the market adopted the word). Menopause stays as an outcome and a layer. Agreed: Sleep, Mood, Cortisol, Menopause, Energy, plus Cravings from the review data.
+
+**Sub-outcomes, Sleep.** 3AM · Racing mind · Light sleep · Hangover. "Can't fall asleep" dropped: that is Night Tea's lane. Stress test moved "night sweats" out of Sleep into Menopause.
+
+**Focus order.** 1. Sleep → 3AM · women 45 to 60 · on HRT and still (own best ad, competitor Dawnfield running the 3AM angle 140 days, 115 quotes). 2. Mood → Rage · the peri woman. 3. Cravings → Night hunger, as a stack with Glow Collagen. Hold: Energy (rhodiola is a morning herb), Cortisol belly (collagen owns it).
+
+**Facets, State.** On HRT and still · Melatonin fails · Magnesium stopped · Wine to sleep · Off an SSRI (exclusion, serotonergic herb). Self-ID line for the first: "Are you on HRT and still up at 3?" Mechanism carried: HRT fixes hormones, not the night surge. Awareness: solution-aware, needs a failure-explainer. Other-gender check added: men 45+ who wake at 4AM, HYPOTHESIS.
+
+**PERSONAS, tiered list.** Tier 1: HRT-and-Still Helen (Sleep → 3AM · women 45 to 60 · on HRT and still). Tier 1: Melatonin-Fails Marie (Sleep → 3AM · women 45 to 60 · melatonin puts her down not keeps her down). Tier 2: Rage-in-the-Car Renée (Mood → Rage · women 45 to 60 · snapped at the kids). Tier 3: 4AM Frank (Sleep → 3AM · men 45+ · HYPOTHESIS). User picks 1 and 2.
+
+**Card, Helen.** Self-ID: "on HRT and still wake at 3am every night." Tried and failed: HRT, magnesium, a sleep tea. Will not hear: "manage your stress". Ingredient story: saffron + magnesium glycinate, evening gummy. First transplant: the 3AM ad, with the opening line swapped to the HRT self-ID and the "tried" beat swapped to HRT and magnesium; every other sentence untouched. Quote bank in `state/personas/hrt-and-still-helen.md`.
+
+**HORIZONTAL.** The 3AM winner is aimed at Helen and Marie. Two swipes, same skeleton, two payloads, ten hooks each in their words. Marie's swipe wins; Helen's does not. Helen is real (115 quotes) but needs her own ad with the failure-explainer up front. That goes to the writing pipeline as a brief.
+
+## What this skill is not
+
+It does not choose formats, styles, or conceits. It does not write finished ads. It does not decide the mechanism story on its own; that is the `positioning-spiral` loop calling this skill as its targets station and the `copy-instincts` skill for the story itself.
+
+## Standards
+
+Before producing anything, read `STANDARDS.md` at the workspace root (and the section for this output type). Grade the draft against it before showing it; rewrite failures first. When the user reacts with a judgment, a banking phrase, or the same note twice, hand the reaction to `remember-that`. At the end of the session, `handoff` scrapes the chat and proposes entries.

package/assets/skills/patterns-and-gaps/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: patterns-and-gaps
+description: Luke's pattern-finding and gap-finding method. Patterns are anything that occurs more often than chance and has salience, weighted by judgment, taste, and psychology, found in four places: the brand's own account, competitor accounts, organic content, and research (reviews, comments, Reddit). Gaps are what competitors and organic are doing, read through the anatomy of ads, that the brand is not doing yet, and what nobody is doing that the data says someone should. Use it whenever someone asks "what patterns do you see", "what do these have in common", "what's working across these", "what are they doing that we aren't", "where are the gaps", "what's nobody doing", "what should we steal", "compare our account to theirs", hands over a swipe file, an ad bank, a comment dump, a review corpus, or a Scout export and wants the read. Also the standing question after any rip or scrape. Patterns are found layer by layer using the anatomy-of-ads grid (WHO × WHAT × HOW × CREATIVE), so an ad set becomes comparable data before anything is counted.
+---
+
+# Patterns and gaps
+
+The whole job, underneath everything, is looking for patterns. A pattern is anything that shows up more often than it should by chance and means something. Counting finds the "more often". Judgment, taste, and psychology decide the "means something". A gap is the space between what the market has proven and what the brand is doing, or between what the data says people want and what anyone is selling.
+
+Think mode for the read, build mode for the counting. Read `thinking-vs-build` if installed.
+
+## Where patterns live
+
+Four sources, each read differently and weighted differently.
+
+| Source | What it tells you | Weight | How you read it |
+|---|---|---|---|
+| Own account | What this audience actually paid for. Hook, hold, revenue, spend. | Highest. A pattern here is proof. | Sort by result, read the top and the bottom raw, then count. |
+| Competitor accounts | What the market has paid to learn. Run-days, reuse, active count. | High, if the brand is strong (the `find-competitors` sheet says). | Longest-running first. A pattern across three or more strong brands is proven. One brand is a hypothesis. |
+| Organic content | What people share without being paid. Outliers versus a creator's average. | Medium for angles and hooks, high for zeitgeist and language. | Outliers only (a post at 10x the account's normal). The Scout library in Exodus holds these when the brand is set up. |
+| Research | Reviews, comments, Reddit, in their own words. | High for language, pain, and segments. Low for formats. | Counted mentions per term, quote banks with reference numbers, the 7-lens read. |
+
+Evidence ladder when a pattern is argued: own winning ad > long-running competitor ad > comment under a running ad > review or Reddit quote > logic. Mark logic HYPOTHESIS.
+
+## The layers (from `anatomy-of-ads`)
+
+Patterns are found layer by layer, not on the whole ad. Tag every ad with the anatomy grid first, then count per layer:
+
+- **WHO**: segment (Outcome × Demographic × Facet), persona, awareness caught at
+- **WHAT**: concept (the flat fact) · angle (the family and the role starred) · mechanism (UMP, UMS, brand gate, the name) · copy blocks present and missing · copy beats present, overbuilt, unreached
+- **HOW**: hook (which beat promoted, intensity, type) · structure (medium, skeleton, conceit, style)
+- **CREATIVE**: static (native, template type, branded) · video (conceit, actor, style, terrain, setup)
+
+The swap-cost rule orders what a pattern is worth: segment and mechanism patterns are driver-level (get them wrong and you are at zero); style and conceit patterns are cosmetic (cheap to copy, cheap to swap). A pattern in a cheap layer with the expensive layers held constant is the cheapest test in the account. Read `anatomy-of-ads` for the tag sheet and the tests per layer; the `message-isolator` Genesis bot dissects a single ad into its layers with exact quotes when one deserves the full read.
+
+## Step 1. Load and normalise
+
+Get everything into one table with the same columns, whatever the source. The ad bank is that table for own and competitor ads. For organic, the Scout export. For research, the quote banks and counts. If the sources are in different shapes, normalise before reading; a pattern across sources only shows when the columns match.
+
+Read the raw material before counting. Top ten and bottom ten by result, read in full. The pattern you feel on the read is the hypothesis the counting tests.
+
+## Step 2. Find patterns
+
+Run these operations per source, then across sources. Write the count next to every claim.
+
+**Frequency.** What repeats, per layer? Which segments, angle families, mechanism words, beats, hooks, skeletons, conceits, styles, template types. Count it. "Symptom stack → single diagnosis" appeared in nine of twenty-three cortisol competitor ads across four brands. That is a pattern. Two of twenty-three is a note.
+
+**Salience.** Of the things that repeat, which land? Weight frequency by result: hook rate and hold on own ads, run-days and reuse on competitor ads, outlier multiple on organic, helpful votes on reviews. A thing that repeats and wins outranks a thing that only repeats.
+
+**Co-occurrence.** What shows up together? Fake-authority actor with a diagnosis conceit. Timeline close with a week-by-week proof. Symptom stack with a named mechanism. These pairs are the reusable parts.
+
+**Structure.** Same idea, same beat order across brands? The order is the pattern, not the words. Write it as a sequence: slap hook → symptom list → "it's cortisol" → dismiss the alternatives → mechanism → put you on the product → timeline → offer.
+
+**Language.** Which phrases are in many ads and few human mouths (competitor coinage, copy lines) and which are in many human mouths and few ads (unclaimed language)? The second list is gold. Count both against the research corpus.
+
+**Segments seen.** Every demographic, state, or occasion a competitor calls out goes on the running list for `odf`.
+
+**Absence.** What does the top set never do? No one uses the founder. No one names the night. No one shows a man. Absence in a strong set is either a gap or a graveyard; the research decides which.
+
+**Negatives are data.** The one-star reviews, the comments that argue, the ads that died. A pattern in what fails is as useful as one in what works.
+
+Then apply judgment, taste, and psychology to rank: does the pattern explain why it works (psychology), does it feel right against everything you have seen (taste), and would it survive a hostile read (judgment)? Say which of the three you are leaning on. A pattern with a count and a psychological reason beats one with a count alone.
+
+## Step 3. Find gaps
+
+Gaps come in three kinds. Look for all three, in this order.
+
+**Kind 1: they do it, we don't.** Lay the competitor pattern set against the brand's own account, layer by layer on the anatomy grid. Every proven pattern (three or more strong brands, or one brand at 90 plus days) the brand has not run is a gap. These are the cheapest wins because the market has already paid to prove them. Output: a list of proven patterns not yet in the account, with the layer they live in and the competitor ad to model.
+
+**Kind 2: nobody does it, the data says someone should.** Lay the research against the competitor set. Words with high counts in human mouths and low counts in ads. Segments in the reviews that no strong brand addresses. A visible symptom nobody has named. An enemy nobody has blamed. A corner of a crowded mechanism word left empty (the `mechanism` skill's corner map). Output: the empty cells with the count that says they are real, marked with the evidence rung.
+
+**Kind 3: we do it, it's fatiguing, and there is a proven replacement.** The brand's own patterns that have stopped working (hook rate falling, the word "stress" in every fatiguing ad) set against what competitors run instead. Output: what to retire and what to swap in.
+
+Rank gaps by: size of the evidence, urgency of the outcome (usually the pain), how many strong brands prove it, how cheap it is to test (one cheap swap away from something proven beats a new segment), and zeitgeist. Then taste. Name the top three and stop; the rest go in the file.
+
+## Step 4. Hand back
+
+In think mode, a short list:
+
+```
+Patterns (counted, salient):
+1. <pattern> — <layer> — <count / n> — <why it works, one line>
+2. …
+Language they say that nobody sells: <word (n)> · <word (n)>
+Segments seen: <a> · <b>
+Gaps:
+1. <kind 1 / 2 / 3> — <the gap> — <evidence rung and count> — <the cheap test>
+2. …
+Hold (thin): <a> · <b>
+```
+
+In build mode, the full pattern file `<brand>/inputs/patterns-<source>-<date>.md` (inside the active brand's folder) with the operations above as sections, every count, every quote with its reference, and the gap ranking at the end. Write the "patterns across the set" section at the top of every swipe file, the way the competitor swipe already does.
+
+Hand-offs: proven patterns go to the production plan as clusters and formats; language gaps go to `mechanism` and `copy-instincts`; segment gaps go to `odf`; retire-and-swap goes to the testing plan.
+
+## Standing checks
+
+- Every pattern has a count. Every gap has an evidence rung. "Feels like" is allowed only when labelled taste.
+- The AI-artifact test on every language pattern: in ads or in mouths?
+- A pattern from one brand is a hypothesis. From one strong brand's 90-day ad it is a strong hypothesis. From three brands it is proven.
+- Absence is not automatically a gap. Check the graveyard (inactive ads with long past runs) before calling an empty space open.
+- Re-run the read after every rip, scrape, or new batch of own results. Patterns move.
+
+## Worked example (fictional)
+
+Evenkeel Reset Gummies. Own account: twelve tested ads, best hold on a 3AM-wake story, "stress" ads fatiguing. Competitor swipe: twenty ads across six strong brands. Research: 9,000 reviews across sleep and cortisol categories, quote banks counted.
+
+Patterns: symptom stack → single diagnosis (11 of 20, four brands, longest 289 days). Fake-authority diagnosis conceit (8 of 20, three brands). Named mechanism the viewer has not heard (all six brands). Week-by-week timeline close (7 of 20). Dismiss the alternatives by name (9 of 20; melatonin and magnesium named most). Language in mouths not ads: "wake up at 3am" (115 in reviews, 2 in ads), "wired but exhausted" (0 in reviews, 14 in ads: copy line, not a segment).
+
+Gaps. Kind 1: the brand has never run a symptom-stack lead or a fake-authority diagnosis; both proven across three or more brands; model the 289-day ad. Kind 2: nobody sells "stay asleep" or names the night; 115 mentions say the buyer is there; corner of cortisol is empty; the founder is an ER night nurse and no competitor uses a founder at all. Kind 3: retire the word "stress" (in all four fatiguing ads, 3 mentions in 9,000 reviews); swap in the 3AM language.
+
+Top three: symptom-stack lead aimed at the 3AM cell (kind 1, cheapest), the nurse-founder diagnosis conceit on the night corner (kind 1 and 2 together), retire "stress" for "3AM" across the account (kind 3).
+
+## What this skill is not
+
+It does not find the competitors (find-competitors), name the mechanism (mechanism), or write the ads. It reads what is there, counts it, weighs it, and says where the space is.
+
+## Standards
+
+Before producing anything, read `STANDARDS.md` at the workspace root (and the section for this output type). Grade the draft against it before showing it; rewrite failures first. When the user reacts with a judgment, a banking phrase, or the same note twice, hand the reaction to `remember-that`. At the end of the session, `handoff` scrapes the chat and proposes entries.

package/assets/skills/positioning-spiral/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: positioning-spiral
+description: The parent thinking loop for positioning a product before any ads get written. Use it whenever someone is onboarding a new brand or client, starting a new SKU, asking "who do we sell this to and what's the story", "what's the mechanism", "does this hang together", "are we positioned right", or wants segments, personas, and mechanisms figured out together. It cycles through five stations (features, targets, research, catalog, thinking) until segments, mechanisms, and story are coherent, calling the station skills (odf, mechanism, find-competitors, patterns-and-gaps) as needed. Trigger it even when the user only names one piece ("let's look at the ingredients", "find me competitors for this") if no coherent positioning exists yet, because that piece will change the others. Do not use it for writing ad copy or images; it stops when the story is coherent.
+---
+
+# Positioning Spiral
+
+Positioning is not a line. It is a spiral. The mechanism you pick depends on the segment, the segment depends on what is provable, what is provable depends on what competitors have already paid to learn, and all of it has to fit inside a catalog that already exists. So you do not do these once each. You loop through them, and each pass changes the question at the next station, until the whole thing holds together and nothing contradicts it.
+
+This skill is the parent (the positioning spiral). It decides which station to visit next, keeps the loop in think mode, and runs the exit test. The station skills do the depth. If a station skill is not installed, run that station as a conversation using the notes below.
+
+## The two modes
+
+Read the `thinking-vs-build` skill if installed. The short version:
+
+- **Think mode** is the default for this whole loop. One station per exchange. Short lists. One or two words per item. Propose, let the user cut, move on. No documents.
+- **Build bursts** happen inside a station when data needs gathering: rip these ads, scrape these reviews, pull these competitor pages. Run them comprehensively without check-ins, write files early, report spend, then come back to think mode and say what the new data changed.
+- **The exit test passing is the build cue.** Only then write the story page, the grid, and the mechanism map.
+
+The most common failure is building a document at a station that only needed a list. If the user has not said "build", "make", "write the doc", or "put that in", stay in think mode.
+
+## The five stations
+
+Each station answers one question. Each has inputs to ask for, a station skill for depth, and a note on what it tends to change elsewhere.
+
+### 1. Features: what is possible to say
+
+Ingredients first. Then everything else the brand can honestly claim: the form factor (dropper, gummy, powder), the founders and creators and their story, the brand's origin, manufacturing or sourcing facts, anything a competitor could not copy tomorrow.
+
+Ask for: the formula with doses, the product bible or spec, founder background, what the brand already says about itself.
+
+Output in think mode: a list of candidate mechanisms and story elements, one or two words each, with the ingredient or feature that backs each one. The star ingredient goes in every mechanism. Supporting ingredients never lead.
+
+Depth: `mechanism` skill (competitor mechanism file, the Genesis mechanism bots, the simplicity gates, the lock).
+
+Changes elsewhere: a mechanism the market already believes (cortisol, gut, hormones) pulls targets toward the people who use that word. A founder story pulls toward the identity axis.
+
+### 2. Targets: who is plausible
+
+Segments and personas. Outcomes the buyer wants fixed, the demographics you can tick from across the room, the identity they claim, the facets that explain why they are here now.
+
+Ask for: current buyers, the ads with the best hold, comments under running ads.
+
+Output in think mode: outcomes as one or two words with sub-outcomes beneath, then demographics, identity, facets, one axis per exchange.
+
+Depth: `odf` skill, MAP entry point. The stress-test rules there apply: different human not synonym, nothing in two rows, states and occasions are facets, copy lines are not segments.
+
+Changes elsewhere: every new segment needs a mechanism it believes and a competitor or review that proves someone like them buys. A segment with neither goes on hold.
+
+### 3. Research: what is proven, and what people already say
+
+Two halves, kept separate because they prove different things.
+
+**Competitor products.** Who is scaling, on which mechanism (their UMP, the mechanism they sell as positioning), with what offer, for how long. Group competitors by mechanism, not by category. A long-running ad is evidence the angle converts. Rip transcript, headline, body, rank, on-screen text, and keep the user's per-brand notes verbatim next to the evidence.
+
+**Voice of customer.** Reviews, comments, Reddit, in exact words. Rank sources by volume because volume is language richness. Count mentions. Keep quote banks by theme with reference numbers. Negatives are data.
+
+Ask for: the brands the user already watches and their read on each, Atria or Ad Library access, Amazon categories to shortlist.
+
+Output in think mode: the two or three angles competitors have proven, the two or three themes reviews say loudest, and one line on where they disagree with the current targets.
+
+Depth: `find-competitors` (who is strong, proven with numbers, grouped by UMP) and `patterns-and-gaps` (what repeats, what lands, what is missing).
+
+Changes elsewhere: this is where "stress" dies and "3AM waking" is born. If no competitor and no review backs a target, mark it hypothesis and move it down the focus order.
+
+### 4. Catalog: what does not collide
+
+Every proposal against the brand's other SKUs and the brand's own live ads. A sister product already claiming the mechanism is a collision. A sister product's ads targeting the same segment is a collision. The product bible saying one ingredient while the ad says another is a flag.
+
+Ask for: the full catalog with formulas, the brand's own ad account pulled by SKU.
+
+Output in think mode: one line per collision and the copy rule that resolves it ("cortisol belly belongs to the collagen; we take night cortisol").
+
+Depth: none needed; this is a scan. Run it after any new mechanism or target proposal, before the user asks. They will ask anyway.
+
+Changes elsewhere: a collision sends you back to features or targets for a lane the catalog leaves open.
+
+### 5. Thinking: the coherent story
+
+The station where the user and the skill sit with the other four and ask whether it holds. No new data. Say the story in three sentences: who, what they feel, what the product does about it and why it works. Then check it against the exit test.
+
+Output in think mode: the story in three sentences, the focus order with a simple argument from ads, competitors, reviews, and logic, and the list of what is still hypothesis.
+
+## How to run the loop
+
+1. **Load what exists and say it back in one paragraph.** Product, formula, what it sells today, who buys now, what is winning and fatiguing, the sister SKUs. If the user has tested ads, read them raw before anything else; own winning ads outrank everything.
+2. **Enter at the richest station.** Usually features if the brand is new, targets if there are tested ads, research if the user arrives with a competitor list and a hypothesis. Do not force a fixed order.
+3. **One station per exchange.** Put a short list down. Let the user cut. Name what the answer changes at other stations in one line.
+4. **Run build bursts only for data.** When a station needs a rip or a scrape, say the plan back in two lines, get the go, then run it comprehensively and report spend. Write files early so a cut connection loses nothing.
+5. **Spiral.** After each station, ask which station the new answer weakens. Go there. Typical paths: features → targets → research → targets again → catalog → features again → thinking.
+6. **Run the standing checks every pass** (below).
+7. **When the exit test passes, say so and stop.** Offer the build: story page, segment grid, mechanism map. Wait for the build cue.
+8. **When the user says "note your place"**: what is done, what is missing, what is next. Then wait.
+
+## Exit test
+
+The story is coherent when every focus segment has all five, and nothing in one row contradicts another:
+
+| Segment | Mechanism | Proof | Quote bank | Collision |
+|---|---|---|---|---|
+| one outcome × one demographic × one or two facets | star ingredient plus at most one partner plus the form factor | a scaling competitor on this angle or an own winning ad | reviews or comments in their words, with counts | none, or a copy rule that resolves it |
+
+Anything backed by logic alone is marked HYPOTHESIS and sits below the proven segments in the focus order. The story in three sentences reads the same from every row.
+
+Evidence ladder when arguing a cell: own winning ad > long-running competitor ad > comment under a running ad > review or Reddit quote > logic.
+
+## Standing checks
+
+- **Collision** after any positioning or mechanism proposal, before being asked.
+- **"Is this backed by the reviews?"** Answer with counts or say thin.
+- **"Are we missing anything?"** Check the data for the biggest themes not on the list. Name at most three.
+- **Segments seen.** Any segment spotted in a competitor ad or the brand's own ads goes on a running list, even if it is not a focus.
+- **Compliance deferred.** World of possibilities first; flag hot words, do not censor them.
+- **Use the user's taxonomy.** Outcome, sub-outcome, demographic, identity, facet. Mechanism = ingredient story. UMP = the mechanism a competitor sells.
+
+## Output when the exit test passes
+
+```
+# <Brand> — <Product> — Positioning Story (v1, <date>)
+
+## The story (three sentences)
+Who. What they feel. What the product does and why it works.
+
+## Focus segments
+| # | Segment | Mechanism | Proof | Quote bank | Collision rule |
+
+## Hold (hypothesis)
+| Segment | Why it is on hold | What would prove it |
+
+## Collisions and copy rules
+- <sister SKU> owns <angle>; we take <angle>.
+
+## Segments seen (not focus yet)
+<a> · <b> · <c>
+
+## Where the evidence lives
+| Source | Path or link |
+```
+
+Then hand off: `odf` writes the grid and the personas, `mechanism` writes the mechanism map, and the production plan follows.
+
+## Worked example: Evenkeel Reset Gummies
+
+Fictional brand, fictional competitors, fictional numbers. The shape is what matters.
+
+**Setup.** Evenkeel sells Reset Gummies: saffron extract, magnesium glycinate, rhodiola, in an evening gummy. The founder is a former ER nurse. Sister SKUs: Night Tea (sleep) and Glow Collagen, whose ads already say "lowers cortisol". Current ads say "stress relief" and are fatiguing.
+
+**Pass 1, targets.** Tested ads read raw. The best hold is on an ad about waking at 3AM, not on any stress ad. Proposed outcomes: Sleep, Mood, Stress, Cortisol, Energy. User cuts Stress to a sub-outcome: "nobody buys for stress." What this changes: features needs a mechanism for night waking.
+
+**Pass 2, features.** Saffron has mood and sleep evidence; magnesium glycinate has night waking; rhodiola is a daytime adaptogen. Candidate mechanisms: "night cortisol" (saffron + magnesium), "mood" (saffron alone), "energy" (rhodiola). Star ingredient set to saffron; it goes in every one. What this changes: research needs to prove someone buys "night cortisol".
+
+**Pass 3, research.** Competitors grouped by UMP. Dawnfield ($2M a month) runs cortisol with symptom stacks in the hook: belly, puffy face, hips, wired at night. Nuvella runs cortisol plus gut. Root & Rise runs perimenopause. Reviews: "wake at 3AM" is the top sleep phrase by count; "puffy face" appears in cortisol product reviews, not sleep ones. What this changes: cortisol is proven as a word, but the visible symptoms are body and face, which Evenkeel cannot honestly claim to fix.
+
+**Pass 4, catalog.** Glow Collagen already says "lowers cortisol" and shows belly and face. Collision. Copy rule: Collagen owns cortisol belly and face; Reset owns night cortisol and the 3AM wake. Night Tea owns "fall asleep"; Reset owns "stay asleep". What this changes: targets tighten to staying asleep, peri mood, and evening rage.
+
+**Pass 5, thinking.** Story: women 40 to 55 who fall asleep fine and wake at 3AM with a racing mind; their evening cortisol never drops; saffron and magnesium bring it down so they sleep through. Proof: Dawnfield's night ads and the 3AM count in reviews. Quote bank: sleep reviews, 3AM theme. Collision: resolved by the copy rule. Hypothesis on hold: men 35 plus who wake at 4AM, no competitor proof yet.
+
+Exit test passes on three segments. The build cue comes from the user. ODF writes the grid.
+
+## What this skill is not
+
+It does not write ads, hooks, or images. It does not choose formats or conceits. It does not replace the station skills; it sequences them. When the story is coherent, it stops.
+
+## Standards
+
+Before producing anything, read `STANDARDS.md` at the workspace root (and the section for this output type). Grade the draft against it before showing it; rewrite failures first. When the user reacts with a judgment, a banking phrase, or the same note twice, hand the reaction to `remember-that`. At the end of the session, `handoff` scrapes the chat and proposes entries.

package/assets/skills/remember-that/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: remember-that
+description: Bank a reaction so it never has to be given again. Fires the moment the user says "remember that", "lock that in", "bank that", "add that to my rules", "always do X", "never do Y", "from now on", "make sure this never happens again", or gives the same note a second time. Also fires when they react to a draft with a clear judgment ("perfect, keep that", "that joke was too much", "not like that, like this"). It quotes the reaction verbatim, decides the rung (note, rule, tool, skill), writes it to STANDARDS.md in the right section, pushes winning lines to the matching Exodus bank, offers rather than pushes anything that would change a workflow or primer, and says in one line where it went. This is the Standards Ladder's "correct once, remember forever" move, packaged.
+---
+
+# Remember that
+
+A reaction that is not banked evaporates by the next session. This skill makes the bank happen in ten seconds, without the user opening a file.
+
+Read `STANDARDS.md` first, especially "How I give feedback". It governs this skill.
+
+## When it fires
+
+- A banking phrase: remember that, lock that in, bank that, add to my rules, always, never, from now on.
+- A tool phrase: make sure this never happens again, this can never slip through, set up a check.
+- A repeat: the same note given twice in this or a previous session (the Log section shows previous ones).
+- A judgment on a draft, when "How I give feedback" allows proposals: perfect keep that, too much, not like that.
+
+If it is a judgment rather than a phrase, propose the entry and wait for a yes. Never write a rule the user has not approved.
+
+## What it does, in order
+
+1. **Quote it exactly.** The raw words, typos included. The quote is the evidence; the rule is the interpretation.
+2. **Name the rung.**
+   - Note: said once, unclear if it generalises. Log it, do not write a rule yet. Say "logged; say it again and it becomes a rule."
+   - Rule: said with "always / never / from now on", or said twice. Write the one-line rule.
+   - Tool: "make sure this never happens again", or a rule that has been broken twice since it was banked. Say it should be a tool, describe the check in one line, build it under `standards/tools/` if the user says go (a script, a lint, a checklist the skill must run). Log it under Tools.
+   - Skill: a whole job that keeps repeating. Hand to `bot-builder`.
+3. **Pick the section.** Hooks, Copy, Statics, Workflows, Skills, Gnomes, Tools. A phrase the bots over-use goes to Gnomes. A change to how a skill behaves goes to Skills. Never edit the skill file itself: `exodus update` rewrites every skill folder, so the edit would be lost. The skills read their Skills rules from `STANDARDS.md`.
+4. **Write the entry.** One line, dated, then the quote underneath:
+   ```
+   - 2026-09-14 · Open on a declarative line, never a question.
+     > "Stop opening my emails with a question. It reads soft."
+   ```
+   Add the same line to Log with the rung and the destination.
+5. **Push what belongs on the server.**
+   - A winning line the user approved (a hook, a headline, a body) → `npx @aicopycoders/exodus bank promote <key> "<text>"` with `--awareness <pair>` for body banks. Automatic when "How I give feedback" says so. Keys: `hooks`, `headlines`, `body:unawareProblemAware`, `body:solutionProductAware`, `body:mostAware`, `modules`.
+   - A style rule that should change how a pipeline writes → offer, do not push: "This would go into the brand voice (`exodus foundation set brandVoice`) or the Guidelines note on the bot nodes in your workflow (`customInstructions`; a Prompt node has no such note, its text is `promptText`). Want it there?" Only on a yes: export, edit, validate, import.
+6. **Say where it went, in one line.** "Banked as a rule under Copy, and promoted to the hooks bank." Then continue the work; do not stop the session.
+
+## Rules for the skill itself
+
+- The user is the only source of rules. Proposals wait. Nothing the AI wrote goes in as if the user said it.
+- One entry per reaction. Do not merge, generalise, or rewrite old entries. If a new one contradicts an old one, add the new one and mark the old one superseded with the date.
+- Hand-edited files are read-only. If the reaction is about a file the user touched, write the rule, do not edit the file.
+- When a section passes a page, move it to `standards/<section>.md`, leave a one-line pointer in STANDARDS.md, and say so.
+- When a rule has been broken twice since it was banked, say so and offer the tool rung. A recurring failure is not a reason to nag harder.
+- Reading rules back: "show me my rules for hooks" prints that section verbatim.
+
+## What this skill is not
+
+It does not review a whole session for things worth banking; that is `handoff`. It does not build bots; that is `bot-builder`. It catches one reaction and puts it where the system will always see it.
+
+## Changelog
+
+- 2026-09-14 · v1.

package/assets/skills/segment-grid/README.md

@@ -0,0 +1,45 @@
+# Segment Grid Kit
+
+Build a segment map (outcomes × demographics × facets) with Claude Code, then push it into Exodus. Serene Herbs (a fictional brand) and its Nervous Balance Drops are the worked example.
+
+## What's in this folder
+
+- `SKILL.md` — the method. Tell Claude Code "build the segment grid" and it walks you through it one axis at a time. The `odf` skill is the newer, fuller version of the same method; this one stays for the hand-off doc.
+
+## How to run it
+
+1. The skill is installed with Exodus. Start Claude Code in your workspace folder.
+2. Give Claude what you have: product facts and formula, current ads and results, competitor ads, reviews, comments. More human language = better facets.
+3. Say "build the segment grid". Answer in short lists. One or two words per item. Let it stress-test.
+4. When the grid is agreed, Claude writes `segment-grid.md`.
+
+## Push it into Exodus
+
+Exodus keeps the map under Plan → Map. The CLI is the edit surface:
+
+```
+npx @aicopycoders/exodus segment export --out segments.json   # pull the current map (empty is fine)
+# edit segments.json
+npx @aicopycoders/exodus segment import segments.json          # dry-runs first, then applies
+npx @aicopycoders/exodus segment show                          # verify
+```
+
+The JSON shape:
+
+```json
+{
+  "brand": "Your Brand",
+  "product": "Your Product",
+  "outcomes": [ { "name": "Sleep", "subs": [ { "name": "3AM" }, { "name": "Racing mind" } ] } ],
+  "demos":    [ { "name": "Age", "values": [ { "name": "45–60" } ] } ],
+  "facets":   [ { "name": "State", "values": [ { "name": "On HRT and still" } ] } ],
+  "personas": []
+}
+```
+
+Things to know:
+
+- Import is a full replace, matched by name. Names missing from the file get deleted; personas they orphan get archived. If anything would be deleted the CLI refuses without `--yes`.
+- The dashboard keeps exactly five demographic rows: Buyer, Gender, Age, Race / Ethnicity, Identity. Extra demo groups are dropped silently. Put life stage under Age, occupation under Identity, medical conditions under the State facet.
+- Facet families are Belief, Identity, State, Value, Occasion.
+- Make sure the right brand is active first: `npx @aicopycoders/exodus brand current`.