ContentForge

🌐 Read this in: English · हिन्दी · 中文 · 日本語 · 한국어 · Español · Português · العربية · اردو · தமிழ் · বাংলা · Русский

You need to ship 30 articles this quarter that sound human, cite real sources, link into your funnel, and survive an editor who checks. Your team is three people. You have nine weeks. Your last "AI-written" batch got flagged for hallucinated stats — and the batch before that quietly went stale and nobody noticed.

Run /contentforge:create-content against each topic. The 10-phase pipeline produces a publication-ready .docx with a 43-pattern humanizer, a fact-checker subagent, three-category internal linking, and C2PA provenance for EU AI Act compliance — in 30–60 minutes per piece. Then the part no single-shot tool has: the lifecycle loop. Every published piece is measured (cf-aeo-check), audited for decay (cf-audit), and fed back into the next calendar and the next brief — through durable file contracts, so what the system learns about your brand survives the session that learned it.

Open-source enterprise content production system — 22 skills · 13 specialist agents · 10 quality gates · 43-pattern AI-detection humanizer · a run auditor that re-derives every gate before a run may call itself finished · 28 Python scripts, stdlib-only. Built for marketing teams producing high volumes of long-form content that needs brand voice consistency, citation integrity, and an internal-link strategy that turns content into a funnel. Installs on Claude Code (CLI + IDE), Anthropic Cowork, OpenAI Codex, Cursor 2.5+, GitHub Copilot CLI, Google Antigravity 2.0, Hermes Agent, OpenClaw, and Grok (xAI Build CLI) + 35+ Agent Skills platforms — with hero skills uploadable to claude.ai (web) as .skill release assets. Created by Indranil Banerjee · LinkedIn · X.

🆕 Just shipped — v4.1.2 (August 17, 2026): schema-clean hooks manifest. Cowork's plugin validation rejects unknown top-level fields in hooks.json, and ours carried a _readme rationale field (digital-marketing-pro#9 — the same defect shipped in all three suite plugins). The rationale now lives in hooks/README.md, hooks.json is exactly {"hooks": {}}, and a new guard keeps it that way. Translations re-stamped. Previously —

v4.1.1 (August 17, 2026): the README goes global, and shows its receipts. This README now reads in 12 languages (हिन्दी, 中文, 日本語, 한국어, Español, Português, العربية, اردو, தமிழ், বাংলা, Русский — switcher at the top, every translation version-stamped and guard-checked), carries the real artifacts from a real validated run — the actual chart the pipeline rendered, the actual humanizer before/after edits, the actual 9.0/A scorecard and CLEAN audit verdict (see them) — and documents running ContentForge on OpenAI surfaces (Codex CLI/IDE/App and ChatGPT via Agent Plugins 1.0) with the same depth as the Claude surfaces, including updating on all nine platforms. Previously —

v4.1.0 (August 17, 2026): two new surfaces. ContentForge now installs natively on Grok (xAI Build CLI) — grok plugin install indranilbanerjee/contentforge — via a first-class .grok-plugin/ manifest pair, version-locked to every other manifest by the release-consistency suite. And five hero skills now ship as claude.ai-uploadable .skill release assets (cf-brief, cf-social-adapt, cf-translate, cf-video-script, cf-aeo-check), built by a deterministic packager (scripts/build-skill-assets.py) that bundles each skill's config/template dependencies and refuses to package any skill whose prose references a file that wouldn't exist after upload — so a claude.ai user never downloads a skill with broken references. Install for your platform →

v4.0.0 (August 17, 2026): the lifecycle release. ContentForge 3.x was a production pipeline; 4.0 makes it a content system. Three architectural changes, each grounded in a defect a real run exposed: (1) The lifecycle loop closed. cf-audit findings now land in a validated, canonical per-brand store (scripts/audit-ledger.py) that cf-calendar and content-refresh read across sessions; AI-visibility history (aeo/checks.json) feeds the freshness model; and each run's verified link inventory merges back into brand_pages automatically — conversion pages only ever staged for your confirmation, because a CTA is a commercial decision the system must not make for you. Before 4.0 every one of those handoffs was conversational, and worked only while one session held both ends. (2) The pipeline contract is data. config/pipeline-graph.json declares every phase's reads, writes, gates, and budgeted loop edges — drift-guarded both directions against the agent contracts, the checkpoint manager, and the run auditor. Encoding it immediately found six under-declared inputs the prose table had lost. (3) The pipeline learns, with floors. New scripts/telemetry.py aggregates loop history, phase timings, and the humanizer's per-pattern hit counts across runs — recurring patterns reach the next drafter brief as advisories behind a recurrence floor, and never touch a gate, a threshold, or a verdict. 22 skills · 27 scripts · 498 tests. Release notes → · Full changelog →

# Install in Claude Code (CLI or VS Code/JetBrains extension):
/plugin marketplace add indranilbanerjee/neels-plugins
/plugin install contentforge@neels-plugins

# Install in Cowork: use the Plugins panel in the UI -- /plugin slash
# commands DON'T work in Cowork (or Claude.ai / Claude Desktop).
# Open Plugins panel -> Add marketplace -> paste indranilbanerjee/neels-plugins
# -> Install ContentForge from the listed plugins.

# Install on Hermes Agent (Nous Research):
hermes plugins install indranilbanerjee/contentforge

# Install on OpenClaw:
openclaw plugins install git:github.com/indranilbanerjee/contentforge

# Install on Grok (xAI Build CLI):
grok plugin install indranilbanerjee/contentforge

If ContentForge saves your team time, give it a star ⭐ — it's the single thing that helps other marketing teams find it.

Why ContentForge

Most AI writing tools produce one draft, in one tone, with no quality gates, and forget the piece the moment it ships. The output reads like AI, factual claims are unverified, internal links don't exist, brand voice drifts, the file format is markdown when the editor wants Word — and six months later nobody knows which pieces went stale. ContentForge fixes this end to end:

Supported surfaces (v4.1.2)

Why this works: Agent Skills became an open standard in December 2025 (41+ agent products by June 2026). All 22 SKILL.md files in ContentForge are platform-portable as written. The sibling manifests are thin platform-specific wrappers around the same skills/ directory — no skill duplication.

Works on 35+ additional Agent Skills platforms without per-platform manifests — Goose (Block), OpenHands, OpenCode (sst), Junie (JetBrains), Gemini CLI, Roo Code, Cline/Windsurf, Kiro, Amp, Letta, Mux, Factory, Workshop, Tabnine, Mistral Vibe, and more. Point any Agent-Skills-compatible client at https://github.com/indranilbanerjee/contentforge/tree/master/skills and all 22 ContentForge skills are immediately discoverable.

Quick start

1. Install the plugin

In Claude Code (CLI or VS Code/JetBrains extension):

/plugin marketplace add indranilbanerjee/neels-plugins
/plugin install contentforge@neels-plugins

In Anthropic Cowork:

1. Open the Plugins panel in the Cowork UI (sidebar / settings)
2. Click Add marketplace, paste indranilbanerjee/neels-plugins
3. After the marketplace syncs, find ContentForge in the listed plugins and click Install
4. Then run /contentforge:cf-cowork-setup once to wire Google Drive as your team's output destination

⚠ /plugin slash commands work only in Claude Code (CLI + IDE extension). They do NOT work in Cowork, Claude.ai web, or Claude Desktop — use UI navigation in those environments. The /contentforge:* skills (like /contentforge:create-content) work in all environments where plugins are loaded; only the /plugin management family is Claude-Code-only.

2. Turn on auto-update (one-time, recommended)

Third-party marketplaces — including this one — have auto-update OFF by default in Claude Code. When a newer version is on the marketplace and you're still running an older one, nothing tells you. There's no banner, no badge, no notification. So the first thing to do after install is enable updates:

Open /plugin, go to the Marketplaces tab, find neels-plugins, and toggle Enable auto-update. Done — Claude Code will refresh and pull new ContentForge releases at startup from now on, prompting you to run /reload-plugins to pick up changes mid-session (no full restart, conversation context preserved).

If you'd rather update manually each time instead, see the Updating section below.

3. Set up your first brand

/contentforge:brand-setup

The agent walks you through brand voice, terminology, guardrails, citation rules, internal-linking site structure, and (if you want commercial impact) the brand_pages block — your product/service URLs, conversion CTAs, and authority pages. When you give it a website, it runs a robots-respecting crawler and harvests a verified page inventory in one confirmation step. It saves a brand-profile.json to ~/.claude-marketing/<brand-slug>/.

4. Generate content

/contentforge:create-content

The skill prompts you for content type, brand, topic, target word count, and audience. It then runs 10 phases via specialized subagents (research → fact-check → draft → visuals → validate → proofread → SEO → humanize → review → output), enforces a quality gate after each phase, audits the finished run against its own artifacts, and writes a real .docx you can hand to your editor or design team.

5. Find your output

ContentForge writes the finished .docx to two places:

User-visible copy — this is the one to open:

~/Documents/ContentForge/<brand-slug>/<content-type>/<YYYY-MM>/<slug>.docx

This lives in your normal Documents folder, visible in Windows Explorer / macOS Finder / Linux file managers by default. Override the root with the CONTENTFORGE_PUBLISH_DIR env var (e.g. point at a Dropbox or team-share path). Run /contentforge:output-folder any time to print the absolute path and open the folder in the OS file manager.

Internal tracking copy — the system-of-record for analytics/audit skills:

~/.claude-marketing/<brand-slug>/tracking/outputs/<YYYY>/<MM-MonthName>/
└── <slug>_v1.0.docx

The intermediate phase artefacts (research brief, fact-check report, draft, SEO scorecard, review report, etc.) plus rendered chart PNGs land alongside the tracking copy in the run directory. The .docx includes the body, references, and four appendices — A SEO Scorecard, B Quality Scorecard, C Production Details, D Internal Link Map.

Historical note (fixed in v3.12.3): earlier versions only wrote to the hidden ~/.claude-marketing/ dotfolder, which Windows Explorer hides by default. Multiple users reported "the file isn't saving on local drive" — it was saving, just somewhere they couldn't see. The dual-copy design is the resolution; /contentforge:output-folder is the quick-reveal command.

6. If the run gets interrupted, resume it

The 10-phase pipeline runs 20–60 minutes end to end. If the session terminates partway through (context-window exhaustion, network blip, Ctrl-C, machine sleep), every completed phase is saved to disk via scripts/checkpoint-manager.py. Resume the run with:

/contentforge:resume                 # auto-picks the most recent in-progress run for the active brand
/contentforge:resume <run-id>        # pick a specific run from `checkpoint-manager.py list`

The resumer reloads the saved Phase 1..N outputs and continues from Phase N+1 — no re-running phases that already completed. It also reports orphaned artifacts (a phase whose artifact exists but was never checkpointed — precisely the window a crash creates), so finished work is verified rather than re-run blind or trusted blind.

7. Close the loop (the v4.0 habit)

After you've published a few pieces, three commands turn production into a lifecycle:

/contentforge:cf-aeo-check      # did AI engines cite the piece? appends to per-brand history
/contentforge:audit-content     # score the library for decay; findings recorded durably
/contentforge:cf-calendar --from-audit=latest   # next period's plan, fed from the recorded audit

Each one writes or reads a durable per-brand file — the loop works across sessions, across weeks, and (with Cowork + Drive) across your whole team. Details in The content lifecycle loop.

What ContentForge does (the 10-phase pipeline)

0.5  Title Curation        → 4-5 SERP-aware title options; user selects
 1   Research              → 12-15 verified sources, competitive analysis, site recon + link inventory
 2   Fact Checking         → URL verification, claim cross-reference → the verified claim ledger
 3   Content Drafting      → SME-calibrated first draft, every statistic ledger-traceable
 3.5 Visual Asset Annotator → deterministic charts from verified data + visual anchors
 4   Scientific Validation → hallucination check vs the ledger; corrections filed in the fix ledger
 5   Structuring & Proofread → grammar, readability, brand compliance; fix ledger applied BY SCRIPT
 6   SEO/GEO Optimization  → keyword placements, meta tags, schema, internal links (3 categories, live-verified)
 6.5 Humanizer             → 43-pattern AI-detection catalog + self-critique + pattern-hit telemetry
 7   Review                → 5-dimension scoring (Content, Citation, Brand, SEO, Readability)
 8   Output Manager        → real .docx with embedded scorecards + link map; run audit gates "completed"

Each phase has a quality gate verified by the orchestrator with scripts, never taken from an agent's self-report. If a gate fails, the orchestrator loops back to the offending phase — max 2 loops per edge, 5 per run, every loop recorded with its reason. All phases run via the Task tool against dedicated subagent definitions in agents/01-researcher.md through agents/08-output-manager.md — there is no single-pass shortcut. On platforms without subagent dispatch, the portable execution lane runs the same phases sequentially from the same agent contracts: same artifacts, same gates, same budgets.

The pipeline's shape — every phase's inputs, outputs, gate, and loop target — is declared as data in config/pipeline-graph.json (v4.0) and drift-guarded against the agent contracts, the checkpoint manager, and the run auditor. A phase asked to verify something its inputs never gave it is now a failing test, not a latent bug.

And when the last phase ends, the run still has to prove it. scripts/run-audit.py re-derives every claim the finished run makes from the artifacts on disk — completed phases vs artifacts, scaffolding in the delivered body, unanchored assets, corrections lost or undone, an APPROVED decision backed by its own score, a completed status hiding a blocked publication. finalize --status completed refuses without a fresh CLEAN verdict; --skip-audit exists as an escape hatch that stamps audit_skipped: true into the manifest, because a skipped audit should be a fact on the record, not a silence.

Realistic timing: FAQ 30–35 min · article 35–45 min · whitepaper 45–75 min · research paper 60–90 min.

The content lifecycle loop (v4.0)

A pipeline makes a piece. A lifecycle keeps a library alive. ContentForge has had every stage of this loop for a while — what 4.0 adds is the connective tissue that makes it a system: every joint is now a file with a schema, so the loop survives the session that ran it.

Three rules keep the loop honest, and they are enforced in code, not intentions:

1. Absence of measurement is never zero. A pre-4.0 run without pattern telemetry is not_instrumented, not clean; an audit that never saw AEO history says "n/a — no aeo/checks.json" in a required field — "not consulted" and "consulted, no signal" can never be the same answer.
2. Learning has floors. Telemetry advisories require a recurrence floor (default: a pattern seen in ≥3 instrumented runs) before a word of them reaches a brief. Below the floor the answer is insufficient_history and nothing is advised — a brief fed from fewer runs than the floor is fed from anecdote.
3. Loops inform; they never gate. Advisories shape drafting style and dashboards. They are forbidden — by contract and by test — from modifying a gate, a threshold, or a verdict. The quality machinery stays human-set and re-derived.

On Cowork, these stores ride the same Drive sync as brand profiles and checkpoints (/contentforge:cf-cowork-setup). Without Drive routing, the Cowork sandbox forgets them at session end — the loop still works within a session, but compounding across sessions is most of its point, so teams should treat Drive routing as required.

Internal linking — the three categories

ContentForge is a marketing system, not a search-engine pipeline. Informational links alone don't drive any commercial outcome. Links are scored in three independent categories:

The SEO agent emits typed <!-- INTERNAL-LINK: type=... | anchor=... | url=... --> markers; the .docx generator renders each as a real Word hyperlink, color-coded by type (topical blue, commercial green, conversion purple, authority slate). Where the brand has not provided a URL, the marker stays as a visibly-distinct red [anchor] [LINK TBD: type] placeholder — the human reviewer fills it in before publication, instead of the link opportunity being silently skipped.

Auto-harvest: /contentforge:brand-setup runs scripts/harvest-brand-pages.py against the brand's website — a stdlib, robots-respecting crawler that returns an HTTP-verified page inventory (service/conversion/authority pages) plus verbatim brand_facts (one source URL per fact; where pages disagree, both versions are kept with an inconsistency_note for you to resolve, never silently merged). One confirmation step and it's saved straight into the brand_pages block. If you decline, the crawl fails, or the brand genuinely has no site, harvest_status records exactly which — honestly, never as a silent skip.

And from v4.0, the inventory stays alive: every pipeline run re-verifies deep brand URLs during Phase 1 reconnaissance, and the orchestrator merges the verified rows back into brand_pages after Gate 1 — freshness stamps updated, new pages added with provenance, your manual curation never overwritten, and conversion candidates staged (never activated) for your review under brand_pages.recon_candidates.

Deep-link rule + thin-brand_pages guard: the researcher (Phase 1) builds a live Internal-Link Inventory of deep brand URLs the piece could naturally reference, HTTP-verified on the day of the run. Phase 6 requires ≥2 deep links (not just the homepage) whenever the brand's site has them — if brand_pages is empty or homepage-only, Phase 6 falls back to that Phase 1 inventory, then a just-in-time sitemap fetch, instead of silently skipping commercial linking.

Configure once per brand:

"seo_preferences": {
  "internal_linking": {
    "page_registry": [
      {"url": "https://yoursite.com/resources/your-pillar-guide", "topic": "pillar topic", "type": "pillar"}
    ],
    "pillar_pages": ["https://yoursite.com/resources/your-pillar-guide"]
  },
  "brand_pages": {
    "product_or_service_pages": [
      {"url": "https://yoursite.com/programs/access", "topic": "patient access program", "category": "program",
       "anchor_text_hints": ["access program", "affordability assistance"]}
    ],
    "conversion_pages": [
      {"url": "https://yoursite.com/contact/msl", "purpose": "request MSL", "audience": "HCP",
       "anchor_text_hints": ["request a Medical Science Liaison consult"]}
    ],
    "authority_pages": [
      {"url": "https://yoursite.com/about/medical-affairs", "purpose": "medical affairs leadership", "audience": "HCP"}
    ]
  }
}

The reviewer (Phase 7) scores 6a Topical / 6b Commercial / 6c Conversion independently. Categories the brand has not configured score N/A and don't penalize — but a brand with a website whose brand_pages was never harvested is a scored deficiency, not an N/A free-pass; homepage-only linking caps the 6b sub-score with a mandatory finding; and any dead internal-link URL is a hard publish-blocking FAIL. The agent must produce useful link markers (real URLs or placeholders) to earn credit.

See config/brand-registry-template.json for the full schema.

Examples

Run a real white paper — worked example

/contentforge:create-content

When prompted, supply:

• Brand: acme-pharma (must already exist via /contentforge:brand-setup)
• Content Type: whitepaper
• Topic: Pharmacovigilance for HER2-Directed ADCs in Community Oncology
• Target Audience: Community medical oncologists, oncology pharmacists
• Word Count: 3500-4200
• SEO Keywords: ADC pharmacovigilance, T-DXd ILD monitoring

The pipeline runs ~60 min. When it finishes you get a .docx in ~/Documents/ContentForge/acme-pharma/whitepaper/<YYYY-MM>/. Open it in Word: the body, the references, then Appendix A (SEO scorecard with keyword placements, meta tags, schema), Appendix B (5-dimension quality scorecard), Appendix C (production details — phase timings, source reliability, accuracy figures with their phase attributions), and Appendix D (internal link map showing every topical / commercial / conversion / authority link the agent placed, with target URLs and anchor text). All inline hyperlinks are clickable in Word.

What a real gated run looks like — from a live validation run

This is an actual run (August 2026, a digital-preservation test brand, 1,200-word blog, keyword "link rot") — reported exactly as it happened, because the failure-catching is the product:

• Phase 2 caught Phase 1 misreading a statistic. The research summarized a source as "the Wayback Machine recovers ~16% of dead URLs"; the fact-checker read the primary source, found 16% was a share of the entire dataset (not of dead URLs), locked corrected wording into the verified ledger, and banned the original sentence from the draft. The correction survived — verbatim — through six more phases into the delivered Word file, with the disambiguation printed for the reader.
• Phase 4 diffed 42 claims against the ledger: zero hallucinations, one minor citation-placement correction — filed in the fix ledger, applied by script at Phase 5, and verified still intact at Phases 6.5, 7, and 8.
• Phase 7 approved at 9.0/10 — and honestly sub-scored internal linking down because the test brand had no conversion_pages configured, naming the config gap instead of hiding it.
• Phase 8's Appendix C corrected a number the orchestrator supplied. Asked to print "source reliability 8.1", the output manager recomputed it from the research artifact, got 7.9, and printed 7.9 with its reasoning. The honesty discipline binds in every direction.
• The run auditor re-derived all of it — 14 checks passed, 0 failed — and only then did finalize --status completed accept the run.

Single-prompt tools produce none of these paper trails. The point isn't that the pipeline never errs — it's that its errors get caught by its own machinery, on the record, before your editor ever sees the file.

The artifacts themselves — real output you can inspect

Everything below is from that same run — not a mock-up, not a demo. The numbers are read from the run's own JSON artifacts (phase-7-review.json, run-audit.json, phase-6.5-report.md, pipeline-run.json):

A chart the pipeline actually rendered (Phase 3.5 annotates the visual opportunity from verified Phase 2 data; a stdlib matplotlib-free renderer produces the PNG; the data citations ride in the caption):

The opening the reader actually gets (from the delivered file — note there's no "In today's digital landscape" anywhere in sight):

38% of webpages that existed in 2013 are not available today (Chapekis et al., 2024). Not redesigned. Not moved. Gone. The same Pew study found that 21% of government webpages contain at least one broken link.

The uncomfortable part is the cause, not the scale. When institutional pages disappear, the trigger is usually organizational rather than slow technical decay: a CMS (content management system) migration that dropped a URL structure, or a decision to take pages down. That has a practical upside: events can be planned for, and decay can't.

What the humanizer actually did to earn that opening — three of the 20 logged edits, verbatim from the Phase 6.5 report (every edit records before → after, and whether SEO placements survived):

And the honesty layer, in one JSON excerpt — the run auditor's verdict that gated finalize --status completed:

{
  "run_id": "20260816-131632-link-rot-…",
  "pass": 14, "fail": 0, "na": 1,
  "verdict": "CLEAN"
}

One more real detail worth knowing: Phase 8 was killed twice mid-run by session limits. Both times the checkpoint contract resumed it from the artifacts on disk — the delivered .docx exists because resume is a contract, not a hope. (The run brand is an internal validation persona for the digital-preservation space, not client work — which is why we can show you its artifacts.)

Close the loop on a growing library

# After a month of publishing:
/contentforge:cf-aeo-check           # record which pieces AI engines cite (history + deltas)
/contentforge:audit-content          # freshness-score the library; the findings are RECORDED
/contentforge:cf-calendar --period=90 --from-audit=latest   # next quarter: refreshes + gaps, from data
/contentforge:content-refresh        # execute a refresh at the audit's recommended scope

Every command reads what the previous one recorded — in a new session, on a different day, by a different teammate.

Commands (visible in the Customize sidebar)

These 9 commands are the user-facing entry points:

Slash command syntax is canonical /<plugin-name>:<command> — the older /cf: shortcuts no longer work as of v3.9.3.

Skills (run via the Skill tool — superset of commands)

Architecture

13 agents

The pipeline graph (v4.0)

config/pipeline-graph.json is the machine-readable form of the pipeline contract: nodes are phases, edges are the file-based handoffs, loop targets carry their budgets. tests/test_pipeline_contract_graph.py fails the build if the graph, the agent contracts, the orchestrator's table, checkpoint-manager.py, or run-audit.py ever disagree — in either direction. Encoding the contract as data immediately surfaced six inputs the prose table had under-declared (including one the agent file itself annotated as "was missing from this list" after a previous drift incident). The portable execution lane and the resumer walk this graph rather than re-deriving the order from prose.

Quality scoring (Phase 7 reviewer, 5 dimensions)

Decision thresholds: 9.0+ A publish + repurpose · 7.0–8.9 B publish · 5.0–6.9 C loop back · <5.0 D human escalation. Thresholds, weights, dimension minimums, and industry overrides live in config/scoring-thresholds.json — the single source of truth; where prose and config disagree, the config wins.

Three-layer fact verification

Single-pass fact-checking misses 15–20% of hallucinations. ContentForge uses three independent layers — Phase 2 (Fact Checker) verifies sources before drafting and builds the verified claim ledger, Phase 4 (Scientific Validator) re-diffs the draft against that ledger claim by claim, Phase 7 (Reviewer) audits factual accuracy as part of holistic scoring. Corrections travel in a machine-verified fix ledger (phase-4-fixes.json): applied by script at Phase 5, guarded so a style pass cannot undo an accuracy fix, re-verified at every later phase, and enforced at Phase 8 — unresolved blocking corrections don't stop the document being produced; they stop it being called ready (DRAFT- prefix, named blockers, blocked tracking status).

The run auditor

scripts/run-audit.py re-checks a finished run the way an outside auditor would: every completed phase has its artifact, no orphaned artifacts in a finalized run, the delivered body carries no production scaffolding and anchors every generated asset, the authorship record matches a fresh measurement, no fix-ledger correction was lost or undone, an APPROVED decision is backed by its own score, and no completed status hides a blocked publication. Every check corresponds to a failure that actually happened in a real run while every individual artifact looked healthy. Two disciplines throughout: re-derive, never trust (gate fields are compared against fresh script output), and a missing input is reported-N/A, never silent-pass.

Industry knowledge packs

10 domain-specific configs at config/industries/ (pharma, BFSI, healthcare, legal, real estate, technology, B2B SaaS, e-commerce, consumer goods, education) calibrate the Content Drafter as a subject-matter expert and give the Scientific Validator domain-specific terminology, evidence standards, regulatory rules, and common pitfalls to check against. A brand whose industry has no pack gets an honest "generic writing mode" declaration that travels to the reviewer — never a silent pretense of expertise.

Phase 6.5 Humanizer (the differentiator)

43-pattern AI-detection catalog (7 buckets: content, language/grammar, style, communication, filler/hedging, structure/framing, detector-signal) adapted from Wikipedia: Signs of AI Writing + blader/humanizer. Includes a self-critique meta-pass ("what makes this still obviously AI?") and optional voice calibration from a brand writing_sample field.

Grounding-first, not trick-first. The old move — inserting short punchy sentences to raise the burstiness number — is gone: it manufactured the exact aphoristic-maxim tell modern detectors flag. In its place, a Human-Expert Grounding Pass grounds every standing maxim, impersonal assertion, and flat-confidence claim in a specific from the Phase 2 verified ledger — or removes it; nothing is invented for style. Sentence variety is content-derived: uniform runs get broken by material the content already earns, never by content-free filler. Burstiness is reported as advisory context, not a pass/fail gate. Significance markers ("here's the thing", "let that sink in") are deleted, never reworded. When an author supplies their own draft (--source-draft), their sentences are carried verbatim, exempt from the catalog, and scripts/authorship.py blocks if any were paraphrased or dropped — the one hard check in the phase, because "the author wrote this and it is gone" is a fact, not a probability.

Advisory --ai-tell-scan. scripts/text-metrics.py --ai-tell-scan runs a deterministic, zero-dependency proxy scan (aphorism density, banned lexemes, connective/participial-opener rate, uniform sentence runs) and reports a LOW / MODERATE / HIGH advisory rating — surfaced in the Phase 6.5 report, the reviewer's Readability sub-score, and the Completion Card. It is never a publish gate, and ContentForge never claims to "beat" any specific detector — see the FAQ and references/ai-detection-signals.md for the full reasoning.

And from v4.0 the phase reports what it fixed, durably: phase-6.5-pattern-hits.json records per-pattern fire counts for scripts/telemetry.py, so a pattern your brand's drafts keep producing eventually reaches the drafter's brief as an advisory — behind the recurrence floor, never as a gate. The pipeline stops re-making mistakes its own quality machinery keeps catching.

Model curator — no hardcoded model ids

Frontier models change every ~6 weeks. ContentForge ships a shared registry + resolver so model ids are never hardcoded across scripts: edit scripts/model_registry.json in one place and every script picks up the change next call. Aliases resolve at call time; deprecated ids auto-fall-forward to their replacement; scripts/refresh_models.py polls live provider catalogs and reports drift. See docs/MODEL-CURATOR.md.

python scripts/resolve_model.py --alias latest-balanced-anthropic
python scripts/resolve_model.py --check <some-old-model-id>      # warns when deprecated + names the replacement

Where your data lives

~/.claude-marketing/<brand-slug>/
├── brand-profile.json        # voice, terminology, guardrails, brand_pages (+ recon_candidates)
├── runs/<run-id>/            # per-run artifacts, checkpoints, fix ledger, run-audit.json, telemetry
├── audits/                   # recorded cf-audit findings (v4.0) — what the calendar reads
├── aeo/checks.json           # append-only AI-visibility history (per-check deltas)
├── tracking/outputs/         # the internal system-of-record .docx copies
└── output/                   # intermediate artifacts + rendered charts

…view the full README on GitHub.