@adsim/wordpress-mcp-server 4.5.1 → 5.1.0

package/src/tools/seo.js

@@ -0,0 +1,1633 @@
+// src/tools/seo.js — seo tools (19)
+// 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_seo_meta', _category: 'seo', description: 'Use to read SEO title, description, focus keyword, canonical, robots, OG for one post. Auto-detects Yoast/RankMath/SEOPress/AIOSEO. Read-only. Hint: prefer this over wp_get_post for SEO-only workflows.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number' }, post_type: { type: 'string', default: 'post', description: 'post or page' } }, required: ['id'] }},
+  { name: 'wp_update_seo_meta', _category: 'seo', description: 'Use to update SEO title, description, focus keyword, canonical, or robots. Auto-detects SEO plugin. Write — blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number' }, post_type: { type: 'string', default: 'post', description: 'post or page' }, title: { type: 'string', description: 'SEO title' }, description: { type: 'string', description: 'Meta description' }, focus_keyword: { type: 'string', description: 'Focus keyword' }, canonical_url: { type: 'string' }, robots_noindex: { type: 'boolean' }, robots_nofollow: { type: 'boolean' } }, required: ['id'] }},
+  { name: 'wp_audit_seo', _category: 'seo', description: 'Use for quick bulk SEO scoring (0-100) across posts or pages. Checks missing titles, descriptions, keywords, and length issues. Read-only. Hint: use wp_audit_rendered_seo for rendered-vs-stored comparison.',
+        inputSchema: { type: 'object', properties: { post_type: { type: 'string', default: 'post', description: 'post or page' }, per_page: { type: 'number', default: 20, description: 'Number of posts to audit (max 100)' }, status: { type: 'string', default: 'publish' }, orderby: { type: 'string', default: 'date' }, order: { type: 'string', default: 'desc' } }}},
+  { name: 'wp_audit_media_seo', _category: 'seo', description: 'Use when checking image SEO. Scans media library for missing/short alt text and bad filenames. Returns per-image scores + fix list. Read-only.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 50 }, page: { type: 'number', default: 1 }, post_id: { type: 'number', description: 'Also scan inline images from this post' } }}},
+  { name: 'wp_find_orphan_pages', _category: 'seo', description: 'Use to find posts with zero inbound internal links, sorted by word count. Read-only. Hint: combine with wp_suggest_internal_links to fix orphans.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 100 }, exclude_ids: { type: 'array', items: { type: 'number' }, description: 'Page IDs to exclude from orphan check' }, min_words: { type: 'number', default: 0, description: 'Minimum word count to include in results' } }}},
+  { name: 'wp_audit_heading_structure', _category: 'seo', description: 'Use to check H1-H6 hierarchy in a single post. Detects H1 in body, level skips, empty headings. Read-only.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number' }, post_type: { type: 'string', default: 'post', description: 'post or page' }, focus_keyword: { type: 'string', description: 'Keyword to check in H2 headings' } }, required: ['id'] }},
+  { name: 'wp_find_thin_content', _category: 'seo', description: 'Use to surface short/low-quality posts below a word count threshold. Classifies severity. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', default: 100 }, min_words: { type: 'number', default: 300, description: 'Threshold for "too short"' }, critical_words: { type: 'number', default: 150, description: 'Threshold for "very short"' }, max_age_days: { type: 'number', default: 730, description: 'Days since update to flag as outdated' }, include_uncategorized: { type: 'boolean', default: true, description: 'Flag uncategorized posts' }, post_type: { type: 'string', default: 'post', description: 'post or page' } }}},
+  { name: 'wp_audit_canonicals', _category: 'seo', description: 'Use to validate canonical URLs across posts/pages. Detects missing, mismatched, or staging URLs. Auto-detects SEO plugin. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', default: 50 }, post_type: { type: 'string', default: 'post', description: 'post, page, or both' }, check_staging_patterns: { type: 'boolean', default: true, description: 'Detect staging/dev URLs' } }}},
+  { name: 'wp_analyze_eeat_signals', _category: 'seo', description: 'Use to score E-E-A-T per post (0-100): author bio, dates, citations, word count, structured data. Read-only.',
+        inputSchema: { type: 'object', properties: { post_ids: { type: 'array', items: { type: 'number' }, description: 'Specific post IDs (if empty, audits latest N)' }, limit: { type: 'number', default: 10 }, post_type: { type: 'string', default: 'post', description: 'post or page' }, authoritative_domains: { type: 'array', items: { type: 'string' }, default: ['wikipedia.org', 'gov', 'edu', 'who.int', 'pubmed'], description: 'Domains considered authoritative' } }}},
+  { name: 'wp_find_broken_internal_links', _category: 'seo', description: 'Use to check internal links via HEAD requests. Returns broken (4xx), redirected (3xx), and slow links. Read-only.',
+        inputSchema: { type: 'object', properties: { limit_posts: { type: 'number', default: 20 }, batch_size: { type: 'number', default: 5, description: 'Links per batch (1-10)' }, timeout_ms: { type: 'number', default: 5000, description: 'Timeout per HEAD request (1000-30000)' }, delay_ms: { type: 'number', default: 200, description: 'Delay between batches (0-2000)' }, post_type: { type: 'string', default: 'post', description: 'post, page, or both' }, include_redirects: { type: 'boolean', default: true, description: 'Include 301/302 redirects in results' } }}},
+  { name: 'wp_find_keyword_cannibalization', _category: 'seo', description: 'Use to detect posts competing on the same focus keyword. Groups conflicts, flags weakest post. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', default: 200 }, post_type: { type: 'string', default: 'post', description: 'post, page, or both' }, similarity_mode: { type: 'string', default: 'normalized', description: 'exact or normalized keyword matching' }, min_group_size: { type: 'number', default: 2, description: 'Minimum articles per group (min 2)' } }}},
+  { name: 'wp_audit_taxonomies', _category: 'seo', description: 'Use to detect taxonomy bloat: empty/single-post terms, near-duplicates, missing descriptions. Read-only.',
+        inputSchema: { type: 'object', properties: { check_tags: { type: 'boolean', default: true }, check_categories: { type: 'boolean', default: true }, min_posts_threshold: { type: 'number', default: 2, description: 'Minimum posts per term' }, detect_duplicates: { type: 'boolean', default: true, description: 'Detect near-duplicate terms via Levenshtein' } }}},
+  { name: 'wp_audit_outbound_links', _category: 'seo', description: 'Use to analyze external link profile per post. Detects over-linking, missing nofollow, broken external URLs. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', default: 30 }, post_type: { type: 'string', default: 'post', description: 'post or page' }, min_outbound: { type: 'number', default: 1, description: 'Minimum outbound links threshold' }, max_outbound: { type: 'number', default: 15, description: 'Maximum outbound links before dilution warning' }, authoritative_domains: { type: 'array', items: { type: 'string' }, default: ['wikipedia.org', 'gov', 'edu', 'who.int', 'pubmed.ncbi'], description: 'Domains considered authoritative' } }}},
+  { name: 'wp_detect_multilingual_plugin', _category: 'seo', description: 'Use to detect active multilingual plugin: WPML, Polylang Pro, Polylang Free (hreflang fallback), TranslatePress, or none. Returns languages, default language, and API availability. Read-only.',
+        inputSchema: { type: 'object', properties: {} }},
+  { name: 'wp_list_languages', _category: 'seo', description: 'Use to list all configured site languages with code, name, native name, locale, URL prefix, and optional post counts. Supports WPML, Polylang (Pro+Free), TranslatePress. Read-only.',
+        inputSchema: { type: 'object', properties: { include_post_count: { type: 'boolean', description: 'default false (expensive)' } }}},
+  { name: 'wp_get_post_translations', _category: 'seo', description: 'Use to get all translations of a post. Returns translation post IDs, titles, URLs, statuses, and SEO meta presence per language. Supports WPML, Polylang (Pro+Free), TranslatePress. Read-only.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Source post ID' }, post_type: { type: 'string', description: 'Post type (default "post")' } }, required: ['post_id'] }},
+  { name: 'wp_audit_translation_coverage', _category: 'seo', description: 'Use to audit translation completeness across all languages and post types. Returns coverage percentages and top untranslated posts by word count. Read-only.',
+        inputSchema: { type: 'object', properties: { post_types: { type: 'array', items: { type: 'string' }, description: 'Post types to audit (default ["post","page"])' }, min_word_count: { type: 'number', description: 'default 0' } }}},
+  { name: 'wp_find_missing_seo_translations', _category: 'seo', description: 'Use to find translated posts missing SEO metadata (title, description, OG). Cross-references source SEO with translations. Read-only.',
+        inputSchema: { type: 'object', properties: { source_lang: { type: 'string', description: 'Source language code (default: site default)' }, post_types: { type: 'array', items: { type: 'string' }, description: 'Post types (default ["post","page"])' }, fields_to_check: { type: 'array', items: { type: 'string' }, description: 'SEO fields to check (default ["title","description","og_title","og_description"])' }, limit: { type: 'number', description: 'default 50' } }}},
+  { name: 'wp_sync_seo_meta_translations', _category: 'seo', description: 'Use to copy SEO metadata from a source post to its translations. Dry run by default for safety. Write — blocked by WP_READ_ONLY (except dry_run=true).',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Source post ID' }, source_lang: { type: 'string', description: 'Source language code' }, target_langs: { type: 'array', items: { type: 'string' }, description: 'Target language codes' }, fields: { type: 'array', items: { type: 'string', enum: ['title', 'description', 'og_title', 'og_description', 'og_image', 'twitter_title', 'twitter_description', 'all'] }, description: 'Fields to sync (default ["all"])' }, dry_run: { type: 'boolean', description: 'default true (preview only)' }, overwrite_existing: { type: 'boolean', description: 'default false' } }, required: ['post_id', 'source_lang', 'target_langs'] }}
+];
+
+export const handlers = {};
+
+handlers['wp_get_seo_meta'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+  const { id, post_type = 'post' } = args;
+  const ep = post_type === 'page' ? `/pages/${id}` : `/posts/${id}`;
+  const p = await wpApiCall(ep);
+  const meta = p.meta || {};
+  const yoastHead = p.yoast_head_json || null;
+
+  // Auto-detect SEO plugin and extract metadata
+  const seo = { plugin: 'none', title: null, description: null, focus_keyword: null, canonical: null, robots: { noindex: false, nofollow: false }, og_title: null, og_description: null, og_image: null, schema: null };
+
+  // Yoast SEO (most common)
+  if (meta._yoast_wpseo_title || meta._yoast_wpseo_metadesc || yoastHead) {
+    seo.plugin = 'yoast';
+    seo.title = meta._yoast_wpseo_title || yoastHead?.title || null;
+    seo.description = meta._yoast_wpseo_metadesc || yoastHead?.description || null;
+    seo.focus_keyword = meta._yoast_wpseo_focuskw || null;
+    seo.canonical = meta._yoast_wpseo_canonical || yoastHead?.canonical || null;
+    seo.robots.noindex = meta._yoast_wpseo_meta_robots_noindex === '1' || yoastHead?.robots?.index === 'noindex';
+    seo.robots.nofollow = meta._yoast_wpseo_meta_robots_nofollow === '1' || yoastHead?.robots?.follow === 'nofollow';
+    if (yoastHead?.og_title) seo.og_title = yoastHead.og_title;
+    if (yoastHead?.og_description) seo.og_description = yoastHead.og_description;
+    if (yoastHead?.og_image?.[0]?.url) seo.og_image = yoastHead.og_image[0].url;
+    if (yoastHead?.schema) seo.schema = yoastHead.schema;
+  }
+  // RankMath
+  else if (meta.rank_math_title || meta.rank_math_description) {
+    seo.plugin = 'rankmath';
+    seo.title = meta.rank_math_title || null;
+    seo.description = meta.rank_math_description || null;
+    seo.focus_keyword = meta.rank_math_focus_keyword || null;
+    seo.canonical = meta.rank_math_canonical_url || null;
+    const robots = meta.rank_math_robots || [];
+    seo.robots.noindex = Array.isArray(robots) ? robots.includes('noindex') : false;
+    seo.robots.nofollow = Array.isArray(robots) ? robots.includes('nofollow') : false;
+    seo.og_title = meta.rank_math_facebook_title || null;
+    seo.og_description = meta.rank_math_facebook_description || null;
+    seo.og_image = meta.rank_math_facebook_image || null;
+  }
+  // SEOPress
+  else if (meta._seopress_titles_title || meta._seopress_titles_desc) {
+    seo.plugin = 'seopress';
+    seo.title = meta._seopress_titles_title || null;
+    seo.description = meta._seopress_titles_desc || null;
+    seo.focus_keyword = meta._seopress_analysis_target_kw || null;
+    seo.canonical = meta._seopress_robots_canonical || null;
+    seo.robots.noindex = meta._seopress_robots_index === 'yes';
+    seo.robots.nofollow = meta._seopress_robots_follow === 'yes';
+    seo.og_title = meta._seopress_social_fb_title || null;
+    seo.og_description = meta._seopress_social_fb_desc || null;
+    seo.og_image = meta._seopress_social_fb_img || null;
+  }
+  // All in One SEO
+  else if (meta._aioseo_title || meta._aioseo_description) {
+    seo.plugin = 'aioseo';
+    seo.title = meta._aioseo_title || null;
+    seo.description = meta._aioseo_description || null;
+    seo.focus_keyword = meta._aioseo_keywords || null;
+    seo.canonical = meta._aioseo_canonical_url || null;
+    seo.robots.noindex = meta._aioseo_noindex === '1';
+    seo.robots.nofollow = meta._aioseo_nofollow === '1';
+    seo.og_title = meta._aioseo_og_title || null;
+    seo.og_description = meta._aioseo_og_description || null;
+    seo.og_image = meta._aioseo_og_image || null;
+  }
+
+  // Fallback: check raw meta keys for any SEO data
+  if (seo.plugin === 'none') {
+    const seoKeys = Object.keys(meta).filter(k => k.includes('seo') || k.includes('yoast') || k.includes('rank_math') || k.includes('aioseo') || k.includes('seopress'));
+    if (seoKeys.length > 0) {
+      seo.plugin = 'unknown';
+      seo.raw_keys = seoKeys;
+    }
+  }
+
+  result = json({
+    id: p.id, title: strip(p.title.rendered), slug: p.slug, link: p.link, status: p.status,
+    seo, all_meta_keys: Object.keys(meta)
+  });
+  auditLog({ tool: name, target: id, target_type: post_type, action: 'read_seo', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};
+handlers['wp_update_seo_meta'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+  const { id, post_type = 'post', title, description, focus_keyword, canonical_url, robots_noindex, robots_nofollow } = args;
+
+  // First, detect which SEO plugin is installed by reading current meta
+  const readEp = post_type === 'page' ? `/pages/${id}` : `/posts/${id}`;
+  const current = await wpApiCall(readEp);
+  const currentMeta = current.meta || {};
+  const yh = current.yoast_head_json || null;
+
+  let plugin = 'none';
+  if (currentMeta._yoast_wpseo_title !== undefined || currentMeta._yoast_wpseo_metadesc !== undefined || yh) plugin = 'yoast';
+  else if (currentMeta.rank_math_title !== undefined || currentMeta.rank_math_description !== undefined) plugin = 'rankmath';
+  else if (currentMeta._seopress_titles_title !== undefined) plugin = 'seopress';
+  else if (currentMeta._aioseo_title !== undefined) plugin = 'aioseo';
+
+  if (plugin === 'none') {
+    // Try to detect by checking if Yoast REST fields exist
+    if (yh) plugin = 'yoast';
+    else throw new Error('No SEO plugin detected. Install Yoast SEO, RankMath, SEOPress, or All in One SEO to manage SEO metadata.');
+  }
+
+  const metaUpdate = {};
+  const updated = [];
+
+  if (plugin === 'yoast') {
+    if (title !== undefined) { metaUpdate._yoast_wpseo_title = title; updated.push('title'); }
+    if (description !== undefined) { metaUpdate._yoast_wpseo_metadesc = description; updated.push('description'); }
+    if (focus_keyword !== undefined) { metaUpdate._yoast_wpseo_focuskw = focus_keyword; updated.push('focus_keyword'); }
+    if (canonical_url !== undefined) { metaUpdate._yoast_wpseo_canonical = canonical_url; updated.push('canonical'); }
+    if (robots_noindex !== undefined) { metaUpdate._yoast_wpseo_meta_robots_noindex = robots_noindex ? '1' : '0'; updated.push('noindex'); }
+    if (robots_nofollow !== undefined) { metaUpdate._yoast_wpseo_meta_robots_nofollow = robots_nofollow ? '1' : '0'; updated.push('nofollow'); }
+  } else if (plugin === 'rankmath') {
+    if (title !== undefined) { metaUpdate.rank_math_title = title; updated.push('title'); }
+    if (description !== undefined) { metaUpdate.rank_math_description = description; updated.push('description'); }
+    if (focus_keyword !== undefined) { metaUpdate.rank_math_focus_keyword = focus_keyword; updated.push('focus_keyword'); }
+    if (canonical_url !== undefined) { metaUpdate.rank_math_canonical_url = canonical_url; updated.push('canonical'); }
+  } else if (plugin === 'seopress') {
+    if (title !== undefined) { metaUpdate._seopress_titles_title = title; updated.push('title'); }
+    if (description !== undefined) { metaUpdate._seopress_titles_desc = description; updated.push('description'); }
+    if (focus_keyword !== undefined) { metaUpdate._seopress_analysis_target_kw = focus_keyword; updated.push('focus_keyword'); }
+    if (canonical_url !== undefined) { metaUpdate._seopress_robots_canonical = canonical_url; updated.push('canonical'); }
+    if (robots_noindex !== undefined) { metaUpdate._seopress_robots_index = robots_noindex ? 'yes' : ''; updated.push('noindex'); }
+    if (robots_nofollow !== undefined) { metaUpdate._seopress_robots_follow = robots_nofollow ? 'yes' : ''; updated.push('nofollow'); }
+  } else if (plugin === 'aioseo') {
+    if (title !== undefined) { metaUpdate._aioseo_title = title; updated.push('title'); }
+    if (description !== undefined) { metaUpdate._aioseo_description = description; updated.push('description'); }
+    if (focus_keyword !== undefined) { metaUpdate._aioseo_keywords = focus_keyword; updated.push('focus_keyword'); }
+    if (canonical_url !== undefined) { metaUpdate._aioseo_canonical_url = canonical_url; updated.push('canonical'); }
+    if (robots_noindex !== undefined) { metaUpdate._aioseo_noindex = robots_noindex ? '1' : '0'; updated.push('noindex'); }
+    if (robots_nofollow !== undefined) { metaUpdate._aioseo_nofollow = robots_nofollow ? '1' : '0'; updated.push('nofollow'); }
+  }
+
+  if (updated.length === 0) throw new Error('No SEO fields provided. Specify at least one of: title, description, focus_keyword, canonical_url, robots_noindex, robots_nofollow.');
+
+  const writeEp = post_type === 'page' ? `/pages/${id}` : `/posts/${id}`;
+  await wpApiCall(writeEp, { method: 'POST', body: JSON.stringify({ meta: metaUpdate }) });
+
+  result = json({ success: true, message: `SEO meta updated for ${post_type} ${id}`, plugin, fields_updated: updated, meta_written: metaUpdate });
+  auditLog({ tool: name, target: id, target_type: post_type, action: 'update_seo', status: 'success', latency_ms: Date.now() - t0, params: { plugin, fields: updated } });
+  return result;
+};
+handlers['wp_audit_seo'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  const { post_type = 'post', per_page = 20, status = 'publish', orderby = 'date', order = 'desc' } = args;
+  const ep_base = post_type === 'page' ? '/pages' : '/posts';
+  const posts = await wpApiCall(`${ep_base}?per_page=${Math.min(per_page, 100)}&status=${status}&orderby=${orderby}&order=${order}`);
+
+  let seoPlugin = 'none';
+  const audit = [];
+  let totalScore = 0;
+
+  for (const p of posts) {
+    const meta = p.meta || {};
+    const yh = p.yoast_head_json || null;
+    const postTitle = strip(p.title?.rendered || '');
+    const item = { id: p.id, title: postTitle, slug: p.slug, link: p.link, seo_title: null, seo_description: null, focus_keyword: null, issues: [], score: 100 };
+
+    // Detect plugin on first post
+    if (seoPlugin === 'none') {
+      if (meta._yoast_wpseo_title !== undefined || meta._yoast_wpseo_metadesc !== undefined || yh) seoPlugin = 'yoast';
+      else if (meta.rank_math_title !== undefined) seoPlugin = 'rankmath';
+      else if (meta._seopress_titles_title !== undefined) seoPlugin = 'seopress';
+      else if (meta._aioseo_title !== undefined) seoPlugin = 'aioseo';
+    }
+
+    // Extract SEO fields based on detected plugin
+    if (seoPlugin === 'yoast') {
+      item.seo_title = meta._yoast_wpseo_title || yh?.title || null;
+      item.seo_description = meta._yoast_wpseo_metadesc || yh?.description || null;
+      item.focus_keyword = meta._yoast_wpseo_focuskw || null;
+    } else if (seoPlugin === 'rankmath') {
+      item.seo_title = meta.rank_math_title || null;
+      item.seo_description = meta.rank_math_description || null;
+      item.focus_keyword = meta.rank_math_focus_keyword || null;
+    } else if (seoPlugin === 'seopress') {
+      item.seo_title = meta._seopress_titles_title || null;
+      item.seo_description = meta._seopress_titles_desc || null;
+      item.focus_keyword = meta._seopress_analysis_target_kw || null;
+    } else if (seoPlugin === 'aioseo') {
+      item.seo_title = meta._aioseo_title || null;
+      item.seo_description = meta._aioseo_description || null;
+      item.focus_keyword = meta._aioseo_keywords || null;
+    }
+
+    // Quality checks
+    if (!item.seo_title) { item.issues.push('missing_seo_title'); item.score -= 30; }
+    else if (item.seo_title.length < 30) { item.issues.push('seo_title_too_short'); item.score -= 10; }
+    else if (item.seo_title.length > 60) { item.issues.push('seo_title_too_long'); item.score -= 10; }
+
+    if (!item.seo_description) { item.issues.push('missing_meta_description'); item.score -= 30; }
+    else if (item.seo_description.length < 120) { item.issues.push('meta_description_too_short'); item.score -= 10; }
+    else if (item.seo_description.length > 160) { item.issues.push('meta_description_too_long'); item.score -= 10; }
+
+    if (!item.focus_keyword) { item.issues.push('missing_focus_keyword'); item.score -= 20; }
+
+    if (item.seo_title && item.focus_keyword && !item.seo_title.toLowerCase().includes(item.focus_keyword.toLowerCase())) {
+      item.issues.push('keyword_not_in_title'); item.score -= 10;
+    }
+
+    if (item.score < 0) item.score = 0;
+    totalScore += item.score;
+    audit.push(item);
+  }
+
+  const avgScore = audit.length > 0 ? Math.round(totalScore / audit.length) : 0;
+  const summary = {
+    total_audited: audit.length,
+    seo_plugin: seoPlugin,
+    average_score: avgScore,
+    issues_breakdown: {
+      missing_seo_title: audit.filter(a => a.issues.includes('missing_seo_title')).length,
+      missing_meta_description: audit.filter(a => a.issues.includes('missing_meta_description')).length,
+      missing_focus_keyword: audit.filter(a => a.issues.includes('missing_focus_keyword')).length,
+      title_length_issues: audit.filter(a => a.issues.includes('seo_title_too_short') || a.issues.includes('seo_title_too_long')).length,
+      description_length_issues: audit.filter(a => a.issues.includes('meta_description_too_short') || a.issues.includes('meta_description_too_long')).length,
+      keyword_not_in_title: audit.filter(a => a.issues.includes('keyword_not_in_title')).length
+    }
+  };
+
+  result = json({ summary, posts: audit });
+  auditLog({ tool: name, action: 'audit_seo', status: 'success', latency_ms: Date.now() - t0, params: { post_type, count: audit.length, avg_score: avgScore } });
+  return result;
+};
+handlers['wp_audit_media_seo'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, parseImagesFromHtml } = rt;
+  validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, page: { type: 'number', min: 1 }, post_id: { type: 'number', min: 1 } });
+  const { per_page = 50, page = 1, post_id } = args;
+  const mediaItems = await wpApiCall(`/media?per_page=${Math.min(per_page, 100)}&page=${page}&media_type=image`);
+
+  const audit = [];
+  let totalScore = 0;
+  for (const m of mediaItems) {
+    const item = { id: m.id, title: m.title?.rendered || '', source_url: m.source_url || '', alt_text: m.alt_text || '', issues: [], score: 100 };
+    if (!item.alt_text) {
+      item.issues.push('missing_alt'); item.score -= 40;
+    } else {
+      const filename = (m.source_url || '').split('/').pop()?.split('.')[0]?.replace(/[-_]/g, ' ') || '';
+      if (filename && item.alt_text.toLowerCase().replace(/[-_]/g, ' ') === filename.toLowerCase()) {
+        item.issues.push('filename_as_alt'); item.score -= 20;
+      }
+      if (item.alt_text.length < 5) { item.issues.push('alt_too_short'); item.score -= 15; }
+    }
+    if (item.score < 0) item.score = 0;
+    totalScore += item.score;
+    audit.push(item);
+  }
+
+  let inlineImages = [];
+  if (post_id) {
+    const p = await wpApiCall(`/posts/${post_id}`);
+    inlineImages = parseImagesFromHtml(p.content?.rendered || '');
+  }
+
+  const avgScore = audit.length > 0 ? Math.round(totalScore / audit.length) : 0;
+  result = json({
+    summary: {
+      total_audited: audit.length, average_score: avgScore,
+      issues_breakdown: {
+        missing_alt: audit.filter(a => a.issues.includes('missing_alt')).length,
+        filename_as_alt: audit.filter(a => a.issues.includes('filename_as_alt')).length,
+        alt_too_short: audit.filter(a => a.issues.includes('alt_too_short')).length,
+      }
+    },
+    media: audit,
+    inline_images: inlineImages
+  });
+  auditLog({ tool: name, action: 'audit_media_seo', status: 'success', latency_ms: Date.now() - t0, params: { count: audit.length, avg_score: avgScore } });
+  return result;
+};
+handlers['wp_find_orphan_pages'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, auditLog, name, extractInternalLinksHtml, countWords } = rt;
+  validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, min_words: { type: 'number', min: 0 } });
+  const { per_page = 100, exclude_ids = [], min_words = 0 } = args;
+  const allPages = await wpApiCall(`/pages?per_page=${Math.min(per_page, 100)}&status=publish`);
+  const { url: siteUrl } = getActiveAuth();
+
+  // Build set of linked page permalinks
+  const linkedPermalinks = new Set();
+  for (const pg of allPages) {
+    const content = pg.content?.rendered || '';
+    const links = extractInternalLinksHtml(content, siteUrl);
+    for (const link of links) {
+      // Normalise trailing slash for comparison
+      linkedPermalinks.add(link.replace(/\/+$/, ''));
+    }
+  }
+
+  // Find orphans: pages whose permalink is NOT in linkedPermalinks
+  const excludeSet = new Set(Array.isArray(exclude_ids) ? exclude_ids : []);
+  const orphans = allPages.filter(pg => {
+    if (excludeSet.has(pg.id)) return false;
+    const normLink = (pg.link || '').replace(/\/+$/, '');
+    if (linkedPermalinks.has(normLink)) return false;
+    const wc = countWords(pg.content?.rendered || '');
+    if (wc < min_words) return false;
+    return true;
+  });
+
+  // Sort by word count descending
+  orphans.sort((a, b) => countWords(b.content?.rendered || '') - countWords(a.content?.rendered || ''));
+
+  result = json({
+    total_pages: allPages.length, total_orphans: orphans.length,
+    orphans: orphans.map(pg => ({
+      id: pg.id, title: strip(pg.title?.rendered || ''), slug: pg.slug, link: pg.link,
+      word_count: countWords(pg.content?.rendered || ''), status: pg.status
+    }))
+  });
+  auditLog({ tool: name, action: 'find_orphan_pages', status: 'success', latency_ms: Date.now() - t0, params: { total: allPages.length, orphans: orphans.length } });
+  return result;
+};
+handlers['wp_audit_heading_structure'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, extractHeadings } = rt;
+  validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+  const { id, post_type = 'post', focus_keyword } = args;
+  const ep = post_type === 'page' ? `/pages/${id}` : `/posts/${id}`;
+  const p = await wpApiCall(ep);
+  const content = p.content?.rendered || '';
+  const postTitle = strip(p.title?.rendered || '');
+
+  const headings = extractHeadings(content);
+  const issues = [];
+  let score = 100;
+
+  // H1 in content
+  const h1s = headings.filter(h => h.level === 1);
+  if (h1s.length > 0) {
+    issues.push({ type: 'h1_in_content', count: h1s.length, message: 'H1 tag found in content — the post title already provides the H1' });
+    score -= 20;
+  }
+
+  // Heading level skips
+  for (let i = 1; i < headings.length; i++) {
+    if (headings[i].level > headings[i - 1].level + 1) {
+      issues.push({ type: 'heading_skip', from: `H${headings[i - 1].level}`, to: `H${headings[i].level}`, message: `Heading level skip: H${headings[i - 1].level} → H${headings[i].level}` });
+      score -= 10;
+    }
+  }
+
+  // Empty headings
+  const emptyHeadings = headings.filter(h => !h.text);
+  if (emptyHeadings.length > 0) {
+    issues.push({ type: 'empty_heading', count: emptyHeadings.length, message: `${emptyHeadings.length} empty heading(s) found` });
+    score -= 10 * emptyHeadings.length;
+  }
+
+  // No H2
+  const h2s = headings.filter(h => h.level === 2);
+  if (h2s.length === 0 && headings.length > 0) {
+    issues.push({ type: 'no_h2', message: 'No H2 headings found — content should use H2 for main sections' });
+    score -= 15;
+  }
+
+  // Keyword checks
+  if (focus_keyword && h2s.length > 0) {
+    const kwLower = focus_keyword.toLowerCase();
+    const h2WithKw = h2s.filter(h => h.text.toLowerCase().includes(kwLower));
+    if (h2WithKw.length === 0) {
+      issues.push({ type: 'keyword_absent_h2', message: `Focus keyword "${focus_keyword}" not found in any H2 heading` });
+      score -= 10;
+    }
+    if (h2s.length >= 3 && h2WithKw.length / h2s.length > 0.5) {
+      issues.push({ type: 'keyword_stuffing', count: h2WithKw.length, total_h2: h2s.length, message: `Keyword "${focus_keyword}" appears in ${h2WithKw.length}/${h2s.length} H2 headings (>50%)` });
+      score -= 15;
+    }
+  }
+
+  if (score < 0) score = 0;
+
+  result = json({
+    post_id: id, post_title: postTitle, headings, issues, score,
+    summary: {
+      total_headings: headings.length,
+      h1_count: h1s.length, h2_count: h2s.length,
+      h3_count: headings.filter(h => h.level === 3).length,
+      h4_count: headings.filter(h => h.level === 4).length,
+      h5_count: headings.filter(h => h.level === 5).length,
+      h6_count: headings.filter(h => h.level === 6).length,
+    }
+  });
+  auditLog({ tool: name, target: id, target_type: post_type, action: 'audit_heading_structure', status: 'success', latency_ms: Date.now() - t0, params: { headings_count: headings.length, issues_count: issues.length, score } });
+  return result;
+};
+handlers['wp_find_thin_content'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, countWords } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 500 },
+    min_words: { type: 'number', min: 1 },
+    critical_words: { type: 'number', min: 1 },
+    max_age_days: { type: 'number', min: 1 },
+    include_uncategorized: { type: 'string' },
+    post_type: { type: 'string', enum: ['post', 'page'] }
+  });
+  const { limit = 100, min_words = 300, critical_words = 150, max_age_days = 730, include_uncategorized = true, post_type = 'post' } = args;
+  const endpoint = post_type === 'page' ? '/pages' : '/posts';
+  const items = await wpApiCall(`${endpoint}?per_page=${Math.min(limit, 100)}&status=publish&_fields=id,title,link,content,modified,date,categories`);
+
+  const now = new Date();
+  const articles = [];
+  for (const item of items) {
+    const wc = countWords(item.content?.rendered || '');
+    const modified = new Date(item.modified);
+    const daysSinceUpdate = Math.floor((now - modified) / (1000 * 60 * 60 * 24));
+
+    const signals = [];
+    if (wc < critical_words) signals.push('very_short');
+    else if (wc < min_words) signals.push('too_short');
+    if (daysSinceUpdate > max_age_days) signals.push('outdated');
+    if (include_uncategorized) {
+      const cats = item.categories || [];
+      if (cats.length === 0 || (cats.length === 1 && cats[0] === 1)) signals.push('uncategorized');
+    }
+
+    if (signals.length === 0) continue;
+
+    let severity = 'medium';
+    if (signals.length >= 3) severity = 'critical';
+    else if (signals.length >= 2) severity = 'high';
+
+    let suggested_action = 'review';
+    if (signals.includes('very_short') && signals.includes('outdated')) suggested_action = 'delete';
+    else if (signals.includes('too_short') || signals.includes('very_short')) suggested_action = 'expand';
+    else if (signals.includes('outdated') && !signals.includes('too_short') && !signals.includes('very_short')) suggested_action = 'update_or_merge';
+
+    articles.push({
+      id: item.id, title: strip(item.title?.rendered || ''), link: item.link || '',
+      word_count: wc, days_since_update: daysSinceUpdate,
+      signals, severity, suggested_action
+    });
+  }
+
+  // Sort: severity DESC (critical > high > medium), then word_count ASC
+  const sevOrder = { critical: 0, high: 1, medium: 2 };
+  articles.sort((a, b) => (sevOrder[a.severity] - sevOrder[b.severity]) || (a.word_count - b.word_count));
+
+  const bySev = { critical: 0, high: 0, medium: 0 };
+  for (const a of articles) bySev[a.severity]++;
+
+  result = json({ total_analyzed: items.length, total_thin: articles.length, by_severity: bySev, articles });
+  auditLog({ tool: name, action: 'audit_seo', target_type: post_type, status: 'success', latency_ms: Date.now() - t0, params: { total_analyzed: items.length, total_thin: articles.length } });
+  return result;
+};
+handlers['wp_audit_canonicals'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, auditLog, name } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 200 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] },
+    check_staging_patterns: { type: 'string' }
+  });
+  const { limit = 50, post_type = 'post', check_staging_patterns = true } = args;
+
+  // Fetch posts (and/or pages)
+  let allPosts = [];
+  const fieldsList = 'id,title,link,meta';
+  if (post_type === 'both' || post_type === 'post') {
+    const posts = await wpApiCall(`/posts?per_page=${Math.min(limit, 100)}&status=publish&_fields=${fieldsList}`);
+    allPosts = allPosts.concat(posts);
+  }
+  if (post_type === 'both' || post_type === 'page') {
+    const pages = await wpApiCall(`/pages?per_page=${Math.min(limit, 100)}&status=publish&_fields=${fieldsList}`);
+    allPosts = allPosts.concat(pages);
+  }
+
+  // Detect site URL from auth
+  const { url: siteUrl } = getActiveAuth();
+  let siteHost = '';
+  let siteProtocol = 'https:';
+  try {
+    const parsed = new URL(siteUrl);
+    siteHost = parsed.host;
+    siteProtocol = parsed.protocol;
+  } catch { /* fallback */ }
+
+  // Detect SEO plugin from meta keys
+  let seoPluginDetected = 'none';
+  const seoCanonicalKeys = {
+    rank_math_canonical_url: 'RankMath',
+    _yoast_wpseo_canonical: 'Yoast',
+    _seopress_robots_canonical: 'SEOPress',
+    _aioseo_og_title: 'AIOSEO'
+  };
+
+  for (const p of allPosts) {
+    const meta = p.meta || {};
+    for (const [key, plugin] of Object.entries(seoCanonicalKeys)) {
+      if (meta[key] !== undefined && meta[key] !== '' && meta[key] !== null) {
+        seoPluginDetected = plugin;
+        break;
+      }
+    }
+    if (seoPluginDetected !== 'none') break;
+  }
+
+  // Get canonical field name
+  const canonicalKey = Object.keys(seoCanonicalKeys).find(k => {
+    return allPosts.some(p => p.meta && p.meta[k] !== undefined);
+  }) || '';
+
+  const stagingPatterns = ['staging', 'dev', 'local', 'preprod', 'test', 'localhost'];
+  const audits = [];
+  const issuesByType = { missing_canonical: 0, http_on_https_site: 0, staging_url: 0, wrong_domain: 0, trailing_slash_mismatch: 0 };
+
+  for (const p of allPosts) {
+    const meta = p.meta || {};
+    const postUrl = p.link || '';
+    const canonical = (canonicalKey && meta[canonicalKey]) ? String(meta[canonicalKey]) : '';
+    const postIssues = [];
+
+    if (!canonical) {
+      postIssues.push('missing_canonical');
+      issuesByType.missing_canonical++;
+    } else {
+      // HTTP on HTTPS site
+      if (siteProtocol === 'https:' && canonical.startsWith('http://')) {
+        postIssues.push('http_on_https_site');
+        issuesByType.http_on_https_site++;
+      }
+      // Staging URL
+      if (check_staging_patterns) {
+        let canonHostLower = '';
+        try { canonHostLower = new URL(canonical).hostname.toLowerCase(); } catch { /* skip */ }
+        if (canonHostLower && stagingPatterns.some(pat => canonHostLower.includes(pat))) {
+          postIssues.push('staging_url');
+          issuesByType.staging_url++;
+        }
+      }
+      // Wrong domain
+      try {
+        const canonHost = new URL(canonical).host;
+        if (siteHost && canonHost !== siteHost) {
+          postIssues.push('wrong_domain');
+          issuesByType.wrong_domain++;
+        }
+      } catch { /* skip invalid canonical URL */ }
+      // Trailing slash mismatch
+      if (postUrl && canonical) {
+        const postTrailing = postUrl.endsWith('/');
+        const canonTrailing = canonical.endsWith('/');
+        if (postTrailing !== canonTrailing) {
+          postIssues.push('trailing_slash_mismatch');
+          issuesByType.trailing_slash_mismatch++;
+        }
+      }
+    }
+
+    audits.push({
+      id: p.id, title: strip(p.title?.rendered || ''), url: postUrl,
+      canonical: canonical || null, issues: postIssues
+    });
+  }
+
+  const totalIssues = audits.filter(a => a.issues.length > 0).length;
+  result = json({ total_audited: audits.length, total_issues: totalIssues, seo_plugin_detected: seoPluginDetected, issues_by_type: issuesByType, audits });
+  auditLog({ tool: name, action: 'audit_seo', target_type: post_type, status: 'success', latency_ms: Date.now() - t0, params: { total_audited: audits.length, total_issues: totalIssues, seo_plugin: seoPluginDetected } });
+  return result;
+};
+handlers['wp_analyze_eeat_signals'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, auditLog, name, countWords } = rt;
+  validateInput(args, {
+    post_ids: { type: 'array' },
+    limit: { type: 'number', min: 1, max: 50 },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    authoritative_domains: { type: 'array' }
+  });
+  const { post_ids, limit = 10, post_type = 'post', authoritative_domains = ['wikipedia.org', 'gov', 'edu', 'who.int', 'pubmed'] } = args;
+
+  // Fetch posts
+  let posts;
+  if (post_ids && post_ids.length > 0) {
+    posts = await wpApiCall(`/${post_type === 'page' ? 'pages' : 'posts'}?include=${post_ids.join(',')}&_fields=id,title,link,content,author,date,modified,meta`);
+  } else {
+    posts = await wpApiCall(`/${post_type === 'page' ? 'pages' : 'posts'}?per_page=${Math.min(limit, 50)}&status=publish&orderby=date&order=desc&_fields=id,title,link,content,author,date,modified,meta`);
+  }
+
+  // Cache authors
+  const authorCache = {};
+  const eeatResults = [];
+
+  for (const p of posts) {
+    const content = p.content?.rendered || '';
+    const wc = countWords(content);
+    const nowDate = new Date();
+    const modified = new Date(p.modified);
+    const daysSinceUpdate = Math.floor((nowDate - modified) / (1000 * 60 * 60 * 24));
+
+    // Fetch author
+    const authorId = p.author;
+    if (authorId && !authorCache[authorId]) {
+      try {
+        authorCache[authorId] = await wpApiCall(`/users/${authorId}`);
+      } catch { authorCache[authorId] = {}; }
+    }
+    const author = authorCache[authorId] || {};
+
+    const signalsPresent = [];
+    const signalsMissing = [];
+
+    // EXPERIENCE (score /25)
+    let experienceScore = 0;
+    const hasBio = !!(author.description && author.description.trim());
+    if (hasBio) { experienceScore += 10; signalsPresent.push('author_has_bio'); } else { signalsMissing.push({ signal: 'author_has_bio', impact: 10, category: 'experience' }); }
+    const hasFirstPerson = /\b(je|nous|notre|mon|ma|j'ai|j'|I|we|my|our|I've)\b/i.test(content);
+    if (hasFirstPerson) { experienceScore += 8; signalsPresent.push('content_has_first_person'); } else { signalsMissing.push({ signal: 'content_has_first_person', impact: 8, category: 'experience' }); }
+    const hasPersonalExp = /\b(expérience|témoignage|cas|exemple|client|projet|experience|testimony|case study|example|project)\b/i.test(content);
+    if (hasPersonalExp) { experienceScore += 7; signalsPresent.push('content_has_personal_experience'); } else { signalsMissing.push({ signal: 'content_has_personal_experience', impact: 7, category: 'experience' }); }
+
+    // EXPERTISE (score /25)
+    let expertiseScore = 0;
+    const hasData = /\d+\s*(%|€|\$|£|kg|km|ml|mg|px|ms|gb|mb|tb)/i.test(content);
+    if (hasData) { expertiseScore += 8; signalsPresent.push('content_has_data'); } else { signalsMissing.push({ signal: 'content_has_data', impact: 8, category: 'expertise' }); }
+    const hasEntities = /[.>]\s+\w+\s+[A-Z][a-z]{2,}/.test(content.replace(/<[^>]*>/g, ''));
+    if (hasEntities) { expertiseScore += 7; signalsPresent.push('content_has_entities'); } else { signalsMissing.push({ signal: 'content_has_entities', impact: 7, category: 'expertise' }); }
+    if (wc > 800) { expertiseScore += 10; signalsPresent.push('content_word_count_expert'); } else { signalsMissing.push({ signal: 'content_word_count_expert', impact: 10, category: 'expertise' }); }
+
+    // AUTHORITATIVENESS (score /25)
+    let authScore = 0;
+    const extLinkRegex = /<a\s[^>]*?href=["'](https?:\/\/[^"']+)["'][^>]*?>/gi;
+    const externalLinks = [];
+    let extMatch;
+    const { url: sUrl } = getActiveAuth();
+    let sHost = '';
+    try { sHost = new URL(sUrl).host; } catch { /* */ }
+    while ((extMatch = extLinkRegex.exec(content)) !== null) {
+      try {
+        const linkHost = new URL(extMatch[1]).host;
+        if (linkHost !== sHost) externalLinks.push(extMatch[1]);
+      } catch { /* skip */ }
+    }
+    if (externalLinks.length >= 2) { authScore += 8; signalsPresent.push('has_outbound_links'); } else { signalsMissing.push({ signal: 'has_outbound_links', impact: 8, category: 'authoritativeness' }); }
+    const hasAuthSources = externalLinks.some(link => {
+      const lowerLink = link.toLowerCase();
+      return authoritative_domains.some(d => lowerLink.includes(d));
+    });
+    if (hasAuthSources) { authScore += 10; signalsPresent.push('has_authoritative_sources'); } else { signalsMissing.push({ signal: 'has_authoritative_sources', impact: 10, category: 'authoritativeness' }); }
+    const hasCitations = /\b(selon|d'après|source|étude|rapport|according to|study|report|research)\b/i.test(content);
+    if (hasCitations) { authScore += 7; signalsPresent.push('content_has_citations'); } else { signalsMissing.push({ signal: 'content_has_citations', impact: 7, category: 'authoritativeness' }); }
+
+    // TRUSTWORTHINESS (score /25)
+    let trustScore = 0;
+    if (daysSinceUpdate <= 365) { trustScore += 10; signalsPresent.push('has_update_date'); } else { signalsMissing.push({ signal: 'has_update_date', impact: 10, category: 'trustworthiness' }); }
+    const hasAvatar = !!(author.avatar_urls && Object.keys(author.avatar_urls).length > 0);
+    if (hasBio && hasAvatar) { trustScore += 8; signalsPresent.push('author_linked'); } else { signalsMissing.push({ signal: 'author_linked', impact: 8, category: 'trustworthiness' }); }
+    const hasStructuredData = content.includes('application/ld+json');
+    if (hasStructuredData) { trustScore += 7; signalsPresent.push('has_structured_data'); } else { signalsMissing.push({ signal: 'has_structured_data', impact: 7, category: 'trustworthiness' }); }
+
+    const total = experienceScore + expertiseScore + authScore + trustScore;
+
+    // Priority fixes: top 3 missing signals by impact
+    const priorityFixes = signalsMissing
+      .sort((a, b) => b.impact - a.impact)
+      .slice(0, 3)
+      .map(s => ({ signal: s.signal, category: s.category, potential_points: s.impact }));
+
+    eeatResults.push({
+      id: p.id, title: strip(p.title?.rendered || ''),
+      scores: { experience: experienceScore, expertise: expertiseScore, authoritativeness: authScore, trustworthiness: trustScore, total },
+      signals_present: signalsPresent,
+      signals_missing: signalsMissing.map(s => s.signal),
+      priority_fixes: priorityFixes
+    });
+  }
+
+  result = json({ total_analyzed: posts.length, analyses: eeatResults });
+  auditLog({ tool: name, action: 'audit_seo', target_type: post_type, status: 'success', latency_ms: Date.now() - t0, params: { total_analyzed: posts.length } });
+  return result;
+};
+handlers['wp_find_broken_internal_links'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, fetch, auditLog, name, extractInternalLinksHtml } = rt;
+  validateInput(args, {
+    limit_posts: { type: 'number', min: 1, max: 100 },
+    batch_size: { type: 'number', min: 1, max: 10 },
+    timeout_ms: { type: 'number', min: 1000, max: 30000 },
+    delay_ms: { type: 'number', min: 0, max: 2000 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] }
+  });
+  const { limit_posts = 20, batch_size = 5, timeout_ms = 5000, delay_ms = 200, post_type = 'post', include_redirects = true } = args;
+  const scanStart = Date.now();
+
+  // Fetch posts
+  const endpoints = post_type === 'both' ? ['/posts', '/pages'] : [post_type === 'page' ? '/pages' : '/posts'];
+  let allPosts = [];
+  for (const ep of endpoints) {
+    const items = await wpApiCall(`${ep}?per_page=${Math.min(limit_posts, 100)}&status=publish&_fields=id,title,link,content`);
+    allPosts = allPosts.concat(items);
+  }
+  allPosts = allPosts.slice(0, limit_posts);
+
+  // Extract internal links per post and deduplicate globally
+  const linkToSources = new Map(); // url → [{post_id, post_title, post_url, html}]
+  for (const p of allPosts) {
+    const html = p.content?.rendered || '';
+    const siteUrl = p.link ? p.link.replace(/\/[^/]*\/?$/, '') : '';
+    const internalUrls = extractInternalLinksHtml(html, siteUrl);
+    const uniqueUrls = [...new Set(internalUrls)];
+    for (const url of uniqueUrls) {
+      if (!linkToSources.has(url)) linkToSources.set(url, []);
+      linkToSources.get(url).push({ post_id: p.id, post_title: strip(p.title?.rendered || ''), post_url: p.link, html });
+    }
+  }
+
+  // Check links in batches
+  const allUrls = [...linkToSources.keys()];
+  const linkResults = new Map(); // url → {status, ok, isTimeout}
+
+  async function checkSingleLink(url, tms) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), tms);
+    try {
+      const response = await fetch(url, { method: 'HEAD', signal: controller.signal, redirect: 'manual' });
+      clearTimeout(timer);
+      return { url, status: response.status, ok: response.status < 400 };
+    } catch (error) {
+      clearTimeout(timer);
+      return { url, status: null, ok: false, isTimeout: error.name === 'AbortError' };
+    }
+  }
+
+  for (let i = 0; i < allUrls.length; i += batch_size) {
+    const batch = allUrls.slice(i, i + batch_size);
+    const results = await Promise.allSettled(batch.map(u => checkSingleLink(u, timeout_ms)));
+    for (const r of results) {
+      const val = r.status === 'fulfilled' ? r.value : { url: batch[0], status: null, ok: false, isTimeout: false };
+      linkResults.set(val.url, val);
+    }
+    if (i + batch_size < allUrls.length && delay_ms > 0) {
+      await new Promise(r => setTimeout(r, delay_ms));
+    }
+  }
+
+  // Extract anchor text helper
+  function getAnchorText(html, href) {
+    const escaped = href.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const m = html.match(new RegExp(`<a\\s[^>]*?href=["']${escaped}["'][^>]*?>(.*?)<\\/a>`, 'i'));
+    return m ? m[1].replace(/<[^>]*>/g, '').trim() : '';
+  }
+
+  // Build results
+  const brokenLinks = [];
+  let totalRedirects = 0;
+  let totalTimeouts = 0;
+  let totalBroken = 0;
+
+  for (const [url, lr] of linkResults) {
+    let issueType = null;
+    if (lr.status === 404) issueType = 'not_found';
+    else if (lr.status === 301 || lr.status === 302) issueType = 'redirect';
+    else if (lr.isTimeout) issueType = 'timeout';
+    else if (!lr.ok && lr.status !== 301 && lr.status !== 302) issueType = 'network_error';
+
+    if (!issueType) continue;
+    if (issueType === 'redirect') { totalRedirects++; if (!include_redirects) continue; }
+    if (issueType === 'timeout') totalTimeouts++;
+    if (issueType === 'not_found' || issueType === 'network_error') totalBroken++;
+
+    const sources = linkToSources.get(url) || [];
+    for (const src of sources) {
+      brokenLinks.push({
+        source_post_id: src.post_id, source_post_title: src.post_title, source_post_url: src.post_url,
+        broken_url: url, anchor_text: getAnchorText(src.html, url),
+        status_code: lr.status, issue_type: issueType
+      });
+    }
+  }
+
+  // Sort: not_found first, then redirect, then timeout, then network_error
+  const typeOrder = { not_found: 0, redirect: 1, timeout: 2, network_error: 3 };
+  brokenLinks.sort((a, b) => (typeOrder[a.issue_type] ?? 9) - (typeOrder[b.issue_type] ?? 9));
+
+  result = json({
+    total_posts_scanned: allPosts.length,
+    total_links_checked: allUrls.length,
+    total_broken: totalBroken,
+    total_redirects: totalRedirects,
+    total_timeouts: totalTimeouts,
+    broken_links: brokenLinks,
+    scan_duration_ms: Date.now() - scanStart
+  });
+  auditLog({ tool: name, action: 'audit_seo', target_type: 'post', status: 'success', latency_ms: Date.now() - t0, params: { limit_posts, total_links_checked: allUrls.length } });
+  return result;
+};
+handlers['wp_find_keyword_cannibalization'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 500 },
+    post_type: { type: 'string', enum: ['post', 'page', 'both'] },
+    similarity_mode: { type: 'string', enum: ['exact', 'normalized'] },
+    min_group_size: { type: 'number', min: 2 }
+  });
+  const { limit = 200, post_type = 'post', similarity_mode = 'normalized', min_group_size = 2 } = args;
+
+  const endpoints = post_type === 'both' ? ['/posts', '/pages'] : [post_type === 'page' ? '/pages' : '/posts'];
+  let allPosts = [];
+  for (const ep of endpoints) {
+    const items = await wpApiCall(`${ep}?per_page=${Math.min(limit, 100)}&status=publish&_fields=id,title,link,date,meta`);
+    allPosts = allPosts.concat(items);
+  }
+  allPosts = allPosts.slice(0, limit);
+
+  // Extract focus keyword
+  function getFocusKeyword(meta) {
+    if (!meta) return null;
+    return meta.rank_math_focus_keyword || meta._yoast_wpseo_focuskw || meta._seopress_analysis_target_kw || meta._aioseo_keywords || null;
+  }
+
+  // Normalize keyword
+  function normalizeKeyword(kw) {
+    return kw
+      .toLowerCase()
+      .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+      .replace(/\b(le|la|les|un|une|des|de|du|en|et|ou|the|a|an|of|for|in|on|at)\b/g, '')
+      .replace(/[^a-z0-9\s]/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+
+  // Group by keyword
+  const kwMap = new Map(); // normalizedKw → [{id, title, url, date, original_keyword}]
+  let postsWithKw = 0;
+  let postsWithoutKw = 0;
+
+  for (const p of allPosts) {
+    const raw = getFocusKeyword(p.meta);
+    if (!raw || !raw.trim()) { postsWithoutKw++; continue; }
+    postsWithKw++;
+    const key = similarity_mode === 'exact' ? raw.trim() : normalizeKeyword(raw);
+    if (!kwMap.has(key)) kwMap.set(key, []);
+    kwMap.get(key).push({
+      id: p.id, title: strip(p.title?.rendered || ''), url: p.link, date: p.date, original_keyword: raw.trim()
+    });
+  }
+
+  // Filter groups by min_group_size
+  const groups = [];
+  for (const [keyword, articles] of kwMap) {
+    if (articles.length < min_group_size) continue;
+    // Recommended action
+    let recommended_action = 'differentiate';
+    if (articles.length >= 3) {
+      recommended_action = 'merge';
+    } else if (articles.length === 2) {
+      const d1 = new Date(articles[0].date);
+      const d2 = new Date(articles[1].date);
+      const diffDays = Math.abs(d1 - d2) / (1000 * 60 * 60 * 24);
+      if (diffDays > 365) recommended_action = 'consolidate_301';
+      else recommended_action = 'differentiate';
+    }
+    groups.push({
+      keyword,
+      variants: [...new Set(articles.map(a => a.original_keyword))],
+      articles_count: articles.length,
+      articles,
+      recommended_action
+    });
+  }
+
+  let articlesAffected = 0;
+  for (const g of groups) articlesAffected += g.articles_count;
+
+  result = json({
+    total_posts_analyzed: allPosts.length,
+    posts_with_keyword: postsWithKw,
+    posts_without_keyword: postsWithoutKw,
+    total_groups: groups.length,
+    articles_affected: articlesAffected,
+    cannibalization_groups: groups
+  });
+  auditLog({ tool: name, action: 'audit_seo', target_type: 'post', status: 'success', latency_ms: Date.now() - t0, params: { total_posts_analyzed: allPosts.length, total_groups: groups.length } });
+  return result;
+};
+handlers['wp_audit_taxonomies'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name } = rt;
+  validateInput(args, {
+    min_posts_threshold: { type: 'number', min: 1 }
+  });
+  const { check_tags = true, check_categories = true, min_posts_threshold = 2, detect_duplicates = true } = args;
+
+  // Levenshtein distance
+  function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from({ length: m + 1 }, (_, i) =>
+      Array.from({ length: n + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0)
+    );
+    for (let i = 1; i <= m; i++)
+      for (let j = 1; j <= n; j++)
+        dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1]
+          : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    return dp[m][n];
+  }
+
+  function normalizeTermName(name) {
+    return name.toLowerCase()
+      .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+      .replace(/[^a-z0-9]/g, '');
+  }
+
+  function auditTerms(terms, isCat) {
+    const empty = [];
+    const singlePost = [];
+    const missingDesc = [];
+    for (const t of terms) {
+      const item = { id: t.id, name: t.name, slug: t.slug, count: t.count };
+      if (t.count === 0) { empty.push({ ...item, issue_type: 'empty' }); }
+      else if (t.count < min_posts_threshold) { singlePost.push({ ...item, issue_type: 'single_post' }); }
+      if (isCat && (!t.description || t.description.trim() === '')) {
+        missingDesc.push({ ...item, issue_type: 'missing_description' });
+      }
+    }
+
+    // Duplicate detection
+    const duplicateGroups = [];
+    if (detect_duplicates && terms.length > 1) {
+      const normalized = terms.map(t => ({ ...t, norm: normalizeTermName(t.name) }));
+      const used = new Set();
+      for (let i = 0; i < normalized.length; i++) {
+        if (used.has(i)) continue;
+        const group = [normalized[i]];
+        for (let j = i + 1; j < normalized.length; j++) {
+          if (used.has(j)) continue;
+          const isExact = normalized[i].norm === normalized[j].norm;
+          const isNear = !isExact && normalized[i].norm.length >= 4 && normalized[j].norm.length >= 4 && levenshtein(normalized[i].norm, normalized[j].norm) <= 2;
+          if (isExact || isNear) {
+            group.push(normalized[j]);
+            used.add(j);
+          }
+        }
+        if (group.length >= 2) {
+          used.add(i);
+          const similarity = group.every(g => g.norm === group[0].norm) ? 'exact' : 'near';
+          duplicateGroups.push({
+            terms: group.map(g => ({ id: g.id, name: g.name, slug: g.slug, count: g.count, issue_type: 'duplicate' })),
+            similarity
+          });
+        }
+      }
+    }
+
+    const issues = { empty, single_post: singlePost, duplicate_groups: duplicateGroups };
+    if (isCat) issues.missing_description = missingDesc;
+    return issues;
+  }
+
+  let tagsResult = null;
+  let catsResult = null;
+  let totalIssues = 0;
+  let totalTerms = 0;
+
+  if (check_tags) {
+    const tags = await wpApiCall('/tags?per_page=100');
+    const issues = auditTerms(tags, false);
+    const tagIssueCount = issues.empty.length + issues.single_post.length + issues.duplicate_groups.reduce((s, g) => s + g.terms.length, 0);
+    totalIssues += tagIssueCount;
+    totalTerms += tags.length;
+    tagsResult = { total: tags.length, issues };
+  }
+
+  if (check_categories) {
+    const cats = await wpApiCall('/categories?per_page=100');
+    const issues = auditTerms(cats, true);
+    const catIssueCount = issues.empty.length + issues.single_post.length + (issues.missing_description || []).length + issues.duplicate_groups.reduce((s, g) => s + g.terms.length, 0);
+    totalIssues += catIssueCount;
+    totalTerms += cats.length;
+    catsResult = { total: cats.length, issues };
+  }
+
+  const crawlWasteScore = totalTerms > 0 ? Math.min(100, Math.round((totalIssues / totalTerms) * 100)) : 0;
+
+  const output = { total_issues: totalIssues, crawl_waste_score: crawlWasteScore };
+  if (tagsResult) output.tags = tagsResult;
+  if (catsResult) output.categories = catsResult;
+
+  result = json(output);
+  auditLog({ tool: name, action: 'audit_seo', target_type: 'taxonomy', status: 'success', latency_ms: Date.now() - t0, params: { total_issues: totalIssues, crawl_waste_score: crawlWasteScore } });
+  return result;
+};
+handlers['wp_audit_outbound_links'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, countWords } = rt;
+  validateInput(args, {
+    limit: { type: 'number', min: 1, max: 100 },
+    post_type: { type: 'string', enum: ['post', 'page'] },
+    min_outbound: { type: 'number', min: 0 },
+    max_outbound: { type: 'number', min: 1 },
+    authoritative_domains: { type: 'array' }
+  });
+  const { limit = 30, post_type = 'post', min_outbound = 1, max_outbound = 15, authoritative_domains = ['wikipedia.org', 'gov', 'edu', 'who.int', 'pubmed.ncbi'] } = args;
+  const endpoint = post_type === 'page' ? '/pages' : '/posts';
+  const posts = await wpApiCall(`${endpoint}?per_page=${Math.min(limit, 100)}&status=publish&_fields=id,title,link,content`);
+
+  function extractDomain(url) {
+    try { return new URL(url).hostname.replace(/^www\./, ''); }
+    catch { return null; }
+  }
+
+  function isAuthoritative(domain) {
+    return authoritative_domains.some(ad => domain === ad || domain.endsWith('.' + ad));
+  }
+
+  const domainCounts = new Map();
+  const articles = [];
+  let totalAuthoritative = 0;
+
+  for (const p of posts) {
+    const html = p.content?.rendered || '';
+    const wc = countWords(html);
+    const siteHost = p.link ? extractDomain(p.link) : '';
+
+    // Extract all links
+    const allLinks = [];
+    const linkRegex = /<a\s[^>]*?href=["']([^"']+)["'][^>]*?>/gi;
+    let m;
+    while ((m = linkRegex.exec(html)) !== null) {
+      try {
+        const href = m[1];
+        if (href.startsWith('http')) allLinks.push(href);
+      } catch { /* skip */ }
+    }
+
+    // Separate external links
+    const externalLinks = [];
+    const externalDomains = new Set();
+    for (const link of allLinks) {
+      const dom = extractDomain(link);
+      if (!dom || dom === siteHost) continue;
+      externalLinks.push(link);
+      externalDomains.add(dom);
+      domainCounts.set(dom, (domainCounts.get(dom) || 0) + 1);
+    }
+
+    const outboundCount = externalLinks.length;
+    let authCount = 0;
+    for (const dom of externalDomains) {
+      if (isAuthoritative(dom)) authCount++;
+    }
+    if (authCount > 0) totalAuthoritative++;
+
+    let status;
+    if (outboundCount === 0) status = 'no_outbound';
+    else if (outboundCount < min_outbound) status = 'insufficient';
+    else if (outboundCount > max_outbound) status = 'excessive';
+    else status = 'good';
+
+    articles.push({
+      id: p.id, title: strip(p.title?.rendered || ''), url: p.link, word_count: wc,
+      outbound_count: outboundCount,
+      authoritative_count: authCount,
+      outbound_ratio: wc > 0 ? Math.round((outboundCount / (wc / 100)) * 100) / 100 : 0,
+      status,
+      external_domains: [...externalDomains]
+    });
+  }
+
+  // Top cited domains
+  const topDomains = [...domainCounts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([domain, count]) => ({ domain, count, is_authoritative: isAuthoritative(domain) }));
+
+  const byStatus = { no_outbound: 0, insufficient: 0, good: 0, excessive: 0 };
+  for (const a of articles) byStatus[a.status]++;
+
+  const avgOutbound = articles.length > 0 ? Math.round((articles.reduce((s, a) => s + a.outbound_count, 0) / articles.length) * 100) / 100 : 0;
+
+  result = json({
+    total_analyzed: posts.length,
+    by_status: byStatus,
+    top_cited_domains: topDomains,
+    articles,
+    average_outbound_per_post: avgOutbound,
+    posts_with_authoritative_sources: totalAuthoritative
+  });
+  auditLog({ tool: name, action: 'audit_seo', target_type: 'post', status: 'success', latency_ms: Date.now() - t0, params: { total_analyzed: posts.length } });
+  return result;
+};
+handlers['wp_detect_multilingual_plugin'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveAuth, fetch, auditLog, name } = rt;
+  let mlPlugin = null, mlVersion = null, mlLangs = [], mlDefault = null, mlApiAvailable = false, mlMethod = 'none';
+  // 1. Try WPML
+  try {
+    const wpmlLangs = await wpApiCall('/languages', { basePath: '/wp-json/wpml/v1' });
+    if (wpmlLangs && (Array.isArray(wpmlLangs) || typeof wpmlLangs === 'object')) {
+      mlPlugin = 'wpml'; mlApiAvailable = true; mlMethod = 'rest_api';
+      const langArr = Array.isArray(wpmlLangs) ? wpmlLangs : Object.values(wpmlLangs);
+      mlLangs = langArr.map(l => ({ code: l.code || l.language_code, name: l.english_name || l.translated_name || l.name, default: !!(l.default_locale || l.is_default) }));
+      mlDefault = mlLangs.find(l => l.default)?.code || mlLangs[0]?.code;
+    }
+  } catch (_e) { /* WPML not available */ }
+  // 2. Try Polylang Pro
+  if (!mlPlugin) {
+    try {
+      const pllLangs = await wpApiCall('/languages', { basePath: '/wp-json/pll/v1' });
+      if (pllLangs && Array.isArray(pllLangs) && pllLangs.length > 0) {
+        mlPlugin = 'polylang_pro'; mlApiAvailable = true; mlMethod = 'rest_api';
+        mlLangs = pllLangs.map(l => ({ code: l.slug || l.locale, name: l.name, default: !!l.is_default }));
+        mlDefault = mlLangs.find(l => l.default)?.code || mlLangs[0]?.code;
+      }
+    } catch (_e) { /* Polylang Pro not available */ }
+  }
+  // 3. Try mu-plugin Polylang endpoint (covers Polylang Free with mu-plugin)
+  if (!mlPlugin) {
+    try {
+      const pllMu = await wpApiCall('/polylang/languages', { basePath: '/wp-json/mcp-diagnostics/v1' });
+      if (pllMu && pllMu.languages && pllMu.languages.length > 0) {
+        mlPlugin = 'polylang_free'; mlApiAvailable = true; mlMethod = 'rest_api';
+        mlLangs = pllMu.languages.map(l => ({ code: l.slug || l.locale, name: l.name, default: !!l.is_default }));
+        mlDefault = mlLangs.find(l => l.default)?.code || mlLangs[0]?.code;
+      }
+    } catch (_e) { /* mu-plugin not available */ }
+  }
+  // 4. Try TranslatePress
+  if (!mlPlugin) {
+    try {
+      const tpLangs = await wpApiCall('/languages', { basePath: '/wp-json/translatepress/v1' });
+      if (tpLangs && (Array.isArray(tpLangs) || typeof tpLangs === 'object')) {
+        mlPlugin = 'translatepress'; mlApiAvailable = true; mlMethod = 'rest_api';
+        const tpArr = Array.isArray(tpLangs) ? tpLangs : Object.values(tpLangs);
+        mlLangs = tpArr.map(l => ({ code: l.code || l.language_code || l.short_language, name: l.english_name || l.name, default: !!l.is_default }));
+        mlDefault = mlLangs.find(l => l.default)?.code || mlLangs[0]?.code;
+      }
+    } catch (_e) { /* TranslatePress not available */ }
+  }
+  // 5. Fallback: hreflang parsing from homepage (Polylang Free without mu-plugin)
+  if (!mlPlugin) {
+    try {
+      const { url: siteUrl } = getActiveAuth();
+      const hlResp = await fetch(siteUrl, { headers: { 'User-Agent': 'WordPress-MCP-Server' }, redirect: 'follow' });
+      if (hlResp.ok) {
+        const hlHtml = await hlResp.text();
+        const hlRe = /<link[^>]*rel=["']alternate["'][^>]*hreflang=["']([^"']+)["'][^>]*href=["']([^"']+)["'][^>]*\/?>/gi;
+        let hlM;
+        const hlLangs = [];
+        while ((hlM = hlRe.exec(hlHtml)) !== null) {
+          if (hlM[1] !== 'x-default') hlLangs.push({ code: hlM[1], url: hlM[2] });
+        }
+        if (hlLangs.length > 0) {
+          mlPlugin = 'polylang_free'; mlMethod = 'hreflang_parsing'; mlApiAvailable = false;
+          mlLangs = hlLangs.map((l, i) => ({ code: l.code, name: l.code, default: i === 0 }));
+          mlDefault = mlLangs[0]?.code;
+        }
+      }
+    } catch (_e) { /* homepage not reachable */ }
+  }
+  // Try to get version from plugins list
+  if (mlPlugin) {
+    try {
+      const pluginsList = await wpApiCall('/plugins', { basePath: '/wp-json/wp/v2' });
+      const pluginMap = { wpml: 'sitepress-multilingual-cms', polylang_pro: 'polylang-pro', polylang_free: 'polylang', translatepress: 'translatepress-multilingual' };
+      const slug = pluginMap[mlPlugin];
+      const found = Array.isArray(pluginsList) ? pluginsList.find(p => (p.plugin || '').includes(slug)) : null;
+      if (found) mlVersion = found.version || null;
+    } catch (_e) { /* plugins list not accessible */ }
+  }
+  result = json({ plugin: mlPlugin, version: mlVersion, languages: mlLangs, default_language: mlDefault, api_available: mlApiAvailable, detection_method: mlMethod });
+  auditLog({ tool: name, action: 'detect_multilingual', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};
+handlers['wp_list_languages'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, handleToolCall } = rt;
+  const { include_post_count = false } = args;
+  // Detect plugin first
+  const mlDetectResult = await handleToolCall({ params: { name: 'wp_detect_multilingual_plugin', arguments: {} } });
+  const mlDetect = JSON.parse(mlDetectResult.content[0].text);
+  if (!mlDetect.plugin) {
+    result = json({ languages: [{ code: 'default', name: 'Site language', native_name: 'Site language', locale: null, url_prefix: null, flag_url: null, is_default: true, post_count: null }], plugin: null });
+    auditLog({ tool: name, action: 'list_languages', status: 'success', latency_ms: Date.now() - t0 });
+    return result;
+  }
+  let llLangs = [];
+  if (mlDetect.plugin === 'wpml') {
+    try {
+      const wpmlL = await wpApiCall('/languages', { basePath: '/wp-json/wpml/v1' });
+      const arr = Array.isArray(wpmlL) ? wpmlL : Object.values(wpmlL);
+      llLangs = arr.map(l => ({ code: l.code || l.language_code, name: l.english_name || l.name, native_name: l.native_name || l.translated_name || l.name, locale: l.default_locale || l.locale, url_prefix: l.url || null, flag_url: l.country_flag_url || l.flag_url || null, is_default: !!(l.default_locale || l.is_default), post_count: null }));
+    } catch (_e) { llLangs = mlDetect.languages.map(l => ({ ...l, native_name: l.name, locale: null, url_prefix: null, flag_url: null, is_default: l.default, post_count: null })); }
+  } else if (mlDetect.plugin === 'polylang_pro') {
+    try {
+      const pllL = await wpApiCall('/languages', { basePath: '/wp-json/pll/v1' });
+      llLangs = pllL.map(l => ({ code: l.slug || l.locale, name: l.name, native_name: l.native_name || l.name, locale: l.locale || null, url_prefix: l.home_url || null, flag_url: l.flag || null, is_default: !!l.is_default, post_count: null }));
+    } catch (_e) { llLangs = mlDetect.languages.map(l => ({ ...l, native_name: l.name, locale: null, url_prefix: null, flag_url: null, is_default: l.default, post_count: null })); }
+  } else if (mlDetect.plugin === 'polylang_free') {
+    if (mlDetect.api_available) {
+      try {
+        const pllMuL = await wpApiCall('/polylang/languages', { basePath: '/wp-json/mcp-diagnostics/v1' });
+        llLangs = pllMuL.languages.map(l => ({ code: l.slug || l.locale, name: l.name, native_name: l.native_name || l.name, locale: l.locale || null, url_prefix: l.home_url || null, flag_url: l.flag || null, is_default: !!l.is_default, post_count: null }));
+      } catch (_e) { llLangs = mlDetect.languages.map(l => ({ ...l, native_name: l.name, locale: null, url_prefix: null, flag_url: null, is_default: l.default, post_count: null })); }
+    } else {
+      llLangs = mlDetect.languages.map(l => ({ code: l.code, name: l.code, native_name: l.code, locale: null, url_prefix: null, flag_url: null, is_default: l.default, post_count: null }));
+    }
+  } else if (mlDetect.plugin === 'translatepress') {
+    try {
+      const tpL = await wpApiCall('/languages', { basePath: '/wp-json/translatepress/v1' });
+      const tpArr = Array.isArray(tpL) ? tpL : Object.values(tpL);
+      llLangs = tpArr.map(l => ({ code: l.code || l.short_language, name: l.english_name || l.name, native_name: l.native_name || l.name, locale: l.locale || null, url_prefix: l.url || null, flag_url: l.flag_url || null, is_default: !!l.is_default, post_count: null }));
+    } catch (_e) { llLangs = mlDetect.languages.map(l => ({ ...l, native_name: l.name, locale: null, url_prefix: null, flag_url: null, is_default: l.default, post_count: null })); }
+  }
+  // Post counts if requested
+  if (include_post_count && llLangs.length > 0) {
+    for (const lang of llLangs) {
+      try {
+        let ep = '/posts?per_page=1&status=publish';
+        if (mlDetect.plugin === 'wpml') ep += `&wpml_language=${lang.code}`;
+        else if (mlDetect.plugin.startsWith('polylang')) ep += `&lang=${lang.code}`;
+        else if (mlDetect.plugin === 'translatepress') ep += `&trp_language=${lang.code}`;
+        const countResp = await wpApiCall(ep);
+        lang.post_count = Array.isArray(countResp) ? countResp.length : 0;
+      } catch (_e) { lang.post_count = null; }
+    }
+  }
+  result = json({ languages: llLangs, plugin: mlDetect.plugin, total: llLangs.length });
+  auditLog({ tool: name, action: 'list_languages', status: 'success', latency_ms: Date.now() - t0 });
+  return result;
+};
+handlers['wp_get_post_translations'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, fetch, auditLog, name, handleToolCall } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 } });
+  const { post_id: trPostId, post_type: trPostType = 'post' } = args;
+  const mlDet = JSON.parse((await handleToolCall({ params: { name: 'wp_detect_multilingual_plugin', arguments: {} } })).content[0].text);
+  if (!mlDet.plugin) {
+    result = json({ source_post_id: trPostId, source_lang: null, multilingual: false, translations: {}, message: 'No multilingual plugin detected.' });
+    auditLog({ tool: name, action: 'get_translations', status: 'success', latency_ms: Date.now() - t0, params: { post_id: trPostId } });
+    return result;
+  }
+  let trSourceLang = mlDet.default_language;
+  const translations = {};
+  const trEp = trPostType === 'page' ? 'pages' : 'posts';
+  if (mlDet.plugin === 'wpml') {
+    try {
+      const wpmlTr = await wpApiCall(`/translations?post_id=${trPostId}`, { basePath: '/wp-json/wpml/v1' });
+      if (wpmlTr.source_language) trSourceLang = wpmlTr.source_language;
+      const trMap = wpmlTr.translations || wpmlTr;
+      for (const [lang, tr] of Object.entries(trMap)) {
+        if (lang === 'source_language') continue;
+        const trId = tr.post_id || tr.id || tr;
+        if (typeof trId === 'number' || typeof trId === 'string') {
+          try {
+            const trPost = await wpApiCall(`/${trEp}/${trId}`);
+            const trMeta = trPost.meta || {};
+            translations[lang] = { post_id: trPost.id, title: trPost.title?.rendered || '', url: trPost.link, status: trPost.status, last_modified: trPost.modified, has_seo_meta: !!(trMeta._yoast_wpseo_title || trMeta.rank_math_title || trMeta._seopress_titles_title) };
+          } catch (_e) { translations[lang] = { post_id: trId, title: null, url: null, status: 'unknown', last_modified: null, has_seo_meta: false }; }
+        }
+      }
+    } catch (_e) { /* WPML translations endpoint failed */ }
+  } else if (mlDet.plugin === 'polylang_pro') {
+    try {
+      const pllTr = await wpApiCall(`/posts/${trPostId}/translations`, { basePath: '/wp-json/pll/v1' });
+      for (const [lang, trId] of Object.entries(pllTr)) {
+        if (trId === trPostId) { trSourceLang = lang; continue; }
+        try {
+          const trPost = await wpApiCall(`/${trEp}/${trId}`);
+          const trMeta = trPost.meta || {};
+          translations[lang] = { post_id: trPost.id, title: trPost.title?.rendered || '', url: trPost.link, status: trPost.status, last_modified: trPost.modified, has_seo_meta: !!(trMeta._yoast_wpseo_title || trMeta.rank_math_title || trMeta._seopress_titles_title) };
+        } catch (_e) { translations[lang] = { post_id: trId, title: null, url: null, status: 'unknown', last_modified: null, has_seo_meta: false }; }
+      }
+    } catch (_e) { /* PLL translations failed */ }
+  } else if (mlDet.plugin === 'polylang_free') {
+    // Try mu-plugin endpoint first
+    try {
+      const pllMuTr = await wpApiCall(`/polylang/translations/${trPostId}`, { basePath: '/wp-json/mcp-diagnostics/v1' });
+      if (pllMuTr && pllMuTr.translations) {
+        for (const [lang, trId] of Object.entries(pllMuTr.translations)) {
+          if (trId === trPostId) { trSourceLang = lang; continue; }
+          try {
+            const trPost = await wpApiCall(`/${trEp}/${trId}`);
+            const trMeta = trPost.meta || {};
+            translations[lang] = { post_id: trPost.id, title: trPost.title?.rendered || '', url: trPost.link, status: trPost.status, last_modified: trPost.modified, has_seo_meta: !!(trMeta._yoast_wpseo_title || trMeta.rank_math_title || trMeta._seopress_titles_title) };
+          } catch (_e) { translations[lang] = { post_id: trId, title: null, url: null, status: 'unknown', last_modified: null, has_seo_meta: false }; }
+        }
+      }
+    } catch (_e) {
+      // Fallback: fetch post HTML, parse hreflang
+      try {
+        const srcPost = await wpApiCall(`/${trEp}/${trPostId}`);
+        const srcUrl = srcPost.link;
+        if (srcUrl) {
+          const hlResp = await fetch(srcUrl, { headers: { 'User-Agent': 'WordPress-MCP-Server' }, redirect: 'follow' });
+          if (hlResp.ok) {
+            const hlHtml = await hlResp.text();
+            const hlRe = /<link[^>]*rel=["']alternate["'][^>]*hreflang=["']([^"']+)["'][^>]*href=["']([^"']+)["'][^>]*\/?>/gi;
+            let hlM;
+            while ((hlM = hlRe.exec(hlHtml)) !== null) {
+              if (hlM[1] === 'x-default') continue;
+              const hlLang = hlM[1]; const hlUrl = hlM[2];
+              if (hlUrl === srcUrl) { trSourceLang = hlLang; continue; }
+              translations[hlLang] = { post_id: null, title: null, url: hlUrl, status: 'unknown', last_modified: null, has_seo_meta: false };
+            }
+          }
+        }
+      } catch (_e2) { /* hreflang fallback failed */ }
+    }
+  } else if (mlDet.plugin === 'translatepress') {
+    try {
+      const srcPost = await wpApiCall(`/${trEp}/${trPostId}`);
+      const tpMeta = srcPost.meta || {};
+      const origId = tpMeta._tp_original_post || trPostId;
+      for (const lang of mlDet.languages) {
+        if (lang.code === trSourceLang) continue;
+        try {
+          const tpResp = await wpApiCall(`/${trEp}?meta_key=_tp_original_post&meta_value=${origId}&lang=${lang.code}&per_page=1`);
+          if (Array.isArray(tpResp) && tpResp.length > 0) {
+            const trPost = tpResp[0];
+            const trMeta = trPost.meta || {};
+            translations[lang.code] = { post_id: trPost.id, title: trPost.title?.rendered || '', url: trPost.link, status: trPost.status, last_modified: trPost.modified, has_seo_meta: !!(trMeta._yoast_wpseo_title || trMeta.rank_math_title || trMeta._seopress_titles_title) };
+          }
+        } catch (_e) { /* translation not found for this lang */ }
+      }
+    } catch (_e) { /* TranslatePress translations failed */ }
+  }
+  result = json({ source_post_id: trPostId, source_lang: trSourceLang, translations, translation_count: Object.keys(translations).length });
+  auditLog({ tool: name, action: 'get_translations', status: 'success', latency_ms: Date.now() - t0, params: { post_id: trPostId } });
+  return result;
+};
+handlers['wp_audit_translation_coverage'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, handleToolCall } = rt;
+  const { post_types: covTypes = ['post', 'page'], min_word_count = 0 } = args;
+  const covLangsResult = JSON.parse((await handleToolCall({ params: { name: 'wp_list_languages', arguments: { include_post_count: false } } })).content[0].text);
+  if (!covLangsResult.plugin || covLangsResult.languages.length <= 1) {
+    result = json({ multilingual: false, message: 'No multilingual plugin detected or only one language configured.' });
+    auditLog({ tool: name, action: 'audit_translation_coverage', status: 'success', latency_ms: Date.now() - t0 });
+    return result;
+  }
+  const covLangs = covLangsResult.languages;
+  const defaultLang = covLangs.find(l => l.is_default)?.code || covLangs[0]?.code;
+  const coverage_by_language = [];
+  const untranslatedPosts = [];
+  for (const lang of covLangs) {
+    const typeCoverage = [];
+    for (const pt of covTypes) {
+      const ep = pt === 'page' ? 'pages' : 'posts';
+      try {
+        let qp = `/${ep}?per_page=100&status=publish`;
+        if (covLangsResult.plugin === 'wpml') qp += `&wpml_language=${lang.code}`;
+        else if (covLangsResult.plugin.startsWith('polylang')) qp += `&lang=${lang.code}`;
+        else if (covLangsResult.plugin === 'translatepress') qp += `&trp_language=${lang.code}`;
+        const posts = await wpApiCall(qp);
+        const count = Array.isArray(posts) ? posts.length : 0;
+        // Get default lang total for comparison
+        let defaultTotal = count;
+        if (lang.code !== defaultLang) {
+          try {
+            let dqp = `/${ep}?per_page=100&status=publish`;
+            if (covLangsResult.plugin === 'wpml') dqp += `&wpml_language=${defaultLang}`;
+            else if (covLangsResult.plugin.startsWith('polylang')) dqp += `&lang=${defaultLang}`;
+            else if (covLangsResult.plugin === 'translatepress') dqp += `&trp_language=${defaultLang}`;
+            const defaultPosts = await wpApiCall(dqp);
+            defaultTotal = Array.isArray(defaultPosts) ? defaultPosts.length : 0;
+          } catch (_e) { defaultTotal = count; }
+        }
+        const pct = defaultTotal > 0 ? Math.round((count / defaultTotal) * 100) : 100;
+        typeCoverage.push({ post_type: pt, total: defaultTotal, translated: count, percentage: pct, missing_count: Math.max(0, defaultTotal - count) });
+        // Collect untranslated for priority list (only from default lang)
+        if (lang.code === defaultLang && min_word_count >= 0) {
+          const postsArr = Array.isArray(posts) ? posts : [];
+          for (const p of postsArr) {
+            const wc = (strip(p.content?.rendered || '').split(/\s+/).length) || 0;
+            if (wc >= min_word_count) untranslatedPosts.push({ post_id: p.id, title: strip(p.title?.rendered || ''), post_type: pt, word_count: wc, url: p.link });
+          }
+        }
+      } catch (_e) { typeCoverage.push({ post_type: pt, total: 0, translated: 0, percentage: 0, missing_count: 0 }); }
+    }
+    const overallPct = typeCoverage.length > 0 ? Math.round(typeCoverage.reduce((s, t) => s + t.percentage, 0) / typeCoverage.length) : 0;
+    coverage_by_language.push({ lang_code: lang.code, lang_name: lang.name, post_type_coverage: typeCoverage, overall_percentage: overallPct });
+  }
+  untranslatedPosts.sort((a, b) => b.word_count - a.word_count);
+  result = json({ coverage_by_language, priority_untranslated: untranslatedPosts.slice(0, 10), ga4_note: 'Connect GA4 for traffic-based prioritization' });
+  auditLog({ tool: name, action: 'audit_translation_coverage', status: 'success', latency_ms: Date.now() - t0, params: { post_types: covTypes } });
+  return result;
+};
+handlers['wp_find_missing_seo_translations'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, auditLog, name, handleToolCall } = rt;
+  const { source_lang: fmsLang, post_types: fmsTypes = ['post', 'page'], fields_to_check: fmsFields = ['title', 'description', 'og_title', 'og_description'], limit: fmsLimit = 50 } = args;
+  const fmsDet = JSON.parse((await handleToolCall({ params: { name: 'wp_detect_multilingual_plugin', arguments: {} } })).content[0].text);
+  const fmsSrcLang = fmsLang || fmsDet.default_language;
+  if (!fmsDet.plugin) {
+    result = json({ multilingual: false, message: 'No multilingual plugin detected.' });
+    auditLog({ tool: name, action: 'find_missing_seo_translations', status: 'success', latency_ms: Date.now() - t0 });
+    return result;
+  }
+  const fmsResults = [];
+  for (const pt of fmsTypes) {
+    const ep = pt === 'page' ? 'pages' : 'posts';
+    let qp = `/${ep}?per_page=${Math.min(fmsLimit, 100)}&status=publish`;
+    if (fmsDet.plugin === 'wpml') qp += `&wpml_language=${fmsSrcLang}`;
+    else if (fmsDet.plugin.startsWith('polylang')) qp += `&lang=${fmsSrcLang}`;
+    let srcPosts = [];
+    try { srcPosts = await wpApiCall(qp); } catch (_e) { continue; }
+    if (!Array.isArray(srcPosts)) continue;
+    for (const sp of srcPosts.slice(0, fmsLimit)) {
+      const meta = sp.meta || {};
+      const yoastHead = sp.yoast_head_json || null;
+      // Detect SEO plugin and extract source values
+      const srcSeo = {};
+      if (meta._yoast_wpseo_title || meta._yoast_wpseo_metadesc || yoastHead) {
+        srcSeo.title = meta._yoast_wpseo_title || yoastHead?.title || null;
+        srcSeo.description = meta._yoast_wpseo_metadesc || yoastHead?.description || null;
+        srcSeo.og_title = yoastHead?.og_title || meta._yoast_wpseo_opengraph_title || null;
+        srcSeo.og_description = yoastHead?.og_description || meta._yoast_wpseo_opengraph_description || null;
+      } else if (meta.rank_math_title || meta.rank_math_description) {
+        srcSeo.title = meta.rank_math_title || null;
+        srcSeo.description = meta.rank_math_description || null;
+        srcSeo.og_title = meta.rank_math_facebook_title || null;
+        srcSeo.og_description = meta.rank_math_facebook_description || null;
+      } else if (meta._seopress_titles_title || meta._seopress_titles_desc) {
+        srcSeo.title = meta._seopress_titles_title || null;
+        srcSeo.description = meta._seopress_titles_desc || null;
+        srcSeo.og_title = meta._seopress_social_fb_title || null;
+        srcSeo.og_description = meta._seopress_social_fb_desc || null;
+      }
+      // Skip posts with no SEO meta at all
+      const hasSeo = fmsFields.some(f => srcSeo[f]);
+      if (!hasSeo) continue;
+      // Get translations
+      const trResult = JSON.parse((await handleToolCall({ params: { name: 'wp_get_post_translations', arguments: { post_id: sp.id, post_type: pt } } })).content[0].text);
+      for (const [tLang, tr] of Object.entries(trResult.translations)) {
+        if (!tr.post_id) continue;
+        try {
+          const trPost = await wpApiCall(`/${ep}/${tr.post_id}`);
+          const trMeta = trPost.meta || {};
+          const trYoast = trPost.yoast_head_json || null;
+          const trSeo = {};
+          if (trMeta._yoast_wpseo_title || trMeta._yoast_wpseo_metadesc || trYoast) {
+            trSeo.title = trMeta._yoast_wpseo_title || trYoast?.title || null;
+            trSeo.description = trMeta._yoast_wpseo_metadesc || trYoast?.description || null;
+            trSeo.og_title = trYoast?.og_title || trMeta._yoast_wpseo_opengraph_title || null;
+            trSeo.og_description = trYoast?.og_description || trMeta._yoast_wpseo_opengraph_description || null;
+          } else if (trMeta.rank_math_title || trMeta.rank_math_description) {
+            trSeo.title = trMeta.rank_math_title || null;
+            trSeo.description = trMeta.rank_math_description || null;
+            trSeo.og_title = trMeta.rank_math_facebook_title || null;
+            trSeo.og_description = trMeta.rank_math_facebook_description || null;
+          } else if (trMeta._seopress_titles_title || trMeta._seopress_titles_desc) {
+            trSeo.title = trMeta._seopress_titles_title || null;
+            trSeo.description = trMeta._seopress_titles_desc || null;
+            trSeo.og_title = trMeta._seopress_social_fb_title || null;
+            trSeo.og_description = trMeta._seopress_social_fb_desc || null;
+          }
+          const missing = fmsFields.filter(f => srcSeo[f] && !trSeo[f]);
+          if (missing.length > 0) {
+            fmsResults.push({ source_post_id: sp.id, source_title: strip(sp.title?.rendered || ''), source_lang: fmsSrcLang, translation_post_id: tr.post_id, translation_lang: tLang, translation_title: strip(trPost.title?.rendered || ''), missing_fields: missing, source_values: Object.fromEntries(missing.map(f => [f, srcSeo[f]])) });
+          }
+        } catch (_e) { /* translation post not accessible */ }
+      }
+    }
+  }
+  result = json({ total_missing: fmsResults.length, results: fmsResults });
+  auditLog({ tool: name, action: 'find_missing_seo_translations', status: 'success', latency_ms: Date.now() - t0, params: { source_lang: fmsSrcLang } });
+  return result;
+};
+handlers['wp_sync_seo_meta_translations'] = async (args) => {
+  const t0 = Date.now();
+  let result;
+  const { wpApiCall, getActiveControls, targets, auditLog, name, handleToolCall } = rt;
+  validateInput(args, { post_id: { type: 'number', required: true, min: 1 }, source_lang: { type: 'string', required: true }, target_langs: { type: 'array', required: true } });
+  const { post_id: syncPostId, source_lang: syncSrcLang, target_langs: syncTargets, fields: syncFieldsArg = ['all'], dry_run: syncDryRun = true, overwrite_existing: syncOverwrite = false } = args;
+  // Enforce read-only UNLESS dry_run
+  if (!syncDryRun && getActiveControls().read_only) {
+    throw new Error('Blocked: Server is in READ-ONLY mode (WP_READ_ONLY=true). Tool "wp_sync_seo_meta_translations" is not allowed. Use dry_run=true to preview.');
+  }
+  const allSeoFields = ['title', 'description', 'og_title', 'og_description', 'og_image', 'twitter_title', 'twitter_description'];
+  const syncFields = syncFieldsArg.includes('all') ? allSeoFields : syncFieldsArg;
+  // Get source post SEO meta
+  const srcPost = await wpApiCall(`/posts/${syncPostId}`);
+  const srcMeta = srcPost.meta || {};
+  const srcYoast = srcPost.yoast_head_json || null;
+  const srcSeo = {};
+  let seoPlugin = 'none';
+  if (srcMeta._yoast_wpseo_title || srcMeta._yoast_wpseo_metadesc || srcYoast) {
+    seoPlugin = 'yoast';
+    srcSeo.title = srcMeta._yoast_wpseo_title || srcYoast?.title || null;
+    srcSeo.description = srcMeta._yoast_wpseo_metadesc || srcYoast?.description || null;
+    srcSeo.og_title = srcYoast?.og_title || null;
+    srcSeo.og_description = srcYoast?.og_description || null;
+    srcSeo.og_image = srcYoast?.og_image?.[0]?.url || null;
+    srcSeo.twitter_title = srcYoast?.twitter_misc?.title || srcMeta._yoast_wpseo_twitter_title || null;
+    srcSeo.twitter_description = srcYoast?.twitter_misc?.description || srcMeta._yoast_wpseo_twitter_description || null;
+  } else if (srcMeta.rank_math_title || srcMeta.rank_math_description) {
+    seoPlugin = 'rankmath';
+    srcSeo.title = srcMeta.rank_math_title || null;
+    srcSeo.description = srcMeta.rank_math_description || null;
+    srcSeo.og_title = srcMeta.rank_math_facebook_title || null;
+    srcSeo.og_description = srcMeta.rank_math_facebook_description || null;
+    srcSeo.og_image = srcMeta.rank_math_facebook_image || null;
+    srcSeo.twitter_title = srcMeta.rank_math_twitter_title || null;
+    srcSeo.twitter_description = srcMeta.rank_math_twitter_description || null;
+  } else if (srcMeta._seopress_titles_title || srcMeta._seopress_titles_desc) {
+    seoPlugin = 'seopress';
+    srcSeo.title = srcMeta._seopress_titles_title || null;
+    srcSeo.description = srcMeta._seopress_titles_desc || null;
+    srcSeo.og_title = srcMeta._seopress_social_fb_title || null;
+    srcSeo.og_description = srcMeta._seopress_social_fb_desc || null;
+    srcSeo.og_image = srcMeta._seopress_social_fb_img || null;
+    srcSeo.twitter_title = srcMeta._seopress_social_twitter_title || null;
+    srcSeo.twitter_description = srcMeta._seopress_social_twitter_desc || null;
+  }
+  // Get translations
+  const syncTrResult = JSON.parse((await handleToolCall({ params: { name: 'wp_get_post_translations', arguments: { post_id: syncPostId } } })).content[0].text);
+  const syncTargetResults = [];
+  // Map SEO field names to plugin-specific meta keys
+  const metaKeyMap = {
+    yoast: { title: '_yoast_wpseo_title', description: '_yoast_wpseo_metadesc', og_title: '_yoast_wpseo_opengraph_title', og_description: '_yoast_wpseo_opengraph_description', og_image: '_yoast_wpseo_opengraph_image', twitter_title: '_yoast_wpseo_twitter_title', twitter_description: '_yoast_wpseo_twitter_description' },
+    rankmath: { title: 'rank_math_title', description: 'rank_math_description', og_title: 'rank_math_facebook_title', og_description: 'rank_math_facebook_description', og_image: 'rank_math_facebook_image', twitter_title: 'rank_math_twitter_title', twitter_description: 'rank_math_twitter_description' },
+    seopress: { title: '_seopress_titles_title', description: '_seopress_titles_desc', og_title: '_seopress_social_fb_title', og_description: '_seopress_social_fb_desc', og_image: '_seopress_social_fb_img', twitter_title: '_seopress_social_twitter_title', twitter_description: '_seopress_social_twitter_desc' },
+  };
+  for (const tLang of syncTargets) {
+    const tr = syncTrResult.translations[tLang];
+    if (!tr || !tr.post_id) {
+      syncTargetResults.push({ lang: tLang, post_id: null, fields_synced: [], fields_skipped: [], status: 'error', error: 'No translation found for this language' });
+      continue;
+    }
+    // Get existing target meta
+    let trPost;
+    try { trPost = await wpApiCall(`/posts/${tr.post_id}`); } catch (_e) {
+      syncTargetResults.push({ lang: tLang, post_id: tr.post_id, fields_synced: [], fields_skipped: [], status: 'error', error: 'Could not read target post' });
+      continue;
+    }
+    const trMeta = trPost.meta || {};
+    const fieldsSynced = [];
+    const fieldsSkipped = [];
+    const metaUpdate = {};
+    const keyMap = metaKeyMap[seoPlugin] || {};
+    for (const field of syncFields) {
+      if (!srcSeo[field]) { fieldsSkipped.push(field); continue; }
+      const metaKey = keyMap[field];
+      if (!metaKey) { fieldsSkipped.push(field); continue; }
+      if (!syncOverwrite && trMeta[metaKey]) { fieldsSkipped.push(field); continue; }
+      metaUpdate[metaKey] = srcSeo[field];
+      fieldsSynced.push(field);
+    }
+    if (syncDryRun) {
+      syncTargetResults.push({ lang: tLang, post_id: tr.post_id, fields_synced: fieldsSynced, fields_skipped: fieldsSkipped, status: 'preview' });
+    } else if (Object.keys(metaUpdate).length > 0) {
+      try {
+        await wpApiCall(`/posts/${tr.post_id}`, { method: 'POST', body: JSON.stringify({ meta: metaUpdate }) });
+        syncTargetResults.push({ lang: tLang, post_id: tr.post_id, fields_synced: fieldsSynced, fields_skipped: fieldsSkipped, status: 'synced' });
+      } catch (_e) {
+        syncTargetResults.push({ lang: tLang, post_id: tr.post_id, fields_synced: [], fields_skipped: syncFields, status: 'error', error: _e.message });
+      }
+    } else {
+      syncTargetResults.push({ lang: tLang, post_id: tr.post_id, fields_synced: [], fields_skipped: fieldsSkipped, status: 'skipped' });
+    }
+  }
+  result = json({ source: { post_id: syncPostId, lang: syncSrcLang, seo_plugin: seoPlugin, fields_available: Object.keys(srcSeo).filter(k => srcSeo[k]) }, targets: syncTargetResults, dry_run: syncDryRun });
+  auditLog({ tool: name, action: 'sync_seo_meta_translations', status: 'success', latency_ms: Date.now() - t0, params: { post_id: syncPostId, target_langs: syncTargets, dry_run: syncDryRun } });
+  return result;
+};