demiurge-peitho 0.1.0

package/CLAUDE.md

@@ -0,0 +1,84 @@
+# PEITHO companion (guided setup and ongoing help)
+
+You are Claude, reading this inside the PEITHO repo or skill folder. You are the setup companion and, after setup, the ongoing guide. One step at a time, plain language, never pressure an optional step.
+
+## What PEITHO is (tell them in one line)
+
+Every AI tool writes marketing copy. PEITHO refuses to ship a line a competitor could have written, and it will not let a headline exist before the positioning does.
+
+## When to reach for it (say this once)
+
+- **PEITHO** once something exists and must be sold: positioning, pricing, landing page, launch posts, ads, pitch, cold outreach.
+- **ATHENA** when the question is whether to enter a market or build the thing at all. Positioning is execution; that question is a decision.
+- **ZOILUS** judges the copy as an artifact. PEITHO produces it and never self-approves.
+- **PYRRHO** owns what the numbers say. No conversion claim ships without passing it.
+
+## Setup, conversationally
+
+1. **Install is one copy.** `SKILL.md`, `lib/`, `bin/` and `references/` into `~/.claude/skills/peitho/`. Show the command for their OS before running it.
+
+   PowerShell:
+   ```powershell
+   Copy-Item -Recurse . "$env:USERPROFILE\.claude\skills\peitho"
+   ```
+   bash:
+   ```bash
+   cp -r . ~/.claude/skills/peitho
+   ```
+
+2. **Check it landed.** `node bin/peitho.js setup` prints a state-aware readout.
+
+3. **Try one thing.** Have them run the line that sells the product:
+   ```powershell
+   node bin/peitho.js line "We help teams work smarter."
+   ```
+   It blocks, names the cliche it matched, and tells them what to do about it.
+
+4. **Zero config.** No API key, no account, no service. The gate runs locally with no model call.
+
+## The rule that matters most
+
+**Positioning before copy.** Do not let them ask you for a headline first. Build the positioning state file (five Dunford components, the angles with their tests, the priced offer), run `peitho check`, and only produce assets when it returns ALLOWED. This is not advice, it is a return value: `canProduceAssets` returns BLOCKED with the reasons named.
+
+If they push for copy anyway, tell them plainly: a headline written before the wedge exists is decoration. Then help them build the wedge, which takes ten minutes and is the actual work.
+
+## The second rule
+
+**PEITHO never grades its own pitch.** When copy is ready, run the ship-gate in order:
+
+1. `peitho gate <copy.md>` (blocking findings stop the ship)
+2. ZOILUS copy-critique lens (where a skeptical reader drops off), blind to the maker
+3. VERITAS anti-slop pass
+4. CALLIOPE if the asset has a visual surface. PEITHO writes the words, CALLIOPE designs the frame.
+
+If a sibling is missing, say so and continue rather than blocking. Recommend it once, never nag.
+
+## The CLI helpers (all zero-LLM)
+
+```
+peitho gate <copy.md>          the anti-generic gate on a whole page
+peitho line "<one line>"       gate a single line
+peitho hype <file|text>        scan for hype vocabulary
+peitho check <state.json>      may we produce assets yet?
+peitho position <state.json>   are all five Dunford components present?
+peitho bets <state.json>       does every angle carry a cheapest test?
+peitho setup
+```
+
+`position` and `bets` accept either a bare object or a full state file.
+
+## Ongoing companion duties (never retire)
+
+- When they write a claim about conversion, stop. Route it through PYRRHO before it reaches a page.
+- When the gate flags low specificity, remember it is a heuristic. Read the line yourself. Do not blindly rewrite good copy because a regex was unsure.
+- When the same rejection keeps firing, offer CHIRON: a rejection you keep hitting should become a permanent rule.
+- Honest limit, tell them once: PEITHO proves copy clears a gate. It cannot prove the copy sells more. That is what the cheapest test attached to every angle is for.
+
+## Laws you must not break
+
+1. Nothing generic. If a line could run unchanged on a competitor's page, it fails.
+2. Positioning before copy. No headline until the wedge exists.
+3. Every angle carries its cheapest test and the metric that decides.
+4. The customer's words, not yours.
+5. Hype omitted. Zero hype vocabulary, zero em dashes, in the product and in anything you write about it. A single em dash here is a self-own.
+6. Never claim a conversion lift without a real test.

package/LICENSE

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

package/README.md

@@ -0,0 +1,138 @@
+<div align="center">
+
+![Peitho, weighing a single word against a coin as borrowed lines turn to ash](assets/hero.png)
+
+# PEITHO: Positioning Earned, Instinct Tested, Hype Omitted
+
+*Every AI tool writes you marketing copy. PEITHO refuses to ship a line a competitor could have written.*
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-E8A23D.svg)](LICENSE)
+[![node](https://img.shields.io/badge/node-%3E%3D18-2C7A7B.svg)](package.json)
+[![tests](https://img.shields.io/badge/tests-27%2F27-2C7A7B.svg)](benchmarks/run.js)
+
+</div>
+
+**Every AI tool writes you marketing copy. PEITHO refuses to ship a line a competitor could have written.**
+
+> I am Peitho. Persuasion was my domain. I never mistook it for volume.
+
+*Positioning Earned, Instinct Tested, Hype Omitted.*
+
+Copy generators are a commodity. Every model writes a passable landing page. That is not the hard part, and it never was. The hard part is refusing the line that sounds fine and means nothing. I do that mechanically, and I do not let you write a headline before you know why anyone should choose you.
+
+## Before and after
+
+**Your AI, asked for a landing page:**
+
+> We help teams work smarter.
+
+**PEITHO, handed the same line:**
+
+```
+$ peitho line "We help teams work smarter."
+
+[blocking] generic-anywhere: cliche: matches \bwe help (?:teams|companies|businesses|people)\b
+    fix: Rewrite until the line could only belong to this offer.
+```
+
+It never reaches a page. Neither does an em dash, neither does `unleash`, and neither does a headline written before the positioning exists.
+
+## The proof, not the promise
+
+I was tested against the thing I claim to beat. Same product, same brief. One landing page written by a single-shot "write me a landing page" prompt. One written through my pipeline: position, offer, assets, gate.
+
+Two independent critics scored both. Neither knew how either page was made. They were shown the pages **in opposite orders** to control for position bias.
+
+| | one-shot | PEITHO pipeline |
+|---|---|---|
+| Critic 1 (control first) | 6/10 | **8/10** |
+| Critic 2 (pipeline first) | 6/10 | **8/10** |
+| Deterministic gate | 7 blocking findings, 10 em dashes | **passed clean** |
+| Chosen by | | **both critics** |
+
+**The honest caveat:** one of the two critics still passed the one-shot page, weakly, calling it "a strong 40-line page wearing a 114-line page." So "the one-shot fails" held for one critic of two, not both. The pipeline won on every measure taken. It did not annihilate the control, and I will not tell you it did.
+
+## The five laws
+
+1. **Nothing generic.** If a line could run unchanged on a competitor's page, it fails. Checked against a cliche corpus and a specificity test, not against my feelings.
+2. **Positioning before copy.** No hooks, no headlines, no ads until the wedge exists. `peitho check` returns BLOCKED until all five positioning components are present, every angle carries a test, and the offer is priced.
+3. **Every angle carries its cheapest test.** Name the two angles you would bet budget on, how to test each this week, and the metric that decides. An untested angle is a guess wearing a suit.
+4. **The customer's words, not yours.** Lead with the outcome they want, in their language. Features are not benefits.
+5. **Hype omitted.** Zero hype vocabulary. Zero em dashes. Checked, not trusted.
+
+And one structural law: **I never grade my own pitch.** The ship-gate hands the copy to ZOILUS (where does a skeptical reader drop off) and VERITAS (anti-slop). A seller marking its own homework is how generic copy ships.
+
+And the reader-side counterpart: **the zero-context test.** Copy is judged as the coldest reader, someone who has seen none of the strategy, the roadmap, or this conversation. If that reader cannot understand the line and act on it, the line does not ship, however good it sounds to the room that wrote it.
+
+## A gate that knows what it does not know
+
+The gate separates two things on purpose:
+
+- **Blocking**: a demonstrable cliche, hype vocabulary, an em dash. Provable. Stops the ship.
+- **Flag**: low specificity. A heuristic. It warns, it does not block.
+
+Because a rule that blocks real copy on a guess is worse than the generic line it was hunting. The test suite pins this: `It never sees who wrote the code.` flags but does not block, while `We help companies save time and money.` blocks.
+
+## Install for your agent
+
+> **From npm:** `npm install -g demiurge-peitho`, then `peitho setup` — or `npx demiurge-peitho gate <copy.md>` with no install. (Skill copy uses the source clone below.)
+
+PowerShell:
+```powershell
+git clone https://github.com/eragonlonelyboy-lab/peitho; cd peitho; node bin/peitho.js setup
+```
+bash:
+```bash
+git clone https://github.com/eragonlonelyboy-lab/peitho && cd peitho && node bin/peitho.js setup
+```
+
+Copy the folder into `~/.claude/skills/peitho/` and invoke with `/peitho`. Zero config. The CLI is the deterministic half:
+
+```
+peitho gate <copy.md>        the anti-generic gate on a whole page
+peitho line "<one line>"     gate a single line
+peitho hype <file>           scan for hype vocabulary
+peitho check <state.json>    may we produce assets yet?
+peitho position <state.json> are all five Dunford components present?
+peitho bets <state.json>     does every angle carry a cheapest test?
+```
+
+## Not for you if
+
+- You want copy fast and you do not care whether anyone could tell it apart from your competitor's.
+- You want a tool that tells you the copy will convert. It cannot, and it says so.
+- You want to skip positioning. `peitho check` will not let you, and that is the product.
+
+## FAQ
+
+**"So it is a copywriter."**
+No. Every model is a copywriter. I am the thing that refuses what the copywriter produced.
+
+**"Can you prove your copy sells more?"**
+No, and be suspicious of anyone who says they can without a real test. I can prove copy clears a gate. Claiming a conversion lift without running the experiment is precisely what I exist to prevent. Before any numeric claim ships, it passes PYRRHO.
+
+**"Your cliche list will go stale."**
+It will. Language moves and a finite corpus lags it. See [HONEST-NUMBERS](docs/HONEST-NUMBERS.md), where I list what I miss.
+
+**"Why can't I write the headline first?"**
+Because a headline written before the wedge is decoration. `peitho check` returns BLOCKED and names what is missing. It is a return value, not advice.
+
+## The family
+
+**ATHENA** decides whether to enter the market. **PEITHO** executes the go-to-market once the decision is made. **ZOILUS** judges the copy as an artifact. **VERITAS** cleans the prose. **CALLIOPE** designs the frame, I write the words, in that order. **PYRRHO** owns what the numbers say, so no conversion claim ships without passing it.
+
+**HORKOS** proves the campaign shipped. **MONETA** budgets the loop. **CHIRON** turns a repeated rejection into a rule.
+
+The working standard the whole house runs on is public too: [ARETE](https://github.com/eragonlonelyboy-lab/arete), five discipline gates any model can run. PEITHO's zero-context test is its reporting gate, applied to a landing page.
+
+## Verify me
+
+```bash
+node benchmarks/run.js   # 27/27
+```
+
+If PEITHO stops one borrowed line from reaching your landing page, star it. If it does not, do not.
+
+MIT. Copyright (c) 2026 Lee Jun Ying. Built by Eragon Lee.
+
+*Named for Peitho, Greek goddess of persuasion and charming speech.*

package/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: peitho
+description: The go-to-market god. Use PEITHO to position, price, and sell anything you have built: the wedge, the offer, the landing page, the launch post, the ads, the pitch, the cold outreach. It refuses to write a headline before the positioning exists, rejects any line a competitor could have written unchanged, and makes every angle carry the cheapest test that would settle it. Trigger on "position this", "write the landing page", "how do I launch this", "price this", "/peitho". Not for deciding WHETHER to enter a market (that is ATHENA), and it never grades its own pitch (that is ZOILUS).
+---
+
+# PEITHO: the go-to-market god
+
+> Peitho, goddess of persuasion and charming speech. Persuasion was her domain; she never mistook it for volume.
+
+**Every AI tool writes you marketing copy. PEITHO refuses to ship a line a competitor could have written.**
+
+Copy generators are a commodity. Every model writes a passable landing page. PEITHO's value is not the copy, it is the discipline around the copy: positioning before words, a gate that rejects the generic, and a cheapest test attached to every claim you intend to bet on.
+
+## When to use / when not
+
+- **Use PEITHO** once something exists and must be sold: positioning, pricing, landing page, launch posts, ads, pitch decks, cold outreach, content.
+- **Not for deciding whether** to enter a market, build the thing, or pursue a strategy. That is **ATHENA** (wisdom of a decision). Positioning is execution.
+- **PEITHO never grades its own pitch.** The ship-gate delegates to **ZOILUS** (copy-critique: where does a skeptical reader drop off) and **VERITAS** (anti-slop). A seller marking its own homework is how generic copy ships.
+
+## The five laws (non-negotiable)
+
+**Zero-context handoff test.** Before a sales or launch asset ships, give only the artifact, offer facts and target reader to a fresh reviewer. It must identify the audience, promise, proof, action and major caveat without access to the maker's reasoning. If it cannot, the handoff failed even when the original team agrees with the copy.
+
+1. **Nothing generic.** If a line could run unchanged on a competitor's page, it fails. `peitho gate` enforces this mechanically: cliche corpus, plus a specificity test (no number, no proper noun, no quoted term means the line could name any product).
+2. **Positioning before copy.** No hooks, no headlines, no ads until the wedge exists. `peitho check` refuses to let the assets stage run until all five Dunford components are present, every angle carries a test, and the offer is priced.
+3. **Every angle carries its cheapest test.** Name the two angles you would bet real budget on and how to test each this week, plus the metric that decides. An untested angle is a guess wearing a suit.
+4. **The customer's words, not yours.** Lead with the outcome the customer wants, in their language. Features are not benefits.
+5. **Hype omitted.** Zero hype vocabulary, zero em dashes. Checked, not trusted.
+
+## The lifecycle
+
+**Mode 0 - WHAT TO SELL** (optional, upstream). Venture ideas matched to real skills, budget and time, each with a buyer, a first-ten-customers plan, unit economics, and the one risk to test cheaply this month.
+
+**Mode 1 - POSITION** (nothing else runs first). Load the reference, do not work from memory.
+- **Dunford positioning** (`references/positioning.md`): the five components, and the statement template `For [segment] who [need], [offer] is the [category] that [key benefit], unlike [alternative], because [proof].` Plus three differentiated messaging hooks and the "where your positioning is weak" note.
+- **Seven angles** (`references/positioning.md`), one per named psychological driver: status, fear of missing out, identity, ease, speed, belonging, transformation. Then the two you would bet budget on and a cheap test for each this week.
+- **Competitor teardown** (`references/competitor-teardown.md`): six sections, label anything speculative, name the one thing of theirs you should NOT copy because it only works at their scale, end with "The wedge:" and one sentence.
+- **SWOT** (`references/swot.md`): 3 to 4 points per quadrant, internal and external split, two cross-pairs (Strength x Opportunity, Weakness x Threat), end with "This month:".
+- **Output:** positioning statement, the wedge line, two bets, their tests. Validate with `peitho position` and `peitho bets`.
+
+**Mode 2 - OFFER** (`references/offer-pricing.md`). Score the offer out of 10 on clarity, desirability and believability, each with the reason and what would raise it. Surface the **five** objections most likely to kill the sale, not three. Give the price verdict (too high, too low, or mismatched) with a better-fitting model, three ways to make it a no-brainer, and end with "The tightened offer:" and one sentence. **Output:** offer, price, guarantee, five objections with answers.
+
+**Mode 3 - ASSETS** (only once `peitho check` says ALLOWED). **Each asset has a reference file carrying its section structure, named taxonomies, constraints and quality bar. Load it. Do not write the asset from memory.**
+
+| Asset | Reference | The structure it must not lose |
+|---|---|---|
+| Landing page | `references/assets/landing-page.md` | 11 labelled sections, grade 6 reading level |
+| Hooks | `references/assets/hooks.md` | 10 hooks, one per named angle, ranked top 3 |
+| Ads | `references/assets/ads.md` | 8 variations, one per named angle, which two to test and the deciding metric |
+| Pitch deck | `references/assets/pitch-deck.md` | 10 slides in order, 3 parts each |
+| Cold outreach | `references/assets/cold-outreach.md` | 3 versions under 90 words, plus the 4-day follow-up |
+| Sales objections | `references/assets/sales-objections.md` | **seven** objections including the unspoken ones, 4 parts each |
+| Content calendar | `references/assets/content-calendar.md` | 30 days across 4 journey stages, 80/20 value ratio |
+| Content kit | `references/assets/content-kit.md` | 6 sections, every quote findable word for word |
+| Long-form script | `references/assets/long-form-script.md` | 5-second hook, re-hook, open loops, pattern interrupt |
+| Newsletter | `references/assets/newsletter.md` | subject plus 2 alternatives, preview text, one idea only |
+| Persuasive case | `references/assets/persuasive-case.md` | 5 parts, `[ADD SOURCE]` rather than an invented source |
+| Business ideas (Mode 0) | `references/assets/business-ideas.md` | 7 ideas, 6-part format, ranked top 3 by fit |
+
+Every reference also carries that prompt's **intake questions**. Ask them before producing. An asset written before its intake is answered is decoration.
+
+**Mode 4 - GATE** (before anything ships).
+1. `peitho gate <copy>`, the anti-generic gate. Blocking findings stop the ship.
+2. **ZOILUS copy-critique lens**, where a skeptical, time-poor reader drops off; the dead weight; the one highest-leverage fix. Blind to the maker.
+3. **VERITAS**, anti-slop pass, voice preserved.
+4. **CALLIOPE** if the asset has a visual surface. PEITHO writes the words, CALLIOPE designs the frame, in that order.
+
+Fail the gate, rewrite, re-run. Budget-capped, like every Demiurge loop.
+
+## Boundaries (do not blur the pantheon)
+
+- **ATHENA** decides. PEITHO executes go-to-market once the decision is made.
+- **ZOILUS** judges the copy as an artifact. PEITHO produces it and never self-approves.
+- **VERITAS** owns prose hygiene. PEITHO composes with it, never reimplements it.
+- **CALLIOPE** owns the visual. PEITHO owns the words.
+- **PYRRHO** owns what the numbers say. If PEITHO wants to claim a result, PYRRHO decides whether the data carries it. No conversion-lift claim ships without passing PYRRHO.
+- **HORKOS** proves it shipped. **MONETA** budgets. **CHIRON** turns a repeated rejection into a rule.
+
+## Honest limit
+PEITHO can prove its copy clears a gate. It cannot prove the copy sells more. Anyone claiming a numeric conversion lift without a real test is doing exactly what this god exists to prevent. See `docs/HONEST-NUMBERS.md`.
+
+## Sibling recommendation
+On setup, detect installed siblings and recommend only the missing natural pairs: ZOILUS (the copy gate), VERITAS (anti-slop), CALLIOPE (the visual half), PYRRHO (before any numeric claim).

package/bin/peitho.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+'use strict';
+// peitho, the go-to-market god. Deterministic CLI half (zero-LLM): the
+// anti-generic gate, the positioning-before-copy check, the every-angle-has-a-test
+// check. The persuasion is skill-driven (SKILL.md); this is what refuses to ship.
+const fs = require('fs');
+const { gateCopy, gateLine, scanHype } = require('../lib/gate');
+const { canProduceAssets, validatePositioning, validateAngles, screenIdeas } = require('../lib/pipeline');
+const siblings = require('../lib/siblings');
+const pkg = require('../package.json');
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+const out = (s) => process.stdout.write(s + '\n');
+const readJson = (f) => JSON.parse(fs.readFileSync(f, 'utf8'));
+
+switch (cmd) {
+  case '--version': case '-v': out(`peitho ${pkg.version}`); break;
+
+  case 'gate': {
+    const file = args[1];
+    if (!file || !fs.existsSync(file)) { out('usage: peitho gate <copy.md>'); process.exit(1); }
+    const r = gateCopy(fs.readFileSync(file, 'utf8'));
+    if (r.pass) { out('PASS: no generic lines, no hype, no em dashes.'); break; }
+    out(`FAIL: ${r.blocking} blocking finding(s).\n`);
+    for (const l of r.perLine) {
+      out(`  line ${l.line}: ${l.text}`);
+      for (const f of l.findings) out(`    [${f.severity}] ${f.id}: ${f.summary}\n      fix: ${f.fix}`);
+    }
+    process.exit(1);
+    break;
+  }
+
+  case 'line': {
+    const line = args.slice(1).join(' ');
+    if (!line) { out('usage: peitho line "<one line of copy>"'); process.exit(1); }
+    const r = gateLine(line);
+    if (r.pass) { out('PASS'); break; }
+    for (const f of r.findings) out(`[${f.severity}] ${f.id}: ${f.summary}\n    fix: ${f.fix}`);
+    process.exit(1);
+    break;
+  }
+
+  case 'hype': {
+    const file = args[1];
+    const text = file && fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : args.slice(1).join(' ');
+    const hits = scanHype(text);
+    out(hits.length ? 'hype words: ' + hits.join(', ') : 'no hype words.');
+    process.exit(hits.length ? 1 : 0);
+    break;
+  }
+
+  case 'check': {
+    // peitho check state.json  -> may we produce assets yet?
+    const file = args[1];
+    if (!file || !fs.existsSync(file)) { out('usage: peitho check <state.json>'); process.exit(1); }
+    const r = canProduceAssets(readJson(file));
+    if (r.allowed) { out('ALLOWED: positioning locked, every angle carries a test, offer priced. Assets may be produced.'); break; }
+    out('BLOCKED: you do not get a headline yet.');
+    for (const b of r.blockers) out('  - ' + b);
+    process.exit(1);
+    break;
+  }
+
+  case 'position': {
+    const file = args[1];
+    if (!file || !fs.existsSync(file)) { out('usage: peitho position <positioning.json | state.json>'); process.exit(1); }
+    const doc = readJson(file);
+    const r = validatePositioning(doc && doc.positioning ? doc.positioning : doc); // accept a full state file too
+    out(r.ok ? 'OK: all five positioning components present.' : 'INCOMPLETE: missing ' + r.missing.join(', '));
+    process.exit(r.ok ? 0 : 1);
+    break;
+  }
+
+  case 'bets': {
+    const file = args[1];
+    if (!file || !fs.existsSync(file)) { out('usage: peitho bets <angles.json | state.json>'); process.exit(1); }
+    const doc = readJson(file);
+    const r = validateAngles(Array.isArray(doc) ? doc : (doc && doc.angles)); // accept a full state file too
+    out(r.ok ? `OK: ${r.count} angle(s), every one carries a test and a metric.` : `FAIL: angles without a cheapest test: ${r.untested.join(', ')}`);
+    process.exit(r.ok ? 0 : 1);
+    break;
+  }
+
+  case 'ideas': {
+    const file = args[1];
+    if (!file || !fs.existsSync(file)) { out('usage: peitho ideas <ideas.json>   (Mode 0: what to sell)'); process.exit(1); }
+    const doc = readJson(file);
+    const r = screenIdeas(Array.isArray(doc) ? doc : (doc && doc.ideas));
+    if (r.ok) { out(`OK: ${r.count} idea(s), each with a buyer, a first-ten plan, unit economics and a cheap risk test.`); break; }
+    out('INCOMPLETE: an idea without a buyer, unit economics and a cheap risk test is a daydream.');
+    for (const i of r.incomplete) out(`  - ${i.name}: missing ${i.missing.join(', ')}`);
+    process.exit(1);
+    break;
+  }
+
+  case 'siblings': {
+    const s = siblings.detect();
+    out('installed: ' + (s.installed.join(', ') || 'none'));
+    const rec = siblings.recommend(s.installed);
+    out('recommended (missing ship-gate pairs): ' + (rec.map((r) => r.name).join(', ') || 'none, the gate is complete'));
+    for (const r of rec) out(`  - ${r.name}: ${r.why}`);
+    break;
+  }
+
+  case 'gate-route': {
+    const stage = args[1];
+    if (!stage) { out('usage: peitho gate-route <copy-critique|anti-slop|visual|numeric-claim>'); break; }
+    out(`${stage} -> ${siblings.routeGate(stage)}`);
+    break;
+  }
+
+  case 'setup': {
+    out('PEITHO setup check');
+    out('------------------');
+    out(`  SKILL.md : ${fs.existsSync(__dirname + '/../SKILL.md') ? 'yes' : 'MISSING'}`);
+    out('');
+    out('PEITHO is skill-first: invoke it with /peitho or "position and launch this".');
+    out('This CLI is the deterministic half: the anti-generic gate and the positioning-before-copy law.');
+    out('PEITHO writes. ZOILUS judges the copy. VERITAS cleans it. CALLIOPE designs the frame.');
+    out('It never grades its own pitch.');
+    break;
+  }
+
+  default:
+    out(`peitho ${pkg.version}, positioning earned, instinct tested, hype omitted`);
+    out('');
+    out('  peitho gate <copy.md>        the anti-generic gate on a whole page');
+    out('  peitho line "<one line>"     gate a single line');
+    out('  peitho hype <file|text>      scan for hype vocabulary');
+    out('  peitho check <state.json>    may we produce assets yet? (positioning first)');
+    out('  peitho position <p.json>     are all five Dunford components present?');
+    out('  peitho bets <angles.json>    does every angle carry a cheapest test?');
+    out('  peitho ideas <ideas.json>    Mode 0: does each idea carry a buyer and a cheap risk test?');
+    out('  peitho siblings              detect installed Demiurge gods');
+    out('  peitho gate-route <stage>    which god owns this ship-gate stage');
+    out('  peitho setup');
+}

package/docs/HONEST-NUMBERS.md

@@ -0,0 +1,38 @@
+# HONEST-NUMBERS
+
+Every claim PEITHO makes about itself, and every one it cannot make. A product whose first law is "nothing generic" does not get to sell itself with a generic claim.
+
+## What is checkable
+
+`node benchmarks/run.js` runs 27 deterministic tests, no model involved. They prove:
+
+- **The gate rejects the demonstrably borrowed.** `We help teams work smarter.` blocks on the cliche corpus. `Unleash your revolutionary workflow.` blocks on hype vocabulary. Any em dash blocks.
+- **The gate does not reject the specific.** `PEITHO refuses to ship a line a competitor could have written.` passes. `Reviews 145 prompts and rejects 35 of them.` passes. An ALL-CAPS brand token counts as specificity even at the start of a line.
+- **Positioning before copy is a return value.** `canProduceAssets` returns BLOCKED, with the reasons named, until all five Dunford components exist, every angle carries a test and a metric, and the offer has a price and its killing objections. A headline cannot be produced from positioning alone.
+- **An angle without a cheapest test is rejected**, and zero angles does not quietly count as "all angles tested."
+
+## The blind A/B, with its caveat
+
+PEITHO's pipeline was tested against a single-shot "write me a landing page" prompt on the same product with the same brief. Two independent critics scored both pages against the ZOILUS copy-critique rubric. Neither knew how either page was produced, and they were shown the pages in opposite orders to control for position bias.
+
+Both critics scored the pipeline page 8/10 and the one-shot 6/10. Both chose the pipeline page. The deterministic gate found 7 blocking findings and 10 em dashes in the one-shot; the pipeline page passed clean.
+
+**The caveat, stated plainly:** one of the two critics still passed the one-shot page, weakly. The intended criterion was "the one-shot does not pass." That held for one critic of two. The pipeline won on every measure taken. It did not annihilate the control.
+
+Two critics is not a study. It is one honest test, run once, reported with its limits.
+
+## What is NOT checkable
+
+**PEITHO cannot prove the copy converts.** It proves copy clears a gate. Conversion is an empirical question about your market, and answering it requires running the test PEITHO tells you to run. Any tool claiming a conversion lift without that test is doing exactly what this one exists to prevent. Before any numeric claim ships, it passes PYRRHO.
+
+**The low-specificity check is a heuristic.** It flags rather than blocks, deliberately, because a rule that blocks real copy on a guess is worse than the generic line it was hunting. It will miss a thoroughly generic line dressed in a proper noun, and it will flag a good short sentence that happens to carry no number or name.
+
+**The cliche corpus is finite and will lag language.** Today's fresh phrasing is next year's entry. The corpus is plain markdown in `lib/gate.js`; when a new cliche escapes it, add it. Absence from the corpus is not proof a line is original.
+
+**Taste is not fully checkable.** The gate catches the provable failures. Whether the copy is actually persuasive, whether the wedge is the right wedge, whether a reader cares: those are judgments. That is why the ship-gate delegates to ZOILUS and VERITAS rather than pretending its own taste is oracle.
+
+**Positioning validation is structural, not semantic.** `peitho position` confirms all five Dunford components are present. It cannot confirm they are true, or that your claimed unique attribute is actually unique. It checks that you did the work, not that the work was right.
+
+## What it costs
+
+Nothing to run the gate. It is a skill and a zero-LLM CLI; the corpus checks and the pipeline validation run locally with no model call. The writing is done by whatever agent invoked the skill, and the ship-gate calls ZOILUS and VERITAS, each of which costs whatever they cost.

package/lib/gate.js

@@ -0,0 +1,132 @@
+'use strict';
+// gate.js, the anti-generic gate.
+// Law 1: if a line could run unchanged on a competitor's page, it fails.
+// Law 5: hype omitted, zero em dashes. Both are checkable, so we check them
+// rather than trusting a model to feel bad about writing "unleash".
+
+const HYPE = [
+  'unleash', 'game-changer', 'game changer', 'game-changing', 'revolutionary', 'revolutionize',
+  'elevate', 'seamless', 'seamlessly', 'cutting-edge', 'state-of-the-art', 'best-in-class',
+  'next level', 'next-level', 'supercharge', 'turbocharge', 'delve', 'harness the power',
+  'empower', 'synergy', 'paradigm shift', 'disruptive', 'world-changing', 'transformative',
+  'work smarter', 'take it to the next level', 'unlock the power', 'navigate the landscape',
+  'in today’s world', 'in today\'s world', 'robust solution', 'holistic solution',
+];
+
+// Lines that could belong to any company in any industry.
+const CLICHE = [
+  /\bwe help (?:teams|companies|businesses|people)\b/i,
+  /\bwork smarter\b/i,
+  /\bsave time and money\b/i,
+  /\bbuilt for (?:the )?modern\b/i,
+  /\bthe future of\b/i,
+  /\ball[- ]in[- ]one (?:platform|solution)\b/i,
+  /\bpowerful(?:ly)? (?:simple|easy)\b/i,
+  /\bdesigned to help you\b/i,
+  /\btake your \w+ to the next level\b/i,
+  /\bmade simple\b/i,
+];
+
+// CHI-R001: spell the banned characters as escapes so this lint never matches
+// itself, and so a bulk "strip the em dashes" pass cannot silently rewrite the
+// detector into one that flags ordinary hyphens. (It did, once. Hence the rule.)
+const EM_DASH = /[\u2014\u2013]/;
+
+// An inline code span is a quoted token, not shipped prose. Naming the word you
+// ban is not using it. Strip `like this` before judging a line, or the gate
+// flags your own documentation. Same family as CHI-R001: a lint must never match
+// the act of describing what it forbids.
+function stripInlineCode(text) {
+  return String(text || '').replace(/`[^`]*`/g, ' ');
+}
+
+function scanHype(text) {
+  const t = stripInlineCode(text).toLowerCase();
+  return HYPE.filter((h) => t.includes(h.toLowerCase()));
+}
+
+function hasEmDash(text) { return EM_DASH.test(String(text || '')); }
+
+// Specificity signals: a digit, a quoted term, an ALL-CAPS brand token anywhere
+// (PEITHO, ZOILUS), or a capitalised word past the first (which would otherwise
+// just be the sentence-initial capital).
+function hasSpecificity(s) {
+  if (/\d/.test(s)) return true;
+  if (/["“].+?["”]/.test(s)) return true;
+  const words = s.split(/\s+/);
+  if (words.some((w) => /^[A-Z]{2,}[A-Z0-9]*[.,!?]?$/.test(w))) return true; // ALL-CAPS brand
+  return words.slice(1).some((w) => /^[A-Z][a-zA-Z]{2,}/.test(w));
+}
+
+// Two distinct failures, deliberately weighted differently:
+//   cliche  -> demonstrable, blocking. The line is provably borrowed.
+//   low specificity -> a heuristic, so it flags rather than blocks. A rule that
+//   blocks real copy on a guess is worse than the generic line it was hunting.
+function genericAnywhere(line) {
+  const raw = String(line || '').trim();
+  if (!raw) return { generic: false, blocking: false, reasons: [] };
+  const s = stripInlineCode(raw).trim(); // a named example is not a shipped claim
+  if (!s) return { generic: false, blocking: false, reasons: [] };
+  const reasons = [];
+  let blocking = false;
+
+  for (const re of CLICHE) {
+    if (re.test(s)) { reasons.push(`cliche: matches ${re.source}`); blocking = true; }
+  }
+  if (!hasSpecificity(s)) {
+    reasons.push('low specificity: no number, no proper noun, no quoted term. Check that this line could only belong to this offer.');
+  }
+  return { generic: reasons.length > 0, blocking, reasons };
+}
+
+// Gate a single line. pass = zero BLOCKING findings (flags are advisory).
+function gateLine(line) {
+  const findings = [];
+  const hype = scanHype(line);
+  if (hype.length) findings.push({ severity: 'blocking', id: 'hype-vocabulary', summary: `Hype words present: ${hype.join(', ')}`, fix: 'Say the specific thing instead.' });
+  if (hasEmDash(line)) findings.push({ severity: 'blocking', id: 'em-dash', summary: 'Em or en dash present.', fix: 'Use a comma, a period, or a colon.' });
+  const g = genericAnywhere(line);
+  if (g.blocking) {
+    findings.push({ severity: 'blocking', id: 'generic-anywhere', summary: g.reasons.filter((r) => r.startsWith('cliche')).join(' | '), fix: 'Rewrite until the line could only belong to this offer.' });
+  } else if (g.generic) {
+    findings.push({ severity: 'major', id: 'low-specificity', summary: g.reasons.join(' | '), fix: 'Add the number, the name, or the concrete noun that makes this yours.' });
+  }
+  const blocking = findings.filter((f) => f.severity === 'blocking').length;
+  return { pass: blocking === 0, blocking, findings };
+}
+
+// Gate a whole block of copy, line by line. Structure and quoted material are
+// not claims you are shipping, so they are exempt: blank lines, headings, rules,
+// fenced code, and blockquotes. A blockquote is usually the bad example you are
+// holding up to mock, and gating it would flag your own before-and-after.
+function gateCopy(text) {
+  const lines = String(text || '').split('\n');
+  const perLine = [];
+  let inFence = false;
+  lines.forEach((raw, i) => {
+    const line = raw.trim();
+    if (/^(```|~~~)/.test(line)) { inFence = !inFence; return; }
+    if (inFence) return;
+    if (!line || /^#{1,6}\s/.test(line) || /^[-*_]{3,}$/.test(line) || /^>/.test(line)) return;
+    const r = gateLine(line);
+    if (r.findings.length) perLine.push({ line: i + 1, text: line, findings: r.findings });
+  });
+  const blocking = perLine.reduce((n, l) => n + l.findings.filter((f) => f.severity === 'blocking').length, 0);
+  const flags = perLine.reduce((n, l) => n + l.findings.filter((f) => f.severity === 'major').length, 0);
+  return { pass: blocking === 0, blocking, flags, perLine };
+}
+
+// The fresh reviewer supplies only what they can recover from the artifact.
+// This gate compares that zero-context readback with the offer owner's facts;
+// agreement inside the producing session is deliberately irrelevant.
+function zeroContextHandoff(expected = {}, observed = {}) {
+  const fields = ['audience', 'promise', 'proof', 'action', 'caveat'];
+  const missing = fields.filter((k) => !String(observed[k] || '').trim());
+  const mismatched = fields.filter((k) => {
+    if (!String(observed[k] || '').trim() || !String(expected[k] || '').trim()) return false;
+    return String(observed[k]).trim().toLowerCase() !== String(expected[k]).trim().toLowerCase();
+  });
+  return { pass: missing.length === 0 && mismatched.length === 0, missing, mismatched };
+}
+
+module.exports = { gateLine, gateCopy, zeroContextHandoff, scanHype, hasEmDash, genericAnywhere, HYPE, CLICHE };