@lovehlmmm/primekit 1.0.0

package/skills/cook/references/subagent-patterns.md

@@ -0,0 +1,87 @@
+# Subagent Patterns
+
+Standard patterns for spawning and using subagents in cook workflows.
+
+## Delegation Capability Pattern
+```
+delegate_agent capability(subagent_type="[type]", prompt="[task description]", description="[brief]")
+```
+
+## Research Phase
+```
+delegate_agent capability(subagent_type="researcher", prompt="Research [topic]. Report ≤150 lines.", description="Research [topic]")
+```
+- Use multiple researchers in parallel for different topics
+- Keep reports ≤150 lines with citations
+
+## Scout Phase
+```
+delegate_agent capability(subagent_type="scout", prompt="Find files related to [feature] in codebase", description="Scout [feature]")
+```
+- Use `/pk:scout ext` (preferred) or `/pk:scout` (fallback)
+
+## Planning Phase
+```
+delegate_agent capability(subagent_type="planner", prompt="Create implementation plan based on reports: [reports]. Save to [path]", description="Plan [feature]")
+```
+- Input: researcher and scout reports
+- Output: `plan.md` + `phase-XX-*.md` files
+
+## UI Implementation
+```
+delegate_agent capability(subagent_type="ui-ux-designer", prompt="Implement [feature] UI per the project's discovered design guidance", description="UI [feature]")
+```
+- For frontend work
+- Follow design guidelines
+
+## Testing
+```
+delegate_agent capability(subagent_type="tester", prompt="Run test suite for plan phase [phase-name]", description="Test [phase]")
+```
+- Must achieve 100% pass rate
+
+## Debugging
+```
+delegate_agent capability(subagent_type="debugger", prompt="Analyze failures: [details]", description="Debug [issue]")
+```
+- Use when tests fail
+- Provides root cause analysis
+
+## Code Review
+```
+delegate_agent capability(subagent_type="code-reviewer",
+     prompt="Review changes for [phase] against these MANDATORY checks: (a) every acceptance criterion met; (b) no regression to business logic in touchpoints/blast-radius from scout; (c) no breaking changes to public contracts (signatures, schemas, APIs, env vars) unless explicitly called out; (d) follows existing patterns from scout; (e) no new lint/type/build errors anywhere. CONTEXT — scout summary: <scout-summary>; acceptance criteria: <acceptance-criteria>. Return score (X/10), critical, warnings, suggestions, and explicitly flag any side effects to trigger HARD-GATE-NO-SIDE-EFFECTS.",
+     description="Review [phase]")
+```
+
+## Conditional Simplify
+```
+delegate_agent capability(subagent_type="code-simplifier", prompt="Simplify these files while preserving behavior exactly: [file-list]", description="Simplify recent edits")
+```
+- Trigger when live `git diff --numstat HEAD --ignore-all-space` breaches any
+  `simplify.threshold` from `.ck.json` (defaults: 400 LOC / 8 files / 200 single-file LOC)
+- Scope the prompt to `git diff --name-only HEAD`
+- Verify with `git diff --shortstat HEAD -- [file-list]` before/after the subagent;
+  do not rely on the agent's prose summary
+- Skip when `CK_SIMPLIFY_DISABLED=1` or `.ck.json` `simplify.gate.enabled=false`
+
+## Project Management
+Activate the `the engineer project-management skill` skill (MANDATORY at Finalize — not a subagent):
+> Run full sync-back in [plan-path]: reconcile completed tasks with all phase files, backfill stale completed checkboxes across all phases, update plan.md status/progress, and report unresolved mappings.
+
+## Documentation
+```
+delegate_agent capability(subagent_type="docs-manager", prompt="Update docs for [phase]. Changed files: [list]", description="Update docs")
+```
+
+## Git Operations
+```
+delegate_agent capability(subagent_type="git-manager", prompt="Stage and commit changes with conventional commit message", description="Commit changes")
+```
+
+## Parallel Execution
+```
+delegate_agent capability(subagent_type="fullstack-developer", prompt="Implement [phase-file] with file ownership: [files]", description="Implement phase [N]")
+```
+- Launch multiple for parallel phases
+- Include file ownership boundaries

package/skills/cook/references/workflow-routing.md

@@ -0,0 +1,53 @@
+# Workflow Routing
+
+Use this file when choosing the sequence for multi-step work. It is a routing
+map only; load the owning `SKILL.md` before executing details.
+
+## Core Sequences
+
+| User intent | Sequence |
+|---|---|
+| Implement a feature | `/pk:brainstorm` -> `the engineer plan skill` -> `/pk:cook` -> `the installed test skill` -> `the installed code-review skill` |
+| Execute an accepted plan | reuse its brainstorm contract -> `/pk:cook <plan-path>` |
+| Quick implementation | bounded brainstorm gate -> `/pk:cook --fast` |
+| Bug, error, failed test, or CI failure | opening intent frame -> `/pk:fix` |
+| Investigate before deciding | `/pk:scout` -> `the engineer debug skill` -> `/pk:brainstorm` -> `the engineer plan skill` |
+| Review a PR | `the installed review-pr skill <PR>` |
+| Fix review feedback | `the installed review-pr skill <PR> --fix` or `/pk:fix --parallel` |
+| Ship a completed branch | `the engineer ship skill` |
+| Explain work visually | `/pk:preview --explain` or `/pk:preview --html --diff` |
+| Update project docs | `/pk:docs update` |
+
+## Implementation Owner
+
+- Start delivery with outcome, constraints, non-goals, and acceptance criteria.
+  Reuse them from an accepted plan instead of asking again.
+- Use `/pk:cook` for known feature scope after requirements are clear.
+- Use `/pk:fix` for concrete bugs, errors, test failures, and CI failures.
+- Use `the engineer plan skill` when work needs architecture, phases, file ownership, or TDD
+  structure.
+- Use `the installed test skill` for verification-only work.
+- Use `the engineer ship skill` only after implementation, tests, and review are done.
+- Read-only scout, debug, review, and explanation work may stop without an
+  interactive design loop. Satisfy the brainstorm gate if it crosses into
+  delivery or workspace mutation.
+
+## Handoff Rules
+
+- Establish the brainstorm contract, then use the domain skill for evidence and
+  design, followed by the workflow owner. Example: for a React feature, route
+  to `the installed frontend-development skill`, then execute through the
+  installed plan skill and `/pk:cook`.
+- For visual explanations, invoke the installed preview skill and follow its
+  explanation routing.
+- For documentation changes, invoke `/pk:docs update` and follow the installed
+  documentation-management routing.
+- If `find-skills` is installed and skill choice is ambiguous, invoke it for
+  domain routing. Otherwise use the installed skill names and descriptions.
+
+## Post-Implementation
+
+- Review high-risk, cross-module, or public-contract changes before shipping.
+- Update docs only when behavior, setup, commands, architecture, security
+  posture, public contracts, or future maintainer decisions changed.
+- Journal when a workflow creates durable decisions or debugging lessons.

package/skills/cook/references/workflow-steps.md

@@ -0,0 +1,261 @@
+# Unified Workflow Steps
+
+All modes share core steps with mode-specific variations.
+
+**Runtime progress contract:** Discover the live task-management surface and use
+it when available. Otherwise, update the active plan directly. Plan files are
+the durable source of truth, and every workflow step must work without runtime
+task tracking.
+
+## Step 0: Brainstorm Contract, Intent Detection & Setup
+
+1. Capture outcome, constraints, non-goals, and acceptance criteria. Reuse them
+   from an accepted plan or design when present.
+2. Resolve only material gaps; routine approval is unnecessary in explicit auto
+   mode when the contract is already concrete.
+3. Parse input with `intent-detection.md` rules.
+4. If mode=code: detect plan path, set active plan, and retain its accepted
+   brainstorm contract.
+5. For three or more meaningful steps, mirror progress into the live task-management surface when available.
+
+**Output:** concise brainstorm contract plus detected workflow mode and reason.
+
+## Step 1: Research (skip if fast/code mode)
+
+**Interactive/Auto:**
+- Spawn multiple `researcher` agents in parallel
+- Use `/pk:scout ext` or `scout` agent for codebase search
+- Keep reports ≤150 lines
+- Evaluate findings against the opening outcome and constraints.
+
+**Parallel:**
+- Optional: max 2 researchers if complex
+
+**Output:** `✓ Step 1: Research complete - [N] reports gathered`
+
+### [Review Gate 1] Post-Research (skip if auto mode)
+- Present research summary to user
+- Use `ask_user capability` to ask: "Proceed to planning?" / "Request more research" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 2: Planning
+
+**Interactive/Auto/No-test:**
+- Use `planner` agent with research context
+- Create `plan.md` + `phase-XX-*.md` files
+
+**Fast:**
+- Use `the engineer plan skill --fast` with scout results only
+- Minimal planning, focus on action
+
+**Parallel:**
+- Use `the engineer plan skill --parallel` for dependency graph + file ownership matrix
+
+**Code:**
+- Skip - plan already exists
+- Parse existing plan for phases
+
+**Output:** `✓ Step 2: Plan created - [N] phases`
+
+### [Review Gate 2] Post-Plan (skip if auto mode)
+- Present plan overview with phases
+- Use `ask_user capability` to ask: "Validate the plan or approve plan to start implementation?" - "Validate" / "Approve" / "Abort" / "Other" ("Request revisions")
+  - "Validate": run `the engineer plan skill validate` skill invocation
+  - "Approve": continue to implementation
+  - "Abort": stop the workflow
+  - "Other": revise the plan based on user's feedback
+- **Auto mode:** Skip this gate
+
+## Step 3: Implementation
+
+**IMPORTANT:**
+1. Read the active plan before trusting session state.
+2. Discover the live task-management surface and compare any existing view with the plan.
+3. If the view is absent or stale, rebuild it from unchecked plan items when supported.
+4. Preserve phase order, dependencies, ownership, and source-plan mapping; otherwise track them in the active plan.
+
+### Conformance Checklist (before writing code)
+
+Before implementing each phase, the developer agent MUST:
+
+1. **Read repository instructions and the routed project docs relevant to this
+   change**; do not assume a standard docs filename exists.
+2. **Scout adjacent code patterns** in the files being modified and follow the
+   same import, logging, and error-wrapping style.
+3. **Check for existing helpers** before creating new utilities so the change
+   stays DRY.
+4. **Verify interface contracts** so new code extends the current surface
+   instead of creating a parallel one.
+5. **Cross-check the plan checklist** so every file in the phase inventory is
+   actually addressed.
+
+After each file is modified:
+- **Compile check:** run the relevant project compile/type-check command
+- **Pattern verify:** confirm the new code matches adjacent conventions
+- **Import check:** confirm no circular dependency or dead import was added
+
+### `--tdd` Flag Behavior
+
+When `--tdd` is active, Step 3 splits into sub-steps per phase:
+
+```
+Step 3.T: Write tests for CURRENT behavior (regression safety net)
+Step 3.I: Implement changes (refactor, new code)
+Step 3.V: Verify all tests from 3.T still pass + compile gates
+```
+
+Tests from Step 3.T document the current behavior. If any fail after Step 3.I,
+the refactor broke something and must be fixed before the workflow proceeds.
+
+**All modes:**
+- Record the current item as active through the live task-management surface when available; otherwise update the active plan.
+- Execute phase tasks sequentially (Step 3.1, 3.2, etc.)
+- Use `ui-ux-designer` for frontend
+- Use `pk:ai-multimodal` for image assets
+- Run type checking after each file
+
+**Parallel mode:**
+- Discover the live task-management surface before using it; do not rely on copied tool names or client restrictions.
+- Launch multiple `fullstack-developer` agents
+- When agents pick up work, record ownership and active state through the live capability or active plan.
+- Respect file ownership boundaries
+- Wait for parallel group before next
+
+**Output:** `✓ Step 3: Implemented [N] files - [X/Y] tasks complete`
+
+### Step 3.S: Conditional Simplify (live-diff gated)
+
+Recompute signals from the live worktree (no hook state):
+
+```bash
+totals=$(git diff --numstat HEAD --ignore-all-space)
+loc=$(echo "$totals" | awk '{s+=$1+$2} END {print s+0}')
+files=$(echo "$totals" | awk 'NF{c++} END {print c+0}')
+maxFile=$(echo "$totals" | awk 'BEGIN{m=0} {if ($1>m) m=$1} END {print m+0}')
+modified=$(git diff --name-only HEAD)
+```
+
+Read thresholds from `.ck.json` (`simplify.threshold.{locDelta,fileCount,singleFileLoc}`),
+defaulting to 400 / 8 / 200. If any threshold is breached, spawn the simplifier
+scoped to the modified files:
+
+```
+delegate_agent capability(subagent_type="code-simplifier", prompt="Simplify these files while preserving behavior exactly: [file-list]", description="Simplify recent edits")
+```
+
+After the subagent returns, log only — never re-run or block:
+- `git diff --shortstat HEAD -- [file-list]` changed → "simplifier made scoped edits"
+- unchanged → "simplifier ran clean"
+
+Skip the step entirely when `CK_SIMPLIFY_DISABLED=1` or
+`.ck.json` `simplify.gate.enabled` is `false`.
+
+**Output:** `✓ Step 3.S: Simplify [ran|skipped] - [scoped changes|clean|under threshold]`
+
+### [Review Gate 3] Post-Implementation (skip if auto mode)
+- Present implementation summary (files changed, key changes)
+- Use `ask_user capability` to ask: "Proceed to testing?" / "Request implementation changes" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 4: Testing (skip if no-test mode)
+
+**All modes (except no-test):**
+- Write tests: happy path, edge cases, errors
+- **MUST** spawn `tester` subagent: `delegate_agent capability(subagent_type="tester", prompt="Run test suite", description="Run tests")`
+- If failures: **MUST** spawn `debugger` subagent → fix → repeat
+- **Forbidden:** fake mocks, commented tests, changed assertions, skipping subagent delegation
+
+**Output:** `✓ Step 4: Tests [X/X passed] - tester subagent invoked`
+
+### [Review Gate 4] Post-Testing (skip if auto mode)
+- Present test results summary
+- Use `ask_user capability` to ask: "Proceed to code review?" / "Request test fixes" / "Abort"
+- **Auto mode:** Skip this gate
+
+## Step 5: Code Review
+
+**All modes - MANDATORY subagent:**
+- **MUST** spawn `code-reviewer` subagent with explicit (a-e) checks and scout/acceptance context:
+  ```
+  delegate_agent capability(subagent_type="code-reviewer",
+       prompt="Review changes against these MANDATORY checks: (a) every acceptance criterion met; (b) no regression to business logic in touchpoints/blast-radius from scout; (c) no breaking changes to public contracts (signatures, schemas, APIs, env vars) unless explicitly called out; (d) follows existing patterns from scout; (e) no new lint/type/build errors anywhere. CONTEXT — scout summary: <scout-summary>; acceptance criteria: <acceptance-criteria>. Return score (X/10), critical, warnings, suggestions, and explicitly flag any side effects to trigger HARD-GATE-NO-SIDE-EFFECTS.",
+       description="Code review")
+  ```
+- **DO NOT** review code yourself - delegate to subagent
+
+**Interactive/Parallel/Code/No-test:**
+- Interactive cycle (max 3): see `review-cycle.md`
+- Requires user approval
+
+**Auto:**
+- Apply the auto-mode decision from `review-cycle.md`
+- Auto-fix critical (max 3 cycles)
+- Escalate to user after 3 failed cycles
+
+**Fast:**
+- Simplified review, no fix loop
+- User approves or aborts
+
+**Output:** `✓ Step 5: Review [score]/10 - [Approved|Auto-approved] - code-reviewer subagent invoked`
+
+## Step 6: Finalize
+
+**All modes - finalize contract:**
+1. **MUST** activate `the engineer project-management skill` skill (MANDATORY) — run full sync-back for [plan-path]: reconcile completed runtime work with all phase files, backfill stale completed checkboxes across every phase, then update plan.md frontmatter/table progress. Do NOT only mark current phase.
+2. Evaluate docs impact using the installed documentation-management routing.
+   If an authority surface changed, delegate `docs-manager` with the changed
+   contract, evidence, and exact routed docs in scope. Do not issue a generic
+   whole-corpus refresh.
+3. Project-management sync-back MUST include:
+
+### Status Sync (Finalize)
+
+When PrimeKit CLI is available, run `primekit plan --help`, then run the selected
+status subcommand with `--help` before changing plan state. Live help owns the
+syntax and effects; do not copy an argument schema into this workflow.
+
+**Fallback:** If `primekit` is not available, edit plan.md directly —
+only change the Status column cell, preserve table structure.
+   - Sweep all `phase-XX-*.md` files in the plan directory.
+   - Mark every completed item `[ ] → [x]` based on completed tasks (including earlier phases finished before current phase).
+   - Update `plan.md` status/progress (`pending`/`in-progress`/`completed`) from actual checkbox state.
+   - Return unresolved mappings if any completed task cannot be matched to a phase file.
+4. After sync-back confirmation, reflect completion in the live task-management surface when available.
+5. Onboarding check (API keys, env vars)
+6. **MUST** spawn git subagent: `delegate_agent capability(subagent_type="git-manager", prompt="Stage and commit changes", description="Commit")`
+
+**CRITICAL:** Step 6 is incomplete without project-management sync-back, an
+explicit docs-impact decision, and the configured git approval flow.
+
+**Auto mode:** Continue to next phase automatically, start from **Step 3**.
+**Others:** Ask user before next phase
+
+**Output:** `✓ Step 6: Finalized - 3 subagents invoked - Full-plan sync-back completed - Committed`
+
+## Mode-Specific Flow Summary
+
+Legend: `[R]` = Review Gate (human approval required)
+
+```
+interactive: 0 → 1 → [R] → 2 → [R] → 3 → [R] → 4 → [R] → 5(user) → 6
+auto:        0 → 1 → 2 → 3 → 4 → 5(auto) → 6 → next phase (NO stops)
+fast:        0 → skip → 2(fast) → [R] → 3 → [R] → 4 → [R] → 5(simple) → 6
+parallel:    0 → 1? → [R] → 2(parallel) → [R] → 3(multi-agent) → [R] → 4 → [R] → 5(user) → 6
+no-test:     0 → 1 → [R] → 2 → [R] → 3 → [R] → skip → 5(user) → 6
+code:        0 → skip → skip → 3 → [R] → 4 → [R] → 5(user) → 6
+```
+
+**Key difference:** `auto` mode is the ONLY mode that skips all review gates.
+
+## Critical Rules
+
+- Never skip steps without mode justification
+- **MANDATORY DELEGATION:** Steps 4, 5, 6 MUST delegate via delegate_agent capability / skill activation. DO NOT implement directly.
+  - Step 4: `tester` (and `debugger` if failures)
+  - Step 5: `code-reviewer`
+  - Step 6: `the engineer project-management skill`, conditional `docs-manager`, `git-manager`
+- Discover the live task-management surface before using runtime tracking.
+- If available, mirror unchecked plan items and keep their status current.
+- If unavailable, update the active plan directly; plan files remain authoritative.
+- All step outputs follow format: `✓ Step [N]: [status] - [metrics]`
+- **VALIDATION:** If delegate_agent calls = 0 at end of workflow, the workflow is INCOMPLETE.

package/skills/copywriting/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: pk:copywriting
+description: Conversion copywriting formulas, headline templates, email copy patterns, landing page structures, CTA optimization, and writing style extraction. Activate for writing high-converting copy, crafting headlines, email campaigns, landing pages, or applying custom writing styles from assets/writing-styles/ directory.
+user-invocable: true
+when_to_use: "Invoke for conversion copy, headlines, emails, or style transfer."
+category: utilities
+keywords: [copy, headlines, email, landing-page]
+license: MIT
+argument-hint: "[copy-type] [context]"
+metadata:
+  author: primekit
+  version: "1.0.0"
+---
+
+# Copywriting
+
+Formulas, templates, patterns, and writing styles for high-converting copy.
+
+## When to Use
+
+- Writing headlines/subject lines, landing page copy, email campaigns
+- Social posts, product descriptions, CTA optimization, A/B variations
+- Applying custom writing styles from user documents
+
+## Writing Styles
+
+Load: `references/writing-styles.md` for the bundled style catalog.
+
+**Extract styles from multi-format files:**
+```bash
+python scripts/extract-writing-styles.py --list        # List files
+python scripts/extract-writing-styles.py --style <name> # Extract style
+```
+
+**Formats:** `.md` `.txt` `.pdf` `.docx` `.xlsx` `.pptx` `.jpg` `.png` `.mp4` (docs/media need `GEMINI_API_KEY`)
+
+## Copy Formulas
+
+Load: `references/copy-formulas.md`
+
+| Formula | Structure | Best For |
+|---------|-----------|----------|
+| AIDA | Attention → Interest → Desire → Action | Landing pages, ads |
+| PAS | Problem → Agitate → Solution | Email, sales pages |
+| BAB | Before → After → Bridge | Testimonials, case studies |
+| 4Ps | Promise → Picture → Proof → Push | Long-form sales |
+| 4Us | Urgent + Unique + Useful + Ultra-specific | Headlines |
+| FAB | Feature → Advantage → Benefit | Product descriptions |
+
+## Headlines
+
+Load: `references/headline-templates.md`
+
+Patterns: "How to [X] without [Y]" • "[Number] ways to [benefit]" • "The secret to [outcome]" • "Why [belief] is wrong"
+
+## Email Copy
+
+Load: `references/email-copy.md`
+
+Subject lines: Curiosity gap • Benefit-driven • Question • Urgency
+
+## Landing Pages & CTAs
+
+Load: `references/landing-page-copy.md` | `references/cta-patterns.md`
+
+Hero: Headline (promise) → Subheadline (how) → CTA (action) → Social proof
+CTAs: "Start [verb]ing" • "Get [benefit]" • "Yes, I want [benefit]"
+
+## References
+
+| File | Purpose |
+|------|---------|
+| `references/writing-styles.md` | 30 writing styles quick reference |
+| `references/copy-formulas.md` | AIDA, PAS, BAB, 4Ps, FAB formulas |
+| `references/headline-templates.md` | Headline patterns & templates |
+| `references/email-copy.md` | Email copy patterns |
+| `references/landing-page-copy.md` | Landing page structure |
+| `references/cta-patterns.md` | CTA optimization |
+| `references/power-words.md` | Power words by emotion |
+| `references/social-media-copy.md` | Platform-specific copy |
+| `scripts/extract-writing-styles.py` | Extract styles from multi-format files |
+| `templates/copy-brief.md` | Creative brief template |
+
+## Agent Integration
+
+**Primary:** fullstack-developer | **Related:** brand-guidelines, content-marketing, email-marketing
+
+## Best Practices
+
+1. Lead with benefit, not feature | 2. One CTA per piece
+3. Specificity > vague claims | 4. Read aloud—if awkward, rewrite
+5. Test headlines first | 6. Match copy to awareness level
+
+## Outputs
+
+**IMPORTANT:** Invoke "the engineer project-organization skill" skill to organize the outputs.

package/skills/copywriting/references/copy-formulas.md

@@ -0,0 +1,150 @@
+# Copy Formulas
+
+Proven frameworks for persuasive writing.
+
+## AIDA (Attention → Interest → Desire → Action)
+
+The classic framework. Works for landing pages, ads, sales emails.
+
+```
+ATTENTION: Bold claim or pattern interrupt
+INTEREST: Explain why this matters to them
+DESIRE: Paint the picture of transformation
+ACTION: Clear CTA with urgency
+```
+
+**Example:**
+```
+[A] Stop losing 80% of your leads.
+[I] Most businesses capture emails but never convert them.
+    The problem isn't your product—it's your follow-up.
+[D] Imagine waking up to sales notifications while you sleep.
+    Our automation sends the right message at the right time.
+[A] Start your free trial → No credit card required.
+```
+
+## PAS (Problem → Agitate → Solution)
+
+Dan Kennedy's "most reliable formula." Works for email, sales pages.
+
+```
+PROBLEM: Name the specific pain
+AGITATE: Twist the knife (consequences, frustration)
+SOLUTION: Present your offer as the answer
+```
+
+**Example:**
+```
+[P] You're posting on LinkedIn daily but getting zero leads.
+[A] Hours of content creation. Crickets in your DMs.
+    Meanwhile, competitors with worse products are
+    booking calls. What do they know that you don't?
+[S] Our LinkedIn system generates 15+ qualified leads/week
+    using posts that take 10 minutes to write.
+```
+
+## BAB (Before → After → Bridge)
+
+Best for testimonials, case studies, transformation stories.
+
+```
+BEFORE: Describe the painful current state
+AFTER: Paint the desired future state
+BRIDGE: Your product/service is the bridge
+```
+
+**Example:**
+```
+[B] Sarah spent 4 hours/day on customer support emails.
+    Burnout was inevitable. Her team was drowning.
+[A] Now she handles 3x the volume in 1 hour.
+    Her team focuses on growth, not firefighting.
+[BR] The bridge? Our AI support assistant that learns
+     your voice and handles 80% of tickets automatically.
+```
+
+## 4Ps (Promise → Picture → Proof → Push)
+
+Long-form sales pages, webinar pitches.
+
+```
+PROMISE: Bold outcome claim
+PICTURE: Help them visualize having it
+PROOF: Evidence it works (testimonials, data)
+PUSH: Create urgency, clear CTA
+```
+
+## 4Us (Urgent + Unique + Useful + Ultra-specific)
+
+Headlines, subject lines, hooks.
+
+| U | Meaning | Example |
+|---|---------|---------|
+| Urgent | Time-sensitive | "24 hours left" |
+| Unique | Different from competition | "The only..." |
+| Useful | Clear benefit | "Save 10 hours/week" |
+| Ultra-specific | Precise details | "47% increase in 30 days" |
+
+**Example headline:**
+"[24 hours] The only cold email template that books [23 calls/month]"
+
+## FAB (Feature → Advantage → Benefit)
+
+Product descriptions, feature announcements.
+
+```
+FEATURE: What it is
+ADVANTAGE: What it does better
+BENEFIT: Why they care
+```
+
+**Example:**
+```
+[F] One-click export to PDF
+[A] No more screenshots or manual formatting
+[B] Share professional reports in seconds, not hours
+```
+
+## ACCA (Awareness → Comprehension → Conviction → Action)
+
+Educational content, complex products.
+
+```
+AWARENESS: Make them aware of the problem/opportunity
+COMPREHENSION: Help them understand the solution
+CONVICTION: Build belief with proof
+ACTION: Direct next step
+```
+
+## The 1-2-3-4 Formula
+
+Quick, punchy copy. Social posts, short emails.
+
+```
+1. What I've got for you
+2. What it will do for you
+3. Who am I? (credibility)
+4. What you need to do next
+```
+
+## Star-Chain-Hook
+
+Storytelling format for longer content.
+
+```
+STAR: Introduce the hero (reader or case study)
+CHAIN: Series of facts, benefits, reasons
+HOOK: Compelling CTA
+```
+
+## Formula Selection Guide
+
+| Situation | Best Formula |
+|-----------|--------------|
+| Cold audience | AIDA, ACCA |
+| Aware of problem | PAS |
+| Testimonial | BAB |
+| Product feature | FAB |
+| Headline | 4Us |
+| Sales page | 4Ps |
+| Quick hook | 1-2-3-4 |