@hanzlaa/rcode 4.3.2 → 4.4.0

package/rcode/skills/seo/seo-content-factory/rules/programmatic-pages.md

@@ -0,0 +1,107 @@
+# Programmatic Pages — marketing/ wiring
+
+This is the concrete Next.js 16 App Router implementation for the canonical `marketing/`
+site (`/home/hanzla/development/teaching/schedule-manager/marketing`). It honors the site's
+existing conventions: **TS data files in `src/data/` (programmatic) + MDX (editorial)**.
+Do NOT add a CMS, contentlayer, gray-matter-DB, or runtime fetching — the site is SSG.
+
+## Two output channels
+
+| Channel | Source | Route | Scale | Use for |
+|---------|--------|-------|-------|---------|
+| **Programmatic** | `src/data/seo/*.ts` (typed) | `src/app/(seo)/[...]/page.tsx` + `generateStaticParams` | 1,000s | service×city, service×industry, location pages |
+| **Editorial (MDX)** | `src/content/<type>/*.mdx` | `src/app/blog/[slug]` (already a shell) + new `alternatives`/`comparisons` | ~100 | alternatives, comparisons, cornerstone, statistics, questions |
+
+## Programmatic: the 2,000-page pattern
+
+100 cities × 20 services = 2,000 pages from **~5 files**, not 2,000 files.
+
+### 1. Dimension registries — `src/data/seo/` (matches existing `src/data/*.ts`)
+```ts
+// src/data/seo/services.ts
+export interface SeoService {
+  slug: string; name: string; h1: string;
+  benefits: string[]; painPoints: string[]; faqs: { q: string; a: string }[];
+}
+export const services: SeoService[] = [ /* 20 records, A7-generated */ ]
+
+// src/data/seo/cities.ts
+export interface SeoCity { slug: string; name: string; region: string; country: string }
+export const cities: SeoCity[] = [ /* 100 records */ ]
+```
+
+### 2. One dynamic route for the cross-product
+```tsx
+// src/app/(seo)/[service]/[city]/page.tsx
+import { services } from '@/data/seo/services'
+import { cities } from '@/data/seo/cities'
+import { notFound } from 'next/navigation'
+
+export function generateStaticParams() {
+  return services.flatMap(s => cities.map(c => ({ service: s.slug, city: c.slug })))
+}
+
+export async function generateMetadata({ params }) {
+  const { service, city } = await params
+  const s = services.find(x => x.slug === service); const c = cities.find(x => x.slug === city)
+  if (!s || !c) return {}
+  return {
+    title: `${s.name} in ${c.name} | LeadLyze`,
+    description: `${s.name} for ${c.name} businesses — ${s.benefits[0]}. Book more meetings with LeadLyze.`,
+    alternates: { canonical: `https://leadlyze.com/${service}/${city}` },
+  }
+}
+
+export default async function Page({ params }) {
+  const { service, city } = await params
+  const s = services.find(x => x.slug === service); const c = cities.find(x => x.slug === city)
+  if (!s || !c) notFound()
+  // Hero → Benefits → Case Studies → Pricing → FAQ → CTA, all composed from s + c
+  // ...
+}
+```
+Full route template: `templates/programmatic-page.tsx`.
+
+### 3. Thin-content guard (mandatory — see quality-gates.md)
+Templated pages are the #1 thin-content / doorway-page risk. Each page MUST inject ≥2
+**city-specific or service-specific** unique elements (local stat, named local use-case,
+varied intro sentence keyed off `c.region`/`s.painPoints`) so no two pages are near-duplicates.
+A page that's pure boilerplate with the city name swapped ships as `noindex`.
+
+## Editorial: the MDX channel
+
+The blog `[slug]` shell already says *"fetch MDX/CMS content by slug"*. Wire it minimally:
+
+```ts
+// src/lib/mdx.ts — tiny loader, no DB
+import { compileMDX } from 'next-mdx-remote/rsc'   // add dep ONLY with user consent
+import fs from 'node:fs/promises'
+export async function getDoc(type: string, slug: string) { /* read src/content/<type>/<slug>.mdx, compile */ }
+export async function listSlugs(type: string) { /* readdir, strip .mdx */ }
+```
+> **DECIDED (2026-06-14):** use `next-mdx-remote` for the editorial channel. It's a new dep —
+> add it at Phase 0 (`pnpm add next-mdx-remote`) and confirm `pnpm build` still passes before
+> wave 1. (Zero-dep fallback, only if the user reverses: structured TS bodies rendered via the
+> existing `src/components/blog` components.)
+
+`generateStaticParams` for blog/alternatives/comparisons then returns `listSlugs(type)`.
+
+## Schema (A8) — extend the existing helper
+
+`src/lib/jsonld.ts` already exists. Add typed builders (`faqPage`, `softwareApplication`,
+`product`, `breadcrumbList`, `aggregateRating`) and render via a `<JsonLd>` component —
+never hand-write `<script type="application/ld+json">` strings inline.
+
+## Sitemap
+
+`next-sitemap` is already configured (`next-sitemap.config.js`, siteUrl leadlyze.com). It
+crawls the built `.next` output, so all `generateStaticParams` pages are included
+automatically on `pnpm build && next-sitemap`. For 2,000+ URLs, enable sitemap splitting:
+add `sitemapSize: 5000` (default already chunks at 5k) — verify `robots.txt` references the
+index. No per-page sitemap code needed.
+
+## Establishing the content layer (Phase 0, once)
+
+If `src/data/seo/` and `src/app/(seo)/` don't exist yet, the orchestrator scaffolds them
+before wave 1: create the dirs, drop the route template + empty typed registries, confirm
+`pnpm build` still passes (baseline). Only THEN do fan-out waves populate them.

package/rcode/skills/seo/seo-content-factory/rules/quality-gates.md

@@ -0,0 +1,68 @@
+# Quality Gates — the firewall against AI slop & thin pages
+
+Scaling to 2,000 pages is worthless if Google classifies them as thin/doorway/spam. These
+gates are non-negotiable. A page that fails ships as `noindex`, never as raw indexable content.
+
+## Gate 1 — Briefs before prose (hard)
+
+The Writer (A5) **refuses to run** for any slug without `briefs/<slug>.md` marked
+`status: approved`. Rationale: a brief forces real-SERP research, an outline, entities, and a
+unique angle BEFORE generation — which is the difference between a ranked page and generic
+filler. Orchestrator enforces: when dispatching a Writer pane, it verifies the brief exists
+first; if missing, it routes the cluster back to A4, not forward to A5.
+
+## Gate 2 — Anti-generic-AI content rules (A5 must obey)
+
+BANNED in any generated page:
+- Filler openers: "In today's fast-paced world", "In the digital age", "When it comes to…".
+- Empty hedging: "can help", "may be able to", "is a great way to" with no specifics.
+- Unsupported stats: every number is cited (source + year) or cut.
+- Restated headings as the first sentence of each section.
+- Conclusion that summarizes with no new CTA/next step.
+
+REQUIRED in any generated page:
+- ≥1 concrete LeadLyze example or named use-case.
+- ≥1 data table or comparison matrix.
+- Real statistics with citations.
+- An FAQ section answering the People-Also-Ask questions from the brief.
+- Inline internal links from the brief (not dumped at the bottom).
+- A specific CTA tied to the page's funnel stage.
+
+## Gate 3 — Thin / duplicate-content gate (programmatic pages)
+
+The doorway-page killer. For templated pages each MUST have:
+- Unique `<title>`, `<h1>`, and **first 2 sentences** (keyed off the varying dimension).
+- ≥2 dimension-specific unique blocks (local stat, named local use-case, region-keyed copy).
+- ≥ the cluster's `min_words` floor of genuinely varying text (boilerplate doesn't count).
+- Pairwise similarity < 0.8 vs sibling pages (cheap check: shingle/Jaccard on body text).
+
+Fail → `noindex` + queue for enrichment. NEVER ship a city-swap-only page indexable.
+
+## Gate 4 — Indexability gate (every page, pre-ship)
+
+Before a page moves `linked → shipped`:
+- [ ] Unique title + meta description (≤60 / ≤155 chars), self-referencing canonical.
+- [ ] ≥10 inbound + ≥10 outbound internal links recorded in `link-map.json` (no orphans).
+- [ ] Valid JSON-LD matching page type (A8), validates against schema.org.
+- [ ] Word count ≥ cluster floor; passes Gate 2/3.
+- [ ] No broken internal links (every link target exists in the route set).
+- [ ] `pnpm build` static-generates it; no tsc error introduced.
+
+## Gate 5 — Build/type baseline (per wave, orchestrator)
+
+Capture `pnpm tsc --noEmit | grep -c "error TS"` at campaign start. After each wave merge,
+re-run; any wave that raises the count is reverted from the integration branch and the
+offending cluster re-dispatched. (Children never run tsc — orchestrator-only, per
+`feedback_no_build_in_child_agents`.)
+
+## Gate 6 — Evidence gate (A1/A2/A9/A10)
+
+No keyword enters `keywords.csv` without a real Semrush volume+KD. AI-estimated metrics are
+a hypothesis flagged `est=true`, never treated as ground truth, and must be confirmed against
+a live SERP or Semrush pull before a money page is built on them.
+
+## What "shipped" means
+
+`shipped` = merged into the integration branch, passed Gates 1–6, recorded in `BACKLOG.md`.
+It does **not** mean pushed to master or deployed — that's a separate, explicit,
+user-consented step (see all three skills' push rules).

package/rcode/skills/seo/seo-content-factory/rules/weekly-cadence.md

@@ -0,0 +1,61 @@
+# Weekly Cadence + 90-Day Plan + the A9/A10 Loop
+
+The factory has a one-shot ramp (build the backlog of pages) and a steady-state loop (keep
+discovering + refreshing). Both are encoded here. In AUTO mode the orchestrator can run the
+whole week's stages back-to-back across waves; the day labels are the *logical* order, not a
+requirement to wait 24h between them.
+
+## Weekly logical order (one full turn of the crank)
+
+| Stage | Agents | Output |
+|-------|--------|--------|
+| Research | A1, A10 | competitor pages + net-new keyword opportunities |
+| Expand | A2 | `keywords.csv` grows |
+| Architect | A3 | `clusters.json` updated, new clusters → BACKLOG |
+| Brief | A4 | `briefs/<slug>.md` for the wave's editorial clusters |
+| Write | A5 (fan-out waves) | `src/content/**.mdx` |
+| Interlink | A6 | `link-map.json` ≥10/≥10 per page |
+| Programmatic | A7 + A8 | `src/data/seo/*.ts` + routes + schema |
+| Publish | gates + merge | clusters → `shipped` (push only on consent) |
+| Analyze | A9 | GSC deltas → refresh decaying pages, feed A10 |
+
+## 90-day target (state honestly to the user)
+
+| Month | Cumulative pages | Emphasis |
+|-------|------------------|----------|
+| 1 | 200 | programmatic location/industry (fast to index) + 20 cornerstone editorial |
+| 2 | 500 | + alternative + comparison money pages |
+| 3 | 1,000+ | + statistics/template/tool/question pages; refresh cycle steady-state |
+
+Reality check to set with the user: programmatic pages can index in **weeks**; cornerstone
+editorial is a **60–180 day** payoff. New content rarely ranks in 30 days. Don't promise
+rankings on a 30-day horizon — promise *production throughput* + a compounding curve.
+
+## The recurring loop (A9 + A10 — never "done")
+
+These are cron-shaped. Under `/loop` or `/schedule`, the orchestrator wakes them:
+
+**A10 Opportunity Finder — daily**
+1. Semrush `organic_research` diff: keywords competitors now rank for that aren't in `keywords.csv`.
+2. Score: `volume × intent_weight × winnability`. Dedupe vs existing keywords.
+3. Auto-brief the top N → append clusters to `BACKLOG.md` as `pending`.
+4. Next fan-out wave picks them up. No human in the loop unless a money cluster needs sign-off.
+
+**A9 Content Refresh — weekly**
+1. Pull `gsc-deltas.csv` (pages with falling position over 28 days) via browser-harness/GSC.
+2. For each decayer: diff vs current top-3 SERP. Update stale stats, add new competitors,
+   add fresh internal links + examples, bump `dateModified`.
+3. Record the diff; re-run gates; mark refreshed.
+
+## Backlog states (the frontier)
+
+`BACKLOG.md` tracks each cluster through: `pending → briefed → written → linked → shipped`
+(+ `noindex` for gate failures awaiting enrichment). This is the durable memory that
+survives auto-compact — the orchestrator always resumes from the file, never from chat
+recollection. Commit it at Phase 0 and after every wave.
+
+## Heartbeat honesty (inherited from autonomous-fix-campaign)
+
+`ScheduleWakeup` only fires under `/loop`. Outside it, saying "I'll wake in 20 min" is a lie.
+At Phase 0 confirm the heartbeat path with the user — `/loop`, `/schedule` cron, or manual
+ping — and act accordingly. Never go silent while panes are `working`.

package/rcode/skills/seo/seo-content-factory/templates/BACKLOG.md

@@ -0,0 +1,23 @@
+# SEO Content Factory — BACKLOG (durable frontier)
+# Commit at Phase 0 and after every wave. The orchestrator resumes from THIS file,
+# never from chat memory. States: pending → briefed → written → linked → shipped (+ noindex).
+
+## Campaign config
+- target_site: /home/hanzla/development/teaching/schedule-manager/marketing
+- integration_branch: seo-factory-integration
+- tsc_baseline: <fill: `pnpm tsc --noEmit | grep -c "error TS"`>
+- push_policy: LOCAL ONLY — no push/deploy without explicit user consent
+- heartbeat: <fill: /loop | /schedule cron | manual ping>
+- seeds: ["lead generation software", "cold email", "ai cold calling", "sales sequences"]
+- competitors: ["apollo.io", "instantly.ai", "lemlist.com", "smartlead.ai"]
+
+## Clusters
+| cluster_id | hub | page_kind | spokes | state | wave | notes |
+|---|---|---|---|---|---|---|
+| alt-apollo | alternatives | editorial | 1 | pending | – | money page |
+| ind-roofers | lead-generation | editorial | 1 | pending | – | |
+| loc-grid | lead-generation×city | programmatic | 2000 | pending | – | 100 cities × 20 services |
+| stat-coldemail | statistics | editorial | 1 | pending | – | linkable asset |
+
+## Wave log
+<!-- append: wave N | clusters | merged SHA | pages shipped | tsc delta -->

package/rcode/skills/seo/seo-content-factory/templates/agent-prompts/01-funnel-A1-A4.md

@@ -0,0 +1,63 @@
+# Funnel prompts (A1→A4) — run SEQUENTIALLY, one agent, before any fan-out.
+
+Common footer appended to EVERY prompt below:
+> Pull REAL data from Semrush MCP / live SERP before asserting any number — never invent volume/KD/traffic.
+> Write output to the canonical file path under `.planning/seo-factory/`. Do not print results only to chat.
+> You are working in the `marketing/` repo. Commit your output file with a clear message.
+
+---
+
+## A1 — Competitor Research
+```
+You are an SEO competitor analyst for LeadLyze (a lead-generation / sales-outreach platform:
+email + LinkedIn + AI cold calling sequences).
+
+Competitors: apollo.io, instantly.ai, lemlist.com, smartlead.ai.
+
+Using Semrush MCP (organic_research, overview_research) + web search, for EACH competitor pull
+their highest-traffic organic pages. For each page produce a CSV row:
+  keyword,type,intent,traffic,funnel,source_url,competitor
+- type ∈ industry | location | alternative | comparison | statistics | template | tool | blog
+- intent ∈ informational | commercial | transactional | navigational
+- funnel ∈ learn | compare | buy
+Keep only rows where LeadLyze could plausibly compete. ≥200 rows.
+Write to .planning/seo-factory/competitors.csv.
+```
+
+## A2 — Keyword Expansion
+```
+Read .planning/seo-factory/competitors.csv. Seeds: "lead generation software", "cold email",
+"ai cold calling", "sales sequences".
+
+Expand every seed across all 8 modifier axes: industry, location, alternative, comparison,
+template, statistics, question, tool. Use Semrush keyword_research (related + questions +
+broad match) to pull REAL volume and KD for each. Drop volume<10 OR KD>70 unless it is a clear
+money term. De-dupe. Thousands of rows.
+Write to .planning/seo-factory/keywords.csv with columns:
+  keyword,parent_seed,modifier_type,volume,kd,intent,funnel,cluster_id   (leave cluster_id blank)
+```
+
+## A3 — Sitemap Architect
+```
+Read .planning/seo-factory/keywords.csv. Cluster keywords by SERP overlap (use the
+claude-seo:seo-cluster skill / serp-analysis) into hub-and-spoke topics.
+
+For each cluster decide page_kind:
+- programmatic = high-volume templated dimensions (service×city, service×industry) → declare dimensions
+- editorial = where prose ranks (alternatives, comparisons, cornerstone, statistics)
+Mark each spoke type (money|supporting|blog) and min_words.
+Write .planning/seo-factory/clusters.json (validate against templates/cluster.schema.json) and
+write each keyword's cluster_id back into keywords.csv. Append new clusters to BACKLOG.md as pending.
+```
+
+## A4 — Content Brief Generator (the GATE feeder)
+```
+Read .planning/seo-factory/clusters.json. For EACH editorial cluster (skip programmatic ones),
+read the LIVE top-5 Google results for its primary keyword (serp-analysis) and produce a brief
+following templates/content-brief.md EXACTLY:
+  title, meta, search intent, full H2/H3 outline (mirror the winning structure + 1 unique
+  LeadLyze angle the top-5 lack), FAQ from People-Also-Ask, entities, inline internal links,
+  CTA, schema types, min_words.
+Write each to .planning/seo-factory/briefs/<slug>.md with status: approved.
+Do NOT write any article — briefs only. Mark each cluster `briefed` in BACKLOG.md.
+```

package/rcode/skills/seo/seo-content-factory/templates/agent-prompts/02-fanout-editorial-A5-A6-A8.md

@@ -0,0 +1,28 @@
+# Fan-out pane prompt — EDITORIAL cluster (runs A5→A6→A8 in one worktree).
+# One pane per cluster. Orchestrator fills {{CLUSTER_ID}}, {{BRANCH}}, {{SLUGS}}.
+
+```
+You are an SEO content agent in an ISOLATED git worktree on branch {{BRANCH}}, inside the
+LeadLyze `marketing/` repo. Work and commit ONLY here. Do NOT run pnpm build / tsc / dev /
+install — use `node --check` only. Do NOT push.
+
+Your cluster: {{CLUSTER_ID}}. Its approved briefs: {{SLUGS}} (under .planning/seo-factory/briefs/).
+
+GATE: For each slug, confirm .planning/seo-factory/briefs/<slug>.md exists with status: approved.
+If a brief is missing, STOP that slug and report it — never write an article without a brief.
+
+For each slug:
+1. (A5 Writer) Write src/content/<type>/<slug>.mdx STRICTLY to its brief, using
+   templates/article.mdx frontmatter. MANDATORY quality rules (quality-gates.md Gate 2):
+   - real LeadLyze examples + named use-cases, ≥1 data table, cited statistics, FAQ section
+   - inline internal links from the brief (not dumped at bottom), funnel-matched CTA
+   - BANNED: "in today's fast-paced world", empty hedging, uncited numbers, restated headings.
+2. (A6 Interlinker) Add ≥10 inbound + ≥10 outbound internal links with KEYWORD-VARIED anchors
+   (never the same anchor twice). Prefer same-cluster + hub↔spoke. Record in
+   .planning/seo-factory/link-map.json (write ONLY your cluster's keys).
+3. (A8 Schema) Inject JSON-LD via src/lib/jsonld.ts builders (FAQPage + the page's type +
+   BreadcrumbList). No hand-written <script> strings.
+
+Commit each page separately. Log what you shipped to .planning/seo-factory/AUDIT-{{CLUSTER_ID}}.md
+(page list, word counts, link counts). When done, give a one-line recap.
+```

package/rcode/skills/seo/seo-content-factory/templates/agent-prompts/03-fanout-programmatic-A7-A6-A8.md

@@ -0,0 +1,25 @@
+# Fan-out pane prompt — PROGRAMMATIC cluster (runs A7→A6→A8 in one worktree).
+# Skips the Writer (no per-page prose). Orchestrator fills {{CLUSTER_ID}}, {{BRANCH}}, {{DIMENSIONS}}.
+
+```
+You are a programmatic-SEO agent in an ISOLATED git worktree on branch {{BRANCH}}, inside the
+LeadLyze `marketing/` repo. Work and commit ONLY here. Do NOT run pnpm build / tsc / dev /
+install — `node --check` only. Do NOT push.
+
+Cluster: {{CLUSTER_ID}}. Dimensions: {{DIMENSIONS}} (e.g. service × city → services.ts × cities.ts).
+
+1. (A7) Build/extend the typed registries under src/data/seo/ (e.g. services.ts, cities.ts,
+   industries.ts) — typed TS exports matching the existing src/data/*.ts convention. Populate
+   real records (real city names/regions; real service benefits/painPoints/faqs from the cluster).
+2. (A7) Create/confirm ONE dynamic route per pattern under src/app/(seo)/... using
+   generateStaticParams over the cross-product (see templates/programmatic-page.tsx). 100×20 = 2000
+   pages from ~5 files — never 2000 separate files.
+   THIN-CONTENT GATE (quality-gates.md Gate 3): every page MUST inject ≥2 dimension-specific
+   unique blocks (region-keyed intro, local stat, named local use-case). A pure city-swap page
+   is a doorway page — forbidden. Keyword-vary the title, H1, and first 2 sentences.
+3. (A6) Wire hub↔spoke + cross-links; record your cluster's keys in link-map.json.
+4. (A8) Add typed JSON-LD builders to src/lib/jsonld.ts for this page type; render via <JsonLd/>.
+
+`node --check` every touched .ts/.tsx. Commit. Log page count + sample slugs to
+.planning/seo-factory/AUDIT-{{CLUSTER_ID}}.md. One-line recap when done.
+```

package/rcode/skills/seo/seo-content-factory/templates/agent-prompts/04-loop-A9-A10.md

@@ -0,0 +1,34 @@
+# Loop prompts (A9 weekly, A10 daily) — the recurring engine. Never "done".
+
+Common footer:
+> Pull REAL data (Semrush / GSC / live SERP). Write to canonical files. Dedupe against existing.
+
+---
+
+## A10 — Opportunity Finder (daily)
+```
+You are an SEO opportunity scout for LeadLyze. Competitors: apollo.io, instantly.ai,
+lemlist.com, smartlead.ai.
+
+Using Semrush organic_research, find keywords competitors NOW rank for that are NOT in
+.planning/seo-factory/keywords.csv (diff vs the file). Score each by volume × intent_weight ×
+winnability (lower KD + topical fit = higher). Dedupe against keywords.csv.
+
+For the top N: append them to keywords.csv, create cluster stubs, and append those clusters to
+BACKLOG.md as `pending` so the next fan-out wave picks them up. For money clusters, flag for
+human sign-off rather than auto-shipping. Report the top opportunities with scores.
+```
+
+## A9 — Content Refresh (weekly)
+```
+You are an SEO refresh agent for LeadLyze. Read .planning/seo-factory/gsc-deltas.csv (pages
+whose position fell over the last 28 days; pull via browser-harness/GSC if the file is stale).
+
+For each decaying page:
+1. Diff the page against the CURRENT top-3 Google results (serp-analysis).
+2. Update stale statistics (re-cite), add newly-relevant competitors/examples, add fresh
+   internal links, and bump dateModified in the frontmatter.
+3. Re-run the indexability gate (quality-gates.md Gate 4). Record the diff (what changed +
+   why) to .planning/seo-factory/AUDIT-refresh.md.
+Do NOT rewrite pages wholesale — incremental refresh only. Commit each page separately.
+```

package/rcode/skills/seo/seo-content-factory/templates/article.mdx

@@ -0,0 +1,39 @@
+---
+# A5 output frontmatter — keep keys stable; the MDX loader + schema (A8) read these.
+title: "The Best Apollo Alternative in 2026: LeadLyze vs Apollo"
+description: "Looking for an Apollo alternative? See how LeadLyze beats Apollo on price, deliverability, and AI outreach."
+slug: apollo-alternative
+cluster_id: alt-apollo
+type: alternatives          # blog | alternatives | comparisons → maps to src/content/<type>/
+keyword: apollo alternative
+intent: commercial
+published: 2026-06-14
+dateModified: 2026-06-14
+schema: [SoftwareApplication, FAQPage, BreadcrumbList]
+internalLinks:
+  - { to: instantly-alternative, anchor: "compared to Instantly" }
+  - { to: ai-cold-calling, anchor: "AI cold calling" }
+  - { to: pricing, anchor: "LeadLyze pricing" }
+faq:
+  - q: "Is there a free Apollo alternative?"
+    a: "Yes — LeadLyze offers a free tier that includes…"
+  - q: "Can I import my Apollo data into LeadLyze?"
+    a: "Yes, via CSV or the migration importer…"
+---
+
+{/* Body: written STRICTLY to briefs/apollo-alternative.md. Obeys quality-gates.md Gate 2.
+    No "in today's fast-paced world". Real table. Cited stats. Inline internal links. */}
+
+Sales teams switch off Apollo for three concrete reasons: per-credit pricing that scales
+badly, [deliverability complaints](/blog/cold-email-deliverability), and no native dialer.
+Here's how LeadLyze handles each.
+
+## LeadLyze vs Apollo — side by side
+
+| Capability | Apollo | LeadLyze |
+|---|---|---|
+| AI cold calling | ❌ | ✅ |
+| Email + LinkedIn sequences | ✅ | ✅ |
+| Per-credit pricing | Yes | Flat seats |
+
+<!-- … rest of body per brief outline … -->

package/rcode/skills/seo/seo-content-factory/templates/cluster.schema.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "clusters.json — A3 output",
+  "type": "object",
+  "required": ["hubs"],
+  "properties": {
+    "hubs": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "hub_page", "spokes", "page_kind"],
+        "properties": {
+          "id": { "type": "string" },
+          "title": { "type": "string" },
+          "hub_page": {
+            "type": "object",
+            "required": ["slug", "type", "keyword"],
+            "properties": {
+              "slug": { "type": "string" },
+              "type": { "enum": ["money", "supporting", "blog"] },
+              "keyword": { "type": "string" }
+            }
+          },
+          "page_kind": { "enum": ["programmatic", "editorial"] },
+          "dimensions": {
+            "type": "object",
+            "description": "Required when page_kind=programmatic",
+            "properties": {
+              "service": { "type": "string" },
+              "vary_by": { "type": "string", "description": "registry file e.g. industries.ts" }
+            }
+          },
+          "spokes": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": ["slug", "type", "keyword", "page_kind", "min_words", "cluster_id"],
+              "properties": {
+                "slug": { "type": "string" },
+                "type": { "enum": ["money", "supporting", "blog"] },
+                "keyword": { "type": "string" },
+                "page_kind": { "enum": ["programmatic", "editorial"] },
+                "min_words": { "type": "integer", "minimum": 600 },
+                "cluster_id": { "type": "string" }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/rcode/skills/seo/seo-content-factory/templates/content-brief.md

@@ -0,0 +1,51 @@
+---
+# A4 output — the brief-before-prose GATE artifact.
+# A5 Writer REFUSES to run unless this file exists and status: approved.
+slug: apollo-alternative
+cluster_id: alt-apollo
+type: money              # money | supporting | blog
+keyword: apollo alternative
+secondary_keywords: [apollo io alternative, apollo competitor, cheaper than apollo]
+intent: commercial      # informational | commercial | transactional | navigational
+funnel: buy             # learn | compare | buy
+min_words: 1600
+schema: [SoftwareApplication, FAQPage, BreadcrumbList]
+status: approved        # draft | approved
+---
+
+# Title (≤60 chars, keyword-leading)
+The Best Apollo Alternative in 2026: LeadLyze vs Apollo
+
+# Meta description (≤155 chars)
+Looking for an Apollo alternative? See how LeadLyze beats Apollo on price, deliverability, and AI outreach — with a side-by-side breakdown.
+
+# Search intent (one paragraph from the live top-5 SERP)
+Buyers comparing tools; want a concrete feature+price comparison and a reason to switch, not a generic listicle. Top-5 are all comparison pages with tables.
+
+# Outline (mirror the winning SERP structure + 1 unique angle)
+## H2: Why teams look for an Apollo alternative
+### H3: Pricing pain points
+### H3: Deliverability / data accuracy complaints
+## H2: LeadLyze vs Apollo — side by side  ← REQUIRED data table
+## H2: Feature-by-feature breakdown
+### H3: AI cold calling (LeadLyze unique angle — Apollo lacks this)
+## H2: Pricing comparison  ← REQUIRED table
+## H2: When Apollo is still the better choice (honesty builds trust)
+## H2: How to migrate from Apollo to LeadLyze
+
+# Entities to cover (from top-5 + gap analysis)
+email deliverability, data enrichment, sequences, CRM sync, credits model, AI dialer, GDPR
+
+# FAQ (from People-Also-Ask — becomes FAQPage schema)
+- Is there a free Apollo alternative?
+- Is LeadLyze cheaper than Apollo?
+- Can I import my Apollo data into LeadLyze?
+- Which has better email deliverability?
+
+# Internal links (inject inline, not at the bottom)
+- → /instantly-alternative (anchor: "compared to Instantly")
+- → /ai-cold-calling (anchor: "AI cold calling")
+- → /pricing (anchor: "LeadLyze pricing")
+
+# CTA (funnel: buy)
+"Start free — migrate your Apollo lists in minutes." → /signup

package/rcode/skills/seo/seo-content-factory/templates/jsonld-builders.ts

@@ -0,0 +1,49 @@
+// A8 — extend the EXISTING src/lib/jsonld.ts with these typed builders.
+// Render via a <JsonLd data={...} /> component, never hand-written <script> strings.
+// Do not duplicate if equivalents already exist in src/lib/jsonld.ts — extend, don't fork.
+
+export function softwareApplication() {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: 'LeadLyze',
+    applicationCategory: 'BusinessApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+    aggregateRating: { '@type': 'AggregateRating', ratingValue: '4.8', reviewCount: '120' },
+  }
+}
+
+export function faqPage(faqs: { q: string; a: string }[]) {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faqs.map((f) => ({
+      '@type': 'Question',
+      name: f.q,
+      acceptedAnswer: { '@type': 'Answer', text: f.a },
+    })),
+  }
+}
+
+export function breadcrumbList(items: { name: string; url: string }[]) {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'BreadcrumbList',
+    itemListElement: items.map((it, i) => ({
+      '@type': 'ListItem',
+      position: i + 1,
+      name: it.name,
+      item: `https://leadlyze.com${it.url}`,
+    })),
+  }
+}
+
+export function product(name: string, rating = '4.8', reviews = '120') {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'Product',
+    name,
+    aggregateRating: { '@type': 'AggregateRating', ratingValue: rating, reviewCount: reviews },
+  }
+}

package/rcode/skills/seo/seo-content-factory/templates/keywords.csv

@@ -0,0 +1,13 @@
+keyword,parent_seed,modifier_type,volume,kd,intent,funnel,cluster_id
+lead generation for dentists,lead generation software,industry,720,34,commercial,buy,ind-dentists
+lead generation for roofers,lead generation software,industry,590,29,commercial,buy,ind-roofers
+lead generation for lawyers,lead generation software,industry,880,41,commercial,buy,ind-lawyers
+lead generation dubai,lead generation software,location,480,22,commercial,buy,loc-dubai
+lead generation london,lead generation software,location,1300,38,commercial,buy,loc-london
+apollo alternative,lead generation software,alternative,2900,61,commercial,buy,alt-apollo
+instantly alternative,cold email,alternative,1600,48,commercial,buy,alt-instantly
+apollo vs leadlyze,lead generation software,comparison,90,12,commercial,compare,cmp-apollo
+cold email templates,cold email,template,5400,52,informational,learn,tpl-coldemail
+cold email open rate statistics,cold email,statistics,1300,18,informational,learn,stat-coldemail
+how to generate leads for saas,lead generation software,question,210,27,informational,learn,q-saas
+free lead generation tool,lead generation software,tool,1900,55,transactional,buy,tool-leadgen