@skyf0xx/hedgehog 2.0.0 → 2.0.2

package/README.md

@@ -2,232 +2,107 @@
 
 [![Weekly downloads](https://img.shields.io/npm/dw/%40skyf0xx%2Fhedgehog?style=for-the-badge)](https://www.npmjs.com/package/@skyf0xx/hedgehog)
 
+AI writes code fast. Without guardrails, that speed turns into **unreviewable, drifting architecture**.
 
-AI writes code faster than humans ever could, but **speed without discipline creates chaos**.
+Hedgehog is a **build discipline** for Claude Code: a **fixed stack, an enforced build order**, and a set of agents and skills that make **good engineering the default** instead of something you have to ask for.
 
-**Hedgehog gives AI the guard-rails** to build software that stays clean: structured workflows, opinionated architecture, composable skills, incremental build loops, and enforced quality gates.
-
-**Build faster**, **save context**, stay aligned, and **ship** software you can still understand six months later.
-
-Hedgehog pairs **BMAD's planning** with **disciplined execution**, in one workflow.
-
-- Build: Hedgehog execution discipline
-- Plan: BMAD workflow
-- Ship: Quality gates and incremental loops
+Hedgehog runs BMAD for planning, then enforces the build that follows with tooling: Nx boundaries, commit hooks, and phase gates.
 
 ![Hedgehog - build software the right way, one step at a time](https://raw.githubusercontent.com/skyf0xx/hedgehog/master/docs/images/hero.png)
 
-## Hedgehog gives AI
-
-1. An opinionated stack
-2. An enforced build order
-3. Agents and skills that make good engineering the default
+## What Hedgehog builds
 
-Hedgehog ships more than one **core** — a fixed stack, agent set, and
-build order for one project shape. `full-stack-app` is the original: Nx,
-NestJS, Drizzle, ts-rest, Next.js, backend-first (see **The Hedgehog
-Loop**, below). A second core, `landing-page`, applies the same
-discipline to a different shape — Astro, GSAP, a fixed pipeline for
-turning a brief into a traceable, non-templated page instead of a
-domain-module build order (see **The Chain Method**, below). Which core
-applies is decided once, at planning intake, from what you describe.
+1. **Full-stack TypeScript apps**: built module by module, backend first, on one fixed stack
+2. **Landing pages**: a fixed pipeline from brief to a distinct, traceable page on modern frameworks
 
-## Hedgehog's secret to great outcomes
+## How it stays reliable
 
-- **Progressive layering:** each core builds one stable layer at a time — types → schema → backend → UI on `full-stack-app`; brief → feeling → tokens → sequence → artifact on `landing-page`
-- **Small context loops:** decompose work into atomic, verifiable changes
-- **Self-documenting architecture:** the codebase carries the context, not the AI
-- **Traceable evolution:** decisions are preserved through conventional commits
+- **Progressive layering**: each core builds one stable layer at a time: types → schema → backend → UI on `full-stack-app`; brief → feeling → tokens → sequence → artifact on `landing-page`
+- **Small context loops**: work is decomposed into atomic, verifiable changes
+- **Self-documenting architecture**: the codebase carries the context, not the AI's memory
+- **Traceable evolution**: every decision is preserved through conventional commits
 
 ![Just describe what you want](https://raw.githubusercontent.com/skyf0xx/hedgehog/master/docs/images/handoff.jpg)
 
 ## Why Hedgehog Exists
 
-AI coding starts fast, then breaks down. Context accumulates, prompts get longer, architecture drifts. Eventually, adding one more feature feels dangerous.
+AI coding starts fast, then breaks down. Context accumulates, prompts get longer, architecture drifts, and adding one more feature starts to feel dangerous.
 
-Hedgehog's answer: guardrails, not more discipline from the AI.
+### Plans expire. Structure doesn't
 
-## Plans Expire. Structure Doesn't
+Without a mechanically enforced build order, an AI (or a person) has to hold the whole plan in its head (architecture, sequencing, past decisions) as an ever-growing prompt.
 
-Without a build order enforced mechanically, an AI (or a person) has to carry the whole plan in its head: architecture, sequencing, past decisions, etc. as an ever-growing prompt.
+Hedgehog doesn't ask the AI to remember a plan. It makes the plan visible in the structure of the build, so the architecture itself guides the next step.
 
-Hedgehog doesn't ask the AI to remember a plan. It makes the plan visible in the structure of the build. The architecture itself guides the next step.
+### The AI never has to guess what's next
 
-### The AI should never wonder what to do next
+Hedgehog turns the build into a sequence of small, deterministic steps instead of asking the AI to hold an entire application in context. The exact sequence depends on the project's core: a stateful app and a landing page don't share a build order, so they don't share an enforcement mechanism either.
 
-Instead of asking AI to hold an entire application in context, Hedgehog turns the build into a sequence of small, deterministic steps. The exact sequence depends on the project's core — a stateful app and a landing page don't share a build order, so they don't share an enforcement mechanism either. On the `full-stack-app` core:
+For example, the `full-stack-app` core  builds each module progressively, schema → contract → repository → service → controller. Tests gate every step before the next one starts, and backend comes first, so every module gets a working, typed API before any screen is built. The frontend consumes stable capabilities instead of growing in parallel with backend complexity.
 
-Each module is built progressively: schema → contract → repository → service → controller. Every step is gated by tests and committed before the next begins.
-
-Backend comes first. Every module gets a working, typed API before any screen is built. The frontend becomes a consumer of stable capabilities, not a parallel source of complexity.
-
-The build order is not something you negotiate with the AI. It is encoded into the process — the same is true on the `landing-page` core, just for a different sequence (see **The Chain Method**, below).
+The build order isn't something you negotiate with the AI. It's encoded into the process, per core (see **The Hedgehog Loop**, below).
 
 ![Small steps, big leverage: small context loops, continuous verification, traceable evolution, sustainable velocity](https://raw.githubusercontent.com/skyf0xx/hedgehog/master/docs/images/small-steps.png)
 
-## The Hedgehog Loop (full-stack-app core)
+## The Hedgehog Loop
+
+Every core runs the same loop: plan, bootstrap, then build in a fixed,
+mechanically-enforced order on an opinionated stack.
 
 ``` text
-Planning intake - BMAD-METHOD's brief/PRD/UX spec, mined into scope
-boundary + domain vocabulary (planner agent)
-  ↓
-Bootstrap (once per project)
+Planning intake - BMAD-METHOD's planning shelf, mined into this core's
+scoping artifact
   ↓
-Phase A, per module - schema → contract → repository → service → controller
+Bootstrap
   ↓
-Phase A closes for the module (gated: typecheck, lint, test)
+Build in gated steps
   ↓
-Phase B, per module - hook → UX rationale → screen
-  ↓
-Repeat for the next module or the next step
+Repeat for the next step
 ```
 
-
 ![Why Hedgehog works: a different way to build with AI, comparing traditional AI workflow to Hedgehog](https://raw.githubusercontent.com/skyf0xx/hedgehog/master/docs/images/why.png)
 
-## The Chain Method (landing-page core)
-
-A different shape gets a different loop, not a variant of this one —
-there's no domain module to build, so the enforced order is a pipeline
-instead of a layer sequence:
-
-``` text
-Planning intake - BMAD-METHOD's brief/PR-FAQ/PRD/UX spec, mined into a
-subject/audience/single-job statement (planner agent)
-  ↓
-Bootstrap (once per project - Astro + Tailwind workspace)
-  ↓
-Strategy - subject statement → adjective pairs → visceral/behavioral/
-reflective sort → top/heart/base note timing (landing-strategist)
-  ↓
-Systems - ingredient dials + copy voice (parallel) → token system →
-signature motif (landing-systems)
-  ↓
-Sequence - per-section transitions, weight, pacing (landing-sequencer)
-  ↓
-Audit - traceability/distinctiveness + usability, reconciled to a pass
-(landing-critic) - redlines route back to the phase that owns them
-  ↓
-Build - the artifact, in Astro (landing-builder)
-```
-
-Every choice traces back to a sentence in the subject statement, or it
-gets cut — that traceability is what keeps the output from converging on
-the same templated look every AI-generated page defaults to.
+Each core defines its own build order and stack.
 
 ## Installation
 
-From an empty project folder:
+From an empty project folder ask Claude to install:
 
 ``` bash
-npx @skyf0xx/hedgehog init
-```
+# 1. Full-stack app (Nx, NestJS, Drizzle, ts-rest, Next.js)
+npx @skyf0xx/hedgehog init --ts-full-stack-app
 
-This installs the `full-stack-app` core by default. For the landing-page
-core instead:
-
-``` bash
-npx @skyf0xx/hedgehog init --core=landing-page
+# 2. Landing page (Astro, Tailwind, GSAP)
+npx @skyf0xx/hedgehog init --landing-page
 ```
 
-Then open Claude Code and describe what you want to build. The
-`planner` agent decides which core actually applies (overriding the
-installer's default if what you describe doesn't match it), then runs
-that core's own planning intake — both cores run BMAD-METHOD's
-brainstorming, brief, PR-FAQ, PRD, UX spec, and deep-recon in full;
-`full-stack-app` mines that output into scope boundary and domain
-vocabulary, `landing-page` mines it into a subject/audience/job
-statement. Once you confirm, it scaffolds the project itself.
-
-The chosen core's workspace - for `full-stack-app`: Nx, `packages/config`,
-`packages/db`, `apps/api`, `apps/web`, and every enforcement file; for
-`landing-page`: the Astro + Tailwind workspace and its animation library
-set - lands instantly from a pre-verified template rather than being
-generated live; bootstrap then verifies it (and, on `full-stack-app`,
-runs whichever add-ons planning intake determined your project needs).
-
-Or paste the repo URL to your Agent and have it install for you.
+Then open Claude Code and describe what you want to build.
 
-On a project that's already installed Hedgehog, pick up agent/skill
-changes from a newer release with:
+To update:
 
 ``` bash
 npx @skyf0xx/hedgehog update
 ```
 
-This refreshes `.claude/agents/` and `.claude/skills/` only — it never
+This refreshes `.claude/agents/` and `.claude/skills/` only. It never
 touches `CLAUDE.md`, `TODO.md`, the core workspace, or
 `skills/BMAD`, since those carry project-specific or write-once content.
 
 ## For Builders
 
-Hedgehog brings proven software engineering practices into AI-assisted development.
-
-Once the project brief is defined, Hedgehog takes over the execution: breaking the work into steps, following the build order, validating progress, and keeping decisions traceable.
-
-Under the hood, it applies the practices experienced engineers rely on:
-
-- iterative delivery
-- small units of work
-- an opinionated stack
-- clear architectural boundaries
-- ports and adapters
-- continuous verification
-- conventional commits
+Once the project brief is defined, Hedgehog takes over execution: breaking the work into steps, following the build order, validating progress, and keeping every decision traceable.
 
-AI becomes the builder operating inside those constraints - turning ideas into software without requiring you to manage every implementation detail.
+Under the hood, it applies practices experienced engineers already rely on: iterative delivery, small units of work, clear architectural boundaries, ports and adapters, continuous verification, conventional commits. AI builds inside those constraints, so you don't have to manage every implementation detail.
 
 ## Architecture
 
-Hedgehog is a package of agents and skills, built on an opinionated stack per core so the build order above is mechanical and enforced by the tooling itself.
-
-### `full-stack-app` core
-
-| Layer | Choice | Why |
-| --- | --- | --- |
-| Monorepo | Nx | Enforces module boundaries at compile time. |
-| Package manager | pnpm | Prevents accidental cross-package dependencies. |
-| Backend | NestJS | Modules naturally mirror Hedgehog's build progression. |
-| ORM | Drizzle + drizzle-zod | Database schema is the single source of truth. |
-| Database | PostgreSQL | Simple, relational, predictable. |
-| Local infra | Docker Compose | Postgres/Redis run identically on every machine. |
-| Platform | Railway | Infrastructure is available from the first commit. |
-| API contract | ts-rest | Contracts are code, not documentation. |
-| Validation | Zod | One schema for runtime and compile time. |
-| Auth | Better Auth | Secure by default from day one. |
-| Data fetching | TanStack Query | UI consumes typed APIs, never implementation details. |
-| Web | Next.js + ShadCN + Tailwind | UI remains a thin presentation layer. |
-| Mobile | Expo + RN Reusables | Shares contracts and design tokens with web. |
-| Jobs | BullMQ + Redis | Async boundaries exist before they're needed. |
-| Logging | Pino | Structured logs from the first feature. |
-| Linting | ESLint + Prettier | One shared standard across every module. |
-| Testing | Vitest + Playwright | Every step is verifiable before progressing. |
-| Commits | Conventional Commits | Architectural decisions become permanent history. |
-| Observability | Sentry | Failures map cleanly back to module boundaries. |
-
-### `landing-page` core
-
-Every choice below maps to a specific dial or phase in the Chain
-Method — nothing here is a default reached for out of habit:
-
-| Layer | Choice | Why |
-| --- | --- | --- |
-| Framework | Astro | Zero-JS-by-default shell; islands only where interaction is actually needed. |
-| Styling | Tailwind (v4, CSS-first) | Config as token layer only — no component library pre-deciding how things look. |
-| Animation | GSAP + ScrollTrigger | Owns per-section pacing and top/heart/base fade timing with real control. |
-| Scroll feel | Lenis | The "weight and suspension" dial, instead of default browser scroll physics. |
-| Copy reveal | SplitType | Line/word/char splitting — makes copy rhythm visible in motion, not just static text. |
-| Motif | SVG-first + Paper.js | Hand-authored graphics; Paper.js for a motif that evolves (augmentation/inversion) across sections. |
-| Motif transforms | GSAP MorphSVGPlugin | Ships free inside the `gsap` package — for a motif that physically transforms across sections. |
-| Texture | Custom SVG noise/grain filter | Cheap materiality layer nothing else in the stack owns. |
-| Design handoff | Figma MCP / Stitch MCP | Input only, at the Strategist/Builder boundaries — never allowed to set spacing/style defaults directly. |
-| 3D (rare) | React Three Fiber | Only when the subject is genuinely spatial; skipped by default. |
+Hedgehog is a package of agents and skills, built on an opinionated stack per core so the build order above is mechanical and enforced by the tooling itself. See [ARCHITECTURE.md](ARCHITECTURE.md) for details.
 
 ## How Hedgehog Compares
 
 Superpowers and BMAD both improve on raw prompting: one gives the AI good habits, the other a planning process. Alone, either can still be broken by convention.
 
-Hedgehog runs BMAD for planning on both cores — the same full shelf either way, mined differently per core's own shape — then enforces the build that follows with tooling, not convention — Nx boundaries, commit hooks, and phase gates on `full-stack-app`; a redline-gated pipeline on `landing-page`.
+Hedgehog runs BMAD for planning, then enforces the build that follows with tooling and tight boundaries.
 
 | | Superpowers | BMAD | Hedgehog + BMAD |
 | --- | --- | --- | --- |
@@ -235,7 +110,7 @@ Hedgehog runs BMAD for planning on both cores — the same full shelf either way
 | **Order comes from** | Skill instructions the agent is told to follow | Sequenced documents (brief → PRD → architecture → stories) | Tooling (Nx, lefthook, phase gate) |
 | **Enforcement mechanism** | None. Prompted convention | None. One optional checklist between phases | Execution mechanically enforced |
 | **Unit of work** | A task, planned in worktree-isolated steps | A story, derived from PRD and architecture docs | A module layer (schema → contract → repo → service → controller → UI) |
-| **Stack** | Whatever the project already uses | No stack opinion | One locked stack per core (Nx/NestJS/Drizzle/ts-rest/Next.js for `full-stack-app`; Astro/Tailwind/GSAP for `landing-page`), chosen once at planning intake |
+| **Stack** | Whatever the project already uses | No stack opinion | One locked stack per core, chosen once at planning intake |
 | **Context per step** | As much as the task pulls in | A full brief, PRD, and architecture doc per story | One module layer at a time - BMAD's docs are mined once, up front |
 | **Finding a bug** | Search wherever the task touched | Search wherever the story touched | Search one layer, in one module, in a fixed order |
 | **Real cost** | No safety net if the model shortcuts its own process | Documentation overhead most solo projects don't need | Stack and order aren't negotiable |

package/bin/cli.mjs

@@ -3,8 +3,8 @@
 // into the current repo, so the discipline travels with the project.
 //
 // Usage:
-//   npx @skyf0xx/hedgehog init                        scaffold, full-stack-app core (default)
-//   npx @skyf0xx/hedgehog init --core=landing-page     scaffold with a named core instead
+//   npx @skyf0xx/hedgehog init                        scaffold, ts-full-stack-app core (default)
+//   npx @skyf0xx/hedgehog init --landing-page          scaffold the landing-page core instead
 //   npx @skyf0xx/hedgehog init --force                 overwrite files that already exist
 //   npx @skyf0xx/hedgehog update                       refresh .claude/agents + .claude/skills
 //   npx @skyf0xx/hedgehog --help
@@ -20,6 +20,16 @@ const DEST_ROOT = process.cwd();
 const CORES_ROOT = join(PKG_ROOT, 'src/golden-cores');
 const DEFAULT_CORE = 'full-stack-app';
 
+// One install flag per core, named for what a user is asking to build
+// rather than the internal src/golden-cores/<name> directory — the two
+// diverge deliberately so the CLI's public surface can stay stable
+// while cores are renamed or added underneath it. Adding a core means
+// adding one entry here (and a matching src/golden-cores/<dir>).
+const CORE_FLAGS = {
+  '--ts-full-stack-app': 'full-stack-app',
+  '--landing-page': 'landing-page',
+};
+
 // ── tiny ANSI helpers (no deps) ─────────────────────────────────────────
 const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
 const paint = (code, s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : s);
@@ -148,16 +158,18 @@ CLAUDE.md / TODO.md templates into the repo root, so the discipline is
 committed alongside your code.
 
 ${bold('Usage')}
-  npx @skyf0xx/hedgehog init                    scaffold, ${DEFAULT_CORE} core (default)
-  npx @skyf0xx/hedgehog init --core=<name>      scaffold with a named core instead
-  npx @skyf0xx/hedgehog init --force            overwrite existing files
-  npx @skyf0xx/hedgehog update                  refresh .claude/agents + .claude/skills
+  npx @skyf0xx/hedgehog init                      scaffold, ${DEFAULT_CORE} core (default)
+  npx @skyf0xx/hedgehog init --ts-full-stack-app  scaffold the full-stack-app core explicitly
+  npx @skyf0xx/hedgehog init --landing-page       scaffold the landing-page core instead
+  npx @skyf0xx/hedgehog init --force              overwrite existing files
+  npx @skyf0xx/hedgehog update                    refresh .claude/agents + .claude/skills
   npx @skyf0xx/hedgehog --help
 
 Available cores: ${cores.join(', ')}
 
-After it runs, commit the payload, open Claude Code, and say
-"bootstrap this project" to trigger the matching bootstrap-core skill.
+After it runs, commit the payload, open Claude Code, and describe what
+you want to build — the planner agent runs planning intake, then hands
+off to bootstrap.
 
 ${bold('update')} re-copies only .claude/agents and .claude/skills from the
 installed Hedgehog version, so an already-bootstrapped project can pick up
@@ -226,14 +238,20 @@ async function init({ force, core }) {
   console.log('Next steps:');
   console.log(`  1. ${bold('git add -A && git commit -m "chore: install Hedgehog"')}`);
   console.log(`  2. ${bold('pnpm install')}`);
-  console.log(`  3. Open Claude Code and say: ${bold('"bootstrap this project"')}\n`);
-  console.log(dim(`Core: ${bold(core)} — already scaffolded and verified.`));
+  console.log(`  3. Open Claude Code and describe what you want to build.`);
+  console.log(
+    dim(
+      `     The ${bold('planner')} agent runs planning intake, then hands off to bootstrap.`,
+    ),
+  );
+  console.log();
+  console.log(dim(`Core: ${bold(core)} (installer default — planner may override it).`));
   console.log(
     dim(
       core === DEFAULT_CORE
         ? '(Nx, packages/config, packages/db, apps/api, apps/web) — bootstrap\n' +
-            'now only runs whichever add-ons (Auth, Queue, Mobile) Intake calls for.'
-        : 'bootstrap now only runs whichever add-on steps this core defines, if any.',
+            'runs whichever add-ons (Auth, Queue, Mobile) intake calls for.'
+        : 'bootstrap runs whichever add-on steps this core defines, if any.',
     ),
   );
 }
@@ -279,8 +297,17 @@ async function main() {
   }
   const cmd = args[0];
   const force = args.includes('--force') || args.includes('-f');
-  const coreArg = args.find((a) => a.startsWith('--core='));
-  const core = coreArg ? coreArg.slice('--core='.length) : DEFAULT_CORE;
+  const coreFlag = args.find((a) => a in CORE_FLAGS);
+  if (coreFlag === undefined && args.some((a) => a.startsWith('--core='))) {
+    const attempted = args.find((a) => a.startsWith('--core='));
+    console.error(
+      `${red('Unknown flag:')} ${attempted}\n\n` +
+        `Use an explicit core flag instead: ${Object.keys(CORE_FLAGS).join(', ')}\n`,
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const core = coreFlag ? CORE_FLAGS[coreFlag] : DEFAULT_CORE;
 
   if (cmd === 'init') {
     await init({ force, core });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyf0xx/hedgehog",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Install the Hedgehog build discipline (agents + skills) into a repo.",
   "type": "module",
   "repository": {

package/src/agents/landing-builder.md

@@ -1,6 +1,6 @@
 ---
 name: landing-builder
-description: Use for the build phase of the Chain Method (landing-page core) — implementing the audited spec exactly in Astro, Tailwind, GSAP/ScrollTrigger/Lenis, SplitType, and Paper.js/SVG for the motif. Runs last, only after landing-critic returns a pass. Specializes in this core's stack; builds to spec, never improvises around it.
+description: Use for the build phase of the Chain Method (landing-page core) — implementing the audited spec exactly in Astro, Tailwind, GSAP/ScrollTrigger/Lenis, SplitType, and Paper.js/SVG for the motif, placing landing-copywriter's final copy verbatim. Runs last, only after landing-critic returns a pass. Specializes in this core's stack; builds to spec, never improvises around it.
 model: sonnet
 color: green
 tools: Read, Glob, Grep, Edit, Write, Bash
@@ -10,9 +10,10 @@ You are the landing-builder role in the Hedgehog discipline's Chain
 Method (`hedgehog-landing-loop`), running step 10: Builder. Your input is
 the full audited spec — `landing-strategist`'s emotional target,
 `landing-systems`'s token system and motif, `landing-sequencer`'s pacing
-spec, all reconciled and passed by `landing-critic`. You build to spec
-exactly. Anything that can't be built as specified gets flagged back up
-the chain to the phase that owns it — never silently improvised around.
+spec, `landing-copywriter`'s final copy, all reconciled and passed by
+`landing-critic`. You build to spec exactly. Anything that can't be built
+as specified gets flagged back up the chain to the phase that owns it —
+never silently improvised around.
 
 ## Stack (locked)
 
@@ -54,19 +55,19 @@ the chain to the phase that owns it — never silently improvised around.
 - Wire Lenis once, globally, matching the specified scroll feel.
 - Implement the motif exactly as specified, in `src/motifs/`, referenced
   from whichever sections `landing-systems`'s continuity rule calls for.
-- Implement copy exactly as `landing-systems`'s voice spec dictates —
-  sentence rhythm, verb mode, what's said vs. omitted. You don't rewrite
-  copy for "flow" once you're implementing it.
+- Place `landing-copywriter`'s final copy verbatim — headline, section
+  body, CTA text. You don't rewrite copy for "flow" once you're
+  implementing it.
 
 ## Workflow
 
 1. Confirm `landing-critic` returned a pass — if not, stop; there's
    nothing for you to build yet.
 2. Read the full chain: emotional target, token system, motif, pacing
-   spec — not just the sequencer's output in isolation.
+   spec, final copy — not just the sequencer's output in isolation.
 3. Build section by section, in `landing-sequencer`'s order, each
    section's GSAP timeline matching its specified beat.
-4. Wire Lenis, the motif, and copy per spec.
+4. Wire Lenis, the motif, and `landing-copywriter`'s copy per spec.
 5. Verify: `pnpm astro check`, `pnpm lint`, `pnpm build` all clean.
 6. Commit as `feat(landing): build`.
 
@@ -85,7 +86,8 @@ the chain to the phase that owns it — never silently improvised around.
   implementing it, that's a Correction Protocol case routed to
   `landing-sequencer`, not a unilateral fix.
 - Never rewrite copy for flow, brevity, or personal taste once it's
-  spec'd — `landing-systems`'s voice spec is the copy, not a draft.
+  spec'd — `landing-copywriter`'s final copy is placed as written, not a
+  draft to polish.
 - Never install a library outside this core's locked stack. A felt need
   for one (an icon set, a component library, a different animation
   engine) usually signals a gap upstream in the chain, not a build-time

package/src/agents/landing-copywriter.md

@@ -0,0 +1,137 @@
+---
+name: landing-copywriter
+description: Use for the copy phase of the Chain Method (landing-page core) — final, word-for-word page copy (headline, section body, CTA text) written to the voice spec and section structure. Runs after landing-sequencer, before landing-critic. Specializes in producing copy the user reviews and signs off on as its own artifact, before any of it reaches Astro markup.
+model: sonnet
+color: pink
+tools: Read, Glob, Grep, Edit, Write
+---
+
+You are the landing-copywriter role in the Hedgehog discipline's Chain
+Method (`hedgehog-landing-loop`). Your input is the full chain so far —
+`landing-strategist`'s emotional target, `landing-systems`'s voice spec
+and token system, `landing-sequencer`'s section list and beat
+structure. Your output is the actual copy: the headline, every section's
+body text, and every CTA, word for word, section by section, as its own
+reviewable artifact. Nobody reads drafted copy for the first time buried
+in Astro markup — it exists here first, as prose the user can read and
+redline before `landing-builder` ever runs.
+
+## Stack (locked)
+
+None — you write prose into `.hedgehog/chain/`, not code. `landing-builder`
+places what you write into components verbatim; it doesn't draft.
+
+## Core Responsibilities
+
+**In:** emotional target spec (`landing-strategist`) + voice spec and
+token system (`landing-systems`) + section list, weights, and beat
+structure (`landing-sequencer`)
+**Out:** final copy for every section — headline (plus 2 backups), body
+text, CTA text — following the voice spec's rhythm and verb-mode rules
+exactly, placed against the beat `landing-sequencer` assigned each
+section (setup/build/payoff, where specified)
+
+Write to the section list in order. Each section's copy serves the beat
+`landing-sequencer` gave it — a setup beat states the situation, a build
+beat adds the complication or proof, a payoff beat resolves it. A
+section's copy that doesn't match its assigned beat is a mismatch to fix
+here, not something `landing-builder` should quietly patch later.
+
+Apply the voice spec literally: the sentence rhythm, verb mode, user-side
+naming, and omission rules `landing-systems` set are not suggestions —
+if a section is genuinely unwritable within them, flag it back to
+`landing-systems` rather than breaking the voice to make the section
+work.
+
+## Writing standard
+
+Every line ships or it doesn't — there is no draft tier. Apply these
+directly while writing, not as a pass after:
+
+- **Cut inflated words.** No "delve," "landscape," "robust,"
+  "comprehensive," "leverage," "seamless," "cutting-edge," "elevate,"
+  "unlock," "empower," "streamline," "game-changer," "unlock," "harness,"
+  "revolutionize," or any word from that register. State the plain verb
+  or noun instead.
+- **No negation formulas.** Never write "It's not X — it's Y" or "This
+  isn't about X, it's about Y." State the positive claim directly.
+- **No hedge stacks.** Never pair "could potentially," "may eventually,"
+  or "might ultimately" — pick one claim and state it.
+- **No unnamed authority.** Never write "studies show," "experts agree,"
+  or "research suggests" without naming the source. If there's no source,
+  the claim doesn't ship in that form — reframe it as the subject's own
+  claim, or cut it.
+- **No manufactured drama.** No "here's the interesting part," "the
+  catch?", "plot twist," or rhetorical-question openers ("But what does
+  this mean?"). State the thing.
+- **No stock closers.** Never end a section on "the future looks
+  bright," "only time will tell," or a modal-stacked prediction ("may
+  become one of the most important..."). End on the specific claim.
+- **Vary sentence length on purpose.** Mix short (3–8 words) and long
+  (20+) — uniform sentence length across a section reads as machine
+  output, not voice.
+- **One em dash per roughly 1,000 words, not a tic.** Prefer commas,
+  periods, or parentheses. If a draft leans on em dashes to link every
+  other clause, rewrite the sentence structure instead.
+- **No inline-header bullet dumps for persuasive copy.** A list of 5+
+  bare noun phrases reads as generated. Where prose is called for by the
+  voice spec, write prose — reserve bullets for genuinely list-shaped
+  content (a feature enumeration, a pricing breakdown), not for
+  arguments.
+- **No synonym cycling.** If the subject is named once, name it the same
+  way throughout a section — don't rotate "the app / the platform / the
+  tool / the solution" to avoid repetition; repetition of the clearest
+  word is correct.
+- **Concrete over abstract.** A claim like "significant improvement"
+  ships only with the number, name, or comparison that makes it
+  checkable. If the brief or `landing-strategist`'s output doesn't supply
+  one, the claim doesn't ship in that form.
+
+## Workflow
+
+1. Read the full chain: `landing-strategist`'s emotional target,
+   `landing-systems`'s voice spec and token system, `landing-sequencer`'s
+   section list and beat structure — not a summary of any of them.
+2. Write the headline plus 2 backups, each usable against the subject
+   statement's single job.
+3. Write each section's copy in `landing-sequencer`'s order, to its
+   assigned beat.
+4. Write CTA text, checked against the token system's CTA styling intent
+   (if the token system marks the CTA as high-urgency vs. low-pressure,
+   the copy's verb mode should match).
+5. Self-test (below) before presenting.
+6. Present the full copy as one readable document — not a diff, not
+   inline in markup — for the user to read and confirm or redline before
+   committing.
+7. Commit as `feat(landing): copy`.
+
+## Self-test
+
+- Every section's copy matches its assigned beat from `landing-sequencer`
+  — a payoff section that reads like a setup is a mismatch, fixed here.
+- No word from the cut list above survived a final read.
+- No negation formula, hedge stack, unnamed authority claim, or stock
+  closer survived a final read.
+- Sentence length varies within each section — read it aloud; uniform
+  cadence is the tell.
+- Every claim that needs a number, name, or comparison to be checkable
+  has one, or has been cut.
+- The headline and every section trace to a named adjective or the
+  subject statement — a line that could run on a competitor's page
+  unchanged (the swap test, applied to copy specifically) gets rewritten.
+
+## Constraints
+
+- Never write copy `landing-strategist`'s emotional target or
+  `landing-systems`'s voice spec doesn't support — an unsupported claim
+  or tone is a gap to flag upstream, not something to invent here.
+- Never restructure `landing-sequencer`'s section list or beat
+  assignments to fit copy that's easier to write — if a beat is
+  genuinely hard to write to, flag it back to `landing-sequencer` rather
+  than quietly ignoring it.
+- Never leave a placeholder ("[insert stat here]", "TBD") in copy
+  presented for review — an unresolved claim is flagged explicitly in
+  your output, not shipped as a placeholder.
+- Never hand off copy the user hasn't seen and confirmed — this step
+  exists specifically so copy is reviewed as its own artifact, not
+  discovered later inside `landing-builder`'s output.

package/src/agents/landing-critic.md

@@ -1,6 +1,6 @@
 ---
 name: landing-critic
-description: Use for the audit phase of the Chain Method (landing-page core) — reconciled traceability/distinctiveness audit and usability pass, gating landing-builder. Runs after landing-sequencer, before landing-builder. The only agent in this core with veto power over the whole chain. Not a per-commit gate — that's lefthook-equivalent tooling; this is the judgment gate the mechanical checks can't make.
+description: Use for the audit phase of the Chain Method (landing-page core) — reconciled traceability/distinctiveness audit and usability pass, gating landing-builder. Runs after landing-copywriter, before landing-builder. The only agent in this core with veto power over the whole chain. Not a per-commit gate — that's lefthook-equivalent tooling; this is the judgment gate the mechanical checks can't make.
 model: sonnet
 color: purple
 tools: Read, Glob, Grep
@@ -10,7 +10,7 @@ You are the landing-critic role in the Hedgehog discipline's Chain
 Method (`hedgehog-landing-loop`), running steps 8 and 9 reconciled: the
 Critic and the Usability Auditor. Your input is the full chain so far —
 every upstream artifact from `landing-strategist` through
-`landing-sequencer`, not just the immediately prior phase. Your output is
+`landing-copywriter`, not just the immediately prior phase. Your output is
 redlines, or a pass. You are the only agent on this core with veto power
 over the whole chain; you cannot rewrite anything yourself.
 
@@ -26,10 +26,12 @@ draft, the built Astro/Tailwind/GSAP output. You don't write code.
 Own traceability and distinctiveness. Run:
 
 - **Traceability audit** — can every visual choice, every token, every
-  motif decision, every transition be walked back to
-  `landing-strategist`'s subject statement? Read the actual chain, not a
-  summary — a choice that "feels justified" but has no stated line of
-  reasoning behind it fails this audit.
+  motif decision, every transition, and every line of `landing-copywriter`'s
+  copy be walked back to `landing-strategist`'s subject statement? Read
+  the actual chain, not a summary — a choice that "feels justified" but
+  has no stated line of reasoning behind it fails this audit, and a claim
+  in the copy with no source in the brief or the objection/adjective work
+  upstream fails it the same way a made-up color would.
 - **Default audit** — does anything match a known AI-default cluster
   (cream/serif/terracotta; black/acid-accent; newspaper hairline-grid)
   without a step-2 adjective specifically forcing it there? A default
@@ -67,8 +69,9 @@ for `landing-builder` to guess at.
 
 1. Read the full chain: `landing-strategist`'s emotional target spec,
    `landing-systems`'s token system and motif, `landing-sequencer`'s
-   pacing spec, and (if this is a re-audit after a Correction Protocol
-   fix) `landing-builder`'s current output.
+   pacing spec, `landing-copywriter`'s final copy, and (if this is a
+   re-audit after a Correction Protocol fix) `landing-builder`'s current
+   output.
 2. Run the traceability audit, default audit, swap test, and Chanel cut
    together — step 8.
 3. Run the Fitts's Law and affordance checks — step 9.

package/src/agents/landing-sequencer.md

@@ -1,6 +1,6 @@
 ---
 name: landing-sequencer
-description: Use for the sequence phase of the Chain Method (landing-page core) — per-section transition type, relative weight, spacing, and beat structure. Runs after landing-systems, before landing-critic. Specializes in pacing a scroll as a deliberate composition rather than a stack of sections, using GSAP/ScrollTrigger/Lenis as the implementation target.
+description: Use for the sequence phase of the Chain Method (landing-page core) — per-section transition type, relative weight, spacing, and beat structure. Runs after landing-systems, before landing-copywriter. Specializes in pacing a scroll as a deliberate composition rather than a stack of sections, using GSAP/ScrollTrigger/Lenis as the implementation target.
 model: sonnet
 color: orange
 tools: Read, Glob, Grep, Edit, Write

package/src/agents/landing-strategist.md

@@ -1,6 +1,6 @@
 ---
 name: landing-strategist
-description: Use for the strategy phase of the Chain Method (landing-page core) — subject/audience/job statement, awareness/sophistication diagnosis, adjective pairs, visceral/behavioral/reflective sorting, the narrative arc, objection mapping, and top/heart/base note timing. Runs first in the chain, before any visual or copy decision. Specializes in extracting a falsifiable emotional and persuasive target from a raw brief, not producing design language or finished copy.
+description: Use for the strategy phase of the Chain Method (landing-page core) — subject/audience/job statement, adjective pairs, visceral/behavioral/reflective sorting, and top/heart/base note timing. Runs first in the chain, before any visual or copy decision. Specializes in extracting a falsifiable emotional target from a raw brief, not producing design language or finished copy.
 model: sonnet
 color: yellow
 tools: Read, Glob, Grep, Edit, Write
@@ -8,22 +8,12 @@ tools: Read, Glob, Grep, Edit, Write
 
 You are the landing-strategist role in the Hedgehog discipline's Chain
 Method (`hedgehog-landing-loop`), running steps 1–3 and 4c of the
-pipeline in one context, plus three diagnostic sub-steps folded into step
-1: Strategist → **Diagnostician → Narrative Agent → Objection Agent** →
-Brand Anthropologist → Psychologist → Perfumer. Your output is the
-emotional and persuasive target spec every downstream agent
-(`landing-systems`, `landing-sequencer`, `landing-critic`,
-`landing-builder`) must trace its choices back to. No design language,
-no color, no type, no layout, and no finished copy — that's
-`landing-systems`'s job, working from what you hand it.
-
-The three diagnostic sub-steps are audience-judgment work, the same kind
-of work as the rest of this agent's steps — not copywriting. They exist
-because a headline or claim written without knowing the audience's
-existing awareness of the problem/solution, or without a named narrative
-role for the product, is written blind. `landing-systems`'s Copywriter
-step reads your diagnosis as an input the same way it reads your sorted
-adjectives; it doesn't re-derive it.
+pipeline in one context: Strategist → Brand Anthropologist →
+Psychologist → Perfumer. Your output is the emotional target spec every
+downstream agent (`landing-systems`, `landing-sequencer`,
+`landing-critic`, `landing-builder`) must trace its choices back to. No
+design language, no color, no type, no layout, and no finished copy —
+that's `landing-systems`'s job, working from what you hand it.
 
 ## Stack (locked)
 
@@ -45,68 +35,6 @@ than proceeding on vagueness — an unstated assumption here is the single
 most expensive thing to get wrong, since every later phase inherits it
 silently.
 
-### Step 1b — Diagnostician
-
-**In:** subject statement
-**Out:** Awareness level, Sophistication level, the Sin/desire the page
-targets, the Big Idea, and a Category/Positioning statement
-
-Chain, in order:
-
-- **Awareness level** (Eugene Schwartz, *Breakthrough Advertising*) —
-  where is the audience relative to the problem/solution: Unaware,
-  Problem-Aware, Solution-Aware, Product-Aware, or Most-Aware? This gates
-  every headline/claim decision downstream — a Product-Aware headline
-  shown to an Unaware audience reads as noise, and the reverse reads as
-  condescending.
-- **Sophistication level** — how many competing claims has this audience
-  already seen in this category? A saturated category needs a
-  mechanism or identity claim, not a plain claim; a fresh category can
-  open with a plain claim.
-- **Sin/desire** — map the page's core appeal to a specific driver from
-  Drew Eric Whitman's Life-Force 8 (*Cashvertising*) or a learned desire
-  — not asserted loosely as "people want to save time," but named as the
-  specific underlying driver (status, security, ease, etc.).
-- **Big Idea** — the single governing concept the whole page proves, in
-  one sentence.
-- **Category/Positioning statement** — Geoffrey Moore's template
-  (*Crossing the Chasm*): *For [reader] who [need], [subject] is a
-  [category] that [benefit]. Unlike [real, named alternative], it
-  [differentiator].* The alternative must be a real, current one — not a
-  strawman invented to make the differentiator look good.
-
-### Step 1c — Narrative Agent
-
-**In:** subject statement + Diagnostician output
-**Out:** the narrative arc
-
-Apply Donald Miller's StoryBrand SB7 framework (*Building a StoryBrand*):
-Character → has a Problem → meets a Guide → who gives a Plan → calls to
-Action → that ends in Success / avoids Failure. The **reader** is the
-Character; the **subject is the Guide, never the hero** — if a draft of
-this arc casts the subject as the hero, that's a reject-and-redo, not a
-minor edit, since it inverts the whole frame everything downstream reads
-from.
-
-### Step 1d — Objection Agent
-
-**In:** subject statement + Diagnostician output
-**Out:** a ranked objection map, each objection tagged with a rebuttal
-mechanism (not prose — `landing-systems`'s Copywriter writes the prose)
-
-Surface what the reader is already doing instead of adopting this
-subject (Rackham's SPIN implication-questioning posture, applied to "why
-would this reader not act"). Rank objections by implication severity —
-how much the unaddressed objection actually costs, not by how easy it is
-to rebut. Assign each a rebuttal mechanism from Cialdini's six principles
-(*Influence*: reciprocity, commitment/consistency, social proof,
-authority, liking, scarcity) — one principle per objection, chosen for
-fit, not defaulted to the first one that comes to mind. Flag any
-objection with no available proof asset to back its assigned principle —
-that's a gap for the user to resolve (source proof, reframe honestly, or
-knowingly accept it), not something to paper over with a rebuttal that
-has nothing behind it.
-
 ### Step 2 — Brand Anthropologist
 
 **In:** subject statement
@@ -156,27 +84,15 @@ adjective is meant to fade rather than hold constant throughout the page.
 1. Read `.hedgehog/chain/00-brief.md` (written by `planner` at planning
    intake). If it's missing or thin, stop and flag it back — you don't
    re-run planning intake yourself.
-2. Run step 1 (subject/audience/job), then 1b (Diagnostician), then 1c
-   (Narrative Agent) and 1d (Objection Agent) — both read step 1b's
-   output, and can run in either order relative to each other, but both
-   need the diagnosis in hand first.
-3. Run steps 2–3 (Brand Anthropologist, Psychologist), informed by
-   everything so far — an adjective can (and often should) reflect the
-   Big Idea or a narrative beat, not just a raw reading of the subject.
+2. Run step 1 (subject/audience/job).
+3. Run steps 2–3 (Brand Anthropologist, Psychologist), informed by the
+   subject statement.
 4. Run step 4c (Perfumer) against the completed sort from step 3.
 5. Self-test (below) before presenting.
 6. Commit the combined artifact as `feat(landing): strategy`.
 
 ## Self-test
 
-- The Category/Positioning statement names a real, current alternative —
-  not a strawman invented to flatter the differentiator.
-- The narrative arc casts the subject as Guide, never Character/hero. If
-  a draft slips into hero framing, redo it — don't patch it into a
-  "humble hero."
-- Every objection in the map has an assigned Cialdini principle, and any
-  objection with no available proof asset is flagged, not silently
-  rebutted anyway.
 - Every adjective has a named opposite. An adjective without one isn't
   falsifiable — send it back through step 2.
 - Every adjective is sorted into exactly one of visceral/behavioral/
@@ -198,19 +114,12 @@ adjective is meant to fade rather than hold constant throughout the page.
   yourself reaching for a hex value or a font name, stop; that's a sign
   the emotional target itself is underspecified, not a shortcut worth
   taking.
-- Never write finished copy — headlines, body prose, CTA text. The
-  Diagnostician's Awareness/Sophistication read and the Objection map are
-  the input to `landing-systems`'s Copywriter step, not a draft of the
-  copy itself.
+- Never write finished copy — headlines, body prose, CTA text. Your
+  sorted adjectives and note timing are the input to `landing-systems`'s
+  Copywriter step, not a draft of the copy itself.
 - Never invent audience or job details the brief didn't state or the user
   didn't confirm. Ambiguity here means stop and ask, the same bar
   `planner` used at intake.
-- Never cast the subject as the narrative's hero. Reader is Character,
-  subject is Guide — no exceptions, no "but this product really is the
-  hero here."
-- Never invent a competing alternative for the Category/Positioning
-  statement — it must be real and current, sourced from the brief or a
-  direct question, not assumed.
 - An adjective that describes a competitor's page unchanged gets cut, not
   kept "just in case."
 - Don't skip the swap test self-check — it's cheap here and expensive if

package/src/agents/landing-systems.md

@@ -56,14 +56,37 @@ Borrowed technique per dial:
 - **Calligraphy** — ductus (stroke rhythm/order) sharpens why a typeface
   reads fast/slow, beyond geometric-vs-humanist labels
 
-### Step 4b — Copywriter (runs against the same input as 4a)
+**The Ingredient Vocabulary** — the dial table's rows, each a dial with a
+direction, not a binary:
+
+- **Color** — hue, saturation, contrast level, where color is withheld
+- **Type** — letterform character, scale jump, tracking/leading, weight
+  contrast
+- **Space** — density, margin around the signature element, grid
+  regularity vs. deliberate breaks
+- **Motion** — easing curve, load sequencing, presence or total absence of
+  motion
+- **Imagery/texture** — photography vs. illustration vs. abstraction,
+  grain, crop tightness
+- **Form** — straight vs. curved edges, hard vs. soft boundaries, outlined
+  vs. filled, symmetry, line weight, depth cues (flat vs. shadowed)
+- **Motif** — a distinct ingredient from Form; see step 6
+- **Copy rhythm** — sentence length, verb mode, omission (step 4b's
+  dial, not this step's, but reconciled against these here at step 5)
+- **Pacing** — `landing-sequencer`'s dial, reconciled against these at
+  step 5 via the note-timing spec
+
+**Governing rule:** ingredients must move in agreement. A page warm in
+color but cold in type, or calm in motion but urgent in copy, cancels
+itself into noise instead of a mood — this is what the self-test's
+"ingredients move in agreement" check below is verifying.
+
+### Step 4b — Voice Spec (runs against the same input as 4a)
 
-**In:** sorted emotional targets + `landing-strategist`'s Diagnostician
-output (Awareness, Sophistication, Big Idea, Category), narrative arc,
-and objection map
+**In:** sorted emotional targets (from `landing-strategist`)
 **Out:** voice spec (sentence rhythm, verb mode, user-side naming, what's
-said vs. omitted) + a headline (with 2 backups) + prose rebuttals for the
-objection map
+said vs. omitted) — rules for `landing-copywriter` to write from, not
+drafted copy itself
 
 Write from the user's side of the screen. Active voice by default. One
 job per line. You have veto power over an adjective: if it's effectively
@@ -78,37 +101,16 @@ technique:
   section, on purpose); pacing-and-leading (match the reader's current
   belief first, then lead to the new claim, rather than opening cold with
   the pitch)
-
-**Headline, gated by Awareness level** (the formula is chosen, not
-picked freely — Sugarman's psychological triggers, Caples' tested
-patterns, Bencivenga swipe structures are the bank to draw from):
-
-- Unaware/Problem-Aware → problem-led headline
-- Solution-Aware → solution-named headline
-- Most-Aware → offer-led headline
-- A headline may fuse problem and solution into one image or metaphor at
-  Problem-Aware *only if* the terms it relies on already read as
-  recognition to that reader, not as a pitch — a judgment call, not a
-  formula lookup. If it's not clearly true, flag it back to
-  `landing-strategist` for an Awareness re-check rather than shipping it
-  on a guess.
-
-Write the winning headline plus 2 backups, each tagged with which
-Diagnostician term it carries (Awareness level, Big Idea, or Category
-statement).
-
-**Objection rebuttals**: for each objection in `landing-strategist`'s
-map, write the prose rebuttal using its pre-assigned Cialdini principle
-and whatever proof asset the brief or user supplied. Don't invent a new
-objection here — sourcing is `landing-strategist`'s job; this step only
-writes the prose for what's already been surfaced and ranked. An
-objection flagged with no proof asset stays flagged in your output, not
-quietly rebutted with an assertion that has nothing behind it.
-
-Use Claude Hopkins' "reason-why" copy (*Scientific Advertising*) for any
-claim that needs a mechanism, not just an assertion — a claim that only
-explains a feature without tying it to the Sin/desire the Diagnostician
-named is incomplete.
+- **Classical rhetoric** — ethos/pathos/logos as an audit of what each
+  section is earning (trust, feeling, or logic — a section that's meant
+  to earn trust but is written as a logic argument is a mismatch to fix
+  here); kairos (the right *moment* in the scroll for the ask, tied to
+  the peak moment the Perfumer named — not just the right placement on
+  the page)
+- **Editorial design** — pull quotes/callouts as a deliberate second
+  reading path for skimmers, without disrupting the primary linear read
+- **Advertising (Hopkins)** — "reason why": every claim needs a stated,
+  specific cause, never a bare assertion
 
 ### Step 5 — Systems Designer
 
@@ -175,12 +177,8 @@ markup or the Paper.js setup into `src/motifs/`.
 - Ingredients move in agreement: color, type, space, motion, and copy
   rhythm all point the same emotional direction. A page warm in color but
   cold in type is a defect to fix here, not a later polish pass.
-- The headline's formula matches the Awareness level it's gated on — a
-  Most-Aware offer-led headline shown against a Diagnostician read of
-  Unaware is a mismatch, not a style choice.
-- Every objection in the map has a written rebuttal, and any objection
-  flagged as unresolvable (no proof asset) stays flagged in your output
-  rather than getting a rebuttal written anyway.
+- Every claim in the voice spec that needs a mechanism has a stated
+  reason-why, not a bare assertion.
 - The motif's source is traceable to the subject statement, not a
   generic decoration. If you can't state which sentence in the subject
   statement it came from, it's not sourced — revise.

package/src/skills/hedgehog-bootstrap-landing-page-core/SKILL.md

@@ -57,7 +57,7 @@ re-copy: patch the specific file at its source.
 
 ### 2. Land `src/golden-cores/landing-page/`
 
-In the common case this is already done — `hedgehog init --core=landing-page`'s
+In the common case this is already done — `hedgehog init --landing-page`'s
 installer copies `src/golden-cores/landing-page/` to the repo root at
 install time, the same way it copies `src/agents` to `.claude/agents`.
 Check whether the core files are already present (same check as step 1).

package/src/skills/hedgehog-landing-loop/SKILL.md

@@ -82,26 +82,27 @@ artifact; everything else is strictly sequential.
 | # | Phase | Agent | Produces | Commit |
 |---|---|---|---|---|
 | 1 | Strategist | `landing-strategist` | Subject/audience/job statement (from planning intake — restated here as this phase's formal output) | `feat(landing): strategy` |
-| 1b | Diagnostician | `landing-strategist` | Awareness level, Sophistication level, Sin/desire, Big Idea, Category/Positioning statement | bundled into `feat(landing): strategy` |
-| 1c | Narrative Agent | `landing-strategist` | StoryBrand arc (Character → Problem → Guide → Plan → Action → Success/Failure), subject as Guide | bundled into `feat(landing): strategy` |
-| 1d | Objection Agent | `landing-strategist` | Ranked objection map, each tagged with a Cialdini rebuttal principle | bundled into `feat(landing): strategy` |
 | 2 | Brand Anthropologist | `landing-strategist` | 3–5 adjective pairs (each with a named opposite) | bundled into `feat(landing): strategy` |
 | 3 | Psychologist | `landing-strategist` | Adjectives sorted visceral / behavioral / reflective | bundled into `feat(landing): strategy` |
 | 4 | Perfumer | `landing-strategist` | Top/heart/base note timing per adjective, the page's peak moment, the ending treatment | bundled into `feat(landing): strategy` |
-| 5 | Ingredient Director + Copywriter | `landing-systems` | Dial table (color/type/form/space/motion) + voice spec + gated headline (2 backups) + objection rebuttal prose, run against the same sorted-adjectives/diagnosis input | `feat(landing): systems` |
+| 5 | Ingredient Director + Copywriter | `landing-systems` | Dial table (color/type/form/space/motion) + voice spec, run against the same sorted-adjectives input | `feat(landing): systems` |
 | 6 | Systems Designer | `landing-systems` | The token system (hex values, type roles, spacing unit, easing family, copy voice, with note timing attached) | bundled into `feat(landing): systems` |
 | 7 | Motif Artist | `landing-systems` | Signature motif (source, persistence, continuity, scale range, literalness) | bundled into `feat(landing): systems` |
 | 8 | Sequencer | `landing-sequencer` | Per-section transition type, weight, spacing, beat structure | `feat(landing): sequence` |
-| 9 | Critic + Usability Auditor | `landing-critic` | Redlines, or a pass — reconciled traceability/distinctiveness + usability audit | `feat(landing): audit` (no commit if redlined — see Correction Protocol) |
-| 10 | Builder | `landing-builder` | The built page, in Astro | `feat(landing): build` |
-
-Phases 1 through 4 (including 1b/1c/1d) are one agent's context
-(`landing-strategist`) because they're one continuous judgment call —
-subject into diagnosis into feeling into timing — not separable artifacts
-with different tool footprints. Same reasoning collapses 5–7 into
-`landing-systems` (everything that becomes a Tailwind token or a line of
-copy) and 8/9's reconciliation into a single `landing-critic` pass. See
-each agent's own file for the internal sub-steps it runs through.
+| 9 | Copywriter | `landing-copywriter` | Final page copy — headline (2 backups), every section's body text, CTA text, written to the voice spec and beat structure, reviewed and confirmed by the user | `feat(landing): copy` |
+| 10 | Critic + Usability Auditor | `landing-critic` | Redlines, or a pass — reconciled traceability/distinctiveness + usability audit | `feat(landing): audit` (no commit if redlined — see Correction Protocol) |
+| 11 | Builder | `landing-builder` | The built page, in Astro | `feat(landing): build` |
+
+Phases 1 through 4 are one agent's context (`landing-strategist`)
+because they're one continuous judgment call — subject into feeling into
+timing — not separable artifacts with different tool footprints. Same
+reasoning collapses 5–7 into `landing-systems` (everything that becomes
+a Tailwind token or a copy rule) and 10's reconciliation into a single
+`landing-critic` pass. Copy is its own phase, not folded into
+`landing-systems` or `landing-builder`, specifically so the user reads
+and confirms the actual words before either the audit or the build runs
+— see `landing-copywriter`'s own file for its writing standard and
+self-test.
 
 ## The Loop (every unit of work)
 
@@ -134,9 +135,9 @@ subject statement, or matches a known AI-default cluster:
 2. Patch the upstream phase directly, in place, via that phase's owning
    agent.
 3. Fast-forward every dependent phase that breaks. A token system change
-   (phase 6) ripples through the motif (7), the sequence (8), and the
-   build (10) — each gets its own small commit, in order, not one bundled
-   fix.
+   (phase 6) ripples through the motif (7), the sequence (8), the copy
+   (9, if the voice spec shifted), and the build (11) — each gets its own
+   small commit, in order, not one bundled fix.
 4. Re-run `landing-critic` against the patched chain before resuming.
 5. The commit messages are the explanation.
 6. Resume the loop.
@@ -146,11 +147,16 @@ one working-tree pass and needs splitting back into per-phase commits.
 
 ## Phase Transition Checks
 
+Before `landing-critic` starts, confirm `landing-copywriter`'s copy has
+been presented to and confirmed by the user, not just written —
+`landing-critic`'s traceability audit reads confirmed copy, not a draft
+still awaiting review.
+
 Before `landing-builder` starts, confirm:
 
 - `landing-critic` returned a pass, not a redline — a redlined spec never
   reaches the Builder; it goes back to the phase the redline names.
-- Every phase 1–9 has its commit landed.
+- Every phase 1–10 has its commit landed.
 
 Before `landing-strategist` starts, confirm planning intake's Confirm &
 Lock has held and its commit has landed. If not, stop and ask.
@@ -180,6 +186,25 @@ Lock has held and its commit has landed. If not, stop and ask.
   those tools is re-derived through the token system (phase 6) before it
   touches Tailwind config — never copied through as final values.
 
+## Core Reference Points
+
+The chain's judgment calls, across every phase, are grounded in these —
+not restated per-agent since they're shared foundation, not one phase's
+procedure:
+
+- Donald Norman, *Emotional Design* — visceral / behavioral / reflective
+  (`landing-strategist`'s step 3)
+- Scott McCloud, *Understanding Comics* — panel transition taxonomy,
+  closure (`landing-sequencer`'s step 7)
+- Will Eisner, *Comics and Sequential Art* — page as one composition
+  before it's a sequence (`landing-sequencer`'s step 7)
+- Rudolf Arnheim, *Art and Visual Perception* — visual weight, tension,
+  balance (`landing-systems`'s step 4a/5 dial reconciliation)
+- Josef Albers, *Interaction of Color* — color as relational, not
+  absolute (`landing-systems`'s step 4a color dial)
+- Dieter Rams / Massimo Vignelli — restraint as an emotional register
+  (`landing-critic`'s Chanel cut, step 8)
+
 ## Stop Condition
 
 A build session ends when every phase in `TODO.md` is checked off and

package/src/templates/CLAUDE.core.landing-page.md

@@ -36,29 +36,29 @@ edited after a phase closes.
 - **`bootstrap`** — runs `hedgehog-bootstrap-landing-page-core`'s steps.
   Triggered automatically by `planner` after its first run; skip if
   `astro.config.mjs` already exists.
-- **`landing-strategist`** — Chain Method steps 1–3 and 4c, plus the
-  Diagnostician/Narrative Agent/Objection Agent sub-steps folded into
-  step 1: subject statement → Awareness/Sophistication/Big-Idea
-  diagnosis → narrative arc → objection map → adjective pairs
-  (visceral/behavioral/reflective) → top/heart/base note timing and the
-  page's single peak moment. One context, one artifact: the emotional
-  and persuasive target spec.
-- **`landing-systems`** — steps 4a/4b/5/6, run together: the ingredient
-  dial table, the copy voice spec (plus the Awareness-gated headline and
-  objection rebuttal prose), the token system that reconciles them, and
-  the signature motif. Owns everything that becomes a Tailwind token or a
-  piece of copy.
-- **`landing-sequencer`** — step 7: per-section transition type, weight,
-  spacing, and beat structure — the GSAP/ScrollTrigger/Lenis pacing spec
-  the Builder implements against.
-- **`landing-critic`** — steps 8–9 reconciled: traceability/distinctiveness
-  audit (does every choice trace to the subject statement, does anything
-  match a known AI-default cluster) and the usability pass (Fitts's Law
-  on the CTA, affordance/signifier check). Has veto power; cannot rewrite,
-  only redline back to the owning agent.
-- **`landing-builder`** — step 10: builds the audited spec exactly in
-  Astro. Anything that can't be built as specified is flagged back up the
-  chain, never silently improvised around.
+- **`landing-strategist`** — subject statement → adjective pairs →
+  visceral/behavioral/reflective sort → top/heart/base note timing and
+  the page's single peak moment. One context, one artifact: the
+  emotional target spec.
+- **`landing-systems`** — the ingredient dial table, the copy voice spec,
+  the token system that reconciles them, and the signature motif. Owns
+  everything that becomes a Tailwind token or a copy rule.
+- **`landing-sequencer`** — per-section transition type, weight, spacing,
+  and beat structure — the GSAP/ScrollTrigger/Lenis pacing spec the
+  Builder implements against.
+- **`landing-copywriter`** — the final page copy: headline (2 backups),
+  every section's body text, CTA text — written to the voice spec and
+  the sequence's beat structure. Presented as its own artifact for the
+  user to read and confirm before the audit or the build runs.
+- **`landing-critic`** — the reconciled traceability/distinctiveness
+  audit (does every choice, including the copy, trace to the subject
+  statement, does anything match a known AI-default cluster) and the
+  usability pass (Fitts's Law on the CTA, affordance/signifier check).
+  Has veto power; cannot rewrite, only redline back to the owning agent.
+- **`landing-builder`** — builds the audited spec exactly in Astro,
+  placing `landing-copywriter`'s copy verbatim. Anything that can't be
+  built as specified is flagged back up the chain, never silently
+  improvised around.
 
 ## The constants (do not deviate)
 

package/src/templates/TODO.core.landing-page.md

@@ -17,8 +17,9 @@ audience, and the page's single job — full detail in
 <!-- The Chain Method, one phase at a time, in strict order except where
 noted. Do not start a phase until the one above it is checked. -->
 
-- [ ] strategy — subject/audience/job + awareness/sophistication diagnosis + narrative arc + objection map + adjective pairs + visceral/behavioral/reflective sort + note timing — `landing-strategist`
+- [ ] strategy — subject/audience/job + adjective pairs + visceral/behavioral/reflective sort + note timing — `landing-strategist`
 - [ ] systems — dial table + voice spec (parallel) → token system → signature motif — `landing-systems`
 - [ ] sequence — per-section transitions, weight, spacing, beat structure — `landing-sequencer`
+- [ ] copy — final headline, section body, and CTA text, reviewed and confirmed by the user — `landing-copywriter`
 - [ ] audit — traceability/distinctiveness + usability, reconciled to a pass — `landing-critic`
 - [ ] build — the artifact, in Astro — `landing-builder`