@skyf0xx/hedgehog 2.0.11 → 2.0.13

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-copywriter. Specializes in pacing a scroll as a deliberate composition rather than a stack of sections, using Motion/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, beat structure, and copy archetype role. Runs after landing-systems, before landing-headline-writer and landing-copywriter. Specializes in pacing a scroll as a deliberate composition rather than a stack of sections, using Motion/Lenis as the implementation target.
 model: sonnet
 color: orange
 tools: Read, Glob, Grep, Edit, Write
@@ -32,7 +32,8 @@ spec. Your artifact is the sequencing decisions, not the code.
 **In:** signature element + token system (from `landing-systems`) +
 note-timing spec (from `landing-strategist`)
 **Out:** per-section transition type, relative section weight, per-
-transition spacing, sub-section beat structure
+transition spacing, sub-section beat structure, and each section's copy
+archetype role (see Copy archetype role, below)
 
 Treat sections as panels in sequence, after McCloud's panel-transition
 taxonomy (*Understanding Comics*): moment-to-moment, action-to-action,
@@ -69,6 +70,38 @@ the exact section your sequence puts them — if your natural pacing wants
 them elsewhere, that's a real conflict to resolve explicitly (flag it
 back), not something to silently override.
 
+## Copy archetype role
+
+Alongside transition, weight, and beat, assign each section exactly one
+role from this fixed set — the taxonomy `landing-copywriter` reads to
+pick which `landing-copy-*` skill it invokes for that section:
+
+- **Hero** — the section immediately beneath the headline; names the
+  mechanism and bridges to credibility (`landing-copy-hero`)
+- **Problem** — establishes the gap the headline's outcome would close
+  (`landing-copy-problem`)
+- **Mechanism** — explains how the product closes that gap
+  (`landing-copy-mechanism`)
+- **Proof** — evidence the mechanism's claim is true
+  (`landing-copy-proof`)
+- **Objection** — names and answers a specific reader hesitation
+  (`landing-copy-objection`)
+- **CTA** — the ask, wherever it falls in the sequence
+  (`landing-copy-cta`)
+
+A section can carry two roles only where they're genuinely the same
+beat doing double duty (a closing section that's both Proof and CTA) —
+name both explicitly rather than picking one arbitrarily. Don't assign a
+role a section doesn't need just to fill out the taxonomy — a short page
+might skip Objection entirely, and that's a legitimate sequencing
+decision, not a gap.
+
+Assign roles in the same pass as the beat structure: a section's role and
+its beat count are two different decisions (role is *what job the
+section does*, beat count is *how much room it gets*), but both come from
+reading the same AIDA beat-map and section list, so make them together
+rather than in separate passes.
+
 ## Workflow
 
 1. Read `landing-systems`'s token system and signature element, and
@@ -80,10 +113,12 @@ back), not something to silently override.
 4. Assign relative weight (section size) and spacing (gutter) per
    section, plus any sub-section beat structure (setup/build/payoff)
    within a section that needs it.
-5. Confirm the peak moment and ending treatment land where
+5. Assign each section's copy archetype role from the fixed set (Copy
+   archetype role, above), in the same pass as its beat structure.
+6. Confirm the peak moment and ending treatment land where
    `landing-strategist` specified, or flag the conflict.
-6. Self-test (below).
-7. Commit as `feat(landing): sequence`.
+7. Self-test (below).
+8. Commit as `feat(landing): sequence`.
 
 ## Self-test
 
@@ -95,16 +130,23 @@ back), not something to silently override.
 - The whole sequence reads as one composition, checked as a whole, not
   approved section-by-section only.
 - The peak moment and ending treatment are placed, not omitted.
+- Every section has exactly one archetype role (or two, only where
+  genuinely doing double duty, both named explicitly) — no section left
+  unassigned, since `landing-copywriter` can't pick a skill for a section
+  with no role.
 
 ## Constraints
 
-- Never introduce a transition, beat, or emphasis choice that doesn't
-  trace to the token system, the signature element, or the note-timing
-  spec — a transition chosen for variety's sake with no upstream
-  justification is exactly what gets redlined at the next phase.
+- Never introduce a transition, beat, emphasis, or archetype-role choice
+  that doesn't trace to the token system, the signature element, or the
+  note-timing spec — a transition chosen for variety's sake with no
+  upstream justification is exactly what gets redlined at the next phase.
 - Never write actual Motion code, Astro markup, or final section
-  content — that's `landing-builder`'s step 10. Your output is the spec,
+  content — that's `landing-builder`'s step 12. Your output is the spec,
   not the implementation.
+- Never assign an archetype role just to fill out the taxonomy — a page
+  that doesn't need an Objection section skips it; forcing one in is a
+  worse defect than an incomplete-looking set.
 - Don't relitigate the token system or the signature element — if
   either seems wrong for pacing purposes, flag it back to
   `landing-systems` rather than quietly working around it.

package/src/agents/landing-strategist.md

@@ -11,9 +11,11 @@ Method (`hedgehog-landing-loop`), running steps 1–3 and 4c of the
 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.
+`landing-headline-writer`, `landing-copywriter`, `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 voice-spec job and `landing-headline-writer`'s/
+`landing-copywriter`'s drafting job, working from what you hand them.
 
 ## Stack (locked)
 
@@ -52,7 +54,7 @@ one-line "here's the big idea" version — and get explicit go-ahead before
 any adjective work is built on it. This is a hard stop, the same weight
 as planning intake's own Confirm & Lock: every phase from here through
 `landing-copywriter` inherits this framing silently, and by the time
-copy is reviewed at phase 9, correcting the framing means unwinding
+copy is reviewed at phases 9–10, correcting the framing means unwinding
 multiple committed phases via the Correction Protocol instead of one
 quick revision now. A revision at this point is just another pass at
 Step 1, not a Correction Protocol entry, since nothing downstream exists
@@ -148,7 +150,8 @@ adjective is meant to fade rather than hold constant throughout the page.
   taking.
 - 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.
+  step 4b (the voice spec) and, downstream of that, `landing-headline-writer`
+  and `landing-copywriter` — 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.

package/src/agents/landing-systems.md

@@ -85,8 +85,8 @@ itself into noise instead of a mood — this is what the self-test's
 
 **In:** sorted emotional targets (from `landing-strategist`)
 **Out:** voice spec (sentence rhythm, verb mode, user-side naming, what's
-said vs. omitted) — rules for `landing-copywriter` to write from, not
-drafted copy itself
+said vs. omitted) — rules for `landing-headline-writer` and
+`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

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

@@ -89,20 +89,26 @@ artifact; everything else is strictly sequential.
 | 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 | Signature Element | `landing-systems` | Signature element (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 | 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` |
+| 9 | Headline | `landing-headline-writer` | The headline plus 2 backups, from 3 distinct rhetorical mechanisms, reviewed and locked by the user | `feat(landing): headline` |
+| 10 | Copywriter (one invocation per section) | `landing-copywriter` | One section's body text and CTA copy per invocation, to the fixed paragraph algorithm, reviewed and locked by the user before the next section starts | `feat(landing): copy` (one commit once every section locks, or extended per section — never split across an unlocked section) |
+| 11 | Critic + Usability Auditor | `landing-critic` | Redlines, or a pass — reconciled traceability/distinctiveness + usability audit | `feat(landing): audit` (no commit if redlined — see Correction Protocol) |
+| 12 | 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.
+a Tailwind token or a copy rule) and 11's reconciliation into a single
+`landing-critic` pass. The headline is its own phase (9), one agent, one
+artifact, one review checkpoint, because it's the single highest-leverage
+line on the page — every section beneath it either delivers on its
+promise or doesn't, so it locks before any section body is drafted. Copy
+(10) is its own phase too, run once per section rather than once for the
+whole page, specifically so the user reads and confirms each section's
+actual words before the next section is drafted, and before either the
+audit or the build runs — see `landing-headline-writer`'s and
+`landing-copywriter`'s own files for their writing standards, the
+paragraph algorithm, and their self-tests.
 
 ## The Loop (every unit of work)
 
@@ -113,14 +119,20 @@ self-test.
 3. **Delegate exactly one phase** to its owning agent, passing it the
    full chain so far (every upstream artifact, not just the immediately
    prior one) — an agent that only sees its direct input can't verify its
-   own traceability back to the subject statement.
+   own traceability back to the subject statement. Phase 10
+   (`landing-copywriter`) is delegated once per section, in
+   `landing-sequencer`'s order — each invocation is still "exactly one
+   phase" in the sense this step means: one section, reviewed and locked,
+   before the next invocation starts.
 4. The agent **runs its self-test** (see that agent's own file for what
    it checks) before presenting its artifact.
 5. The agent **commits** using the exact Conventional Commit format
    above.
 6. **Check off the line in `TODO.md`** once the agent reports the commit
-   landed.
-7. **Repeat**, one delegated phase at a time.
+   landed. Phase 10 stays unchecked until every section in
+   `landing-sequencer`'s list has locked, not after the first section.
+7. **Repeat**, one delegated phase (or one section, at phase 10) at a
+   time.
 
 Each commit batches exactly one phase's artifact; a wrong phase is fixed
 forward later via the Correction Protocol.
@@ -152,8 +164,10 @@ subject statement, or matches a known AI-default cluster:
    agent.
 3. Fast-forward every dependent phase that breaks. A token system change
    (phase 6) ripples through the signature element (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.
+   (8), the headline (9, if the voice spec shifted) and every locked
+   section of copy (10, re-run per affected section, not the whole phase
+   over again), and the build (12) — 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.
@@ -168,12 +182,23 @@ confirm step 1's subject/audience/job statement has been shown to and
 confirmed by the user — not just drafted. This is the cheapest point in
 the whole chain to correct the core framing (nothing downstream exists
 yet); every phase after it inherits that framing silently, and by the
-time `landing-copywriter` is reviewed at phase 9, a wrong framing means
-unwinding four committed phases via the Correction Protocol instead of
-one free revision here.
-
-Before `landing-critic` starts, confirm `landing-copywriter`'s copy has
-been presented to and confirmed by the user, not just written —
+time copy is reviewed at phases 9–10, a wrong framing means unwinding
+several committed phases via the Correction Protocol instead of one free
+revision here.
+
+Before `landing-copywriter` starts (phase 10), confirm
+`landing-headline-writer`'s headline has been presented to and locked by
+the user, not just drafted — every section's copy is written against
+whichever headline is locked at phase 9, so an unlocked headline means
+every section written against it is provisional too.
+
+Before each `landing-copywriter` invocation after the first, confirm the
+previous section is locked, not just presented — the next section's
+continuity check (no repeated claims, no synonym drift) reads the prior
+section's actual locked text, not a draft still awaiting edits.
+
+Before `landing-critic` starts, confirm every section `landing-copywriter`
+wrote has been presented to and locked by the user, not just written —
 `landing-critic`'s traceability audit reads confirmed copy, not a draft
 still awaiting review.
 
@@ -181,7 +206,7 @@ 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–10 has its commit landed.
+- Every phase 1–11 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.

package/src/skills/landing-copy-cta/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: landing-copy-cta
+description: Use whenever `landing-copywriter` drafts the CTA/close — the final ask, or any mid-page section `landing-sequencer` assigned the CTA. Trigger when a section carries the token system's CTA styling intent, distinct from every other archetype (which build the case, not make the ask).
+---
+
+# Landing Copy: CTA / Close
+
+This is the ask. Every other section builds toward this moment; this
+section's only job is to make the ask itself, matched to the urgency the
+token system already specified. It is not a place to introduce new
+argument, new proof, or new mechanism — if the case isn't made by the
+time this section runs, that's an upstream section's gap, not something
+to patch here with more copy.
+
+## What this section answers
+
+One thing: **what does the reader do right now?** Not why (that's every
+section before this one), not what happens after (a line of reassurance
+is allowed, but this section doesn't re-argue the case) — the specific
+action, named as an action.
+
+## The algorithm
+
+Per `landing-copywriter`'s paragraph algorithm, a CTA-only section gets
+**0 paragraphs — 1 line**, rendered as a `>` blockquote per the output
+format. Where `landing-sequencer` assigns the CTA to a section that also
+carries a beat (a closing section with both a payoff paragraph and the
+ask), the CTA line still stays separate from the paragraph — never
+merged into the last sentence of prose.
+
+The line itself, in order:
+
+1. **Verb first, plain and specific.** "Start your free trial," not "Get
+   started" if there's a more specific verb available — "Get started" is
+   correct only when it's genuinely the most specific true description
+   of the action.
+2. **Match the token system's urgency.** If `landing-systems` marked the
+   CTA high-urgency, the verb mode carries that (imperative, immediate:
+   "Start now"). If low-pressure, the verb mode matches (invitational,
+   unhurried: "See how it works"). A CTA whose verb mode contradicts the
+   token system's stated intent is a mismatch to fix here, not something
+   `landing-builder` should silently soften or sharpen later.
+3. **No stacked qualifiers.** One clear verb phrase — "Start your free
+   14-day trial, no credit card required" crams a second claim into the
+   CTA line itself; if that reassurance is load-bearing, it's a
+   fragment of copy just below the button, not inside the CTA text.
+
+## Writing standard (scoped to this section)
+
+- Apply `landing-copywriter`'s full writing standard.
+- **No stock closers.** Never end the page on "the future looks bright"
+  or "join us on this journey" — the CTA is the specific action, not a
+  sentiment.
+- **No urgency manufactured with punctuation or caps.** Urgency comes
+  from verb mode and the token system's specified intent, never from an
+  exclamation point or all-caps standing in for an actual persuasive
+  reason.
+- **No hedge in the ask.** "You might want to consider starting a trial"
+  fails here completely — the ask is direct or it isn't an ask.
+
+## Self-test
+
+- The line is a specific action verb, not a vague "Learn more" where a
+  more specific true verb was available.
+- Verb mode matches the token system's stated CTA urgency (high-pressure
+  vs. low-pressure) — checked explicitly, not assumed.
+- The line stands alone as a `>` blockquote, not merged into the
+  preceding paragraph's last sentence.
+- No new argument, proof, or mechanism claim appears in this section —
+  if the case isn't made by now, that's flagged upstream, not patched
+  here.
+
+## Constraints
+
+- Never introduce new persuasive content in the CTA section — its job
+  is the ask, not one more argument.
+- Never let the CTA's verb mode drift from what the token system
+  specified for this build — a mismatch here is a defect, not a stylistic
+  choice.
+- Never stack a second claim or qualifier into the CTA line itself —
+  supporting reassurance is separate copy, not part of the action verb
+  phrase.

package/src/skills/landing-copy-headline/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: landing-copy-headline
+description: Use whenever `landing-headline-writer` drafts the page headline (Chain Method step 9). Gives the 8 named rhetorical mechanisms, the outcome-subject test, and the selection procedure for generating 3 distinct-mechanism candidates and presenting them for the user's lock. Trigger on "write the headline", "headline candidates", or the start of `landing-headline-writer`'s own workflow.
+---
+
+# Landing Copy: Headline
+
+The headline is the single highest-leverage line on the page — every
+section beneath it either delivers on its promise or doesn't. This skill
+is the algorithm `landing-headline-writer` runs to generate it: don't
+draft headline wording by feel, run the mechanism generation and the
+outcome-subject test below every time.
+
+This skill covers the headline only. The subhead or lede immediately
+beneath it, if the page has one, is `landing-copywriter`'s
+`landing-copy-hero` skill — a different section, a different algorithm.
+
+## Step 1: Pull the raw material, don't invent it
+
+Read, don't re-derive:
+
+- `landing-strategist`'s subject/audience/job statement — the concrete
+  claim available to make
+- The adjective pairs and their named opposites — what the headline is
+  allowed to promise emotionally
+- `landing-systems`'s voice spec — sentence rhythm, verb mode, user-side
+  naming
+
+Every candidate below is generated from this material. A headline that
+doesn't trace to a specific adjective or the subject statement fails
+`landing-critic`'s traceability audit later — catch that here, not there.
+
+## Step 2: Generate one candidate per mechanism
+
+Generate against at least 3 of these 8, chosen as whichever the subject
+statement actually supports — not the same 3 by default on every build:
+
+- **Outcome** — state the desired outcome directly ("Build software
+  that holds together.")
+- **Transformation** — current state → desired state ("Turn ideas into
+  products people use.")
+- **Tension** — expectation → contradiction ("Your product is ready.
+  Your story isn't.")
+- **Reframe** — common frame → stronger frame ("Your website isn't a
+  brochure. It's a decision engine.")
+- **Provocation** — command → uncomfortable truth ("Stop building
+  features nobody asked for.")
+- **Identity** — audience → belief or standard ("For teams that refuse
+  to ship generic software.")
+- **Mechanism** — how it works → implied benefit ("A disciplined path
+  from schema to screen.") — use only when the mechanism itself is the
+  distinctive, ownable claim; it still has to pass Step 3.
+- **Curiosity** — open question → implied possibility ("What happens
+  when your tools finally work together?")
+
+Generate from **distinct mechanisms**, not three phrasings of one idea —
+the point is testing which mechanism the subject statement actually
+supports, not polishing a single guess.
+
+## Step 3: The outcome-subject test (run on every candidate)
+
+**The reader wants an outcome, not the mechanism that produces it** — the
+headline's grammatical subject must be what the reader gets (what
+changes for them, what they now have or no longer have to worry about),
+not the product, feature, or mechanism that delivers it.
+
+Run this test by reading only the headline, with no subhead for context:
+does it state what the reader gets, or does it name the thing that gets
+it to them?
+
+- "One signature. Three uses." **fails** — the signature is the subject.
+- "Your agent's work outlives the session that made it." **passes.**
+
+A headline built from the subject statement's own phrasing ("ZenBin is
+one cryptographic trust primitive...") tends to smuggle the mechanism
+into the subject position by default — naming it is not the same as
+leading with it. Demote the mechanism one level: it belongs in the
+subhead or the sentence right after, earning its specificity once the
+outcome has already landed. If a candidate only works because the reader
+already knows what the mechanism is for, it's failing this test, not
+passing it narrowly.
+
+**This test overrides mechanism choice.** An Outcome- or
+Transformation-mechanism candidate that fails it still fails, and a
+Mechanism-mechanism candidate that passes it is still eligible. Rewrite
+or cut any candidate that fails before Step 4.
+
+## Step 4: Apply the writing standard
+
+Scoped to a single line — the same bar `landing-copywriter` holds section
+copy to:
+
+- **Cut inflated words.** No "delve," "landscape," "robust,"
+  "comprehensive," "leverage," "seamless," "cutting-edge," "elevate,"
+  "unlock," "empower," "streamline," "game-changer," "harness,"
+  "revolutionize," or any word from that register.
+- **No negation formulas.** Never write "It's not X — it's Y."
+- **No em dashes.** Use a comma, period, or restructure the sentence.
+- **Concrete over abstract.** A claim like "significant improvement"
+  ships only with the number, name, or comparison that makes it
+  checkable. If the brief doesn't supply one, the claim doesn't ship in
+  that form.
+
+## Step 5: Select and present
+
+Select the 3 strongest, distinct candidates that survived Steps 3 and 4.
+Label each with its mechanism name and present all 3 to the user — this
+is a hard stop; wait for an explicit pick (the other 2 stand as backups)
+or a redirect. Every section `landing-copywriter` writes afterward is
+checked against whichever headline locks here, so an unconfirmed pick
+compounds the same way an unconfirmed subject statement does at strategy
+step 1.
+
+## Self-test
+
+- All 3 presented candidates came from 3 distinct mechanisms, not 3
+  phrasings of the same one.
+- Every candidate traces to a named adjective or the subject statement —
+  a line that could run on a competitor's page unchanged (the swap test)
+  was rewritten before presenting, not left for `landing-critic` to
+  catch.
+- Every candidate passed the outcome-subject test individually — not
+  waved through because the set as a whole "feels balanced."
+- The user was shown all 3, labeled by mechanism, and explicitly picked
+  or redirected — not assumed.
+
+## Constraints
+
+- Never present fewer than 3 distinct-mechanism candidates.
+- Never lock a headline without the user's explicit confirmation.
+- Never draft the subhead, section body, or CTA copy here — that's
+  `landing-copywriter`'s `landing-copy-hero` and other section skills,
+  run only after this one locks.

package/src/skills/landing-copy-hero/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: landing-copy-hero
+description: Use whenever `landing-copywriter` drafts the section directly beneath the locked headline — the subhead/lede that makes the headline's claim credible. Trigger when the section's role is "hero support" in `landing-sequencer`'s list, distinct from the headline itself (`landing-copy-headline`) or the problem/agitation section (`landing-copy-problem`).
+---
+
+# Landing Copy: Hero (subhead/lede)
+
+The hero section's job is narrow: make the headline's claim credible in
+one breath, before the reader has committed to reading further. It is not
+the place to make the full case — that's every section after it. A hero
+section that tries to argue, prove, or handle objections has taken on a
+different section's job.
+
+This skill covers the section immediately beneath the locked headline
+only. The headline itself is `landing-headline-writer`'s
+`landing-copy-headline` skill.
+
+## What this section answers
+
+One question, in this order:
+
+1. **What is the mechanism, named plainly?** The headline led with the
+   outcome and deliberately withheld the mechanism (per
+   `landing-copy-headline`'s outcome-subject test) — this section is
+   where that mechanism gets named, in plain language, for the first
+   time.
+2. **Why should the reader believe the headline's claim is achievable,
+   not aspirational?** One line of credibility, not a proof point (proof
+   points belong to `landing-copy-proof`) — a plain statement of how the
+   mechanism gets the reader from their current state to the headline's
+   promise.
+
+## The algorithm
+
+Per this core's fixed paragraph algorithm (`landing-copywriter`'s own
+file): this section's paragraph count is set by however many beats
+`landing-sequencer` assigned it, almost always 1 (a hero is rarely a
+multi-beat section). Within that single paragraph:
+
+1. **Sentence 1 — name the mechanism.** Plain verb, plain noun. No
+   abstraction standing in for the thing itself (the same plain-verb
+   discipline `landing-strategist` applies at the subject-statement
+   stage).
+2. **Sentence 2 (only if the beat has room) — the credibility bridge.**
+   One sentence connecting the mechanism to the headline's promise: how
+   doing this thing gets the reader that outcome. Not evidence, not a
+   number — that's `landing-copy-proof`'s job — just the logical link
+   made explicit.
+
+Two sentences is the ceiling for a single-beat hero. If it's taking a
+third sentence to make the mechanism credible, the mechanism itself is
+underspecified — flag it back rather than padding the section to compensate.
+
+## Writing standard (scoped to this section)
+
+- Apply `landing-copywriter`'s full writing standard (inflated words, em
+  dashes, hedge stacks, etc.) — this section gets no exception.
+- **No proof, no numbers, no named evidence here.** A stat or case study
+  in the hero section is `landing-copy-proof`'s content pulled forward —
+  redirect it downstream, keep this section to the plain claim.
+- **No objection-handling here.** "But you might be wondering..." belongs
+  to `landing-copy-objection`, not this section.
+- Match the token system's CTA styling intent only if this section
+  carries a CTA (rare — most builds put the CTA in `landing-copy-cta`'s
+  section instead).
+
+## Self-test
+
+- The mechanism is named in plain language, not gestured at.
+- The section makes no argument, cites no proof, and handles no
+  objection — those are the next sections' jobs.
+- Paragraph count matches the beat count `landing-sequencer` assigned —
+  1 paragraph for a single beat, not padded to 2 for weight.
+- Read against the locked headline: does this section make the headline
+  more believable, or does it just restate the headline in different
+  words? Restating fails this test.
+
+## Constraints
+
+- Never draft the headline itself — that's `landing-copy-headline`,
+  already locked before this section starts.
+- Never pull proof points, stats, or objection-handling into this
+  section to make it feel more substantial — a thin hero section is
+  correct; padding it borrows from a downstream section's job.

package/src/skills/landing-copy-mechanism/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: landing-copy-mechanism
+description: Use whenever `landing-copywriter` drafts a mechanism/how-it-works section — the section that resolves the problem section's tension by explaining how the product changes the situation. Trigger when the section's role in `landing-sequencer`'s list is to earn the headline's claim through explanation, distinct from proof (evidence the claim is true) or pricing (tiers and plans).
+---
+
+# Landing Copy: Mechanism (how it works)
+
+This section earns the claim the headline made and the hero section
+named. Its job is explanation, not evidence — "here is how this changes
+your situation," not "here is why you should believe it changes your
+situation" (that's `landing-copy-proof`). A mechanism section that leans
+on stats or testimonials instead of actually explaining the how has
+borrowed proof's job instead of doing its own.
+
+## What this section answers
+
+One question: **how, specifically, does the product close the gap the
+problem section named?** Specific enough that the reader could explain
+it back in one sentence. A mechanism explained so abstractly it could
+describe any competing product's approach unchanged has failed the swap
+test the same way an ungrounded adjective does.
+
+## The algorithm
+
+Paragraph count from the beat count `landing-sequencer` assigned. Order
+within budget:
+
+1. **State the mechanism directly.** The specific thing the product does
+   — a feature, a process, a discipline — named plainly, in the same
+   register the hero section used (no re-invention of terminology
+   mid-page; if the hero section named it one way, this section uses the
+   same name — no synonym cycling across section boundaries).
+2. **Connect it to the problem section's specific friction.** Not a
+   generic benefit statement — the mechanism resolving the exact cost the
+   problem section named. This is the section's actual load-bearing
+   sentence: if it could be deleted and the mechanism would still sound
+   equally justified, it's not doing its job.
+3. **Land on the changed state.** Close on what's now true for the reader
+   that wasn't true before this section — the transformation completed,
+   not a segue into proof or a preview of what's coming.
+
+A 1-beat mechanism section compresses all three (state it, connect it,
+land the change) into one paragraph; a 3-beat section earns each its own
+paragraph, particularly when the mechanism has real internal steps worth
+walking through (in which case genuinely enumerable steps become a `-`
+list per `landing-copywriter`'s output format, alongside the connecting
+prose — not instead of it).
+
+## Writing standard (scoped to this section)
+
+- Apply `landing-copywriter`'s full writing standard.
+- **No unnamed authority, here specifically.** A mechanism section is the
+  easiest place to reach for "proven approach" or "industry-standard
+  method" without naming what makes it proven — if there's no named
+  source, state the mechanism as the product's own claim, not a floated
+  authority.
+- **List-shaped content only for genuine steps.** If the mechanism has 3+
+  discrete, ordered steps, a numbered or bulleted list is correct per
+  `landing-copywriter`'s output format. If it's one continuous idea, keep
+  it prose — don't force steps that don't exist to make the section look
+  more substantial.
+- **No proof creep.** A specific number, a named customer, a benchmark —
+  all belong to `landing-copy-proof`. If a proof point is doing the
+  persuading here instead of the mechanism's own logic, that's the wrong
+  section carrying the weight.
+
+## Self-test
+
+- The mechanism is named specifically enough to explain back in one
+  sentence — not a category noun standing in for the actual thing (the
+  same plain-verb discipline from `landing-strategist`'s step 1).
+- This section's central claim connects directly to the specific
+  friction the problem section named, not a generic benefit.
+- No proof point (stat, name, benchmark) appears here — that content is
+  flagged to `landing-copy-proof` instead.
+- The terminology matches whatever the hero section already named the
+  mechanism — no synonym rotation across the section boundary.
+
+## Constraints
+
+- Never lean on a proof point instead of an actual explanation — a
+  mechanism section that's mostly a stat has skipped its own job.
+- Never introduce new terminology for something already named in the
+  hero section.
+- Never turn a single continuous idea into a padded list to look more
+  thorough — list only what's genuinely enumerable.