@adsim/wordpress-mcp-server 4.6.0 → 5.1.0

package/src/tools/intelligence.js

@@ -0,0 +1,2082 @@
+// src/tools/intelligence.js — intelligence tools (22)
+// Definitions + handlers (v5.0.0 refactor Step B+C)
+
+import { json, strip } from '../shared/utils.js';
+import { validateInput } from '../shared/governance.js';
+import { rt } from '../shared/context.js';
+
+export const definitions = [
+  { name: 'wp_get_content_brief', _category: 'intelligence', description: 'Use to get a compact content brief in 1 call: title, SEO meta, headings, word count, links, categories. Read-only. Hint: start here before writing or rewriting content.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number' }, post_type: { type: 'string', default: 'post', description: 'post or page' } }, required: ['id'] }},
+  { name: 'wp_extract_post_outline', _category: 'intelligence', description: 'Use to extract H1-H4 outline from N posts in a category as a reference template for new content. Read-only.',
+        inputSchema: { type: 'object', properties: { category_id: { type: 'number' }, post_type: { type: 'string', default: 'post', description: 'post or page' }, limit: { type: 'number', default: 10 } }, required: ['category_id'] }},
+  { name: 'wp_audit_readability', _category: 'intelligence', description: 'Use to score text readability (Flesch-Kincaid adapted). Returns transition density and passive ratio. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] }, category_id: { type: 'number' }, min_words: { type: 'number', description: 'default 100' } }}},
+  { name: 'wp_audit_update_frequency', _category: 'intelligence', description: 'Use to find stale posts not updated since N days, cross-referenced with SEO score. Read-only.',
+        inputSchema: { type: 'object', properties: { days_threshold: { type: 'number', description: 'default 180' }, limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] }, include_seo_score: { type: 'boolean', description: 'default true' } }}},
+  { name: 'wp_build_link_map', _category: 'intelligence', description: 'Use to generate full internal link matrix with simplified PageRank scores per post. Read-only.',
+        inputSchema: { type: 'object', properties: { post_type: { type: 'string', enum: ['post', 'page', 'both'] }, limit: { type: 'number' }, category_id: { type: 'number' } }}},
+  { name: 'wp_audit_anchor_texts', _category: 'intelligence', description: 'Use to check internal link anchor diversity. Detects generic (\'click here\') and over-optimized anchors. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page', 'both'] } }}},
+  { name: 'wp_audit_schema_markup', _category: 'intelligence', description: 'Use to detect and validate JSON-LD in post HTML content (Article, FAQ, HowTo, LocalBusiness). Read-only. Hint: use wp_audit_schema_plugins for plugin-native schema instead.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page', 'both'] } }}},
+  { name: 'wp_audit_content_structure', _category: 'intelligence', description: 'Use to analyze post structure: intro/body/conclusion ratio, FAQ presence, TOC, lists, tables. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page', 'both'] }, category_id: { type: 'number' } }}},
+  { name: 'wp_find_duplicate_content', _category: 'intelligence', description: 'Use to detect near-duplicate posts via TF-IDF cosine similarity. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] }, category_id: { type: 'number' }, similarity_threshold: { type: 'number', description: 'default 0.7 (0-1)' } }}},
+  { name: 'wp_find_content_gaps', _category: 'intelligence', description: 'Use to find under-represented taxonomy terms (< N posts) as content creation opportunities. Read-only.',
+        inputSchema: { type: 'object', properties: { min_posts: { type: 'number', description: 'default 3' }, taxonomy: { type: 'string', enum: ['category', 'post_tag', 'both'] }, exclude_empty: { type: 'boolean', description: 'default false' } }}},
+  { name: 'wp_extract_faq_blocks', _category: 'intelligence', description: 'Use to inventory all FAQ blocks (Gutenberg + schema JSON-LD) across the corpus. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page', 'both'] } }}},
+  { name: 'wp_audit_cta_presence', _category: 'intelligence', description: 'Use to detect presence/absence of CTAs (contact links, forms, buttons) per post. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page', 'both'] }, category_id: { type: 'number' } }}},
+  { name: 'wp_extract_entities', _category: 'intelligence', description: 'Use to extract named entities (brands, places, people, organizations) from post content. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] }, min_occurrences: { type: 'number', description: 'default 2' } }}},
+  { name: 'wp_get_publishing_velocity', _category: 'intelligence', description: 'Use to measure publication cadence per author and category over 30/90/180 days. Read-only.',
+        inputSchema: { type: 'object', properties: { periods: { type: 'string', description: "Comma-separated day periods (default '30,90,180')" }, post_type: { type: 'string', enum: ['post', 'page'] }, limit: { type: 'number' } }}},
+  { name: 'wp_compare_revisions_diff', _category: 'intelligence', description: 'Use to diff two revisions and measure update amplitude. Read-only.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number' }, revision_id_from: { type: 'number', description: 'Older revision ID (baseline)' }, revision_id_to: { type: 'number', description: 'Newer revision ID (omit for current post)' }, post_type: { type: 'string', enum: ['post', 'page'] } }, required: ['post_id', 'revision_id_from'] }},
+  { name: 'wp_list_posts_by_word_count', _category: 'intelligence', description: 'Use to rank posts by length with auto-segmentation (<500, 500-1k, 1k-2k, 2k+). Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page', 'both'] }, order: { type: 'string', enum: ['asc', 'desc'] }, category_id: { type: 'number' } }}},
+  { name: 'wp_get_rendered_head', _category: 'intelligence', description: 'Use to fetch the real <head> HTML Google sees via RankMath/Yoast headless endpoint. Compares rendered vs stored meta. Read-only. Requires WP_ENABLE_PLUGIN_INTELLIGENCE=true.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] } }, required: ['post_id'] }},
+  { name: 'wp_audit_rendered_seo', _category: 'intelligence', description: 'Use for bulk rendered-vs-stored SEO divergence detection with per-post scoring. Read-only. Requires WP_ENABLE_PLUGIN_INTELLIGENCE=true.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] } }}},
+  { name: 'wp_get_pillar_content', _category: 'intelligence', description: 'Use to read or set RankMath cornerstone/pillar flag. Read always allowed. Write — blocked by WP_READ_ONLY. Requires WP_ENABLE_PLUGIN_INTELLIGENCE=true.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number' }, set_pillar: { type: 'boolean', description: 'Set pillar flag (true=pillar, false=not). Requires write access.' }, list_pillars: { type: 'boolean', description: 'List all pillar content posts (ignores post_id)' }, post_type: { type: 'string', enum: ['post', 'page'] }, limit: { type: 'number' } }}},
+  { name: 'wp_audit_schema_plugins', _category: 'intelligence', description: 'Use to validate JSON-LD from SEO plugin native fields (rank_math_schema or yoast_head_json). Read-only. Requires WP_ENABLE_PLUGIN_INTELLIGENCE=true.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page', 'both'] } }}},
+  { name: 'wp_get_seo_score', _category: 'intelligence', description: 'Use to read RankMath native SEO score (0-100). Bulk mode shows distribution stats. Read-only. Requires WP_ENABLE_PLUGIN_INTELLIGENCE=true.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number' }, limit: { type: 'number', description: 'default 20, max 100' }, post_type: { type: 'string', enum: ['post', 'page'] }, order: { type: 'string', enum: ['asc', 'desc'] } }}},
+  { name: 'wp_get_twitter_meta', _category: 'intelligence', description: 'Use to read or update Twitter Card meta (title, description, image) for RankMath/Yoast/SEOPress. Write — blocked by WP_READ_ONLY. Requires WP_ENABLE_PLUGIN_INTELLIGENCE=true.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] }, twitter_title: { type: 'string', description: 'Set Twitter title (write mode)' }, twitter_description: { type: 'string', description: 'Set Twitter description (write mode)' }, twitter_image: { type: 'string', description: 'Set Twitter image URL (write mode)' } }, required: ['post_id'] }}
+];
+
+export const handlers = {};
+
+handlers['wp_get_content_brief'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, auditLog, name, calculateReadabilityScore, extractHeadingsOutline, detectContentSections, countWords, extractInternalLinks, extractExternalLinks, extractFocusKeyword } = rt;
+  validateInput(args, {
+    id: { type: 'number', required: true, min: 1 },
+    post_type: { type: 'string', enum: ['post', 'page'] }
+  });
+  const { id, post_type: briefPostType = 'post' } = args;
+  const briefEndpoint = briefPostType === 'page' ? '/pages' : '/posts';
+  const briefPost = await wpApiCall(`${briefEndpoint}/${id}?_fields=id,title,content,excerpt,slug,status,date,modified,link,categories,tags,author,featured_media,meta`);
+
+  const briefContent = briefPost.content?.rendered || '';
+  const { url: briefSiteUrl } = getActiveAuth();
+
+  // Word count & readability
+  const briefWordCount = countWords(briefContent);
+  const readability = calculateReadabilityScore(briefContent);
+
+  // Structure
+  const briefHeadings = extractHeadingsOutline(briefContent);
+  const structure = detectContentSections(briefContent);
+
+  // Links
+  const briefInternalLinks = extractInternalLinks(briefContent, briefSiteUrl);
+  const briefExternalLinks = extractExternalLinks(briefContent, briefSiteUrl);
+
+  // SEO meta
+  const briefMeta = briefPost.meta || {};
+  const briefFocusKw = extractFocusKeyword(briefMeta);
+  const seoTitle = briefMeta._yoast_wpseo_title || briefMeta.rank_math_title || briefMeta._seopress_titles_title || null;
+  const seoDescription = briefMeta._yoast_wpseo_metadesc || briefMeta.rank_math_description || briefMeta._seopress_titles_desc || null;
+  const seoCanonical = briefMeta._yoast_wpseo_canonical || briefMeta.rank_math_canonical_url || briefMeta._seopress_robots_canonical || null;
+
+  // Resolve categories to names
+  const briefCatIds = briefPost.categories || [];
+  let briefCategories = [];
+  if (briefCatIds.length > 0) {
+    try {
+      const cats = await wpApiCall(`/categories?include=${briefCatIds.join(',')}&_fields=id,name`);
+      briefCategories = cats.map(c => ({ id: c.id, name: c.name }));
+    } catch { briefCategories = briefCatIds.map(cid => ({ id: cid, name: null })); }
+  }
+
+  // Resolve tags to names
+  const briefTagIds = briefPost.tags || [];
+  let briefTags = [];
+  if (briefTagIds.length > 0) {
+    try {
+      const tags = await wpApiCall(`/tags?include=${briefTagIds.join(',')}&_fields=id,name`);
+      briefTags = tags.map(t => ({ id: t.id, name: t.name }));
+    } catch { briefTags = briefTagIds.map(tid => ({ id: tid, name: null })); }
+  }
+
+  result = json({
+    id: briefPost.id,
+    title: strip(briefPost.title?.rendered || ''),
+    slug: briefPost.slug,
+    status: briefPost.status,
+    date: briefPost.date,
+    modified: briefPost.modified,
+    link: briefPost.link,
+    author: briefPost.author,
+    word_count: briefWordCount,
+    readability: { score: readability.score, level: readability.level, avg_words_per_sentence: readability.avg_words_per_sentence },
+    seo: {
+      title: seoTitle,
+      description: seoDescription,
+      focus_keyword: briefFocusKw,
+      canonical: seoCanonical
+    },
+    structure: {
+      headings: briefHeadings,
+      has_intro: structure.has_intro,
+      has_conclusion: structure.has_conclusion,
+      has_faq: structure.has_faq,
+      lists_count: structure.lists_count,
+      tables_count: structure.tables_count,
+      images_count: structure.images_count
+    },
+    categories: briefCategories,
+    tags: briefTags,
+    internal_links: { count: briefInternalLinks.length, links: briefInternalLinks },
+    external_links: { count: briefExternalLinks.length, links: briefExternalLinks },
+    featured_media: briefPost.featured_media || null
+  });
+  auditLog({ tool: name, target: id, target_type: briefPostType, action: 'content_brief', status: 'success', latency_ms: Date.now() - t0, params: { id, post_type: briefPostType } });
+  return result;
+};
+handlers['wp_extract_post_outline'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, extractHeadingsOutline, countWords } = rt;
+  validateInput(args, {
+    category_id: { type: 'number', required: true, min: 1 },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    limit: { type: 'number', min: 1, max: 50 }
+  });
+  const { category_id, post_type: outlinePostType = 'post', limit: outlineLimit = 10 } = args;
+  const outlineEndpoint = outlinePostType === 'page' ? '/pages' : '/posts';
+  let outlineUrl = `${outlineEndpoint}?per_page=${Math.min(outlineLimit, 50)}&status=publish&_fields=id,title,content,slug,link,meta`;
+  if (outlinePostType !== 'page') outlineUrl += `&categories=${category_id}`;
+  const outlinePosts = await wpApiCall(outlineUrl);
+
+  const outlines = [];
+  const h2Counter = new Map();
+
+  for (const p of outlinePosts) {
+    const html = p.content?.rendered || '';
+    const headings = extractHeadingsOutline(html);
+    const wc = countWords(html);
+
+    // Count H2 patterns
+    for (const h of headings) {
+      if (h.level === 2) {
+        const normalized = h.text.toLowerCase().trim();
+        if (normalized) h2Counter.set(normalized, (h2Counter.get(normalized) || 0) + 1);
+      }
+    }
+
+    outlines.push({
+      id: p.id,
+      title: strip(p.title?.rendered || ''),
+      slug: p.slug,
+      link: p.link,
+      word_count: wc,
+      headings_count: headings.length,
+      headings
+    });
+  }
+
+  // Aggregated stats
+  const totalWords = outlines.reduce((s, o) => s + o.word_count, 0);
+  const totalHeadings = outlines.reduce((s, o) => s + o.headings_count, 0);
+  const avgWordCount = outlines.length > 0 ? Math.round(totalWords / outlines.length) : 0;
+  const avgHeadingsCount = outlines.length > 0 ? Math.round(totalHeadings / outlines.length) : 0;
+
+  // Common H2 patterns (top 10)
+  const commonH2 = [...h2Counter.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([text, frequency]) => ({ text, frequency }));
+
+  result = json({
+    category_id,
+    posts_analyzed: outlines.length,
+    avg_word_count: avgWordCount,
+    avg_headings_count: avgHeadingsCount,
+    common_h2_patterns: commonH2,
+    outlines
+  });
+  auditLog({ tool: name, action: 'extract_outline', status: 'success', latency_ms: Date.now() - t0, params: { category_id, post_type: outlinePostType, limit: outlineLimit } });
+  return result;
+};
+handlers['wp_audit_readability'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, calculateReadabilityScore, extractTransitionWords, countPassiveSentences, countWords } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 200 },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    category_id: { type: 'number' },
+    min_words: { type: 'number', min: 0 }
+  });
+  const { limit: arLimit = 50, post_type: arPostType = 'post', category_id: arCatId, min_words: arMinWords = 100 } = args;
+  const arEndpoint = arPostType === 'page' ? '/pages' : '/posts';
+  let arUrl = `${arEndpoint}?per_page=${Math.min(arLimit, 200)}&status=publish&_fields=id,title,content,slug,link,categories,meta`;
+  if (arCatId && arPostType !== 'page') arUrl += `&categories=${arCatId}`;
+  const arPosts = await wpApiCall(arUrl);
+
+  const arResults = [];
+  for (const p of arPosts) {
+    const html = p.content?.rendered || '';
+    const wc = countWords(html);
+    if (wc < arMinWords) continue;
+    const plainText = strip(html);
+    const readabilityResult = calculateReadabilityScore(html);
+    const transitionResult = extractTransitionWords(plainText);
+    const passiveResult = countPassiveSentences(plainText);
+
+    const issues = [];
+    if (readabilityResult.score < 20) issues.push('very_low_readability');
+    else if (readabilityResult.score < 40) issues.push('low_readability');
+    if (transitionResult.count === 0) issues.push('no_transition_words');
+    else if (transitionResult.density < 0.1) issues.push('low_transition_density');
+    if (passiveResult.ratio > 0.3) issues.push('high_passive_ratio');
+
+    arResults.push({
+      id: p.id,
+      title: strip(p.title?.rendered || ''),
+      slug: p.slug,
+      link: p.link,
+      word_count: wc,
+      readability: {
+        score: readabilityResult.score,
+        level: readabilityResult.level,
+        avg_words_per_sentence: readabilityResult.avg_words_per_sentence,
+        avg_syllables_per_word: readabilityResult.avg_syllables_per_word
+      },
+      transition_density: transitionResult.density,
+      passive_ratio: passiveResult.ratio,
+      issues
+    });
+  }
+
+  // Sort by score ASC (worst first)
+  arResults.sort((a, b) => a.readability.score - b.readability.score);
+
+  // Aggregation
+  const arTotal = arResults.length;
+  const arAvgScore = arTotal > 0 ? Math.round(arResults.reduce((s, r) => s + r.readability.score, 0) / arTotal * 10) / 10 : 0;
+  const arAvgTD = arTotal > 0 ? Math.round(arResults.reduce((s, r) => s + r.transition_density, 0) / arTotal * 1000) / 1000 : 0;
+  const arAvgPR = arTotal > 0 ? Math.round(arResults.reduce((s, r) => s + r.passive_ratio, 0) / arTotal * 1000) / 1000 : 0;
+  const distribution = { 'très facile': 0, 'facile': 0, 'standard': 0, 'difficile': 0, 'très difficile': 0 };
+  for (const r of arResults) { distribution[r.readability.level] = (distribution[r.readability.level] || 0) + 1; }
+
+  result = json({
+    total_analyzed: arTotal,
+    avg_readability_score: arAvgScore,
+    distribution,
+    avg_transition_density: arAvgTD,
+    avg_passive_ratio: arAvgPR,
+    posts: arResults
+  });
+  auditLog({ tool: name, action: 'audit_readability', status: 'success', latency_ms: Date.now() - t0, params: { limit: arLimit, post_type: arPostType, category_id: arCatId, min_words: arMinWords } });
+  return result;
+};
+handlers['wp_audit_update_frequency'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, countWords, extractFocusKeyword } = rt;
+  validateInput(args, {
+    days_threshold: { type: 'number', min: 1 },
+    limit: { type: 'number', min: 1, max: 200 },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    include_seo_score: { type: 'boolean' }
+  });
+  const { days_threshold: aufDays = 180, limit: aufLimit = 50, post_type: aufPostType = 'post', include_seo_score: aufIncludeSeo = true } = args;
+  const aufEndpoint = aufPostType === 'page' ? '/pages' : '/posts';
+  const aufUrl = `${aufEndpoint}?per_page=${Math.min(aufLimit, 200)}&status=publish&_fields=id,title,slug,link,date,modified,content,meta,categories`;
+  const aufAllPosts = await wpApiCall(aufUrl);
+
+  const aufNow = Date.now();
+  const aufFiltered = [];
+
+  for (const p of aufAllPosts) {
+    const daysSince = Math.floor((aufNow - new Date(p.modified).getTime()) / 86400000);
+    if (daysSince < aufDays) continue;
+
+    const meta = p.meta || {};
+    const html = p.content?.rendered || '';
+    const wc = countWords(html);
+
+    let seoScore = null;
+    const issues = ['outdated_180d'];
+    if (daysSince >= 365) issues.push('outdated_365d');
+    if (wc < 300) issues.push('thin_content');
+
+    if (aufIncludeSeo) {
+      const seoTitle = meta.rank_math_title || meta._yoast_wpseo_title || meta._seopress_titles_title || meta._aioseo_title || null;
+      const seoDesc = meta.rank_math_description || meta._yoast_wpseo_metadesc || meta._seopress_titles_desc || meta._aioseo_description || null;
+      const focusKw = extractFocusKeyword(meta);
+      seoScore = 100;
+      if (!seoTitle) { seoScore -= 30; issues.push('missing_seo_title'); }
+      if (!seoDesc) { seoScore -= 30; issues.push('missing_meta_description'); }
+      if (!focusKw) seoScore -= 20;
+      if (seoTitle && focusKw && !seoTitle.toLowerCase().includes(focusKw.toLowerCase())) seoScore -= 10;
+      if (seoScore < 70) issues.push('low_seo_score');
+    }
+
+    const priority = daysSince * (aufIncludeSeo && seoScore !== null ? (100 - seoScore) / 100 : 1) * (wc < 300 ? 1.5 : 1);
+
+    aufFiltered.push({
+      id: p.id,
+      title: strip(p.title?.rendered || ''),
+      slug: p.slug,
+      link: p.link,
+      date: p.date,
+      modified: p.modified,
+      days_since_modified: daysSince,
+      word_count: wc,
+      seo_score: seoScore,
+      priority_score: Math.round(priority * 10) / 10,
+      issues
+    });
+  }
+
+  aufFiltered.sort((a, b) => b.priority_score - a.priority_score);
+
+  result = json({
+    days_threshold: aufDays,
+    total_published: aufAllPosts.length,
+    outdated_count: aufFiltered.length,
+    outdated_ratio: aufAllPosts.length > 0 ? Math.round(aufFiltered.length / aufAllPosts.length * 100) / 100 : 0,
+    posts: aufFiltered
+  });
+  auditLog({ tool: name, action: 'audit_update_frequency', status: 'success', latency_ms: Date.now() - t0, params: { days_threshold: aufDays, limit: aufLimit, post_type: aufPostType, include_seo_score: aufIncludeSeo } });
+  return result;
+};
+handlers['wp_build_link_map'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, targets, auditLog, name, extractInternalLinks } = rt;
+  validateInput(args, {
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] },
+    limit: { type: 'number', min: 1, max: 200 },
+    category_id: { type: 'number' }
+  });
+  const { post_type: lmPostType = 'post', limit: lmLimit = 50, category_id: lmCatId } = args;
+  const { url: lmSiteUrl } = getActiveAuth();
+  const perPage = Math.min(lmLimit, 200);
+  const fields = '_fields=id,title,slug,link,content,categories';
+
+  let lmPosts = [];
+  if (lmPostType === 'both') {
+    let postsUrl = `/posts?per_page=${perPage}&status=publish&${fields}`;
+    if (lmCatId) postsUrl += `&categories=${lmCatId}`;
+    const [posts, pages] = await Promise.all([
+      wpApiCall(postsUrl),
+      wpApiCall(`/pages?per_page=${perPage}&status=publish&${fields}`)
+    ]);
+    lmPosts = [...posts, ...pages];
+  } else {
+    const ep = lmPostType === 'page' ? '/pages' : '/posts';
+    let postsUrl = `${ep}?per_page=${perPage}&status=publish&${fields}`;
+    if (lmCatId && lmPostType !== 'page') postsUrl += `&categories=${lmCatId}`;
+    lmPosts = await wpApiCall(postsUrl);
+  }
+
+  // Build lookup maps
+  const postMap = new Map();
+  const slugToId = new Map();
+  for (const p of lmPosts) {
+    postMap.set(p.id, {
+      id: p.id,
+      title: strip(p.title?.rendered || ''),
+      slug: p.slug,
+      link: p.link,
+      outbound_links: [],
+      inbound_count: 0,
+      unresolved_links: 0
+    });
+    slugToId.set(p.slug, p.id);
+    if (p.link) {
+      try { slugToId.set(new URL(p.link).pathname.replace(/\/+$/, ''), p.id); } catch { /* skip */ }
+    }
+  }
+
+  // Extract links and resolve targets
+  let totalLinks = 0;
+  const linkMatrix = {};
+
+  for (const p of lmPosts) {
+    const html = p.content?.rendered || '';
+    const internalLinks = extractInternalLinks(html, lmSiteUrl);
+    const resolvedTargets = [];
+    let unresolvedCount = 0;
+
+    for (const link of internalLinks) {
+      let targetId = null;
+      // Try to match by URL path
+      try {
+        const linkPath = new URL(link.url || link).pathname.replace(/\/+$/, '');
+        targetId = slugToId.get(linkPath) || null;
+        if (!targetId) {
+          // Try matching just the last segment as slug
+          const lastSeg = linkPath.split('/').filter(Boolean).pop();
+          if (lastSeg) targetId = slugToId.get(lastSeg) || null;
+        }
+      } catch { /* skip */ }
+
+      if (targetId && targetId !== p.id && postMap.has(targetId)) {
+        const target = postMap.get(targetId);
+        resolvedTargets.push({
+          target_id: targetId,
+          target_title: target.title,
+          anchor_text: link.anchor_text || link.text || ''
+        });
+        target.inbound_count++;
+        totalLinks++;
+      } else {
+        unresolvedCount++;
+      }
+    }
+
+    const entry = postMap.get(p.id);
+    entry.outbound_links = resolvedTargets;
+    entry.unresolved_links = unresolvedCount;
+    if (resolvedTargets.length > 0) {
+      linkMatrix[p.id] = resolvedTargets.map(l => l.target_id);
+    }
+  }
+
+  // Simplified PageRank (10 iterations, damping 0.85)
+  const N = lmPosts.length;
+  const damping = 0.85;
+  let scores = new Map();
+  for (const p of lmPosts) scores.set(p.id, 1 / N);
+
+  for (let iter = 0; iter < 10; iter++) {
+    const newScores = new Map();
+    for (const p of lmPosts) newScores.set(p.id, (1 - damping) / N);
+    for (const p of lmPosts) {
+      const entry = postMap.get(p.id);
+      const outCount = entry.outbound_links.length;
+      if (outCount > 0) {
+        const share = (damping * scores.get(p.id)) / outCount;
+        for (const link of entry.outbound_links) {
+          newScores.set(link.target_id, (newScores.get(link.target_id) || 0) + share);
+        }
+      }
+    }
+    scores = newScores;
+  }
+
+  // Normalize to 0-100
+  let maxScore = 0;
+  for (const s of scores.values()) { if (s > maxScore) maxScore = s; }
+  const normalizedScores = new Map();
+  for (const [id, s] of scores) {
+    normalizedScores.set(id, maxScore > 0 ? Math.round((s / maxScore) * 100 * 10) / 10 : 0);
+  }
+
+  // Build result array
+  const lmResults = [];
+  for (const [id, entry] of postMap) {
+    lmResults.push({
+      id,
+      title: entry.title,
+      slug: entry.slug,
+      link: entry.link,
+      outbound_count: entry.outbound_links.length,
+      inbound_count: entry.inbound_count,
+      pagerank_score: normalizedScores.get(id) || 0,
+      is_orphan: entry.inbound_count === 0,
+      outbound_links: entry.outbound_links,
+      unresolved_links: entry.unresolved_links
+    });
+  }
+
+  lmResults.sort((a, b) => b.pagerank_score - a.pagerank_score);
+
+  const orphanCount = lmResults.filter(r => r.is_orphan).length;
+  result = json({
+    total_analyzed: lmPosts.length,
+    total_internal_links: totalLinks,
+    avg_outbound_per_post: lmPosts.length > 0 ? Math.round(totalLinks / lmPosts.length * 10) / 10 : 0,
+    orphan_posts: orphanCount,
+    posts: lmResults,
+    link_matrix: linkMatrix
+  });
+  auditLog({ tool: name, action: 'build_link_map', status: 'success', latency_ms: Date.now() - t0, params: { post_type: lmPostType, limit: lmLimit, category_id: lmCatId } });
+  return result;
+};
+handlers['wp_audit_anchor_texts'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, targets, auditLog, name, extractInternalLinks } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 200 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] }
+  });
+  const { limit: aatLimit = 50, post_type: aatPostType = 'post' } = args;
+  const { url: aatSiteUrl } = getActiveAuth();
+  const aatPerPage = Math.min(aatLimit, 200);
+  const aatFields = '_fields=id,title,slug,link,content';
+
+  let aatPosts = [];
+  if (aatPostType === 'both') {
+    const [posts, pages] = await Promise.all([
+      wpApiCall(`/posts?per_page=${aatPerPage}&status=publish&${aatFields}`),
+      wpApiCall(`/pages?per_page=${aatPerPage}&status=publish&${aatFields}`)
+    ]);
+    aatPosts = [...posts, ...pages];
+  } else {
+    const ep = aatPostType === 'page' ? '/pages' : '/posts';
+    aatPosts = await wpApiCall(`${ep}?per_page=${aatPerPage}&status=publish&${aatFields}`);
+  }
+
+  const GENERIC_ANCHORS = ['cliquez ici', 'click here', 'lire la suite', 'read more', 'en savoir plus', 'learn more', 'ici', 'here', 'lien', 'link', 'voir', 'see', 'plus', 'more', 'article', 'page', 'ce lien', 'this link', 'cet article', 'this article'];
+
+  // Corpus-wide anchor map: anchor_text_lower → { count, posts: Set, targets: Set }
+  const anchorMap = new Map();
+  const postAnchors = new Map(); // postId → { anchors: [{text,type}], total, unique }
+
+  let totalInternalLinks = 0;
+
+  for (const p of aatPosts) {
+    const html = p.content?.rendered || '';
+    const links = extractInternalLinks(html, aatSiteUrl);
+    const postAnchorList = [];
+
+    for (const link of links) {
+      const text = (link.anchor_text || '').trim();
+      const lower = text.toLowerCase();
+      totalInternalLinks++;
+
+      postAnchorList.push({ text, lower, href: link.url });
+
+      if (!anchorMap.has(lower)) {
+        anchorMap.set(lower, { count: 0, posts: new Set(), targets: new Set() });
+      }
+      const entry = anchorMap.get(lower);
+      entry.count++;
+      entry.posts.add(p.id);
+      entry.targets.add(link.url);
+    }
+
+    postAnchors.set(p.id, postAnchorList);
+  }
+
+  // Classify each anchor
+  const anchorHealth = { healthy: 0, generic: 0, over_optimized: 0, image_link: 0 };
+  const genericAnchorsMap = new Map(); // text → { count, post_ids }
+  const overOptimized = [];
+
+  for (const [lower, entry] of anchorMap) {
+    if (lower === '' || /^\s*$/.test(lower)) {
+      anchorHealth.image_link += entry.count;
+    } else if (GENERIC_ANCHORS.includes(lower)) {
+      anchorHealth.generic += entry.count;
+      genericAnchorsMap.set(lower, { text: lower, count: entry.count, post_ids: [...entry.posts] });
+    } else if (entry.count > 3 && entry.targets.size > 1) {
+      anchorHealth.over_optimized += entry.count;
+      overOptimized.push({ text: lower, count: entry.count, target_count: entry.targets.size, post_ids: [...entry.posts] });
+    } else {
+      anchorHealth.healthy += entry.count;
+    }
+  }
+
+  // Top 10 generic anchors sorted by count DESC
+  const genericAnchors = [...genericAnchorsMap.values()].sort((a, b) => b.count - a.count).slice(0, 10);
+
+  // Per-post results
+  const aatResults = [];
+  for (const p of aatPosts) {
+    const anchors = postAnchors.get(p.id) || [];
+    const total = anchors.length;
+    const uniqueTexts = new Set(anchors.map(a => a.lower));
+    const unique = uniqueTexts.size;
+    const ds = total > 0 ? unique / total : 1;
+
+    const issues = [];
+    const hasGeneric = anchors.some(a => GENERIC_ANCHORS.includes(a.lower));
+    const hasOverOpt = anchors.some(a => {
+      const e = anchorMap.get(a.lower);
+      return e && e.count > 3 && e.targets.size > 1 && a.lower !== '' && !GENERIC_ANCHORS.includes(a.lower);
+    });
+    const hasImageLink = anchors.some(a => a.lower === '' || /^\s*$/.test(a.lower));
+    if (hasGeneric) issues.push('has_generic_anchors');
+    if (hasOverOpt) issues.push('has_over_optimized_anchors');
+    if (hasImageLink) issues.push('has_image_links');
+    if (total > 0 && ds < 0.5) issues.push('low_anchor_diversity');
+
+    aatResults.push({
+      id: p.id,
+      title: strip(p.title?.rendered || ''),
+      slug: p.slug,
+      internal_links_count: total,
+      unique_anchors_count: unique,
+      diversity_score: Math.round(ds * 100) / 100,
+      issues
+    });
+  }
+
+  aatResults.sort((a, b) => a.diversity_score - b.diversity_score);
+
+  result = json({
+    total_analyzed: aatPosts.length,
+    total_internal_links: totalInternalLinks,
+    total_unique_anchors: anchorMap.size,
+    anchor_health: anchorHealth,
+    generic_anchors: genericAnchors,
+    over_optimized_anchors: overOptimized,
+    posts: aatResults
+  });
+  auditLog({ tool: name, action: 'audit_anchor_texts', status: 'success', latency_ms: Date.now() - t0, params: { limit: aatLimit, post_type: aatPostType } });
+  return result;
+};
+handlers['wp_audit_schema_markup'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 200 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] }
+  });
+  const { limit: asmLimit = 50, post_type: asmPostType = 'post' } = args;
+  const asmPerPage = Math.min(asmLimit, 200);
+  const asmFields = '_fields=id,title,slug,link,content';
+
+  let asmPosts = [];
+  if (asmPostType === 'both') {
+    const [posts, pages] = await Promise.all([
+      wpApiCall(`/posts?per_page=${asmPerPage}&status=publish&${asmFields}`),
+      wpApiCall(`/pages?per_page=${asmPerPage}&status=publish&${asmFields}`)
+    ]);
+    asmPosts = [...posts, ...pages];
+  } else {
+    const ep = asmPostType === 'page' ? '/pages' : '/posts';
+    asmPosts = await wpApiCall(`${ep}?per_page=${asmPerPage}&status=publish&${asmFields}`);
+  }
+
+  const SCHEMA_REQUIRED_FIELDS = {
+    'Article': ['headline', 'datePublished', 'author'],
+    'NewsArticle': ['headline', 'datePublished', 'author'],
+    'BlogPosting': ['headline', 'datePublished', 'author'],
+    'FAQPage': ['mainEntity'],
+    'HowTo': ['name', 'step'],
+    'LocalBusiness': ['name', 'address'],
+    'BreadcrumbList': ['itemListElement'],
+    'Organization': ['name'],
+    'WebPage': ['name']
+  };
+  const ARTICLE_TYPES = ['Article', 'NewsArticle', 'BlogPosting'];
+
+  const typeDist = {};
+  let totalSchemas = 0;
+  let validCount = 0;
+  let invalidCount = 0;
+  let postsWithSchema = 0;
+  let postsWithout = 0;
+
+  const ldJsonRegex = /<script\s+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+  const asmResults = [];
+  for (const p of asmPosts) {
+    const html = p.content?.rendered || '';
+    const schemas = [];
+    const issues = [];
+    let hasInvalidJson = false;
+    let hasArticleSchema = false;
+
+    let ldMatch;
+    ldJsonRegex.lastIndex = 0;
+    while ((ldMatch = ldJsonRegex.exec(html)) !== null) {
+      const raw = ldMatch[1].trim();
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        schemas.push({ type: 'unknown', valid: false, missing_fields: [], raw_type: 'parse_error' });
+        hasInvalidJson = true;
+        invalidCount++;
+        totalSchemas++;
+        continue;
+      }
+
+      const types = Array.isArray(parsed['@type']) ? parsed['@type'] : [parsed['@type'] || 'unknown'];
+      for (const t of types) {
+        const required = SCHEMA_REQUIRED_FIELDS[t];
+        if (ARTICLE_TYPES.includes(t)) hasArticleSchema = true;
+
+        if (required) {
+          const missing = required.filter(f => {
+            const val = parsed[f];
+            if (val === undefined || val === null) return true;
+            if (Array.isArray(val) && val.length === 0) return true;
+            return false;
+          });
+          const isValid = missing.length === 0;
+          schemas.push({ type: t, valid: isValid, missing_fields: missing, raw_type: t });
+          if (isValid) validCount++; else invalidCount++;
+          if (!isValid) issues.push('missing_required_fields');
+          typeDist[t] = (typeDist[t] || 0) + 1;
+        } else {
+          schemas.push({ type: t, valid: true, missing_fields: [], raw_type: t });
+          validCount++;
+          typeDist['other'] = (typeDist['other'] || 0) + 1;
+        }
+        totalSchemas++;
+      }
+    }
+
+    if (schemas.length === 0) {
+      issues.push('no_schema');
+      postsWithout++;
+    } else {
+      postsWithSchema++;
+    }
+    if (hasInvalidJson) issues.push('invalid_json');
+    if (!hasArticleSchema && schemas.length > 0) issues.push('no_article_schema');
+
+    asmResults.push({
+      id: p.id,
+      title: strip(p.title?.rendered || ''),
+      slug: p.slug,
+      link: p.link,
+      schemas_found: schemas.length,
+      schemas,
+      issues
+    });
+  }
+
+  // Sort: posts with issues first, by issue count DESC
+  asmResults.sort((a, b) => b.issues.length - a.issues.length);
+
+  result = json({
+    total_analyzed: asmPosts.length,
+    posts_with_schema: postsWithSchema,
+    posts_without_schema: postsWithout,
+    schema_type_distribution: typeDist,
+    total_schemas_found: totalSchemas,
+    total_valid: validCount,
+    total_invalid: invalidCount,
+    posts: asmResults
+  });
+  auditLog({ tool: name, action: 'audit_schema_markup', status: 'success', latency_ms: Date.now() - t0, params: { limit: asmLimit, post_type: asmPostType } });
+  return result;
+};
+handlers['wp_audit_content_structure'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, detectContentSections, countWords } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 200 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] },
+    category_id: { type: 'number' }
+  });
+  const { limit: acsLimit = 50, post_type: acsPostType = 'post', category_id: acsCatId } = args;
+  const acsPerPage = Math.min(acsLimit, 200);
+  const acsFields = '_fields=id,title,slug,link,content,categories';
+
+  let acsPosts = [];
+  if (acsPostType === 'both') {
+    let postsUrl = `/posts?per_page=${acsPerPage}&status=publish&${acsFields}`;
+    if (acsCatId) postsUrl += `&categories=${acsCatId}`;
+    const [posts, pages] = await Promise.all([
+      wpApiCall(postsUrl),
+      wpApiCall(`/pages?per_page=${acsPerPage}&status=publish&${acsFields}`)
+    ]);
+    acsPosts = [...posts, ...pages];
+  } else {
+    const ep = acsPostType === 'page' ? '/pages' : '/posts';
+    let postsUrl = `${ep}?per_page=${acsPerPage}&status=publish&${acsFields}`;
+    if (acsCatId && acsPostType !== 'page') postsUrl += `&categories=${acsCatId}`;
+    acsPosts = await wpApiCall(postsUrl);
+  }
+
+  let totalScore = 0;
+  const distribution = { excellent: 0, good: 0, average: 0, poor: 0 };
+  const featureCounts = { intro: 0, conclusion: 0, faq: 0, toc: 0, lists: 0, tables: 0, images: 0, blockquotes: 0 };
+
+  const acsResults = [];
+  for (const p of acsPosts) {
+    const html = p.content?.rendered || '';
+    const sections = detectContentSections(html);
+    const wc = countWords(html);
+
+    // Paragraphs count (non-empty <p>)
+    const pMatches = html.match(/<p[^>]*>(?!\s*<\/p>)/gi) || [];
+    const paragraphsCount = pMatches.length || 1;
+    const avgParagraphLength = Math.round(wc / paragraphsCount);
+
+    // TOC detection
+    const hasToc = /<[^>]+(?:id|class)=["'][^"']*(?:toc|table-of-contents|table-des-matieres)[^"']*["'][^>]*>/i.test(html);
+
+    // Blockquotes and code blocks
+    const blockquotesCount = (html.match(/<blockquote\b/gi) || []).length;
+    const codeBlocksCount = (html.match(/<(?:pre|code)\b/gi) || []).length;
+
+    // Heading density: headings per 300 words
+    const headingDensity = wc > 0 ? sections.headings_count / (wc / 300) : 0;
+
+    // Structure score (0-100)
+    let score = 0;
+    if (sections.has_intro) score += 15;
+    if (sections.has_conclusion) score += 10;
+    if (sections.headings_count >= 3) score += 15;
+    if (headingDensity >= 0.5 && headingDensity <= 2.0) score += 10;
+    if (sections.lists_count >= 1) score += 10;
+    if (sections.images_count >= 1) score += 10;
+    if (sections.has_faq) score += 10;
+    if (sections.tables_count >= 1) score += 5;
+    if (hasToc) score += 5;
+    if (blockquotesCount > 0 || codeBlocksCount > 0) score += 5;
+    if (avgParagraphLength < 100) score += 5;
+
+    totalScore += score;
+
+    if (score >= 80) distribution.excellent++;
+    else if (score >= 60) distribution.good++;
+    else if (score >= 40) distribution.average++;
+    else distribution.poor++;
+
+    // Feature coverage tracking
+    if (sections.has_intro) featureCounts.intro++;
+    if (sections.has_conclusion) featureCounts.conclusion++;
+    if (sections.has_faq) featureCounts.faq++;
+    if (hasToc) featureCounts.toc++;
+    if (sections.lists_count >= 1) featureCounts.lists++;
+    if (sections.tables_count >= 1) featureCounts.tables++;
+    if (sections.images_count >= 1) featureCounts.images++;
+    if (blockquotesCount > 0) featureCounts.blockquotes++;
+
+    // Issues
+    const issues = [];
+    if (!sections.has_intro) issues.push('no_intro');
+    if (!sections.has_conclusion) issues.push('no_conclusion');
+    if (sections.headings_count === 0) issues.push('no_headings');
+    if (headingDensity < 0.3 && wc > 100) issues.push('low_heading_density');
+    if (headingDensity > 3.0) issues.push('high_heading_density');
+    if (sections.images_count === 0) issues.push('no_images');
+    if (sections.lists_count === 0) issues.push('no_lists');
+    if (avgParagraphLength > 150) issues.push('long_paragraphs');
+    if (score < 40) issues.push('poor_structure');
+
+    acsResults.push({
+      id: p.id,
+      title: strip(p.title?.rendered || ''),
+      slug: p.slug,
+      link: p.link,
+      word_count: wc,
+      structure_score: score,
+      features: {
+        has_intro: sections.has_intro,
+        has_conclusion: sections.has_conclusion,
+        has_faq: sections.has_faq,
+        has_toc: hasToc,
+        headings_count: sections.headings_count,
+        lists_count: sections.lists_count,
+        tables_count: sections.tables_count,
+        images_count: sections.images_count,
+        paragraphs_count: paragraphsCount,
+        avg_paragraph_length: avgParagraphLength,
+        blockquotes_count: blockquotesCount,
+        code_blocks_count: codeBlocksCount,
+        heading_density: Math.round(headingDensity * 100) / 100
+      },
+      issues
+    });
+  }
+
+  acsResults.sort((a, b) => a.structure_score - b.structure_score);
+
+  const acsTotal = acsPosts.length;
+  const featureCoverage = {};
+  for (const [key, count] of Object.entries(featureCounts)) {
+    featureCoverage[key] = acsTotal > 0 ? Math.round(count / acsTotal * 100) : 0;
+  }
+
+  result = json({
+    total_analyzed: acsTotal,
+    avg_structure_score: acsTotal > 0 ? Math.round(totalScore / acsTotal * 10) / 10 : 0,
+    distribution,
+    feature_coverage: featureCoverage,
+    posts: acsResults
+  });
+  auditLog({ tool: name, action: 'audit_content_structure', status: 'success', latency_ms: Date.now() - t0, params: { limit: acsLimit, post_type: acsPostType, category_id: acsCatId } });
+  return result;
+};
+handlers['wp_find_duplicate_content'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, findDuplicatePairs, countWords } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 100 },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    category_id: { type: 'number' },
+    similarity_threshold: { type: 'number', min: 0, max: 1 }
+  });
+  const { limit: fdcLimit = 50, post_type: fdcPostType = 'post', category_id: fdcCatId, similarity_threshold: fdcThreshold = 0.7 } = args;
+  const fdcPerPage = Math.min(fdcLimit, 100);
+  const fdcFields = '_fields=id,title,content,slug,link';
+
+  const fdcEp = fdcPostType === 'page' ? '/pages' : '/posts';
+  let fdcUrl = `${fdcEp}?per_page=${fdcPerPage}&status=publish&${fdcFields}`;
+  if (fdcCatId && fdcPostType !== 'page') fdcUrl += `&categories=${fdcCatId}`;
+
+  const fdcPosts = await wpApiCall(fdcUrl);
+
+  const fdcDocs = [];
+  const fdcPostMap = new Map();
+  for (const p of fdcPosts) {
+    const text = strip(p.content?.rendered || '');
+    const wc = countWords(p.content?.rendered || '');
+    fdcPostMap.set(p.id, { id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, word_count: wc });
+    if (wc >= 50) {
+      fdcDocs.push({ id: p.id, title: strip(p.title?.rendered || ''), text });
+    }
+  }
+
+  const fdcPairs = findDuplicatePairs(fdcDocs, fdcThreshold);
+
+  const formattedPairs = fdcPairs
+    .sort((a, b) => b.similarity - a.similarity)
+    .map(pair => {
+      const p1 = fdcPostMap.get(pair.doc1_id);
+      const p2 = fdcPostMap.get(pair.doc2_id);
+      const sim = Math.round(pair.similarity * 1000) / 1000;
+      return {
+        post1: { id: p1.id, title: p1.title, slug: p1.slug, word_count: p1.word_count },
+        post2: { id: p2.id, title: p2.title, slug: p2.slug, word_count: p2.word_count },
+        similarity: sim,
+        severity: sim >= 0.9 ? 'critical' : sim >= 0.8 ? 'high' : 'medium'
+      };
+    });
+
+  // Union-find clustering
+  const ufParent = new Map();
+  const ufFind = (x) => {
+    if (!ufParent.has(x)) ufParent.set(x, x);
+    if (ufParent.get(x) !== x) ufParent.set(x, ufFind(ufParent.get(x)));
+    return ufParent.get(x);
+  };
+  const ufUnion = (a, b) => { ufParent.set(ufFind(a), ufFind(b)); };
+
+  for (const pair of fdcPairs) ufUnion(pair.doc1_id, pair.doc2_id);
+
+  const clusterMap = new Map();
+  const idsInPairs = new Set();
+  for (const pair of fdcPairs) { idsInPairs.add(pair.doc1_id); idsInPairs.add(pair.doc2_id); }
+  for (const id of idsInPairs) {
+    const root = ufFind(id);
+    if (!clusterMap.has(root)) clusterMap.set(root, { posts: [], maxSim: 0 });
+    const info = fdcPostMap.get(id);
+    clusterMap.get(root).posts.push({ id: info.id, title: info.title, slug: info.slug });
+  }
+  for (const pair of fdcPairs) {
+    const root = ufFind(pair.doc1_id);
+    const cluster = clusterMap.get(root);
+    if (pair.similarity > cluster.maxSim) cluster.maxSim = pair.similarity;
+  }
+
+  let fdcClusterId = 0;
+  const clusters = [...clusterMap.values()].map(c => ({
+    cluster_id: ++fdcClusterId,
+    posts: c.posts,
+    max_similarity: Math.round(c.maxSim * 1000) / 1000
+  }));
+
+  result = json({
+    total_analyzed: fdcPosts.length,
+    similarity_threshold: fdcThreshold,
+    duplicate_pairs_found: formattedPairs.length,
+    duplicate_clusters: clusters.length,
+    pairs: formattedPairs,
+    clusters
+  });
+  auditLog({ tool: name, action: 'find_duplicate_content', status: 'success', latency_ms: Date.now() - t0, params: { limit: fdcLimit, post_type: fdcPostType, category_id: fdcCatId, similarity_threshold: fdcThreshold } });
+  return result;
+};
+handlers['wp_find_content_gaps'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, {
+    min_posts: { type: 'number', min: 1, max: 50 },
+    taxonomy: { type: 'string', enum: ['category', 'post_tag', 'both'] },
+    exclude_empty: { type: 'boolean' }
+  });
+  const { min_posts: fcgMinPosts = 3, taxonomy: fcgTaxonomy = 'both', exclude_empty: fcgExcludeEmpty = false } = args;
+
+  let fcgCategories = [];
+  let fcgTags = [];
+
+  if (fcgTaxonomy === 'category' || fcgTaxonomy === 'both') {
+    fcgCategories = await wpApiCall('/categories?per_page=100&_fields=id,name,slug,count,description,parent');
+  }
+  if (fcgTaxonomy === 'post_tag' || fcgTaxonomy === 'both') {
+    fcgTags = await wpApiCall('/tags?per_page=100&_fields=id,name,slug,count');
+  }
+
+  const catMap = new Map();
+  for (const c of fcgCategories) catMap.set(c.id, c);
+
+  const fcgGaps = [];
+  const fcgWellCovered = [];
+
+  for (const c of fcgCategories) {
+    if (fcgExcludeEmpty && c.count === 0) continue;
+    if (c.count < fcgMinPosts) {
+      const parentInfo = c.parent ? catMap.get(c.parent) : null;
+      fcgGaps.push({
+        taxonomy: 'category', id: c.id, name: c.name, slug: c.slug,
+        current_count: c.count, deficit: fcgMinPosts - c.count,
+        parent_name: parentInfo ? parentInfo.name : null,
+        parent_count: parentInfo ? parentInfo.count : null,
+        severity: c.count === 0 ? 'empty' : 'underrepresented',
+        suggestion: c.count === 0
+          ? `Create ${fcgMinPosts} posts for "${c.name}"`
+          : `Add ${fcgMinPosts - c.count} more posts for "${c.name}"`
+      });
+    } else {
+      fcgWellCovered.push({ taxonomy: 'category', id: c.id, name: c.name, count: c.count });
+    }
+  }
+
+  for (const t of fcgTags) {
+    if (fcgExcludeEmpty && t.count === 0) continue;
+    if (t.count < fcgMinPosts) {
+      fcgGaps.push({
+        taxonomy: 'post_tag', id: t.id, name: t.name, slug: t.slug,
+        current_count: t.count, deficit: fcgMinPosts - t.count,
+        parent_name: null, parent_count: null,
+        severity: t.count === 0 ? 'empty' : 'underrepresented',
+        suggestion: t.count === 0
+          ? `Create ${fcgMinPosts} posts for "${t.name}"`
+          : `Add ${fcgMinPosts - t.count} more posts for "${t.name}"`
+      });
+    } else {
+      fcgWellCovered.push({ taxonomy: 'post_tag', id: t.id, name: t.name, count: t.count });
+    }
+  }
+
+  fcgGaps.sort((a, b) => b.deficit - a.deficit || a.current_count - b.current_count);
+  fcgWellCovered.sort((a, b) => b.count - a.count);
+
+  const catGaps = fcgGaps.filter(g => g.taxonomy === 'category');
+  const tagGaps = fcgGaps.filter(g => g.taxonomy === 'post_tag');
+
+  result = json({
+    min_posts_threshold: fcgMinPosts,
+    total_terms_analyzed: fcgCategories.length + fcgTags.length,
+    gaps_found: fcgGaps.length,
+    gaps_by_taxonomy: { categories: catGaps.length, tags: tagGaps.length },
+    gaps: fcgGaps,
+    well_covered: fcgWellCovered.slice(0, 10)
+  });
+  auditLog({ tool: name, action: 'find_content_gaps', status: 'success', latency_ms: Date.now() - t0, params: { min_posts: fcgMinPosts, taxonomy: fcgTaxonomy, exclude_empty: fcgExcludeEmpty } });
+  return result;
+};
+handlers['wp_extract_faq_blocks'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 200 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] }
+  });
+  const { limit: efbLimit = 50, post_type: efbPostType = 'post' } = args;
+  const efbPerPage = Math.min(efbLimit, 200);
+  const efbFields = '_fields=id,title,slug,link,content';
+
+  let efbPosts = [];
+  if (efbPostType === 'both') {
+    const [posts, pages] = await Promise.all([
+      wpApiCall(`/posts?per_page=${efbPerPage}&status=publish&${efbFields}`),
+      wpApiCall(`/pages?per_page=${efbPerPage}&status=publish&${efbFields}`)
+    ]);
+    efbPosts = [...posts, ...pages];
+  } else {
+    const ep = efbPostType === 'page' ? '/pages' : '/posts';
+    efbPosts = await wpApiCall(`${ep}?per_page=${efbPerPage}&status=publish&${efbFields}`);
+  }
+
+  const efbLdRegex = /<script\s+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  const efbYoastRegex = /<!-- wp:yoast\/faq-block -->([\s\S]*?)<!-- \/wp:yoast\/faq-block -->/gi;
+  const efbRankMathRegex = /<!-- wp:rank-math\/faq-block -->([\s\S]*?)<!-- \/wp:rank-math\/faq-block -->/gi;
+  const efbFaqHeadingRegex = /<h[2-4][^>]*>[^<]*(?:FAQ|Questions fréquentes|Questions courantes|Foire aux questions)[^<]*<\/h[2-4]>/gi;
+
+  let efbTotalQ = 0;
+  let efbPostsWithFaq = 0;
+  const efbBySource = { 'json-ld': 0, 'gutenberg-block': 0, 'html-pattern': 0 };
+
+  const efbResults = [];
+  for (const p of efbPosts) {
+    const html = p.content?.rendered || '';
+    const faqBlocks = [];
+
+    // Type A: JSON-LD FAQPage
+    efbLdRegex.lastIndex = 0;
+    let ldMatch;
+    while ((ldMatch = efbLdRegex.exec(html)) !== null) {
+      try {
+        const parsed = JSON.parse(ldMatch[1].trim());
+        const pType = Array.isArray(parsed['@type']) ? parsed['@type'] : [parsed['@type']];
+        if (pType.includes('FAQPage') && Array.isArray(parsed.mainEntity)) {
+          const questions = parsed.mainEntity
+            .filter(q => q['@type'] === 'Question' && q.name)
+            .map(q => ({ question: q.name, answer: (q.acceptedAnswer?.text || '').slice(0, 200) }));
+          if (questions.length > 0) {
+            faqBlocks.push({ source: 'json-ld', plugin: null, questions_count: questions.length, questions });
+            efbBySource['json-ld'] += questions.length;
+            efbTotalQ += questions.length;
+          }
+        }
+      } catch { /* invalid JSON */ }
+    }
+
+    // Type B: Gutenberg FAQ blocks
+    const processGutenberg = (regex, plugin) => {
+      regex.lastIndex = 0;
+      let gMatch;
+      while ((gMatch = regex.exec(html)) !== null) {
+        const blockHtml = gMatch[1];
+        const questions = [];
+        const qRegex = /<(?:strong|h3)[^>]*class=["'][^"']*faq-question[^"']*["'][^>]*>([\s\S]*?)<\/(?:strong|h3)>/gi;
+        const aRegex = /<(?:p|div)[^>]*class=["'][^"']*faq-answer[^"']*["'][^>]*>([\s\S]*?)<\/(?:p|div)>/gi;
+        const qs = [];
+        const as = [];
+        let qm;
+        while ((qm = qRegex.exec(blockHtml)) !== null) qs.push(strip(qm[1]));
+        let am;
+        while ((am = aRegex.exec(blockHtml)) !== null) as.push(strip(am[1]).slice(0, 200));
+        for (let i = 0; i < qs.length; i++) {
+          questions.push({ question: qs[i], answer: as[i] || '' });
+        }
+        if (questions.length > 0) {
+          faqBlocks.push({ source: 'gutenberg-block', plugin, questions_count: questions.length, questions });
+          efbBySource['gutenberg-block'] += questions.length;
+          efbTotalQ += questions.length;
+        }
+      }
+    };
+    processGutenberg(efbYoastRegex, 'yoast');
+    processGutenberg(efbRankMathRegex, 'rankmath');
+
+    // Type C: HTML pattern FAQ
+    efbFaqHeadingRegex.lastIndex = 0;
+    if (efbFaqHeadingRegex.test(html)) {
+      const questions = [];
+      const h3pRegex = /<h3[^>]*>([\s\S]*?)<\/h3>\s*<p[^>]*>([\s\S]*?)<\/p>/gi;
+      const dtddRegex = /<dt[^>]*>([\s\S]*?)<\/dt>\s*<dd[^>]*>([\s\S]*?)<\/dd>/gi;
+      let hm;
+      while ((hm = h3pRegex.exec(html)) !== null) {
+        const q = strip(hm[1]);
+        if (q) questions.push({ question: q, answer: strip(hm[2]).slice(0, 200) });
+      }
+      if (questions.length === 0) {
+        while ((hm = dtddRegex.exec(html)) !== null) {
+          const q = strip(hm[1]);
+          if (q) questions.push({ question: q, answer: strip(hm[2]).slice(0, 200) });
+        }
+      }
+      if (questions.length > 0) {
+        faqBlocks.push({ source: 'html-pattern', plugin: null, questions_count: questions.length, questions });
+        efbBySource['html-pattern'] += questions.length;
+        efbTotalQ += questions.length;
+      }
+    }
+
+    const hasFaq = faqBlocks.length > 0;
+    if (hasFaq) efbPostsWithFaq++;
+
+    efbResults.push({
+      id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, link: p.link,
+      has_faq: hasFaq, faq_blocks: faqBlocks
+    });
+  }
+
+  let efbFiltered = efbPosts.length <= 10
+    ? efbResults
+    : efbResults.filter(r => r.has_faq);
+
+  efbFiltered.sort((a, b) => {
+    const qA = a.faq_blocks.reduce((s, f) => s + f.questions_count, 0);
+    const qB = b.faq_blocks.reduce((s, f) => s + f.questions_count, 0);
+    return qB - qA;
+  });
+
+  result = json({
+    total_analyzed: efbPosts.length,
+    posts_with_faq: efbPostsWithFaq,
+    total_questions: efbTotalQ,
+    faq_by_source: efbBySource,
+    posts: efbFiltered
+  });
+  auditLog({ tool: name, action: 'extract_faq_blocks', status: 'success', latency_ms: Date.now() - t0, params: { limit: efbLimit, post_type: efbPostType } });
+  return result;
+};
+handlers['wp_audit_cta_presence'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 200 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] },
+    category_id: { type: 'number' }
+  });
+  const { limit: acpLimit = 50, post_type: acpPostType = 'post', category_id: acpCatId } = args;
+  const acpPerPage = Math.min(acpLimit, 200);
+  const acpFields = '_fields=id,title,slug,link,content,categories';
+
+  let acpPosts = [];
+  if (acpPostType === 'both') {
+    let postsUrl = `/posts?per_page=${acpPerPage}&status=publish&${acpFields}`;
+    if (acpCatId) postsUrl += `&categories=${acpCatId}`;
+    const [posts, pages] = await Promise.all([
+      wpApiCall(postsUrl),
+      wpApiCall(`/pages?per_page=${acpPerPage}&status=publish&${acpFields}`)
+    ]);
+    acpPosts = [...posts, ...pages];
+  } else {
+    const ep = acpPostType === 'page' ? '/pages' : '/posts';
+    let postsUrl = `${ep}?per_page=${acpPerPage}&status=publish&${acpFields}`;
+    if (acpCatId && acpPostType !== 'page') postsUrl += `&categories=${acpCatId}`;
+    acpPosts = await wpApiCall(postsUrl);
+  }
+
+  const CTA_CONTACT_HREFS = ['/contact', '/nous-contacter', '/contactez-nous', 'mailto:'];
+  const CTA_CONTACT_ANCHORS = ['contactez', 'contact', 'nous contacter'];
+  const CTA_FORM_PATTERNS = ['wpforms', 'cf7', 'gravity', 'elementor-form', 'formulaire', 'form'];
+  const CTA_BUTTON_TEXTS = ['devis', 'essai', 'commencer', 'inscription', "s'inscrire", 'acheter', 'commander', 'réserver', 'télécharger', 'download', 'get started', 'sign up', 'buy', 'order', 'book', 'subscribe'];
+  const CTA_QUOTE_TEXTS = ['devis', 'demande de devis', 'quote', 'request a quote', 'estimation'];
+  const CTA_SIGNUP_HREFS = ['/inscription', '/register', '/signup', '/trial', '/essai'];
+
+  let acpWithCta = 0;
+  let acpWithoutCta = 0;
+  const ctaTypeDist = { contact_link: 0, form: 0, button_cta: 0, phone_link: 0, quote_request: 0, signup_link: 0 };
+
+  const acpResults = [];
+  for (const p of acpPosts) {
+    const html = p.content?.rendered || '';
+    const lower = html.toLowerCase();
+    const ctas = [];
+    const ctaTypesFound = new Set();
+
+    // Scan all links
+    const linkRegex = /<a\b[^>]*href=["']([^"']*)["'][^>]*>([\s\S]*?)<\/a>/gi;
+    let lm;
+    while ((lm = linkRegex.exec(html)) !== null) {
+      const href = lm[1].toLowerCase();
+      const anchor = strip(lm[2]).toLowerCase();
+
+      if (CTA_CONTACT_HREFS.some(pat => href.includes(pat)) || CTA_CONTACT_ANCHORS.some(txt => anchor.includes(txt))) {
+        ctas.push({ type: 'contact_link', text: strip(lm[2]), href: lm[1] });
+        ctaTypesFound.add('contact_link');
+      }
+      if (href.startsWith('tel:')) {
+        ctas.push({ type: 'phone_link', text: strip(lm[2]), href: lm[1] });
+        ctaTypesFound.add('phone_link');
+      }
+      if (CTA_SIGNUP_HREFS.some(pat => href.includes(pat))) {
+        ctas.push({ type: 'signup_link', text: strip(lm[2]), href: lm[1] });
+        ctaTypesFound.add('signup_link');
+      }
+      if (CTA_QUOTE_TEXTS.some(txt => anchor.includes(txt))) {
+        ctas.push({ type: 'quote_request', text: strip(lm[2]), href: lm[1] });
+        ctaTypesFound.add('quote_request');
+      }
+    }
+
+    // Forms
+    if (/<form\b/i.test(html) || CTA_FORM_PATTERNS.some(pat => lower.includes(pat))) {
+      const formElement = CTA_FORM_PATTERNS.find(pat => lower.includes(pat)) || 'form';
+      ctas.push({ type: 'form', element: formElement });
+      ctaTypesFound.add('form');
+    }
+
+    // Button CTAs (by class)
+    const btnClassRegex = /<(?:button|a)\b[^>]*class=["'][^"']*(?:cta|btn-cta|call-to-action|bouton-action)[^"']*["'][^>]*>([\s\S]*?)<\/(?:button|a)>/gi;
+    let bm;
+    while ((bm = btnClassRegex.exec(html)) !== null) {
+      ctas.push({ type: 'button_cta', text: strip(bm[1]) });
+      ctaTypesFound.add('button_cta');
+    }
+    // Button CTAs (by text)
+    if (!ctaTypesFound.has('button_cta')) {
+      const btnTextRegex = /<button\b[^>]*>([\s\S]*?)<\/button>/gi;
+      let btm;
+      while ((btm = btnTextRegex.exec(html)) !== null) {
+        const btnText = strip(btm[1]).toLowerCase();
+        if (CTA_BUTTON_TEXTS.some(txt => btnText.includes(txt))) {
+          ctas.push({ type: 'button_cta', text: strip(btm[1]) });
+          ctaTypesFound.add('button_cta');
+          break;
+        }
+      }
+    }
+
+    const uniqueTypes = ctaTypesFound.size;
+    let ctaScore = 0;
+    if (uniqueTypes >= 3) ctaScore = 100;
+    else if (uniqueTypes === 2) ctaScore = 70;
+    else if (uniqueTypes === 1) ctaScore = 40;
+
+    const issues = [];
+    if (uniqueTypes === 0) { issues.push('no_cta'); acpWithoutCta++; }
+    else { acpWithCta++; }
+    if (uniqueTypes === 1) issues.push('single_cta_type');
+
+    for (const ct of ctaTypesFound) ctaTypeDist[ct]++;
+
+    acpResults.push({
+      id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, link: p.link,
+      cta_score: ctaScore, cta_count: ctas.length, cta_types: [...ctaTypesFound],
+      ctas, issues
+    });
+  }
+
+  acpResults.sort((a, b) => a.cta_score - b.cta_score);
+
+  const acpTotal = acpPosts.length;
+  result = json({
+    total_analyzed: acpTotal,
+    posts_with_cta: acpWithCta,
+    posts_without_cta: acpWithoutCta,
+    cta_coverage: acpTotal > 0 ? Math.round(acpWithCta / acpTotal * 100) : 0,
+    cta_type_distribution: ctaTypeDist,
+    posts: acpResults
+  });
+  auditLog({ tool: name, action: 'audit_cta_presence', status: 'success', latency_ms: Date.now() - t0, params: { limit: acpLimit, post_type: acpPostType, category_id: acpCatId } });
+  return result;
+};
+handlers['wp_extract_entities'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, extractEntities } = rt;
+  validateInput(args, { limit: { type: 'number', min: 1, max: 100 }, post_type: { type: 'string', enum: ['post', 'page'] }, min_occurrences: { type: 'number', min: 1 } });
+  const eeLimit = args.limit || 20;
+  const eePostType = args.post_type || 'post';
+  const eeMinOcc = args.min_occurrences || 2;
+
+  const eePosts = await wpApiCall(`/${eePostType}s?per_page=${eeLimit}&status=publish&_fields=id,title,content,slug`);
+
+  const globalEntities = new Map(); // name -> { type, count, post_ids, contexts }
+  const postResults = [];
+
+  for (const p of eePosts) {
+    const text = strip(p.content?.rendered || '');
+    const entities = extractEntities(text);
+    const localEntities = [];
+
+    for (const ent of entities) {
+      localEntities.push({ name: ent.name, type: ent.type, count: ent.count });
+      if (!globalEntities.has(ent.name)) {
+        globalEntities.set(ent.name, { type: ent.type, count: 0, post_ids: new Set(), contexts: [] });
+      }
+      const g = globalEntities.get(ent.name);
+      g.count += ent.count;
+      g.post_ids.add(p.id);
+      for (const ctx of ent.contexts) {
+        if (g.contexts.length < 2) g.contexts.push(ctx);
+      }
+    }
+
+    postResults.push({
+      id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug,
+      entities_count: localEntities.length,
+      entities: localEntities
+    });
+  }
+
+  // Filter by min_occurrences and build aggregated results
+  const filteredEntities = [...globalEntities.entries()]
+    .filter(([, v]) => v.count >= eeMinOcc)
+    .sort((a, b) => b[1].count - a[1].count);
+
+  const byType = { brand: 0, location: 0, person: 0, organization: 0, unknown: 0 };
+  for (const [, v] of filteredEntities) {
+    if (byType[v.type] !== undefined) byType[v.type]++;
+  }
+
+  result = json({
+    total_analyzed: eePosts.length,
+    total_entities_found: filteredEntities.length,
+    entities_by_type: byType,
+    top_entities: filteredEntities.slice(0, 20).map(([name, v]) => ({
+      name, type: v.type, total_count: v.count, post_ids: [...v.post_ids], contexts: v.contexts
+    })),
+    posts: postResults
+  });
+  auditLog({ tool: name, action: 'extract_entities', status: 'success', latency_ms: Date.now() - t0, params: { limit: eeLimit, post_type: eePostType, min_occurrences: eeMinOcc } });
+  return result;
+};
+handlers['wp_get_publishing_velocity'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, { periods: { type: 'string' }, post_type: { type: 'string', enum: ['post', 'page'] }, limit: { type: 'number', min: 1, max: 500 } });
+  const pvPeriodsStr = args.periods || '30,90,180';
+  const pvPostType = args.post_type || 'post';
+  const pvLimit = args.limit || 200;
+
+  const periodDays = pvPeriodsStr.split(',').map(s => parseInt(s.trim(), 10)).filter(n => n > 0);
+  if (periodDays.length === 0) throw new Error('Invalid periods: must be comma-separated positive integers');
+
+  const pvPosts = await wpApiCall(`/${pvPostType}s?per_page=${pvLimit}&status=publish&orderby=date&order=desc&_fields=id,title,date,author,categories`);
+  const pvAuthors = await wpApiCall('/users?per_page=100&_fields=id,name');
+  const pvCategories = await wpApiCall('/categories?per_page=100&_fields=id,name');
+
+  const authorMap = new Map(pvAuthors.map(a => [a.id, a.name]));
+  const catMap = new Map(pvCategories.map(c => [c.id, c.name]));
+  const now = Date.now();
+
+  const periodsResult = periodDays.map(p => {
+    const cutoff = now - p * 86400000;
+    const inPeriod = pvPosts.filter(post => new Date(post.date).getTime() >= cutoff);
+    const velocity = Math.round(inPeriod.length / (p / 30) * 10) / 10;
+
+    // By author
+    const authorCounts = new Map();
+    for (const post of inPeriod) {
+      authorCounts.set(post.author, (authorCounts.get(post.author) || 0) + 1);
+    }
+    const byAuthor = [...authorCounts.entries()]
+      .map(([id, count]) => ({ id, name: authorMap.get(id) || `Author ${id}`, posts_count: count, velocity_per_month: Math.round(count / (p / 30) * 10) / 10 }))
+      .sort((a, b) => b.velocity_per_month - a.velocity_per_month);
+
+    // By category
+    const catCounts = new Map();
+    for (const post of inPeriod) {
+      for (const catId of (post.categories || [])) {
+        catCounts.set(catId, (catCounts.get(catId) || 0) + 1);
+      }
+    }
+    const byCategory = [...catCounts.entries()]
+      .map(([id, count]) => ({ id, name: catMap.get(id) || `Category ${id}`, posts_count: count, velocity_per_month: Math.round(count / (p / 30) * 10) / 10 }))
+      .sort((a, b) => b.velocity_per_month - a.velocity_per_month);
+
+    return { days: p, posts_count: inPeriod.length, velocity_per_month: velocity, by_author: byAuthor, by_category: byCategory };
+  });
+
+  // Trend calculation
+  const sortedPeriods = [...periodsResult].sort((a, b) => a.days - b.days);
+  const shortV = sortedPeriods[0].velocity_per_month;
+  const longV = sortedPeriods[sortedPeriods.length - 1].velocity_per_month;
+  const changePct = longV > 0 ? Math.round(((shortV - longV) / longV) * 100) : 0;
+  let direction = 'stable';
+  if (changePct > 20) direction = 'accelerating';
+  else if (changePct < -20) direction = 'decelerating';
+
+  // Top authors/categories from shortest period
+  const shortPeriod = sortedPeriods[0];
+
+  result = json({
+    total_posts_fetched: pvPosts.length,
+    post_type: pvPostType,
+    periods: periodsResult,
+    trend: { direction, short_period_velocity: shortV, long_period_velocity: longV, change_percent: changePct },
+    top_authors: shortPeriod.by_author.slice(0, 10),
+    top_categories: shortPeriod.by_category.slice(0, 10)
+  });
+  auditLog({ tool: name, action: 'publishing_velocity', status: 'success', latency_ms: Date.now() - t0, params: { periods: periodDays, post_type: pvPostType, limit: pvLimit } });
+  return result;
+};
+handlers['wp_compare_revisions_diff'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, extractHeadingsOutline, computeTextDiff, countWords } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true }, revision_id_from: { type: 'number', required: true }, revision_id_to: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] } });
+  const crdPostId = args.post_id;
+  const crdRevFrom = args.revision_id_from;
+  const crdRevTo = args.revision_id_to;
+  const crdPostType = args.post_type || 'post';
+
+  const revFrom = await wpApiCall(`/${crdPostType}s/${crdPostId}/revisions/${crdRevFrom}?_fields=id,date,content,title`);
+  let revTo;
+  let revToId;
+  if (crdRevTo) {
+    revTo = await wpApiCall(`/${crdPostType}s/${crdPostId}/revisions/${crdRevTo}?_fields=id,date,content,title`);
+    revToId = crdRevTo;
+  } else {
+    revTo = await wpApiCall(`/${crdPostType}s/${crdPostId}?_fields=id,content,title,modified`);
+    revToId = 'current';
+  }
+
+  const textFrom = strip(revFrom.content?.rendered || revFrom.content || '');
+  const textTo = strip(revTo.content?.rendered || revTo.content || '');
+  const diff = computeTextDiff(textFrom, textTo);
+
+  const wcFrom = countWords(revFrom.content?.rendered || revFrom.content || '');
+  const wcTo = countWords(revTo.content?.rendered || revTo.content || '');
+
+  const headingsFrom = extractHeadingsOutline(revFrom.content?.rendered || revFrom.content || '');
+  const headingsTo = extractHeadingsOutline(revTo.content?.rendered || revTo.content || '');
+  const headingsFromSet = new Set(headingsFrom.map(h => `${h.level}:${h.text}`));
+  const headingsToSet = new Set(headingsTo.map(h => `${h.level}:${h.text}`));
+  const headingsAdded = headingsTo.filter(h => !headingsFromSet.has(`${h.level}:${h.text}`));
+  const headingsRemoved = headingsFrom.filter(h => !headingsToSet.has(`${h.level}:${h.text}`));
+
+  const amplitude = diff.change_ratio >= 0.5 ? 'major' : diff.change_ratio >= 0.2 ? 'moderate' : 'minor';
+
+  result = json({
+    post_id: crdPostId,
+    from: {
+      revision_id: crdRevFrom,
+      date: revFrom.date,
+      title: strip(revFrom.title?.rendered || revFrom.title || ''),
+      word_count: wcFrom
+    },
+    to: {
+      revision_id: revToId,
+      date: revTo.date || revTo.modified,
+      title: strip(revTo.title?.rendered || revTo.title || ''),
+      word_count: wcTo
+    },
+    diff: {
+      lines_added: diff.lines_added,
+      lines_removed: diff.lines_removed,
+      lines_unchanged: diff.lines_unchanged,
+      words_added: diff.words_added,
+      words_removed: diff.words_removed,
+      word_count_change: wcTo - wcFrom,
+      change_ratio: Math.round(diff.change_ratio * 1000) / 1000,
+      amplitude
+    },
+    headings_diff: { added: headingsAdded, removed: headingsRemoved },
+    sample_changes: {
+      added: diff.added_lines.slice(0, 10),
+      removed: diff.removed_lines.slice(0, 10)
+    }
+  });
+  auditLog({ tool: name, action: 'compare_revisions_diff', status: 'success', latency_ms: Date.now() - t0, params: { post_id: crdPostId, revision_id_from: crdRevFrom, revision_id_to: crdRevTo } });
+  return result;
+};
+handlers['wp_list_posts_by_word_count'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, countWords } = rt;
+  validateInput(args, { limit: { type: 'number', min: 1, max: 500 }, post_type: { type: 'string', enum: ['post', 'page', 'both'] }, order: { type: 'string', enum: ['asc', 'desc'] }, category_id: { type: 'number' } });
+  const wclLimit = args.limit || 100;
+  const wclPostType = args.post_type || 'post';
+  const wclOrder = args.order || 'desc';
+  const wclCatId = args.category_id;
+
+  let wclPosts;
+  if (wclPostType === 'both') {
+    const catParam = wclCatId ? `&categories=${wclCatId}` : '';
+    const [postsArr, pagesArr] = await Promise.all([
+      wpApiCall(`/posts?per_page=${wclLimit}&status=publish&_fields=id,title,slug,link,content,date,modified,categories${catParam}`),
+      wpApiCall(`/pages?per_page=${wclLimit}&status=publish&_fields=id,title,slug,link,content,date,modified,categories`)
+    ]);
+    wclPosts = [...postsArr, ...pagesArr];
+  } else {
+    const catParam = wclCatId ? `&categories=${wclCatId}` : '';
+    wclPosts = await wpApiCall(`/${wclPostType}s?per_page=${wclLimit}&status=publish&_fields=id,title,slug,link,content,date,modified,categories${catParam}`);
+  }
+
+  const postsWithWc = wclPosts.map(p => {
+    const wc = countWords(p.content?.rendered || '');
+    let segment;
+    if (wc < 300) segment = 'very_short';
+    else if (wc < 600) segment = 'short';
+    else if (wc < 1000) segment = 'medium';
+    else if (wc < 2000) segment = 'standard';
+    else if (wc < 3000) segment = 'long';
+    else segment = 'very_long';
+
+    return {
+      id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, link: p.link,
+      word_count: wc, segment,
+      date: p.date, modified: p.modified,
+      categories: p.categories || []
+    };
+  });
+
+  postsWithWc.sort((a, b) => wclOrder === 'asc' ? a.word_count - b.word_count : b.word_count - a.word_count);
+
+  const counts = postsWithWc.map(p => p.word_count);
+  const total = counts.length || 1;
+  const avg = counts.reduce((s, c) => s + c, 0) / total;
+  const sorted = [...counts].sort((a, b) => a - b);
+  const median = sorted.length % 2 === 0 ? (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2 : sorted[Math.floor(sorted.length / 2)];
+
+  const dist = { very_short: 0, short: 0, medium: 0, standard: 0, long: 0, very_long: 0 };
+  for (const p of postsWithWc) dist[p.segment]++;
+  const distribution = {};
+  for (const [seg, count] of Object.entries(dist)) {
+    distribution[seg] = { count, percent: Math.round(count / total * 100) };
+  }
+
+  result = json({
+    total_analyzed: postsWithWc.length,
+    avg_word_count: Math.round(avg),
+    median_word_count: median,
+    min_word_count: sorted[0] || 0,
+    max_word_count: sorted[sorted.length - 1] || 0,
+    distribution,
+    posts: postsWithWc
+  });
+  auditLog({ tool: name, action: 'list_by_word_count', status: 'success', latency_ms: Date.now() - t0, params: { limit: wclLimit, post_type: wclPostType, order: wclOrder, category_id: wclCatId } });
+  return result;
+};
+handlers['wp_get_rendered_head'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, fetch, auditLog, name, detectSeoPlugin, getRenderedHead, parseRenderedHead } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true }, post_type: { type: 'string', enum: ['post', 'page'] } });
+  const grhPostId = args.post_id;
+  const grhPostType = args.post_type || 'post';
+  const { url: grhBaseUrl, auth: grhAuth } = getActiveAuth();
+
+  const grhPlugin = await detectSeoPlugin(grhBaseUrl, fetch);
+  if (!grhPlugin) throw new Error('No supported SEO plugin detected. wp_get_rendered_head requires RankMath or Yoast.');
+  if (grhPlugin !== 'rankmath' && grhPlugin !== 'yoast') throw new Error(`Rendered head requires RankMath or Yoast (detected: ${grhPlugin})`);
+
+  const grhEp = grhPostType === 'page' ? `/pages/${grhPostId}?_fields=id,title,link,slug,meta` : `/posts/${grhPostId}?_fields=id,title,link,slug,meta`;
+  const grhPost = await wpApiCall(grhEp);
+
+  const grhHeadResult = await getRenderedHead(grhBaseUrl, grhPost.link, grhPlugin, fetch, grhAuth);
+  if (!grhHeadResult.success) throw new Error(grhHeadResult.error);
+
+  const grhParsed = parseRenderedHead(grhHeadResult.head);
+  const grhMeta = grhPost.meta || {};
+
+  // Extract stored SEO meta based on plugin
+  let grhStoredTitle, grhStoredDesc, grhStoredKeyword, grhStoredCanonical, grhStoredRobots;
+  if (grhPlugin === 'rankmath') {
+    grhStoredTitle = grhMeta.rank_math_title || null;
+    grhStoredDesc = grhMeta.rank_math_description || null;
+    grhStoredKeyword = grhMeta.rank_math_focus_keyword || null;
+    grhStoredCanonical = grhMeta.rank_math_canonical_url || null;
+    const rm = grhMeta.rank_math_robots || [];
+    grhStoredRobots = Array.isArray(rm) && rm.length > 0 ? rm.join(', ') : null;
+  } else {
+    grhStoredTitle = grhMeta._yoast_wpseo_title || null;
+    grhStoredDesc = grhMeta._yoast_wpseo_metadesc || null;
+    grhStoredKeyword = grhMeta._yoast_wpseo_focuskw || null;
+    grhStoredCanonical = grhMeta._yoast_wpseo_canonical || null;
+    grhStoredRobots = grhMeta._yoast_wpseo_meta_robots_noindex === '1' ? 'noindex' : null;
+  }
+
+  result = json({
+    post_id: grhPostId,
+    post_url: grhPost.link,
+    seo_plugin: grhPlugin,
+    rendered: grhParsed,
+    stored: {
+      title: grhStoredTitle,
+      description: grhStoredDesc,
+      focus_keyword: grhStoredKeyword,
+      canonical: grhStoredCanonical,
+      robots: grhStoredRobots
+    },
+    raw_head_length: grhHeadResult.head.length,
+    schemas_count: grhParsed.schema_json_ld.length
+  });
+  auditLog({ tool: name, action: 'get_rendered_head', status: 'success', latency_ms: Date.now() - t0, params: { post_id: grhPostId, post_type: grhPostType, plugin: grhPlugin } });
+  return result;
+};
+handlers['wp_audit_rendered_seo'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, fetch, auditLog, name, detectSeoPlugin, getRenderedHead, parseRenderedHead } = rt;
+  validateInput(args, { limit: { type: 'number', min: 1, max: 50 }, post_type: { type: 'string', enum: ['post', 'page'] } });
+  const arsLimit = args.limit || 10;
+  const arsPostType = args.post_type || 'post';
+  const { url: arsBaseUrl, auth: arsAuth } = getActiveAuth();
+
+  const arsPlugin = await detectSeoPlugin(arsBaseUrl, fetch);
+  if (!arsPlugin) throw new Error('No supported SEO plugin detected. wp_audit_rendered_seo requires RankMath or Yoast.');
+  if (arsPlugin !== 'rankmath' && arsPlugin !== 'yoast') throw new Error(`Rendered SEO audit requires RankMath or Yoast (detected: ${arsPlugin})`);
+
+  const arsEp = `/${arsPostType}s?per_page=${arsLimit}&status=publish&_fields=id,title,link,slug,meta`;
+  const arsPosts = await wpApiCall(arsEp);
+
+  const arsResults = [];
+  const arsSummary = { title_mismatch: 0, description_mismatch: 0, canonical_mismatch: 0, missing_rendered_title: 0, missing_rendered_description: 0, robots_mismatch: 0, schema_missing: 0 };
+
+  for (const p of arsPosts) {
+    const headRes = await getRenderedHead(arsBaseUrl, p.link, arsPlugin, fetch, arsAuth);
+    if (!headRes.success) {
+      arsResults.push({ id: p.id, title: strip(p.title?.rendered || ''), url: p.link, score: 0, issues: ['head_fetch_failed'], rendered: null, stored: null });
+      continue;
+    }
+
+    const parsed = parseRenderedHead(headRes.head);
+    const meta = p.meta || {};
+    const issues = [];
+
+    // Extract stored meta
+    let storedTitle, storedDesc, storedCanonical, storedRobots;
+    if (arsPlugin === 'rankmath') {
+      storedTitle = meta.rank_math_title || null;
+      storedDesc = meta.rank_math_description || null;
+      storedCanonical = meta.rank_math_canonical_url || null;
+      const rm = meta.rank_math_robots || [];
+      storedRobots = Array.isArray(rm) && rm.length > 0 ? rm.join(', ') : null;
+    } else {
+      storedTitle = meta._yoast_wpseo_title || null;
+      storedDesc = meta._yoast_wpseo_metadesc || null;
+      storedCanonical = meta._yoast_wpseo_canonical || null;
+      storedRobots = meta._yoast_wpseo_meta_robots_noindex === '1' ? 'noindex' : null;
+    }
+
+    // Compare rendered vs stored
+    if (!parsed.title) { issues.push('missing_rendered_title'); arsSummary.missing_rendered_title++; }
+    else if (storedTitle && !parsed.title.includes(storedTitle)) { issues.push('title_mismatch'); arsSummary.title_mismatch++; }
+
+    if (!parsed.meta_description) { issues.push('missing_rendered_description'); arsSummary.missing_rendered_description++; }
+    else if (storedDesc && parsed.meta_description !== storedDesc) { issues.push('description_mismatch'); arsSummary.description_mismatch++; }
+
+    if (parsed.canonical && parsed.canonical !== p.link && storedCanonical && parsed.canonical !== storedCanonical) { issues.push('canonical_mismatch'); arsSummary.canonical_mismatch++; }
+
+    if (parsed.robots && parsed.robots.includes('noindex') && (!storedRobots || !storedRobots.includes('noindex'))) { issues.push('robots_mismatch'); arsSummary.robots_mismatch++; }
+
+    if (parsed.schema_json_ld.length === 0) { issues.push('schema_missing'); arsSummary.schema_missing++; }
+
+    const score = Math.max(0, 100 - issues.length * 15);
+
+    arsResults.push({
+      id: p.id, title: strip(p.title?.rendered || ''), url: p.link, score, issues,
+      rendered: { title: parsed.title, description: parsed.meta_description, canonical: parsed.canonical, robots: parsed.robots, schemas_count: parsed.schema_json_ld.length },
+      stored: { title: storedTitle, description: storedDesc, canonical: storedCanonical, robots: storedRobots }
+    });
+  }
+
+  const arsAvgScore = arsResults.length > 0 ? arsResults.reduce((s, r) => s + r.score, 0) / arsResults.length : 0;
+
+  result = json({
+    seo_plugin: arsPlugin,
+    total_audited: arsResults.length,
+    avg_score: Math.round(arsAvgScore),
+    issues_summary: arsSummary,
+    posts: arsResults
+  });
+  auditLog({ tool: name, action: 'audit_rendered_seo', status: 'success', latency_ms: Date.now() - t0, params: { limit: arsLimit, post_type: arsPostType, plugin: arsPlugin } });
+  return result;
+};
+handlers['wp_get_pillar_content'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, getActiveControls, fetch, auditLog, name, detectSeoPlugin } = rt;
+  validateInput(args, {
+    post_id: { type: 'number' },
+    set_pillar: { type: 'boolean' },
+    list_pillars: { type: 'boolean' },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    limit: { type: 'number', min: 1, max: 500 }
+  });
+  const pcPostType = args.post_type || 'post';
+  const { url: pcBaseUrl } = getActiveAuth();
+
+  const pcPlugin = await detectSeoPlugin(pcBaseUrl, fetch);
+  if (pcPlugin !== 'rankmath') throw new Error('Pillar content requires RankMath (detected: ' + (pcPlugin || 'none') + ')');
+
+  if (args.list_pillars) {
+    // Mode: list all pillar posts
+    const pcLimit = args.limit || 100;
+    const pcPosts = await wpApiCall(`/${pcPostType}s?per_page=${pcLimit}&status=publish&_fields=id,title,link,slug,meta`);
+    const pillars = pcPosts.filter(p => (p.meta || {}).rank_math_pillar_content === 'on').map(p => ({
+      id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, link: p.link, post_type: pcPostType
+    }));
+    result = json({ mode: 'list_pillars', seo_plugin: pcPlugin, pillar_count: pillars.length, pillars });
+    auditLog({ tool: name, action: 'read_pillar_content', status: 'success', latency_ms: Date.now() - t0, params: { list_pillars: true, post_type: pcPostType, limit: pcLimit } });
+  } else if (args.post_id !== undefined && args.set_pillar !== undefined) {
+    // Mode: write — set/unset pillar flag
+    if (getActiveControls().read_only) throw new Error('Blocked: READ-ONLY mode. Cannot update pillar content flag.');
+    const pcPost = await wpApiCall(`/${pcPostType}s/${args.post_id}?_fields=id,title,link,meta`);
+    await wpApiCall(`/${pcPostType}s/${args.post_id}`, { method: 'POST', body: JSON.stringify({ meta: { rank_math_pillar_content: args.set_pillar ? 'on' : '' } }) });
+    result = json({
+      mode: 'write', post_id: args.post_id, title: strip(pcPost.title?.rendered || ''),
+      is_pillar: args.set_pillar, action: args.set_pillar ? 'marked_as_pillar' : 'unmarked_as_pillar', seo_plugin: pcPlugin
+    });
+    auditLog({ tool: name, action: 'update_pillar_content', target: args.post_id, target_type: pcPostType, status: 'success', latency_ms: Date.now() - t0, params: { set_pillar: args.set_pillar } });
+  } else if (args.post_id !== undefined) {
+    // Mode: read single post
+    const pcPost = await wpApiCall(`/${pcPostType}s/${args.post_id}?_fields=id,title,link,meta`);
+    const isPillar = (pcPost.meta || {}).rank_math_pillar_content === 'on';
+    result = json({ mode: 'read', post_id: args.post_id, title: strip(pcPost.title?.rendered || ''), is_pillar: isPillar, seo_plugin: pcPlugin });
+    auditLog({ tool: name, action: 'read_pillar_content', status: 'success', latency_ms: Date.now() - t0, params: { post_id: args.post_id, post_type: pcPostType } });
+  } else {
+    throw new Error('Provide post_id (read/write) or list_pillars:true');
+  }
+  return result;
+};
+handlers['wp_audit_schema_plugins'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, fetch, auditLog, name, detectSeoPlugin, getRenderedHead, parseRenderedHead } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 100 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] }
+  });
+  const aspLimit = args.limit || 20;
+  const aspPostType = args.post_type || 'post';
+  const { url: aspBaseUrl, auth: aspAuth } = getActiveAuth();
+
+  const aspPlugin = await detectSeoPlugin(aspBaseUrl, fetch);
+  if (!aspPlugin) throw new Error('No supported SEO plugin detected');
+  if (aspPlugin !== 'rankmath' && aspPlugin !== 'yoast') throw new Error(`Schema plugin audit requires RankMath or Yoast (detected: ${aspPlugin})`);
+
+  const aspRequired = {
+    'Article': ['headline', 'datePublished', 'author'],
+    'BlogPosting': ['headline', 'datePublished', 'author'],
+    'NewsArticle': ['headline', 'datePublished', 'author'],
+    'FAQPage': ['mainEntity'],
+    'HowTo': ['name', 'step'],
+    'LocalBusiness': ['name', 'address'],
+    'BreadcrumbList': ['itemListElement'],
+    'Organization': ['name'],
+    'WebPage': ['name'],
+    'WebSite': ['name', 'url']
+  };
+
+  let aspAllPosts = [];
+  if (aspPostType === 'both') {
+    const aspP = await wpApiCall(`/posts?per_page=${aspLimit}&status=publish&_fields=id,title,link,slug,meta`);
+    const aspG = await wpApiCall(`/pages?per_page=${aspLimit}&status=publish&_fields=id,title,link,slug,meta`);
+    aspAllPosts = [...aspP, ...aspG];
+  } else {
+    aspAllPosts = await wpApiCall(`/${aspPostType}s?per_page=${aspLimit}&status=publish&_fields=id,title,link,slug,meta`);
+  }
+
+  const aspResults = [];
+  const aspTypesCounts = {};
+  const aspIssuesSummary = { no_plugin_schema: 0, invalid_schema_json: 0, missing_required_fields: 0, no_article_schema: 0 };
+  let aspWithSchema = 0;
+
+  for (const p of aspAllPosts) {
+    const postIssues = [];
+    const postSchemas = [];
+    let schemas = [];
+
+    if (aspPlugin === 'rankmath') {
+      const rawSchema = (p.meta || {}).rank_math_schema;
+      if (!rawSchema || rawSchema === '{}') {
+        postIssues.push('no_plugin_schema');
+        aspIssuesSummary.no_plugin_schema++;
+      } else {
+        try {
+          const parsed = typeof rawSchema === 'string' ? JSON.parse(rawSchema) : rawSchema;
+          if (parsed['@type']) {
+            schemas = [parsed];
+          } else if (parsed['@graph']) {
+            schemas = parsed['@graph'];
+          } else {
+            schemas = Object.values(parsed).filter(v => v && typeof v === 'object' && v['@type']);
+          }
+          if (schemas.length === 0) { postIssues.push('no_plugin_schema'); aspIssuesSummary.no_plugin_schema++; }
+        } catch {
+          postIssues.push('invalid_schema_json');
+          aspIssuesSummary.invalid_schema_json++;
+        }
+      }
+    } else {
+      const headRes = await getRenderedHead(aspBaseUrl, p.link, aspPlugin, fetch, aspAuth);
+      if (headRes.success) {
+        const parsed = parseRenderedHead(headRes.head);
+        schemas = parsed.schema_json_ld || [];
+        if (schemas.length === 0) { postIssues.push('no_plugin_schema'); aspIssuesSummary.no_plugin_schema++; }
+      } else {
+        postIssues.push('no_plugin_schema');
+        aspIssuesSummary.no_plugin_schema++;
+      }
+    }
+
+    let hasArticleType = false;
+    for (const schema of schemas) {
+      const schemaType = schema['@type'] || 'Unknown';
+      if (['Article', 'BlogPosting', 'NewsArticle'].includes(schemaType)) hasArticleType = true;
+      aspTypesCounts[schemaType] = (aspTypesCounts[schemaType] || 0) + 1;
+
+      const requiredFields = aspRequired[schemaType];
+      const missingFields = [];
+      if (requiredFields) {
+        for (const field of requiredFields) {
+          if (!schema[field]) missingFields.push(field);
+        }
+      }
+      if (missingFields.length > 0) { postIssues.push('missing_required_fields'); aspIssuesSummary.missing_required_fields++; }
+      postSchemas.push({ type: schemaType, valid: missingFields.length === 0, missing_fields: missingFields });
+    }
+
+    if (schemas.length > 0 && !hasArticleType && aspPostType === 'post') {
+      postIssues.push('no_article_schema');
+      aspIssuesSummary.no_article_schema++;
+    }
+
+    if (schemas.length > 0) aspWithSchema++;
+    const postScore = Math.max(0, 100 - postIssues.length * 15);
+    aspResults.push({ id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, score: postScore, schemas: postSchemas, issues: postIssues });
+  }
+
+  const aspAvg = aspResults.length > 0 ? aspResults.reduce((s, r) => s + r.score, 0) / aspResults.length : 0;
+  const aspWithout = aspAllPosts.length - aspWithSchema;
+
+  result = json({
+    seo_plugin: aspPlugin,
+    total_audited: aspResults.length,
+    avg_score: Math.round(aspAvg),
+    schema_coverage: {
+      posts_with_schema: aspWithSchema,
+      posts_without_schema: aspWithout,
+      coverage_percent: aspAllPosts.length > 0 ? Math.round(aspWithSchema / aspAllPosts.length * 100) : 0
+    },
+    schema_types_found: aspTypesCounts,
+    issues_summary: aspIssuesSummary,
+    posts: aspResults
+  });
+  auditLog({ tool: name, action: 'audit_schema_plugins', status: 'success', latency_ms: Date.now() - t0, params: { limit: aspLimit, post_type: aspPostType, plugin: aspPlugin } });
+  return result;
+};
+handlers['wp_get_seo_score'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, fetch, auditLog, name, detectSeoPlugin } = rt;
+  validateInput(args, {
+    post_id: { type: 'number' },
+    limit: { type: 'number', min: 1, max: 100 },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    order: { type: 'string', enum: ['asc', 'desc'] }
+  });
+  const gssPostType = args.post_type || 'post';
+  const { url: gssBaseUrl } = getActiveAuth();
+
+  const gssPlugin = await detectSeoPlugin(gssBaseUrl, fetch);
+  if (gssPlugin !== 'rankmath') throw new Error('SEO score requires RankMath (detected: ' + (gssPlugin || 'none') + ')');
+
+  if (args.post_id !== undefined) {
+    const gssPost = await wpApiCall(`/${gssPostType}s/${args.post_id}?_fields=id,title,link,slug,meta`);
+    const gssMeta = gssPost.meta || {};
+    const gssRaw = gssMeta.rank_math_seo_score;
+    const gssScore = gssRaw !== undefined && gssRaw !== null && gssRaw !== '' ? parseInt(gssRaw, 10) : null;
+    const gssKw = gssMeta.rank_math_focus_keyword || null;
+    const gssRating = gssScore === null || gssScore === 0 ? 'no_score' : gssScore >= 80 ? 'excellent' : gssScore >= 60 ? 'good' : gssScore >= 40 ? 'average' : 'poor';
+
+    result = json({
+      mode: 'single', post_id: args.post_id, title: strip(gssPost.title?.rendered || ''),
+      link: gssPost.link, seo_score: gssScore, focus_keyword: gssKw, rating: gssRating
+    });
+    auditLog({ tool: name, action: 'get_seo_score', status: 'success', latency_ms: Date.now() - t0, params: { post_id: args.post_id, post_type: gssPostType } });
+  } else {
+    const gssLimit = args.limit || 20;
+    const gssSortOrder = args.order || 'desc';
+    const gssPosts = await wpApiCall(`/${gssPostType}s?per_page=${gssLimit}&status=publish&_fields=id,title,link,slug,meta`);
+
+    const gssItems = gssPosts.map(p => {
+      const m = p.meta || {};
+      const raw = m.rank_math_seo_score;
+      const score = raw !== undefined && raw !== null && raw !== '' ? parseInt(raw, 10) : null;
+      const kw = m.rank_math_focus_keyword || null;
+      const rating = score === null || score === 0 ? 'no_score' : score >= 80 ? 'excellent' : score >= 60 ? 'good' : score >= 40 ? 'average' : 'poor';
+      return { id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, link: p.link, seo_score: score, focus_keyword: kw, rating };
+    });
+
+    gssItems.sort((a, b) => {
+      const sa = a.seo_score === null ? -1 : a.seo_score;
+      const sb = b.seo_score === null ? -1 : b.seo_score;
+      return gssSortOrder === 'asc' ? sa - sb : sb - sa;
+    });
+
+    const gssDist = { excellent: 0, good: 0, average: 0, poor: 0, no_score: 0 };
+    const gssScores = [];
+    for (const item of gssItems) {
+      gssDist[item.rating]++;
+      if (item.seo_score !== null && item.seo_score > 0) gssScores.push(item.seo_score);
+    }
+    const gssTotal = gssItems.length;
+    const gssAvg = gssScores.length > 0 ? gssScores.reduce((a, b) => a + b, 0) / gssScores.length : 0;
+    const gssSorted = [...gssScores].sort((a, b) => a - b);
+    const gssMedian = gssSorted.length > 0 ? (gssSorted.length % 2 === 0 ? (gssSorted[gssSorted.length / 2 - 1] + gssSorted[gssSorted.length / 2]) / 2 : gssSorted[Math.floor(gssSorted.length / 2)]) : 0;
+
+    result = json({
+      mode: 'bulk', total_analyzed: gssItems.length,
+      avg_score: Math.round(gssAvg), median_score: gssMedian,
+      distribution: {
+        excellent: { count: gssDist.excellent, percent: gssTotal > 0 ? Math.round(gssDist.excellent / gssTotal * 100) : 0 },
+        good: { count: gssDist.good, percent: gssTotal > 0 ? Math.round(gssDist.good / gssTotal * 100) : 0 },
+        average: { count: gssDist.average, percent: gssTotal > 0 ? Math.round(gssDist.average / gssTotal * 100) : 0 },
+        poor: { count: gssDist.poor, percent: gssTotal > 0 ? Math.round(gssDist.poor / gssTotal * 100) : 0 },
+        no_score: { count: gssDist.no_score, percent: gssTotal > 0 ? Math.round(gssDist.no_score / gssTotal * 100) : 0 }
+      },
+      posts: gssItems
+    });
+    auditLog({ tool: name, action: 'get_seo_score', status: 'success', latency_ms: Date.now() - t0, params: { limit: gssLimit, post_type: gssPostType, order: gssSortOrder } });
+  }
+  return result;
+};
+handlers['wp_get_twitter_meta'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, getActiveControls, fetch, auditLog, name, detectSeoPlugin } = rt;
+  validateInput(args, {
+    post_id: { type: 'number', required: true },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    twitter_title: { type: 'string' },
+    twitter_description: { type: 'string' },
+    twitter_image: { type: 'string' }
+  });
+  const gtmPostId = args.post_id;
+  const gtmPostType = args.post_type || 'post';
+  const { url: gtmBaseUrl } = getActiveAuth();
+  const gtmPlugin = await detectSeoPlugin(gtmBaseUrl, fetch);
+  if (!gtmPlugin) throw new Error('No supported SEO plugin detected');
+
+  const gtmIsWrite = args.twitter_title !== undefined || args.twitter_description !== undefined || args.twitter_image !== undefined;
+
+  if (gtmIsWrite) {
+    if (getActiveControls().read_only) throw new Error('Blocked: READ-ONLY mode. Cannot update Twitter meta.');
+    if (gtmPlugin !== 'rankmath' && gtmPlugin !== 'yoast') throw new Error('Twitter meta write requires RankMath or Yoast (detected: ' + gtmPlugin + ')');
+
+    const gtmMeta = {};
+    const gtmUpdated = [];
+    if (gtmPlugin === 'rankmath') {
+      if (args.twitter_title !== undefined) { gtmMeta.rank_math_twitter_title = args.twitter_title; gtmUpdated.push('twitter_title'); }
+      if (args.twitter_description !== undefined) { gtmMeta.rank_math_twitter_description = args.twitter_description; gtmUpdated.push('twitter_description'); }
+      if (args.twitter_image !== undefined) { gtmMeta.rank_math_twitter_image = args.twitter_image; gtmUpdated.push('twitter_image'); }
+    } else {
+      if (args.twitter_title !== undefined) { gtmMeta['_yoast_wpseo_twitter-title'] = args.twitter_title; gtmUpdated.push('twitter_title'); }
+      if (args.twitter_description !== undefined) { gtmMeta['_yoast_wpseo_twitter-description'] = args.twitter_description; gtmUpdated.push('twitter_description'); }
+      if (args.twitter_image !== undefined) { gtmMeta['_yoast_wpseo_twitter-image'] = args.twitter_image; gtmUpdated.push('twitter_image'); }
+    }
+
+    const gtmPost = await wpApiCall(`/${gtmPostType}s/${gtmPostId}?_fields=id,title,link,meta`);
+    await wpApiCall(`/${gtmPostType}s/${gtmPostId}`, { method: 'POST', body: JSON.stringify({ meta: gtmMeta }) });
+
+    result = json({
+      mode: 'write', post_id: gtmPostId, title: strip(gtmPost.title?.rendered || ''),
+      seo_plugin: gtmPlugin, updated_fields: gtmUpdated,
+      twitter: { title: args.twitter_title || null, description: args.twitter_description || null, image: args.twitter_image || null }
+    });
+    auditLog({ tool: name, action: 'update_twitter_meta', target: gtmPostId, target_type: gtmPostType, status: 'success', latency_ms: Date.now() - t0, params: { updated_fields: gtmUpdated } });
+  } else {
+    const gtmPost = await wpApiCall(`/${gtmPostType}s/${gtmPostId}?_fields=id,title,link,meta`);
+    const gtmM = gtmPost.meta || {};
+
+    let gtmTitle, gtmDesc, gtmImage, gtmCard;
+    if (gtmPlugin === 'rankmath') {
+      gtmTitle = gtmM.rank_math_twitter_title || null;
+      gtmDesc = gtmM.rank_math_twitter_description || null;
+      gtmImage = gtmM.rank_math_twitter_image || null;
+      gtmCard = gtmM.rank_math_twitter_card_type || null;
+    } else if (gtmPlugin === 'yoast') {
+      gtmTitle = gtmM['_yoast_wpseo_twitter-title'] || null;
+      gtmDesc = gtmM['_yoast_wpseo_twitter-description'] || null;
+      gtmImage = gtmM['_yoast_wpseo_twitter-image'] || null;
+      gtmCard = null;
+    } else {
+      gtmTitle = gtmM._seopress_social_twitter_title || null;
+      gtmDesc = gtmM._seopress_social_twitter_desc || null;
+      gtmImage = gtmM._seopress_social_twitter_img || null;
+      gtmCard = null;
+    }
+
+    result = json({
+      mode: 'read', post_id: gtmPostId, title: strip(gtmPost.title?.rendered || ''),
+      link: gtmPost.link, seo_plugin: gtmPlugin,
+      twitter: { title: gtmTitle, description: gtmDesc, image: gtmImage, card_type: gtmCard }
+    });
+    auditLog({ tool: name, action: 'read_twitter_meta', status: 'success', latency_ms: Date.now() - t0, params: { post_id: gtmPostId, post_type: gtmPostType, plugin: gtmPlugin } });
+  }
+  return result;
+};