@adsim/wordpress-mcp-server 3.1.0 → 4.4.0

package/index.js

@@ -22,12 +22,18 @@ import fetch from 'node-fetch';
 import { readFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import { HttpTransportManager } from './src/transport/http.js';
+import { generateToken, validateToken } from './src/confirmationToken.js';
+import { extractInternalLinks, extractExternalLinks, checkLinkStatus, extractFocusKeyword, calculateRelevanceScore, suggestAnchorText } from './src/linkUtils.js';
+import { wcApiCall, getWcCredentials } from './src/woocommerceClient.js';
+import { parseImagesFromHtml, extractHeadings, extractInternalLinks as extractInternalLinksHtml, countWords } from './src/htmlParser.js';
+import { summarizePost, applyContentFormat } from './src/utils/contentCompressor.js';
+import { calculateReadabilityScore, extractHeadingsOutline, detectContentSections, extractTransitionWords, countPassiveSentences, buildTFIDFVectors, computeCosineSimilarity, findDuplicatePairs, extractEntities, computeTextDiff } from './src/contentAnalyzer.js';
 
 // ============================================================
 // CONFIGURATION
 // ============================================================
 
-const VERSION = '2.2.0';
+const VERSION = '3.2.0';
 const VERBOSE = process.env.WP_MCP_VERBOSE === 'true' || process.argv.includes('--verbose');
 const MAX_RETRIES = parseInt(process.env.WP_MCP_MAX_RETRIES || '3', 10);
 const TIMEOUT_MS = parseInt(process.env.WP_MCP_TIMEOUT || '30000', 10);
@@ -41,6 +47,8 @@ const READ_ONLY = process.env.WP_READ_ONLY === 'true';
 const DRAFT_ONLY = process.env.WP_DRAFT_ONLY === 'true';
 const DISABLE_DELETE = process.env.WP_DISABLE_DELETE === 'true';
 const DISABLE_PLUGIN_MANAGEMENT = process.env.WP_DISABLE_PLUGIN_MANAGEMENT === 'true';
+const REQUIRE_APPROVAL = process.env.WP_REQUIRE_APPROVAL === 'true';
+const CONFIRM_DESTRUCTIVE = process.env.WP_CONFIRM_DESTRUCTIVE === 'true';
 const MAX_CALLS_PER_MINUTE = parseInt(process.env.WP_MAX_CALLS_PER_MINUTE || '0', 10); // 0 = unlimited
 const ALLOWED_TYPES = process.env.WP_ALLOWED_TYPES ? process.env.WP_ALLOWED_TYPES.split(',').map(s => s.trim()) : null; // null = all
 const ALLOWED_STATUSES = process.env.WP_ALLOWED_STATUSES ? process.env.WP_ALLOWED_STATUSES.split(',').map(s => s.trim()) : null;
@@ -50,38 +58,39 @@ const AUDIT_LOG = process.env.WP_AUDIT_LOG !== 'off'; // on by default
 const rateLimiter = { calls: [], windowMs: 60000 };
 
 function checkRateLimit() {
-  if (MAX_CALLS_PER_MINUTE <= 0) return;
+  const maxCpm = getActiveControls().max_calls_per_minute;
+  if (maxCpm <= 0) return;
   const now = Date.now();
   rateLimiter.calls = rateLimiter.calls.filter(t => now - t < rateLimiter.windowMs);
-  if (rateLimiter.calls.length >= MAX_CALLS_PER_MINUTE) {
-    throw new Error(`Rate limit exceeded: ${MAX_CALLS_PER_MINUTE} calls/minute. Try again in a few seconds.`);
+  if (rateLimiter.calls.length >= maxCpm) {
+    throw new Error(`Rate limit exceeded: ${maxCpm} calls/minute. Try again in a few seconds.`);
   }
   rateLimiter.calls.push(now);
 }
 
 function enforceReadOnly(toolName) {
-  const writeTools = ['wp_create_post', 'wp_update_post', 'wp_delete_post', 'wp_create_page', 'wp_update_page', 'wp_upload_media', 'wp_create_comment', 'wp_create_taxonomy_term', 'wp_update_seo_meta', 'wp_activate_plugin', 'wp_deactivate_plugin', 'wp_restore_revision', 'wp_delete_revision'];
-  if (process.env.WP_READ_ONLY === 'true' && writeTools.includes(toolName)) {
+  const writeTools = ['wp_create_post', 'wp_update_post', 'wp_delete_post', 'wp_create_page', 'wp_update_page', 'wp_upload_media', 'wp_create_comment', 'wp_create_taxonomy_term', 'wp_update_seo_meta', 'wp_activate_plugin', 'wp_deactivate_plugin', 'wp_restore_revision', 'wp_delete_revision', 'wp_submit_for_review', 'wp_approve_post', 'wp_reject_post', 'wc_list_products', 'wc_get_product', 'wc_list_orders', 'wc_get_order', 'wc_list_customers', 'wc_inventory_alert', 'wc_order_intelligence', 'wc_seo_product_audit', 'wc_suggest_product_links', 'wc_update_product', 'wc_update_stock', 'wc_update_order_status'];
+  if (getActiveControls().read_only && writeTools.includes(toolName)) {
     throw new Error(`Blocked: Server is in READ-ONLY mode (WP_READ_ONLY=true). Tool "${toolName}" is not allowed.`);
   }
 }
 
 function enforceDeleteDisabled(toolName) {
   const deleteTools = ['wp_delete_post', 'wp_delete_revision'];
-  if (process.env.WP_DISABLE_DELETE === 'true' && deleteTools.includes(toolName)) {
+  if (getActiveControls().disable_delete && deleteTools.includes(toolName)) {
     throw new Error(`Blocked: Destructive actions are disabled (WP_DISABLE_DELETE=true). Tool "${toolName}" is not allowed.`);
   }
 }
 
 function enforcePluginManagement(toolName) {
   const pluginWriteTools = ['wp_activate_plugin', 'wp_deactivate_plugin'];
-  if (process.env.WP_DISABLE_PLUGIN_MANAGEMENT === 'true' && pluginWriteTools.includes(toolName)) {
+  if (getActiveControls().disable_plugin_management && pluginWriteTools.includes(toolName)) {
     throw new Error(`Blocked: Plugin management is disabled (WP_DISABLE_PLUGIN_MANAGEMENT=true). Tool "${toolName}" is not allowed.`);
   }
 }
 
 function enforceDraftOnly(status) {
-  if (process.env.WP_DRAFT_ONLY === 'true' && status && status !== 'draft' && status !== 'pending') {
+  if (getActiveControls().draft_only && status && status !== 'draft' && status !== 'pending') {
     throw new Error(`Blocked: Server is in DRAFT-ONLY mode (WP_DRAFT_ONLY=true). Only "draft" and "pending" statuses are allowed, got "${status}".`);
   }
 }
@@ -98,6 +107,55 @@ function enforceAllowedStatuses(status) {
   }
 }
 
+// ── Per-target controls merge (OR strict) ──
+
+function getActiveControls() {
+  const tc = currentTarget?.controls || {};
+  const globalMaxCpm = parseInt(process.env.WP_MAX_CALLS_PER_MINUTE || '0', 10);
+  const targetMaxCpm = tc.max_calls_per_minute || 0;
+  let effectiveMaxCpm;
+  if (globalMaxCpm > 0 && targetMaxCpm > 0) effectiveMaxCpm = Math.min(globalMaxCpm, targetMaxCpm);
+  else if (globalMaxCpm > 0) effectiveMaxCpm = globalMaxCpm;
+  else if (targetMaxCpm > 0) effectiveMaxCpm = targetMaxCpm;
+  else effectiveMaxCpm = 0;
+
+  return {
+    read_only: process.env.WP_READ_ONLY === 'true' || tc.read_only === true,
+    draft_only: process.env.WP_DRAFT_ONLY === 'true' || tc.draft_only === true,
+    disable_delete: process.env.WP_DISABLE_DELETE === 'true' || tc.disable_delete === true,
+    disable_plugin_management: process.env.WP_DISABLE_PLUGIN_MANAGEMENT === 'true' || tc.disable_plugin_management === true,
+    require_approval: process.env.WP_REQUIRE_APPROVAL === 'true' || tc.require_approval === true,
+    confirm_destructive: process.env.WP_CONFIRM_DESTRUCTIVE === 'true' || tc.confirm_destructive === true,
+    max_calls_per_minute: effectiveMaxCpm,
+  };
+}
+
+function getControlSources() {
+  const tc = currentTarget?.controls || {};
+  const src = (g, t) => (g && t) ? 'both' : g ? 'global' : t ? 'target' : 'none';
+  const globalMaxCpm = parseInt(process.env.WP_MAX_CALLS_PER_MINUTE || '0', 10);
+  const targetMaxCpm = tc.max_calls_per_minute || 0;
+  return {
+    read_only_source: src(process.env.WP_READ_ONLY === 'true', tc.read_only === true),
+    draft_only_source: src(process.env.WP_DRAFT_ONLY === 'true', tc.draft_only === true),
+    disable_delete_source: src(process.env.WP_DISABLE_DELETE === 'true', tc.disable_delete === true),
+    disable_plugin_management_source: src(process.env.WP_DISABLE_PLUGIN_MANAGEMENT === 'true', tc.disable_plugin_management === true),
+    require_approval_source: src(process.env.WP_REQUIRE_APPROVAL === 'true', tc.require_approval === true),
+    confirm_destructive_source: src(process.env.WP_CONFIRM_DESTRUCTIVE === 'true', tc.confirm_destructive === true),
+    max_calls_per_minute_source: (globalMaxCpm > 0 && targetMaxCpm > 0) ? 'both' : (globalMaxCpm > 0 ? 'global' : (targetMaxCpm > 0 ? 'target' : 'none')),
+  };
+}
+
+// Test helper — not part of public API
+function _testSetTarget(name, config) {
+  if (name && config) {
+    targets[name] = config;
+    currentTarget = { name, ...config };
+  } else {
+    currentTarget = null;
+  }
+}
+
 // ============================================================
 // LOGGER & AUDIT
 // ============================================================
@@ -121,7 +179,8 @@ function auditLog(entry) {
     latency_ms: entry.latency_ms,
     site: entry.site || currentTarget?.name || 'default',
     params: entry.params || {},
-    error: entry.error || null
+    error: entry.error || null,
+    ...(entry.effective_controls ? { effective_controls: entry.effective_controls } : {})
   };
   console.error(`[AUDIT] ${JSON.stringify(record)}`);
 }
@@ -376,24 +435,32 @@ const ORDERBY = ['date', 'relevance', 'id', 'title', 'slug', 'modified', 'author
 const ORDERS = ['asc', 'desc'];
 const MEDIA_TYPES = ['image', 'video', 'audio', 'application'];
 const COMMENT_STATUSES = ['approved', 'hold', 'spam', 'trash'];
-const TOOLS_COUNT = 35;
+const TOOLS_COUNT = 79;
 
 function json(data) { return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] }; }
 function strip(html) { return (html || '').replace(/<[^>]*>/g, '').trim(); }
 
 // ============================================================
-// TOOL DEFINITIONS (35 tools)
+// TOOL DEFINITIONS (56 tools)
 // ============================================================
 
 const TOOLS_DEFINITIONS = [
       // ── POSTS (6) ──
-      { name: 'wp_list_posts', description: 'List posts with filtering and search.', inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 10 }, page: { type: 'number', default: 1 }, status: { type: 'string', default: 'publish' }, orderby: { type: 'string', default: 'date' }, order: { type: 'string', default: 'desc' }, categories: { type: 'string' }, tags: { type: 'string' }, search: { type: 'string' }, author: { type: 'number' } }}},
-      { name: 'wp_get_post', description: 'Get post by ID with full content and meta.', inputSchema: { type: 'object', properties: { id: { type: 'number' } }, required: ['id'] }},
+      { name: 'wp_list_posts', description: 'List posts with filtering and search. Default "full" mode returns all fields including excerpts — use mode:"summary" for listing/inventory workflows (id, title, slug, date, status, link only), mode:"ids_only" when you only need IDs for a subsequent batch operation (e.g. then calling wp_get_post per ID). Use mode:"full" only when you need excerpts or category/tag details.', inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 10 }, page: { type: 'number', default: 1 }, status: { type: 'string', default: 'publish' }, orderby: { type: 'string', default: 'date' }, order: { type: 'string', default: 'desc' }, categories: { type: 'string' }, tags: { type: 'string' }, search: { type: 'string' }, author: { type: 'number' }, mode: { type: 'string', default: 'full', description: 'full=all fields, summary=id/title/slug/date/status/link only, ids_only=flat ID array' } }}},
+      { name: 'wp_get_post', description: 'Get post by ID. WARNING: default returns full HTML content (50,000-187,000 chars on Elementor/page-builder sites) — always specify content_format to avoid context overflow. Use content_format:"links_only" for internal linking workflows (~800 chars instead of 187,000). Use content_format:"text" for content audit/rewrite workflows (plain text truncated to 15,000 chars). Use content_format:"html" only when you need raw HTML for structure analysis. Combine with fields:["id","title","content"] for rewrite tasks or fields:["id","title","meta"] for SEO-only tasks. Prefer wp_get_seo_meta over wp_get_post when you only need SEO metadata.', inputSchema: { type: 'object', properties: { id: { type: 'number' }, fields: { type: 'array', items: { type: 'string' }, description: 'Return only specified fields (id,title,content,excerpt,slug,status,date,modified,categories,tags,author,featured_media,meta,link). Omit for all.' }, content_format: { type: 'string', default: 'html', description: 'html=raw HTML (truncated at WP_MAX_CONTENT_CHARS), text=plain text, links_only=extract internal links only' } }, required: ['id'] }},
       { name: 'wp_create_post', description: 'Create a post (default: draft).', inputSchema: { type: 'object', properties: { title: { type: 'string' }, content: { type: 'string' }, status: { type: 'string', default: 'draft' }, excerpt: { type: 'string' }, categories: { type: 'array', items: { type: 'number' } }, tags: { type: 'array', items: { type: 'number' } }, slug: { type: 'string' }, featured_media: { type: 'number' }, meta: { type: 'object' }, author: { type: 'number' } }, required: ['title', 'content'] }},
       { name: 'wp_update_post', description: 'Update a post.', inputSchema: { type: 'object', properties: { id: { type: 'number' }, title: { type: 'string' }, content: { type: 'string' }, status: { type: 'string' }, excerpt: { type: 'string' }, categories: { type: 'array', items: { type: 'number' } }, tags: { type: 'array', items: { type: 'number' } }, slug: { type: 'string' }, featured_media: { type: 'number' }, meta: { type: 'object' }, author: { type: 'number' } }, required: ['id'] }},
-      { name: 'wp_delete_post', description: 'Delete a post (trash or permanent).', inputSchema: { type: 'object', properties: { id: { type: 'number' }, force: { type: 'boolean', default: false } }, required: ['id'] }},
+      { name: 'wp_delete_post', description: 'Delete a post (trash or permanent). When WP_CONFIRM_DESTRUCTIVE=true, requires a confirmation_token (call once without to get token, then again with token).', inputSchema: { type: 'object', properties: { id: { type: 'number' }, force: { type: 'boolean', default: false }, confirmation_token: { type: 'string', description: 'Confirmation token returned by the first call when WP_CONFIRM_DESTRUCTIVE=true' } }, required: ['id'] }},
       { name: 'wp_search', description: 'Full-text search across all content.', inputSchema: { type: 'object', properties: { search: { type: 'string' }, per_page: { type: 'number', default: 10 }, type: { type: 'string', default: '' } }, required: ['search'] }},
 
+      // ── APPROVAL WORKFLOW (3) ──
+      { name: 'wp_submit_for_review', description: 'Submit a draft post for editorial review (draft → pending). Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Post ID' }, note: { type: 'string', description: 'Optional review note (stored as post meta _mcp_review_note)' } }, required: ['id'] }},
+      { name: 'wp_approve_post', description: 'Approve a pending post for publication (pending → publish). Blocked by WP_READ_ONLY and WP_DRAFT_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Post ID' } }, required: ['id'] }},
+      { name: 'wp_reject_post', description: 'Reject a pending post back to draft with a reason (pending → draft). Stores rejection reason and increments rejection count. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Post ID' }, reason: { type: 'string', description: 'Reason for rejection (stored as post meta _mcp_rejection_reason)' } }, required: ['id', 'reason'] }},
+
       // ── PAGES (4) ──
       { name: 'wp_list_pages', description: 'List pages with hierarchy.', inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 10 }, page: { type: 'number', default: 1 }, status: { type: 'string', default: 'publish' }, parent: { type: 'number' }, orderby: { type: 'string', default: 'menu_order' }, order: { type: 'string', default: 'asc' }, search: { type: 'string' } }}},
       { name: 'wp_get_page', description: 'Get page by ID with content and template.', inputSchema: { type: 'object', properties: { id: { type: 'number' } }, required: ['id'] }},
@@ -430,11 +497,11 @@ const TOOLS_DEFINITIONS = [
         inputSchema: { type: 'object', properties: {} }},
 
       // ── SEO METADATA (3) ──
-      { name: 'wp_get_seo_meta', description: 'Get SEO metadata (title, description, focus keyword, robots, canonical, og) for a post or page. Auto-detects Yoast SEO, RankMath, SEOPress, or All in One SEO.',
+      { name: 'wp_get_seo_meta', description: 'Get SEO metadata (title, description, focus keyword, robots, canonical, og) for a post or page. Auto-detects Yoast SEO, RankMath, SEOPress, or All in One SEO. Preferred over wp_get_post for SEO-only workflows — no HTML content loaded.',
         inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Post or page ID' }, post_type: { type: 'string', default: 'post', description: 'post or page' } }, required: ['id'] }},
       { name: 'wp_update_seo_meta', description: 'Update SEO metadata (title, description, focus keyword) for a post or page. Auto-detects installed SEO plugin.',
         inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Post or page ID' }, 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', description: 'Canonical URL' }, robots_noindex: { type: 'boolean', description: 'Set noindex' }, robots_nofollow: { type: 'boolean', description: 'Set nofollow' } }, required: ['id'] }},
-      { name: 'wp_audit_seo', description: 'Audit SEO metadata across multiple posts/pages. Returns missing titles, descriptions, keywords, and quality scores.',
+      { name: 'wp_audit_seo', description: 'Audit SEO metadata across multiple posts/pages. Returns scores and issue flags only — never loads post content, safe for bulk operations.',
         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' } }}},
 
       // ── PLUGINS (3) ──
@@ -458,8 +525,114 @@ const TOOLS_DEFINITIONS = [
         inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post or page ID' }, revision_id: { type: 'number', description: 'Revision ID' }, post_type: { type: 'string', enum: ['post', 'page'], default: 'post', description: 'Post type' } }, required: ['post_id', 'revision_id'] }},
       { name: 'wp_restore_revision', description: 'Restore a post or page to a previous revision. Copies revision content back to the post. Blocked by WP_READ_ONLY.',
         inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post or page ID' }, revision_id: { type: 'number', description: 'Revision ID to restore' }, post_type: { type: 'string', enum: ['post', 'page'], default: 'post', description: 'Post type' } }, required: ['post_id', 'revision_id'] }},
-  { name: 'wp_delete_revision', description: 'Permanently delete a revision. This action cannot be undone. Blocked by WP_READ_ONLY and WP_DISABLE_DELETE.',
-    inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post or page ID' }, revision_id: { type: 'number', description: 'Revision ID to delete' }, post_type: { type: 'string', enum: ['post', 'page'], default: 'post', description: 'Post type' } }, required: ['post_id', 'revision_id'] }}
+  { name: 'wp_delete_revision', description: 'Permanently delete a revision. This action cannot be undone. Blocked by WP_READ_ONLY and WP_DISABLE_DELETE. When WP_CONFIRM_DESTRUCTIVE=true, requires a confirmation_token.',
+    inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post or page ID' }, revision_id: { type: 'number', description: 'Revision ID to delete' }, post_type: { type: 'string', enum: ['post', 'page'], default: 'post', description: 'Post type' }, confirmation_token: { type: 'string', description: 'Confirmation token returned by the first call when WP_CONFIRM_DESTRUCTIVE=true' } }, required: ['post_id', 'revision_id'] }},
+
+      // ── LINK ANALYSIS (2) ──
+      { name: 'wp_analyze_links', description: 'Analyze internal and external links in a post. Optionally checks for broken internal links via HEAD requests (read-only).',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post ID to analyze' }, check_broken: { type: 'boolean', default: true, description: 'Check broken internal links via HEAD request' }, timeout_ms: { type: 'number', default: 5000, description: 'Timeout per HEAD request in ms' } }, required: ['post_id'] }},
+      { name: 'wp_suggest_internal_links', description: 'Suggest internal links for a post based on keyword relevance, shared categories, and content freshness (read-only). Use before wp_get_post with content_format:"links_only" to map existing links first.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post ID to get suggestions for' }, max_suggestions: { type: 'number', default: 5, description: 'Number of suggestions (1-10)' }, focus_keywords: { type: 'array', items: { type: 'string' }, description: 'Additional keywords to match against' }, exclude_already_linked: { type: 'boolean', default: true, description: 'Exclude posts already linked from the current post' } }, required: ['post_id'] }},
+
+      // ── WOOCOMMERCE (6) ──
+      { name: 'wc_list_products', description: 'List WooCommerce products with filtering and search. Requires WC_CONSUMER_KEY and WC_CONSUMER_SECRET. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 10 }, page: { type: 'number', default: 1 }, status: { type: 'string', default: 'any', description: 'any, draft, pending, private, publish' }, search: { type: 'string' }, category: { type: 'number', description: 'Category ID' }, orderby: { type: 'string', default: 'date', description: 'date, id, title, price, popularity' }, order: { type: 'string', default: 'desc', description: 'asc or desc' } }}},
+      { name: 'wc_get_product', description: 'Get a WooCommerce product by ID with full details. Includes variations summary for variable products. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Product ID' } }, required: ['id'] }},
+      { name: 'wc_list_orders', description: 'List WooCommerce orders with filtering. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 10 }, page: { type: 'number', default: 1 }, status: { type: 'string', default: 'any', description: 'any, pending, processing, on-hold, completed, cancelled, refunded, failed' }, customer: { type: 'number', description: 'Customer ID' }, orderby: { type: 'string', default: 'date' }, order: { type: 'string', default: 'desc' } }}},
+      { name: 'wc_get_order', description: 'Get a WooCommerce order by ID with full details including line items, shipping, billing, and payment info. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Order ID' } }, required: ['id'] }},
+      { name: 'wc_list_customers', description: 'List WooCommerce customers with search and filtering. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 10 }, page: { type: 'number', default: 1 }, search: { type: 'string' }, orderby: { type: 'string', default: 'date_created' }, order: { type: 'string', default: 'desc' }, role: { type: 'string', default: 'customer' } }}},
+      { name: 'wc_price_guardrail', description: 'Analyze a product price change without modifying anything. Returns safe/unsafe assessment based on threshold percentage. Always allowed even in WP_READ_ONLY mode.',
+        inputSchema: { type: 'object', properties: { product_id: { type: 'number', description: 'Product ID' }, new_price: { type: 'number', description: 'Proposed new price' }, threshold_percent: { type: 'number', default: 20, description: 'Maximum allowed change percentage (default 20)' } }, required: ['product_id', 'new_price'] }},
+
+      // ── WOOCOMMERCE INTELLIGENCE (4) ──
+      { name: 'wc_inventory_alert', description: 'Identify low-stock and out-of-stock products below a threshold, sorted by urgency. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { threshold: { type: 'number', default: 5, description: 'Stock quantity threshold (default 5)' }, per_page: { type: 'number', default: 50, description: 'Products to scan (max 100)' }, include_out_of_stock: { type: 'boolean', default: true, description: 'Include out-of-stock products' } }}},
+      { name: 'wc_order_intelligence', description: 'Analyze customer purchase history: lifetime value, average order, favourite products, order frequency, status breakdown. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { customer_id: { type: 'number', description: 'Customer ID' } }, required: ['customer_id'] }},
+      { name: 'wc_seo_product_audit', description: 'Audit WooCommerce product listings for SEO issues (missing descriptions, images, alt text, generic slugs, missing price). Returns per-product scores. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 20, description: 'Products to audit (max 100)' }, page: { type: 'number', default: 1 } }}},
+      { name: 'wc_suggest_product_links', description: 'Suggest WooCommerce products to link from a WordPress blog post based on SEO keyword relevance. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'WordPress post ID' }, max_suggestions: { type: 'number', default: 3, description: 'Maximum suggestions (1-5)' } }, required: ['post_id'] }},
+
+      // ── WOOCOMMERCE WRITE (3) ──
+      { name: 'wc_update_product', description: 'Update a WooCommerce product. Includes automatic price guardrail: price changes >20% require price_guardrail_confirmed=true. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Product ID' }, name: { type: 'string' }, description: { type: 'string' }, short_description: { type: 'string' }, regular_price: { type: 'string', description: 'Format "19.99"' }, sale_price: { type: 'string' }, status: { type: 'string', description: 'publish, draft, or private' }, price_guardrail_confirmed: { type: 'boolean', default: false, description: 'Set true to bypass price guardrail after calling wc_price_guardrail' } }, required: ['id'] }},
+      { name: 'wc_update_stock', description: 'Update stock quantity of a WooCommerce product or variation. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Product ID' }, stock_quantity: { type: 'number', description: 'New stock quantity (>= 0)' }, variation_id: { type: 'number', description: 'Variation ID (for variable products)' } }, required: ['id', 'stock_quantity'] }},
+      { name: 'wc_update_order_status', description: 'Update WooCommerce order status with transition validation. Blocked by WP_READ_ONLY.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Order ID' }, status: { type: 'string', description: 'New status (processing, completed, cancelled, refunded, on-hold, failed)' }, note: { type: 'string', description: 'Optional internal note added to the order' } }, required: ['id', 'status'] }},
+
+      // ── SEO ADVANCED (3) ──
+      { name: 'wp_audit_media_seo', description: 'Audit media library images for SEO issues (missing alt text, filename-as-alt, alt too short). Optionally scans post content for inline images. Read-only.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 50, description: 'Media items to audit (max 100)' }, page: { type: 'number', default: 1 }, post_id: { type: 'number', description: 'Optional: also scan inline images from this post' } }}},
+      { name: 'wp_find_orphan_pages', description: 'Find published pages with no internal links pointing to them from other pages. Read-only.',
+        inputSchema: { type: 'object', properties: { per_page: { type: 'number', default: 100, description: 'Pages to scan (max 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', description: 'Audit heading hierarchy (H1-H6) of a post or page for SEO issues: H1 in content, level skips, empty headings, keyword stuffing. Read-only.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Post or page ID' }, post_type: { type: 'string', default: 'post', description: 'post or page' }, focus_keyword: { type: 'string', description: 'Optional keyword to check in H2 headings' } }, required: ['id'] }},
+
+      // ── SEO ADVANCED v4.1 (3) ──
+      { name: 'wp_find_thin_content', description: 'Find thin/low-quality published posts: too short, outdated, uncategorized. Classifies severity and suggests actions. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', default: 100, description: 'Max posts to scan (1-500)' }, 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', description: 'Audit canonical URLs for SEO issues: missing, HTTP on HTTPS site, staging URLs, wrong domain, trailing slash mismatch. Auto-detects SEO plugin. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', default: 50, description: 'Max posts to audit (1-200)' }, 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', description: 'Analyze E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) signals for posts. Scores 0-100 with actionable priority fixes. Read-only.',
+        inputSchema: { type: 'object', properties: { post_ids: { type: 'array', items: { type: 'number' }, description: 'Specific post IDs to analyze (if empty, audits latest N)' }, limit: { type: 'number', default: 10, description: 'Number of latest posts to audit (1-50)' }, 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' } }}},
+
+      // ── SEO ADVANCED v4.2 (4) ──
+      { name: 'wp_find_broken_internal_links', description: 'Scan published posts, extract all internal links and verify accessibility via HEAD requests. Detects 404s, 301/302 redirects, timeouts and network errors. Configurable batching to avoid overloading WordPress. Read-only.',
+        inputSchema: { type: 'object', properties: { limit_posts: { type: 'number', default: 20, description: 'Max posts to scan (1-100)' }, 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', description: 'Detect articles targeting the same SEO focus keywords, creating internal competition that dilutes authority. Returns cannibalization groups with recommended actions. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', default: 200, description: 'Max posts to analyze (1-500)' }, 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', description: 'Audit categories and tags for taxonomy bloat: empty tags, single-post tags, near-duplicate terms, categories without SEO description. These archive pages create crawl waste for Googlebot. Read-only.',
+        inputSchema: { type: 'object', properties: { check_tags: { type: 'boolean', default: true, description: 'Audit tags' }, check_categories: { type: 'boolean', default: true, description: 'Audit categories' }, 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', description: 'Analyze outbound (external) links in published posts. Detects posts without external sources, posts with too many outbound links (dilution), and identifies most-cited domains. Good outbound link profile improves E-E-A-T credibility. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', default: 30, description: 'Max posts to audit (1-100)' }, 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' } }}},
+
+      // ── CONTENT INTELLIGENCE v4.4 (2) ──
+      { name: 'wp_get_content_brief', description: 'Aggregate a complete editorial/SEO brief for a single post or page in one call: word count, readability score, heading structure, internal/external links, SEO metadata, content sections (intro, conclusion, FAQ, lists, tables, images), categories and tags resolved to names. Read-only.',
+        inputSchema: { type: 'object', properties: { id: { type: 'number', description: 'Post or page ID' }, post_type: { type: 'string', default: 'post', description: 'post or page' } }, required: ['id'] }},
+      { name: 'wp_extract_post_outline', description: 'Extract heading structure (H1-H4) from N posts in a category to build a reference outline. Returns per-post outlines with word counts, aggregated stats, and common H2 patterns ranked by frequency. Read-only.',
+        inputSchema: { type: 'object', properties: { category_id: { type: 'number', description: 'Category ID to analyze' }, post_type: { type: 'string', default: 'post', description: 'post or page' }, limit: { type: 'number', default: 10, description: 'Max posts to analyze (1-50)' } }, required: ['category_id'] }},
+
+      // ── CONTENT INTELLIGENCE v4.4 Week 2 (3) ──
+      { name: 'wp_audit_readability', description: 'Audit Flesch-Kincaid FR readability in bulk across N published posts. Returns per-post scores, transition word density, passive voice ratio, issues flagged, and aggregated distribution. Sorted worst-first. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to analyze (1-200, default 50)' }, post_type: { type: 'string', enum: ['post', 'page'], description: 'post or page (default post)' }, category_id: { type: 'number', description: 'Optional: filter by category ID' }, min_words: { type: 'number', description: 'Minimum word count to include (default 100)' } }}},
+      { name: 'wp_audit_update_frequency', description: 'Find posts not modified in X days, cross-referenced with SEO metadata quality to prioritize content refreshes. Sorted by priority (age x SEO gap). Read-only.',
+        inputSchema: { type: 'object', properties: { days_threshold: { type: 'number', description: 'Flag posts not modified in X days (default 180)' }, limit: { type: 'number', description: 'Max posts to analyze (1-200, default 50)' }, post_type: { type: 'string', enum: ['post', 'page'], description: 'post or page (default post)' }, include_seo_score: { type: 'boolean', description: 'Cross-reference with SEO metadata quality (default true)' } }}},
+      { name: 'wp_build_link_map', description: 'Build a complete internal linking matrix with simplified PageRank scoring. Identifies orphan posts, inbound/outbound counts, and generates a sparse adjacency matrix. Read-only.',
+        inputSchema: { type: 'object', properties: { post_type: { type: 'string', enum: ['post', 'page', 'both'], description: 'post, page, or both (default post)' }, limit: { type: 'number', description: 'Max posts to analyze (1-200, default 50)' }, category_id: { type: 'number', description: 'Optional: filter by category ID' } }}},
+
+      // ── CONTENT INTELLIGENCE v4.4 Week 3 (3) ──
+      { name: 'wp_audit_anchor_texts', description: 'Audit internal link anchor text diversity and relevance across N posts. Detects generic anchors, over-optimized anchors, image links without text. Sorted by diversity score ASC. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to analyze (1-200, default 50)' }, post_type: { type: 'string', enum: ['post', 'page', 'both'], description: 'post, page, or both (default post)' } }}},
+      { name: 'wp_audit_schema_markup', description: 'Detect and validate JSON-LD schema.org blocks in post HTML. Checks Article, FAQPage, HowTo, LocalBusiness, BreadcrumbList types for required fields. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to analyze (1-200, default 50)' }, post_type: { type: 'string', enum: ['post', 'page', 'both'], description: 'post, page, or both (default post)' } }}},
+      { name: 'wp_audit_content_structure', description: 'Analyze editorial structure: intro/conclusion/FAQ presence, heading density, lists, tables, images, paragraphs. Scores 0-100. Sorted by structure score ASC. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to analyze (1-200, default 50)' }, post_type: { type: 'string', enum: ['post', 'page', 'both'], description: 'post, page, or both (default post)' }, category_id: { type: 'number', description: 'Optional: filter by category ID' } }}},
+
+      // ── CONTENT INTELLIGENCE v4.4 Batch 4A (4) ──
+      { name: 'wp_find_duplicate_content', description: 'Detect near-duplicate content via TF-IDF cosine similarity. Returns duplicate pairs with severity and clusters. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to analyze (1-100, default 50)' }, post_type: { type: 'string', enum: ['post', 'page'], description: 'post or page (default post)' }, category_id: { type: 'number', description: 'Optional: filter by category ID' }, similarity_threshold: { type: 'number', description: 'Minimum similarity to flag (0.0-1.0, default 0.7)' } }}},
+      { name: 'wp_find_content_gaps', description: 'Identify taxonomy terms (categories/tags) with too few posts — content creation opportunities. Read-only.',
+        inputSchema: { type: 'object', properties: { min_posts: { type: 'number', description: 'Minimum posts per term to NOT be flagged (default 3)' }, taxonomy: { type: 'string', enum: ['category', 'post_tag', 'both'], description: 'Taxonomy to analyze (default both)' }, exclude_empty: { type: 'boolean', description: 'Exclude terms with 0 posts (default false)' } }}},
+      { name: 'wp_extract_faq_blocks', description: 'Inventory all FAQ blocks: JSON-LD FAQPage, Gutenberg Yoast/RankMath blocks, HTML Q&A patterns. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to scan (1-200, default 50)' }, post_type: { type: 'string', enum: ['post', 'page', 'both'], description: 'post, page, or both (default post)' } }}},
+      { name: 'wp_audit_cta_presence', description: 'Detect CTA presence per post: contact links, forms, buttons, phone links, quote requests, signup links. Scores 0-100. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to analyze (1-200, default 50)' }, post_type: { type: 'string', enum: ['post', 'page', 'both'], description: 'post, page, or both (default post)' }, category_id: { type: 'number', description: 'Optional: filter by category ID' } }}},
+
+      // ── CONTENT INTELLIGENCE v4.4 Batch 4B (4) ──
+      { name: 'wp_extract_entities', description: 'Extract named entities (brands, locations, persons, organizations) from posts using regex heuristics. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to analyze (1-100, default 20)' }, post_type: { type: 'string', enum: ['post', 'page'], description: 'post or page (default post)' }, min_occurrences: { type: 'number', description: 'Minimum total occurrences across corpus (default 2)' } }}},
+      { name: 'wp_get_publishing_velocity', description: 'Analyze publishing cadence by author and category over configurable periods. Read-only.',
+        inputSchema: { type: 'object', properties: { periods: { type: 'string', description: "Comma-separated day periods (default '30,90,180')" }, post_type: { type: 'string', enum: ['post', 'page'], description: 'post or page (default post)' }, limit: { type: 'number', description: 'Max posts to fetch (1-500, default 200)' } }}},
+      { name: 'wp_compare_revisions_diff', description: 'Diff between two post revisions: lines/words added/removed, headings diff, amplitude score. Read-only.',
+        inputSchema: { type: 'object', properties: { post_id: { type: 'number', description: 'Post or page ID' }, revision_id_from: { type: 'number', description: 'Older revision ID (baseline)' }, revision_id_to: { type: 'number', description: 'Newer revision ID (omit for current post)' }, post_type: { type: 'string', enum: ['post', 'page'], description: 'post or page (default post)' } }, required: ['post_id', 'revision_id_from'] }},
+      { name: 'wp_list_posts_by_word_count', description: 'List posts sorted by word count with automatic length segmentation and distribution stats. Read-only.',
+        inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'Max posts to analyze (1-500, default 100)' }, post_type: { type: 'string', enum: ['post', 'page', 'both'], description: 'post, page, or both (default post)' }, order: { type: 'string', enum: ['asc', 'desc'], description: 'Sort order by word count (default desc)' }, category_id: { type: 'number', description: 'Optional: filter by category ID' } }}}
 ];
 
 function registerHandlers(s) {
@@ -498,21 +671,34 @@ export async function handleToolCall(request) {
       // ── POSTS ──
 
       case 'wp_list_posts': {
-        validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, page: { type: 'number', min: 1 }, status: { type: 'string', enum: STATUSES }, orderby: { type: 'string', enum: ORDERBY }, order: { type: 'string', enum: ORDERS } });
-        const { per_page = 10, page = 1, status = 'publish', orderby = 'date', order = 'desc', categories, tags, search, author } = args;
+        validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, page: { type: 'number', min: 1 }, status: { type: 'string', enum: STATUSES }, orderby: { type: 'string', enum: ORDERBY }, order: { type: 'string', enum: ORDERS }, mode: { type: 'string', enum: ['full', 'summary', 'ids_only'] } });
+        const { per_page = 10, page = 1, status = 'publish', orderby = 'date', order = 'desc', categories, tags, search, author, mode = 'full' } = args;
         let ep = `/posts?per_page=${per_page}&page=${page}&status=${status}&orderby=${orderby}&order=${order}`;
         if (categories) ep += `&categories=${categories}`; if (tags) ep += `&tags=${tags}`;
         if (search) ep += `&search=${encodeURIComponent(search)}`; if (author) ep += `&author=${author}`;
         const posts = await wpApiCall(ep);
-        result = json({ total: posts.length, page, posts: posts.map(p => ({ id: p.id, title: p.title.rendered, status: p.status, date: p.date, modified: p.modified, link: p.link, author: p.author, categories: p.categories, tags: p.tags, excerpt: strip(p.excerpt.rendered).substring(0, 200) })) });
+        let listResult;
+        if (mode === 'ids_only') {
+          listResult = { total: posts.length, page, mode: 'ids_only', ids: posts.map(p => p.id) };
+        } else if (mode === 'summary') {
+          listResult = { total: posts.length, page, mode: 'summary', posts: posts.map(p => ({ id: p.id, title: p.title.rendered, slug: p.slug, date: p.date, status: p.status, link: p.link })) };
+        } else {
+          listResult = { total: posts.length, page, posts: posts.map(p => ({ id: p.id, title: p.title.rendered, status: p.status, date: p.date, modified: p.modified, link: p.link, author: p.author, categories: p.categories, tags: p.tags, excerpt: strip(p.excerpt.rendered).substring(0, 200) })) };
+        }
+        result = json(listResult);
         auditLog({ tool: name, action: 'list', status: 'success', latency_ms: Date.now() - t0, params: sanitizeParams(args) });
         break;
       }
 
       case 'wp_get_post': {
-        validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+        validateInput(args, { id: { type: 'number', required: true, min: 1 }, fields: { type: 'array' }, content_format: { type: 'string', enum: ['html', 'text', 'links_only'] } });
+        const { content_format = 'html', fields: requestedFields } = args;
         const p = await wpApiCall(`/posts/${args.id}`);
-        result = json({ id: p.id, title: p.title.rendered, content: p.content.rendered, excerpt: p.excerpt.rendered, status: p.status, date: p.date, modified: p.modified, link: p.link, slug: p.slug, categories: p.categories, tags: p.tags, author: p.author, featured_media: p.featured_media, comment_status: p.comment_status, meta: p.meta || {} });
+        let postData = { id: p.id, title: p.title.rendered, content: p.content.rendered, excerpt: p.excerpt.rendered, status: p.status, date: p.date, modified: p.modified, link: p.link, slug: p.slug, categories: p.categories, tags: p.tags, author: p.author, featured_media: p.featured_media, comment_status: p.comment_status, meta: p.meta || {} };
+        const { url: siteUrl } = getActiveAuth();
+        postData = applyContentFormat(postData, content_format, siteUrl);
+        if (requestedFields && requestedFields.length > 0) postData = summarizePost(postData, requestedFields);
+        result = json(postData);
         auditLog({ tool: name, target: args.id, target_type: 'post', action: 'read', status: 'success', latency_ms: Date.now() - t0 });
         break;
       }
@@ -520,6 +706,10 @@ export async function handleToolCall(request) {
       case 'wp_create_post': {
         validateInput(args, { title: { type: 'string', required: true }, content: { type: 'string', required: true }, status: { type: 'string', enum: STATUSES.filter(s => s !== 'trash') } });
         enforceDraftOnly(args.status); enforceAllowedStatuses(args.status); enforceAllowedTypes('post');
+        if (getActiveControls().require_approval && args.status === 'publish') {
+          auditLog({ tool: name, target: null, target_type: 'post', action: 'create', status: 'blocked', latency_ms: Date.now() - t0, params: sanitizeParams(args), error: 'APPROVAL REQUIRED: Use wp_submit_for_review then wp_approve_post' });
+          return { content: [{ type: 'text', text: 'Error: APPROVAL REQUIRED: Use wp_submit_for_review then wp_approve_post' }], isError: true };
+        }
         const { title, content, status = 'draft', excerpt, categories, tags, slug, featured_media, meta, author } = args;
         const data = { title, content, status };
         if (excerpt) data.excerpt = excerpt; if (categories) data.categories = categories; if (tags) data.tags = tags;
@@ -533,6 +723,10 @@ export async function handleToolCall(request) {
       case 'wp_update_post': {
         validateInput(args, { id: { type: 'number', required: true, min: 1 }, status: { type: 'string', enum: STATUSES } });
         if (args.status) { enforceDraftOnly(args.status); enforceAllowedStatuses(args.status); }
+        if (getActiveControls().require_approval && args.status === 'publish') {
+          auditLog({ tool: name, target: args.id, target_type: 'post', action: 'update', status: 'blocked', latency_ms: Date.now() - t0, params: sanitizeParams(args), error: 'APPROVAL REQUIRED: Use wp_submit_for_review then wp_approve_post' });
+          return { content: [{ type: 'text', text: 'Error: APPROVAL REQUIRED: Use wp_submit_for_review then wp_approve_post' }], isError: true };
+        }
         const { id, ...upd } = args;
         const up = await wpApiCall(`/posts/${id}`, { method: 'POST', body: JSON.stringify(upd) });
         result = json({ success: true, message: `Post ${id} updated`, post: { id: up.id, title: up.title.rendered, status: up.status, link: up.link, modified: up.modified } });
@@ -542,10 +736,31 @@ export async function handleToolCall(request) {
 
       case 'wp_delete_post': {
         validateInput(args, { id: { type: 'number', required: true, min: 1 } });
-        const { id, force = false } = args;
+        const { id, force = false, confirmation_token } = args;
+        const deleteAction = force ? 'permanent_delete' : 'trash';
+
+        // Two-step confirmation when WP_CONFIRM_DESTRUCTIVE=true
+        if (getActiveControls().confirm_destructive) {
+          if (!confirmation_token) {
+            // Step 1: return confirmation_required with token
+            const p = await wpApiCall(`/posts/${id}`);
+            const token = generateToken(id, deleteAction);
+            const verb = force ? 'permanently deleted' : 'trashed';
+            result = json({ status: 'confirmation_required', post_id: id, post_title: p.title?.rendered || `Post #${id}`, action: deleteAction, confirmation_token: token, expires_in: 60, message: `Post #${id} '${p.title?.rendered || ''}' will be ${verb}. Call again with confirmation_token to confirm.` });
+            auditLog({ tool: name, target: id, target_type: 'post', action: 'delete_requested', status: 'pending', latency_ms: Date.now() - t0, params: { id, force } });
+            break;
+          }
+          // Step 2: validate token then execute
+          const validation = validateToken(confirmation_token, id, deleteAction);
+          if (!validation.valid) {
+            auditLog({ tool: name, target: id, target_type: 'post', action: deleteAction, status: 'error', latency_ms: Date.now() - t0, params: { id, force }, error: 'Invalid or expired confirmation token' });
+            return { content: [{ type: 'text', text: 'Error: Invalid or expired confirmation token' }], isError: true };
+          }
+        }
+
         const dp = await wpApiCall(`/posts/${id}${force ? '?force=true' : ''}`, { method: 'DELETE' });
         result = json({ success: true, message: force ? `Post ${id} permanently deleted` : `Post ${id} trashed`, post: { id: dp.id, title: dp.title?.rendered || dp.previous?.title?.rendered, status: force ? 'deleted' : 'trash' } });
-        auditLog({ tool: name, target: id, target_type: 'post', action: force ? 'permanent_delete' : 'trash', status: 'success', latency_ms: Date.now() - t0 });
+        auditLog({ tool: name, target: id, target_type: 'post', action: deleteAction, status: 'success', latency_ms: Date.now() - t0 });
         break;
       }
 
@@ -751,8 +966,9 @@ export async function handleToolCall(request) {
         const prev = currentTarget?.name || 'default';
         currentTarget = { name: site, ...targets[site] };
         log.info(`Target switched: ${prev} → ${site} (${currentTarget.url})`);
-        result = json({ success: true, message: `Active site: ${site}`, previous: prev, current: { name: site, url: currentTarget.url } });
-        auditLog({ tool: name, action: 'switch_target', status: 'success', latency_ms: Date.now() - t0, params: { from: prev, to: site } });
+        const effectiveControls = getActiveControls();
+        result = json({ success: true, message: `Active site: ${site}`, previous: prev, current: { name: site, url: currentTarget.url }, effective_controls: effectiveControls });
+        auditLog({ tool: name, action: 'switch_target', status: 'success', latency_ms: Date.now() - t0, params: { from: prev, to: site }, effective_controls: effectiveControls });
         break;
       }
 
@@ -774,12 +990,17 @@ export async function handleToolCall(request) {
           site: { name: si.name, description: si.description, url: si.url || baseUrl, gmt_offset: si.gmt_offset, timezone_string: si.timezone_string },
           current_user: u ? { id: u.id, name: u.name, slug: u.slug, roles: u.roles } : null,
           post_types: postTypes,
-          enterprise_controls: {
-            read_only: process.env.WP_READ_ONLY === 'true', draft_only: process.env.WP_DRAFT_ONLY === 'true', delete_disabled: process.env.WP_DISABLE_DELETE === 'true', plugin_management_disabled: process.env.WP_DISABLE_PLUGIN_MANAGEMENT === 'true',
-            rate_limit: MAX_CALLS_PER_MINUTE > 0 ? `${MAX_CALLS_PER_MINUTE}/min` : 'unlimited',
-            allowed_types: ALLOWED_TYPES || 'all', allowed_statuses: ALLOWED_STATUSES || 'all',
-            audit_log: AUDIT_LOG
-          },
+          enterprise_controls: (() => {
+            const c = getActiveControls();
+            const s = getControlSources();
+            return {
+              read_only: c.read_only, draft_only: c.draft_only, delete_disabled: c.disable_delete, plugin_management_disabled: c.disable_plugin_management, require_approval: c.require_approval, confirm_destructive: c.confirm_destructive,
+              rate_limit: c.max_calls_per_minute > 0 ? `${c.max_calls_per_minute}/min` : 'unlimited',
+              allowed_types: ALLOWED_TYPES || 'all', allowed_statuses: ALLOWED_STATUSES || 'all',
+              audit_log: AUDIT_LOG,
+              ...s
+            };
+          })(),
           multi_target: {
             enabled: isMultiTarget, active_site: currentTarget?.name || 'default',
             available_sites: Object.keys(targets)
@@ -1282,8 +1503,24 @@ export async function handleToolCall(request) {
           revision_id: { type: 'number', required: true, min: 1 },
           post_type: { type: 'string', enum: ['post', 'page'] }
         });
-        const { post_id, revision_id, post_type = 'post' } = args;
+        const { post_id, revision_id, post_type = 'post', confirmation_token } = args;
         const base = post_type === 'page' ? 'pages' : 'posts';
+
+        // Two-step confirmation when WP_CONFIRM_DESTRUCTIVE=true
+        if (getActiveControls().confirm_destructive) {
+          if (!confirmation_token) {
+            const token = generateToken(revision_id, 'delete_revision');
+            result = json({ status: 'confirmation_required', revision_id, post_id, action: 'delete_revision', confirmation_token: token, expires_in: 60, message: `Revision #${revision_id} of post #${post_id} will be permanently deleted. Call again with confirmation_token to confirm.` });
+            auditLog({ tool: name, target: revision_id, target_type: 'revision', action: 'delete_requested', status: 'pending', latency_ms: Date.now() - t0, params: { post_id, revision_id } });
+            break;
+          }
+          const validation = validateToken(confirmation_token, revision_id, 'delete_revision');
+          if (!validation.valid) {
+            auditLog({ tool: name, target: revision_id, target_type: 'revision', action: 'delete_revision', status: 'error', latency_ms: Date.now() - t0, params: { post_id, revision_id }, error: 'Invalid or expired confirmation token' });
+            return { content: [{ type: 'text', text: 'Error: Invalid or expired confirmation token' }], isError: true };
+          }
+        }
+
         try {
           await wpApiCall(`/${base}/${post_id}/revisions/${revision_id}?force=true`, { method: 'DELETE' });
           result = json({ deleted: true, revision_id, post_id, post_type });
@@ -1299,6 +1536,2889 @@ export async function handleToolCall(request) {
         break;
       }
 
+      // ── APPROVAL WORKFLOW ──
+
+      case 'wp_submit_for_review': {
+        validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+        const { id, note } = args;
+        const p = await wpApiCall(`/posts/${id}`);
+        if (p.status !== 'draft' && p.status !== 'auto-draft') {
+          throw new Error(`Post ${id} is in "${p.status}" status. Only "draft" or "auto-draft" posts can be submitted for review.`);
+        }
+        const data = { status: 'pending' };
+        if (note) data.meta = { _mcp_review_note: note };
+        const up = await wpApiCall(`/posts/${id}`, { method: 'POST', body: JSON.stringify(data) });
+        result = json({ success: true, message: `Post ${id} submitted for review`, post: { id: up.id, title: up.title.rendered, status: up.status, link: up.link } });
+        auditLog({ tool: name, target: id, target_type: 'post', action: 'submit_for_review', status: 'success', latency_ms: Date.now() - t0, params: { id } });
+        break;
+      }
+
+      case 'wp_approve_post': {
+        validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+        const { id } = args;
+        if (getActiveControls().draft_only) {
+          auditLog({ tool: name, target: id, target_type: 'post', action: 'approve', status: 'blocked', latency_ms: Date.now() - t0, params: { id }, error: 'Blocked: Server is in DRAFT-ONLY mode (WP_DRAFT_ONLY=true). Publishing is not allowed.' });
+          return { content: [{ type: 'text', text: 'Error: Blocked: Server is in DRAFT-ONLY mode (WP_DRAFT_ONLY=true). Publishing is not allowed.' }], isError: true };
+        }
+        const p = await wpApiCall(`/posts/${id}`);
+        if (p.status !== 'pending') {
+          throw new Error(`Post ${id} is in "${p.status}" status. Only "pending" posts can be approved.`);
+        }
+        const up = await wpApiCall(`/posts/${id}`, { method: 'POST', body: JSON.stringify({ status: 'publish' }) });
+        result = json({ success: true, message: `Post ${id} approved and published`, post: { id: up.id, title: up.title.rendered, status: up.status, link: up.link } });
+        auditLog({ tool: name, target: id, target_type: 'post', action: 'approve', status: 'success', latency_ms: Date.now() - t0, params: { id } });
+        break;
+      }
+
+      case 'wp_reject_post': {
+        validateInput(args, { id: { type: 'number', required: true, min: 1 }, reason: { type: 'string', required: true } });
+        const { id, reason } = args;
+        const p = await wpApiCall(`/posts/${id}`);
+        if (p.status !== 'pending') {
+          throw new Error(`Post ${id} is in "${p.status}" status. Only "pending" posts can be rejected.`);
+        }
+        const currentCount = parseInt(p.meta?._mcp_rejection_count || '0', 10);
+        const up = await wpApiCall(`/posts/${id}`, { method: 'POST', body: JSON.stringify({ status: 'draft', meta: { _mcp_rejection_reason: reason, _mcp_rejection_count: currentCount + 1 } }) });
+        result = json({ success: true, message: `Post ${id} rejected and moved to draft`, post: { id: up.id, title: up.title.rendered, status: up.status }, rejection: { reason, count: currentCount + 1 } });
+        auditLog({ tool: name, target: id, target_type: 'post', action: 'reject', status: 'success', latency_ms: Date.now() - t0, params: { id } });
+        break;
+      }
+
+      // ── LINK ANALYSIS ──
+
+      case 'wp_analyze_links': {
+        validateInput(args, { post_id: { type: 'number', required: true, min: 1 }, timeout_ms: { type: 'number', min: 100 } });
+        const { post_id, check_broken = true, timeout_ms = 5000 } = args;
+        const p = await wpApiCall(`/posts/${post_id}`);
+        const content = p.content?.rendered || '';
+        const postTitle = strip(p.title?.rendered || '');
+        const { url: siteUrl } = getActiveAuth();
+        const internal_links = extractInternalLinks(content, siteUrl);
+        const external_links = extractExternalLinks(content, siteUrl);
+        let broken_count = 0, warning_count = 0, unknown_count = 0;
+        if (check_broken) {
+          const toCheck = internal_links.slice(0, 20);
+          for (const link of toCheck) {
+            const fullUrl = link.url.startsWith('/') ? `${siteUrl}${link.url}` : link.url;
+            const { status, http_code } = await checkLinkStatus(fullUrl, timeout_ms);
+            link.status = status;
+            link.http_code = http_code;
+            if (status === 'broken') broken_count++;
+            else if (status === 'warning') warning_count++;
+            else if (status === 'unknown') unknown_count++;
+          }
+          for (let i = 20; i < internal_links.length; i++) {
+            internal_links[i].status = 'unchecked';
+            internal_links[i].http_code = null;
+          }
+        } else {
+          for (const link of internal_links) { link.status = 'unchecked'; link.http_code = null; }
+        }
+        result = json({
+          post_id, post_title: postTitle, internal_links, external_links,
+          summary: { total_internal: internal_links.length, total_external: external_links.length, broken_count, warning_count, unknown_count }
+        });
+        auditLog({ tool: name, target: post_id, target_type: 'post', action: 'analyze_links', status: 'success', latency_ms: Date.now() - t0 });
+        break;
+      }
+
+      case 'wp_suggest_internal_links': {
+        validateInput(args, { post_id: { type: 'number', required: true, min: 1 }, max_suggestions: { type: 'number', min: 1, max: 10 } });
+        const { post_id, max_suggestions = 5, focus_keywords = [], exclude_already_linked = true } = args;
+        const p = await wpApiCall(`/posts/${post_id}`);
+        const content = p.content?.rendered || '';
+        const postTitle = strip(p.title?.rendered || '');
+        const postMeta = p.meta || {};
+        const postCategories = p.categories || [];
+        const { url: siteUrl } = getActiveAuth();
+
+        // Step 1 — Collect keywords
+        const seoKeyword = extractFocusKeyword(postMeta);
+        let keywords = [...(Array.isArray(focus_keywords) ? focus_keywords : [])];
+        if (seoKeyword) keywords.unshift(seoKeyword);
+        keywords = [...new Set(keywords.map(k => k.toLowerCase()))];
+        if (keywords.length === 0) {
+          keywords = postTitle.split(/\s+/).slice(0, 5).filter(w => w.length > 2).map(w => w.toLowerCase());
+        }
+
+        // Already-linked URLs
+        const linkedUrls = siteUrl ? extractInternalLinks(content, siteUrl).map(l => l.url) : [];
+
+        // Step 2 — Search for candidates (max 3 keyword searches)
+        const candidateMap = new Map();
+        for (const kw of keywords.slice(0, 3)) {
+          try {
+            const results = await wpApiCall(`/posts?search=${encodeURIComponent(kw)}&per_page=10&status=publish`);
+            if (Array.isArray(results)) {
+              for (const r of results) {
+                if (r.id !== post_id && !candidateMap.has(r.id)) candidateMap.set(r.id, r);
+              }
+            }
+          } catch { /* search failed */ }
+        }
+
+        // Step 3 — Score each candidate
+        const currentPostData = { id: post_id, categories: postCategories, linkedUrls: exclude_already_linked ? linkedUrls : [] };
+        const scored = [];
+        let excluded_count = 0;
+
+        for (const [, cand] of candidateMap) {
+          const candTitle = typeof cand.title === 'string' ? cand.title : (cand.title?.rendered || '');
+          const { total, breakdown } = calculateRelevanceScore(
+            { id: cand.id, title: candTitle, date: cand.date, categories: cand.categories || [], meta: cand.meta || {}, link: cand.link || '' },
+            currentPostData, keywords
+          );
+          if (total === -999) { excluded_count++; continue; }
+          scored.push({
+            target_post_id: cand.id, target_title: strip(candTitle), target_url: cand.link || '',
+            anchor_text: suggestAnchorText({ meta: cand.meta || {}, title: candTitle }),
+            relevance_score: total, score_breakdown: breakdown,
+            already_linked: linkedUrls.some(u => u === cand.link)
+          });
+        }
+
+        scored.sort((a, b) => b.relevance_score - a.relevance_score);
+        const suggestions = scored.slice(0, Math.min(max_suggestions, 10));
+        result = json({ post_id, post_title: postTitle, keywords_used: keywords, suggestions, excluded_already_linked: excluded_count });
+        auditLog({ tool: name, target: post_id, target_type: 'post', action: 'suggest_links', status: 'success', latency_ms: Date.now() - t0 });
+        break;
+      }
+
+      // ── WOOCOMMERCE ──
+
+      case 'wc_list_products': {
+        validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, page: { type: 'number', min: 1 } });
+        const { per_page = 10, page = 1, status = 'any', search, category, orderby = 'date', order = 'desc' } = args;
+        const { url: baseUrl } = getActiveAuth();
+        let ep = `/products?per_page=${per_page}&page=${page}&orderby=${orderby}&order=${order}`;
+        if (status && status !== 'any') ep += `&status=${status}`;
+        if (search) ep += `&search=${encodeURIComponent(search)}`;
+        if (category) ep += `&category=${category}`;
+        const products = await wcApiCall(ep, {}, baseUrl);
+        result = json({ total: products.length, page, products: products.map(p => ({ id: p.id, name: p.name, slug: p.slug, status: p.status, price: p.price, regular_price: p.regular_price, sale_price: p.sale_price, stock_status: p.stock_status, stock_quantity: p.stock_quantity, categories: (p.categories || []).map(c => ({ id: c.id, name: c.name })), image: p.images?.[0]?.src || null, permalink: p.permalink })) });
+        auditLog({ tool: name, action: 'list', target_type: 'product', status: 'success', latency_ms: Date.now() - t0, params: sanitizeParams(args) });
+        break;
+      }
+
+      case 'wc_get_product': {
+        validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+        const { url: baseUrl } = getActiveAuth();
+        const p = await wcApiCall(`/products/${args.id}`, {}, baseUrl);
+        const productData = { ...p };
+        if (p.type === 'variable' && p.variations && p.variations.length > 0) {
+          try {
+            const vars = await wcApiCall(`/products/${args.id}/variations?per_page=100`, {}, baseUrl);
+            productData.variations_detail = vars.map(v => ({ id: v.id, sku: v.sku, price: v.price, regular_price: v.regular_price, sale_price: v.sale_price, stock_status: v.stock_status, stock_quantity: v.stock_quantity, attributes: v.attributes }));
+          } catch { productData.variations_detail = []; }
+        }
+        result = json(productData);
+        auditLog({ tool: name, target: args.id, target_type: 'product', action: 'read', status: 'success', latency_ms: Date.now() - t0 });
+        break;
+      }
+
+      case 'wc_list_orders': {
+        validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, page: { type: 'number', min: 1 } });
+        const { per_page = 10, page = 1, status = 'any', customer, orderby = 'date', order = 'desc' } = args;
+        const { url: baseUrl } = getActiveAuth();
+        let ep = `/orders?per_page=${per_page}&page=${page}&orderby=${orderby}&order=${order}`;
+        if (status && status !== 'any') ep += `&status=${status}`;
+        if (customer) ep += `&customer=${customer}`;
+        const orders = await wcApiCall(ep, {}, baseUrl);
+        result = json({ total: orders.length, page, orders: orders.map(o => ({ id: o.id, number: o.number, status: o.status, date_created: o.date_created, customer_id: o.customer_id, billing_name: `${o.billing?.first_name || ''} ${o.billing?.last_name || ''}`.trim(), billing_email: o.billing?.email || '', total: o.total, currency: o.currency, line_items: (o.line_items || []).map(li => ({ name: li.name, quantity: li.quantity, total: li.total })) })) });
+        auditLog({ tool: name, action: 'list', target_type: 'order', status: 'success', latency_ms: Date.now() - t0, params: sanitizeParams(args) });
+        break;
+      }
+
+      case 'wc_get_order': {
+        validateInput(args, { id: { type: 'number', required: true, min: 1 } });
+        const { url: baseUrl } = getActiveAuth();
+        const o = await wcApiCall(`/orders/${args.id}`, {}, baseUrl);
+        result = json(o);
+        auditLog({ tool: name, target: args.id, target_type: 'order', action: 'read', status: 'success', latency_ms: Date.now() - t0 });
+        break;
+      }
+
+      case 'wc_list_customers': {
+        validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, page: { type: 'number', min: 1 } });
+        const { per_page = 10, page = 1, search, orderby = 'date_created', order = 'desc', role = 'customer' } = args;
+        const { url: baseUrl } = getActiveAuth();
+        let ep = `/customers?per_page=${per_page}&page=${page}&orderby=${orderby}&order=${order}&role=${role}`;
+        if (search) ep += `&search=${encodeURIComponent(search)}`;
+        const customers = await wcApiCall(ep, {}, baseUrl);
+        result = json({ total: customers.length, page, customers: customers.map(c => ({ id: c.id, first_name: c.first_name, last_name: c.last_name, email: c.email, date_created: c.date_created, orders_count: c.orders_count, total_spent: c.total_spent, username: c.username })) });
+        auditLog({ tool: name, action: 'list', target_type: 'customer', status: 'success', latency_ms: Date.now() - t0, params: sanitizeParams(args) });
+        break;
+      }
+
+      case 'wc_price_guardrail': {
+        validateInput(args, { product_id: { type: 'number', required: true, min: 1 }, new_price: { type: 'number', required: true }, threshold_percent: { type: 'number', min: 0 } });
+        const { product_id, new_price, threshold_percent = 20 } = args;
+        const { url: baseUrl } = getActiveAuth();
+        const p = await wcApiCall(`/products/${product_id}`, {}, baseUrl);
+        const current_price = parseFloat(p.price);
+        if (isNaN(current_price) || current_price <= 0) {
+          result = json({ safe: false, product_id, product_name: p.name, current_price: p.price, new_price, change_percent: null, message: 'Cannot evaluate: current price is zero or invalid' });
+          auditLog({ tool: name, target: product_id, target_type: 'product', action: 'price_check', status: 'success', latency_ms: Date.now() - t0, params: { new_price, threshold_percent } });
+          break;
+        }
+        const change_percent = Math.round(Math.abs(new_price - current_price) / current_price * 10000) / 100;
+        const safe = change_percent <= threshold_percent;
+        result = json({
+          safe, product_id, product_name: p.name, current_price, new_price, change_percent,
+          ...(safe
+            ? { message: 'Price change within threshold' }
+            : { requires_confirmation: true, message: `Price change of ${change_percent}% exceeds threshold of ${threshold_percent}%. Use wp_update_product with confirm=true to proceed.` })
+        });
+        auditLog({ tool: name, target: product_id, target_type: 'product', action: 'price_check', status: 'success', latency_ms: Date.now() - t0, params: { current_price, new_price, change_percent, threshold_percent, safe } });
+        break;
+      }
+
+      // ── WOOCOMMERCE INTELLIGENCE ──
+
+      case 'wc_inventory_alert': {
+        validateInput(args, { threshold: { type: 'number', min: 0 }, per_page: { type: 'number', min: 1, max: 100 } });
+        const { threshold = 5, per_page = 50, include_out_of_stock = true } = args;
+        const { url: baseUrl } = getActiveAuth();
+        const fetchSize = Math.min(per_page * 2, 100);
+        let allProducts = [];
+        const instock = await wcApiCall(`/products?stock_status=instock&per_page=${fetchSize}`, {}, baseUrl);
+        allProducts.push(...instock);
+        if (include_out_of_stock) {
+          const oos = await wcApiCall(`/products?stock_status=outofstock&per_page=${fetchSize}`, {}, baseUrl);
+          allProducts.push(...oos);
+        }
+        const alerts = allProducts.filter(p => {
+          if (p.stock_status === 'outofstock') return true;
+          if (p.stock_quantity !== null && p.stock_quantity !== undefined && p.stock_quantity <= threshold) return true;
+          return false;
+        });
+        alerts.sort((a, b) => (a.stock_quantity ?? -1) - (b.stock_quantity ?? -1));
+        const out_of_stock_count = alerts.filter(p => p.stock_status === 'outofstock').length;
+        const low_stock_count = alerts.length - out_of_stock_count;
+        result = json({
+          products: alerts.map(p => ({ id: p.id, name: p.name, sku: p.sku || '', stock_quantity: p.stock_quantity, stock_status: p.stock_status, price: p.price, permalink: p.permalink })),
+          summary: { total_alerts: alerts.length, out_of_stock_count, low_stock_count, threshold_used: threshold }
+        });
+        auditLog({ tool: name, action: 'inventory_alert', target_type: 'product', status: 'success', latency_ms: Date.now() - t0, params: { threshold, include_out_of_stock } });
+        break;
+      }
+
+      case 'wc_order_intelligence': {
+        validateInput(args, { customer_id: { type: 'number', required: true, min: 1 } });
+        const { customer_id } = args;
+        const { url: baseUrl } = getActiveAuth();
+        const orders = await wcApiCall(`/orders?customer=${customer_id}&per_page=100&orderby=date&order=desc`, {}, baseUrl);
+        const total_orders = orders.length;
+        if (total_orders === 0) {
+          result = json({ customer_id, total_orders: 0, total_spent: 0, average_order_value: 0, first_order_date: null, last_order_date: null, order_frequency_days: null, favourite_products: [], statuses_breakdown: {}, recent_orders: [] });
+          auditLog({ tool: name, target: customer_id, target_type: 'customer', action: 'order_intelligence', status: 'success', latency_ms: Date.now() - t0 });
+          break;
+        }
+        const total_spent = Math.round(orders.reduce((sum, o) => sum + parseFloat(o.total || '0'), 0) * 100) / 100;
+        const average_order_value = Math.round(total_spent / total_orders * 100) / 100;
+        const last_order_date = orders[0].date_created;
+        const first_order_date = orders[orders.length - 1].date_created;
+        let order_frequency_days = null;
+        if (total_orders > 1) {
+          const firstMs = new Date(first_order_date).getTime();
+          const lastMs = new Date(last_order_date).getTime();
+          order_frequency_days = Math.round((lastMs - firstMs) / (1000 * 60 * 60 * 24) / total_orders);
+        }
+        const productFreq = {};
+        for (const o of orders) {
+          for (const li of (o.line_items || [])) {
+            productFreq[li.name] = (productFreq[li.name] || 0) + li.quantity;
+          }
+        }
+        const favourite_products = Object.entries(productFreq).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([pname, quantity]) => ({ name: pname, quantity }));
+        const statuses_breakdown = {};
+        for (const o of orders) { statuses_breakdown[o.status] = (statuses_breakdown[o.status] || 0) + 1; }
+        const recent_orders = orders.slice(0, 5).map(o => ({ id: o.id, date: o.date_created, total: o.total, status: o.status }));
+        result = json({ customer_id, total_orders, total_spent, average_order_value, first_order_date, last_order_date, order_frequency_days, favourite_products, statuses_breakdown, recent_orders });
+        auditLog({ tool: name, target: customer_id, target_type: 'customer', action: 'order_intelligence', status: 'success', latency_ms: Date.now() - t0 });
+        break;
+      }
+
+      case 'wc_seo_product_audit': {
+        validateInput(args, { per_page: { type: 'number', min: 1, max: 100 }, page: { type: 'number', min: 1 } });
+        const { per_page = 20, page = 1 } = args;
+        const { url: baseUrl } = getActiveAuth();
+        const products = await wcApiCall(`/products?per_page=${per_page}&page=${page}&status=publish`, {}, baseUrl);
+        let totalScore = 0;
+        const audited = products.map(p => {
+          const issues = [];
+          const descText = strip(p.description || '');
+          if (descText.length === 0) issues.push('missing_description');
+          else if (descText.length < 50) issues.push('description_too_short');
+          if (!p.short_description || strip(p.short_description).length === 0) issues.push('missing_short_description');
+          if (p.slug && p.slug.includes('product-')) issues.push('generic_slug');
+          if (!p.images || p.images.length === 0 || !p.images[0]?.src) issues.push('missing_image');
+          else if (!p.images[0]?.alt || p.images[0].alt.trim() === '') issues.push('missing_image_alt');
+          if (!p.price || p.price === '') issues.push('missing_price');
+          const score = Math.max(0, 100 - issues.length * 15);
+          totalScore += score;
+          return { id: p.id, name: p.name, score, issues, permalink: p.permalink };
+        });
+        const average_score = audited.length > 0 ? Math.round(totalScore / audited.length) : 0;
+        result = json({
+          average_score, total_audited: audited.length, products: audited,
+          summary: { perfect_score_count: audited.filter(p => p.score === 100).length, needs_attention_count: audited.filter(p => p.score < 70).length }
+        });
+        auditLog({ tool: name, action: 'seo_product_audit', target_type: 'product', status: 'success', latency_ms: Date.now() - t0, params: { per_page, page, avg_score: average_score } });
+        break;
+      }
+
+      case 'wc_suggest_product_links': {
+        validateInput(args, { post_id: { type: 'number', required: true, min: 1 }, max_suggestions: { type: 'number', min: 1, max: 5 } });
+        const { post_id, max_suggestions = 3 } = args;
+        const { url: baseUrl } = getActiveAuth();
+        const post = await wpApiCall(`/posts/${post_id}`);
+        const postTitle = strip(post.title?.rendered || '');
+        const postMeta = post.meta || {};
+        const focusKw = extractFocusKeyword(postMeta);
+        const keywords = [];
+        if (focusKw) keywords.push(focusKw);
+        const titleWords = postTitle.split(/\s+/).filter(w => w.length > 3).slice(0, 3);
+        for (const w of titleWords) {
+          if (!keywords.some(k => k.toLowerCase() === w.toLowerCase())) keywords.push(w);
+        }
+        const candidateMap = new Map();
+        for (const kw of keywords.slice(0, 2)) {
+          try {
+            const prods = await wcApiCall(`/products?search=${encodeURIComponent(kw)}&per_page=10&status=publish`, {}, baseUrl);
+            if (Array.isArray(prods)) {
+              for (const p of prods) { if (!candidateMap.has(p.id)) candidateMap.set(p.id, p); }
+            }
+          } catch { /* search failed */ }
+        }
+        const scored = [];
+        for (const [, p] of candidateMap) {
+          let relevance_score = 0;
+          const nameLower = (p.name || '').toLowerCase();
+          const descLower = strip(p.description || '').toLowerCase();
+          for (const kw of keywords) {
+            const kwLower = kw.toLowerCase();
+            if (nameLower.includes(kwLower)) relevance_score += 3;
+            if (descLower.includes(kwLower)) relevance_score += 2;
+          }
+          if (p.stock_status === 'instock') relevance_score += 1;
+          if (p.images && p.images.length > 0 && p.images[0]?.src) relevance_score += 1;
+          scored.push({ product_id: p.id, product_name: p.name, product_url: p.permalink, anchor_text: (p.name || '').substring(0, 50), price: p.price, relevance_score, in_stock: p.stock_status === 'instock' });
+        }
+        scored.sort((a, b) => b.relevance_score - a.relevance_score);
+        const suggestions = scored.slice(0, max_suggestions);
+        result = json({ post_id, post_title: postTitle, keywords_used: keywords, suggestions });
+        auditLog({ tool: name, target: post_id, target_type: 'post', action: 'suggest_product_links', status: 'success', latency_ms: Date.now() - t0, params: { post_id, suggestion_count: suggestions.length } });
+        break;
+      }
+
+      // ── WOOCOMMERCE WRITE ──
+
+      case 'wc_update_product': {
+        validateInput(args, { id: { type: 'number', required: true, min: 1 }, status: { type: 'string', enum: ['publish', 'draft', 'private'] } });
+        const { id, name: prodName, description, short_description, regular_price, sale_price, status: prodStatus, price_guardrail_confirmed = false } = args;
+        const { url: baseUrl } = getActiveAuth();
+
+        // Price guardrail check
+        if (regular_price !== undefined || sale_price !== undefined) {
+          const current = await wcApiCall(`/products/${id}`, {}, baseUrl);
+          const checks = [];
+          if (regular_price !== undefined) checks.push({ label: 'regular_price', current: parseFloat(current.regular_price), proposed: parseFloat(regular_price) });
+          if (sale_price !== undefined && sale_price !== '') checks.push({ label: 'sale_price', current: parseFloat(current.sale_price || '0'), proposed: parseFloat(sale_price) });
+
+          for (const chk of checks) {
+            if (!isNaN(chk.current) && chk.current > 0) {
+              const changePct = Math.round(Math.abs(chk.proposed - chk.current) / chk.current * 10000) / 100;
+              if (changePct > 20 && !price_guardrail_confirmed) {
+                auditLog({ tool: name, target: id, target_type: 'product', action: 'update_product', status: 'blocked', latency_ms: Date.now() - t0, params: sanitizeParams(args), error: 'PRICE_GUARDRAIL_TRIGGERED' });
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'PRICE_GUARDRAIL_TRIGGERED', message: `Price change of ${changePct}% exceeds 20% threshold. Call wc_price_guardrail first, then retry with price_guardrail_confirmed: true`, current_price: chk.current, new_price: chk.proposed, change_percent: changePct }, null, 2) }], isError: true };
+              }
+            }
+          }
+        }
+
+        const updateData = {};
+        if (prodName !== undefined) updateData.name = prodName;
+        if (description !== undefined) updateData.description = description;
+        if (short_description !== undefined) updateData.short_description = short_description;
+        if (regular_price !== undefined) updateData.regular_price = regular_price;
+        if (sale_price !== undefined) updateData.sale_price = sale_price;
+        if (prodStatus !== undefined) updateData.status = prodStatus;
+
+        const updated = await wcApiCall(`/products/${id}`, { method: 'PUT', body: JSON.stringify(updateData) }, baseUrl);
+        const auditParams = { id, ...updateData };
+        if (regular_price !== undefined || sale_price !== undefined) auditParams.price_change = true;
+        result = json({ success: true, message: `Product ${id} updated`, product: { id: updated.id, name: updated.name, status: updated.status, regular_price: updated.regular_price, sale_price: updated.sale_price, permalink: updated.permalink } });
+        auditLog({ tool: name, target: id, target_type: 'product', action: 'update_product', status: 'success', latency_ms: Date.now() - t0, params: sanitizeParams(auditParams) });
+        break;
+      }
+
+      case 'wc_update_stock': {
+        validateInput(args, { id: { type: 'number', required: true, min: 1 }, stock_quantity: { type: 'number', required: true, min: 0 }, variation_id: { type: 'number', min: 1 } });
+        const { id, stock_quantity, variation_id } = args;
+        const { url: baseUrl } = getActiveAuth();
+
+        // Fetch current product/variation for audit
+        let previousStock;
+        if (variation_id) {
+          const currentVar = await wcApiCall(`/products/${id}/variations/${variation_id}`, {}, baseUrl);
+          previousStock = currentVar.stock_quantity;
+          await wcApiCall(`/products/${id}/variations/${variation_id}`, { method: 'PUT', body: JSON.stringify({ stock_quantity, manage_stock: true }) }, baseUrl);
+        } else {
+          const currentProd = await wcApiCall(`/products/${id}`, {}, baseUrl);
+          previousStock = currentProd.stock_quantity;
+          await wcApiCall(`/products/${id}`, { method: 'PUT', body: JSON.stringify({ stock_quantity, manage_stock: true }) }, baseUrl);
+        }
+
+        result = json({ success: true, message: variation_id ? `Variation ${variation_id} stock updated` : `Product ${id} stock updated`, product_id: id, variation_id: variation_id || null, previous_stock: previousStock, new_stock: stock_quantity });
+        auditLog({ tool: name, target: id, target_type: 'product', action: 'update_stock', status: 'success', latency_ms: Date.now() - t0, params: { id, variation_id: variation_id || null, previous_stock: previousStock, new_stock: stock_quantity } });
+        break;
+      }
+
+      case 'wc_update_order_status': {
+        validateInput(args, { id: { type: 'number', required: true, min: 1 }, status: { type: 'string', required: true } });
+        const { id, status: newStatus, note } = args;
+        const { url: baseUrl } = getActiveAuth();
+
+        const VALID_TRANSITIONS = {
+          'pending': ['processing', 'cancelled', 'on-hold'],
+          'processing': ['completed', 'cancelled', 'refunded', 'on-hold'],
+          'on-hold': ['processing', 'cancelled'],
+          'completed': ['refunded'],
+          'cancelled': [],
+          'refunded': [],
+          'failed': ['processing', 'cancelled']
+        };
+
+        const order = await wcApiCall(`/orders/${id}`, {}, baseUrl);
+        const currentStatus = order.status;
+        const validNext = VALID_TRANSITIONS[currentStatus];
+
+        if (validNext === undefined) {
+          auditLog({ tool: name, target: id, target_type: 'order', action: 'update_order_status', status: 'error', latency_ms: Date.now() - t0, params: { current_status: currentStatus, requested_status: newStatus }, error: 'UNKNOWN_STATUS' });
+          return { content: [{ type: 'text', text: JSON.stringify({ error: 'UNKNOWN_STATUS', current_status: currentStatus, requested_status: newStatus, message: `Unknown current status "${currentStatus}"` }, null, 2) }], isError: true };
+        }
+
+        if (!validNext.includes(newStatus)) {
+          auditLog({ tool: name, target: id, target_type: 'order', action: 'update_order_status', status: 'error', latency_ms: Date.now() - t0, params: { current_status: currentStatus, requested_status: newStatus }, error: 'INVALID_TRANSITION' });
+          return { content: [{ type: 'text', text: JSON.stringify({ error: 'INVALID_TRANSITION', current_status: currentStatus, requested_status: newStatus, valid_transitions: validNext, message: validNext.length === 0 ? `Order status "${currentStatus}" is terminal — no transitions allowed` : `Cannot transition from "${currentStatus}" to "${newStatus}". Valid: ${validNext.join(', ')}` }, null, 2) }], isError: true };
+        }
+
+        await wcApiCall(`/orders/${id}`, { method: 'PUT', body: JSON.stringify({ status: newStatus }) }, baseUrl);
+
+        let noteAdded = false;
+        if (note) {
+          await wcApiCall(`/orders/${id}/notes`, { method: 'POST', body: JSON.stringify({ note, customer_note: false }) }, baseUrl);
+          noteAdded = true;
+        }
+
+        result = json({ success: true, message: `Order ${id} status updated: ${currentStatus} → ${newStatus}`, order_id: id, previous_status: currentStatus, new_status: newStatus, note_added: noteAdded });
+        auditLog({ tool: name, target: id, target_type: 'order', action: 'update_order_status', status: 'success', latency_ms: Date.now() - t0, params: { previous_status: currentStatus, new_status: newStatus, note_added: noteAdded } });
+        break;
+      }
+
+      // ── SEO ADVANCED ──
+
+      case 'wp_audit_media_seo': {
+        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 } });
+        break;
+      }
+
+      case 'wp_find_orphan_pages': {
+        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 } });
+        break;
+      }
+
+      case 'wp_audit_heading_structure': {
+        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 } });
+        break;
+      }
+
+      // ── SEO ADVANCED v4.1 ──
+
+      case 'wp_find_thin_content': {
+        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 } });
+        break;
+      }
+
+      case 'wp_audit_canonicals': {
+        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 } });
+        break;
+      }
+
+      case 'wp_analyze_eeat_signals': {
+        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 } });
+        break;
+      }
+
+      // ── SEO ADVANCED v4.2 ──
+
+      case 'wp_find_broken_internal_links': {
+        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 } });
+        break;
+      }
+
+      case 'wp_find_keyword_cannibalization': {
+        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 } });
+        break;
+      }
+
+      case 'wp_audit_taxonomies': {
+        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 } });
+        break;
+      }
+
+      case 'wp_audit_outbound_links': {
+        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 } });
+        break;
+      }
+
+      // ── CONTENT INTELLIGENCE v4.4 ──
+
+      case 'wp_get_content_brief': {
+        validateInput(args, {
+          id: { type: 'number', required: true, min: 1 },
+          post_type: { type: 'string', enum: ['post', 'page'] }
+        });
+        const { id, post_type: briefPostType = 'post' } = args;
+        const briefEndpoint = briefPostType === 'page' ? '/pages' : '/posts';
+        const briefPost = await wpApiCall(`${briefEndpoint}/${id}?_fields=id,title,content,excerpt,slug,status,date,modified,link,categories,tags,author,featured_media,meta`);
+
+        const briefContent = briefPost.content?.rendered || '';
+        const { url: briefSiteUrl } = getActiveAuth();
+
+        // Word count & readability
+        const briefWordCount = countWords(briefContent);
+        const readability = calculateReadabilityScore(briefContent);
+
+        // Structure
+        const briefHeadings = extractHeadingsOutline(briefContent);
+        const structure = detectContentSections(briefContent);
+
+        // Links
+        const briefInternalLinks = extractInternalLinks(briefContent, briefSiteUrl);
+        const briefExternalLinks = extractExternalLinks(briefContent, briefSiteUrl);
+
+        // SEO meta
+        const briefMeta = briefPost.meta || {};
+        const briefFocusKw = extractFocusKeyword(briefMeta);
+        const seoTitle = briefMeta._yoast_wpseo_title || briefMeta.rank_math_title || briefMeta._seopress_titles_title || null;
+        const seoDescription = briefMeta._yoast_wpseo_metadesc || briefMeta.rank_math_description || briefMeta._seopress_titles_desc || null;
+        const seoCanonical = briefMeta._yoast_wpseo_canonical || briefMeta.rank_math_canonical_url || briefMeta._seopress_robots_canonical || null;
+
+        // Resolve categories to names
+        const briefCatIds = briefPost.categories || [];
+        let briefCategories = [];
+        if (briefCatIds.length > 0) {
+          try {
+            const cats = await wpApiCall(`/categories?include=${briefCatIds.join(',')}&_fields=id,name`);
+            briefCategories = cats.map(c => ({ id: c.id, name: c.name }));
+          } catch { briefCategories = briefCatIds.map(cid => ({ id: cid, name: null })); }
+        }
+
+        // Resolve tags to names
+        const briefTagIds = briefPost.tags || [];
+        let briefTags = [];
+        if (briefTagIds.length > 0) {
+          try {
+            const tags = await wpApiCall(`/tags?include=${briefTagIds.join(',')}&_fields=id,name`);
+            briefTags = tags.map(t => ({ id: t.id, name: t.name }));
+          } catch { briefTags = briefTagIds.map(tid => ({ id: tid, name: null })); }
+        }
+
+        result = json({
+          id: briefPost.id,
+          title: strip(briefPost.title?.rendered || ''),
+          slug: briefPost.slug,
+          status: briefPost.status,
+          date: briefPost.date,
+          modified: briefPost.modified,
+          link: briefPost.link,
+          author: briefPost.author,
+          word_count: briefWordCount,
+          readability: { score: readability.score, level: readability.level, avg_words_per_sentence: readability.avg_words_per_sentence },
+          seo: {
+            title: seoTitle,
+            description: seoDescription,
+            focus_keyword: briefFocusKw,
+            canonical: seoCanonical
+          },
+          structure: {
+            headings: briefHeadings,
+            has_intro: structure.has_intro,
+            has_conclusion: structure.has_conclusion,
+            has_faq: structure.has_faq,
+            lists_count: structure.lists_count,
+            tables_count: structure.tables_count,
+            images_count: structure.images_count
+          },
+          categories: briefCategories,
+          tags: briefTags,
+          internal_links: { count: briefInternalLinks.length, links: briefInternalLinks },
+          external_links: { count: briefExternalLinks.length, links: briefExternalLinks },
+          featured_media: briefPost.featured_media || null
+        });
+        auditLog({ tool: name, target: id, target_type: briefPostType, action: 'content_brief', status: 'success', latency_ms: Date.now() - t0, params: { id, post_type: briefPostType } });
+        break;
+      }
+
+      case 'wp_extract_post_outline': {
+        validateInput(args, {
+          category_id: { type: 'number', required: true, min: 1 },
+          post_type: { type: 'string', enum: ['post', 'page'] },
+          limit: { type: 'number', min: 1, max: 50 }
+        });
+        const { category_id, post_type: outlinePostType = 'post', limit: outlineLimit = 10 } = args;
+        const outlineEndpoint = outlinePostType === 'page' ? '/pages' : '/posts';
+        let outlineUrl = `${outlineEndpoint}?per_page=${Math.min(outlineLimit, 50)}&status=publish&_fields=id,title,content,slug,link,meta`;
+        if (outlinePostType !== 'page') outlineUrl += `&categories=${category_id}`;
+        const outlinePosts = await wpApiCall(outlineUrl);
+
+        const outlines = [];
+        const h2Counter = new Map();
+
+        for (const p of outlinePosts) {
+          const html = p.content?.rendered || '';
+          const headings = extractHeadingsOutline(html);
+          const wc = countWords(html);
+
+          // Count H2 patterns
+          for (const h of headings) {
+            if (h.level === 2) {
+              const normalized = h.text.toLowerCase().trim();
+              if (normalized) h2Counter.set(normalized, (h2Counter.get(normalized) || 0) + 1);
+            }
+          }
+
+          outlines.push({
+            id: p.id,
+            title: strip(p.title?.rendered || ''),
+            slug: p.slug,
+            link: p.link,
+            word_count: wc,
+            headings_count: headings.length,
+            headings
+          });
+        }
+
+        // Aggregated stats
+        const totalWords = outlines.reduce((s, o) => s + o.word_count, 0);
+        const totalHeadings = outlines.reduce((s, o) => s + o.headings_count, 0);
+        const avgWordCount = outlines.length > 0 ? Math.round(totalWords / outlines.length) : 0;
+        const avgHeadingsCount = outlines.length > 0 ? Math.round(totalHeadings / outlines.length) : 0;
+
+        // Common H2 patterns (top 10)
+        const commonH2 = [...h2Counter.entries()]
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 10)
+          .map(([text, frequency]) => ({ text, frequency }));
+
+        result = json({
+          category_id,
+          posts_analyzed: outlines.length,
+          avg_word_count: avgWordCount,
+          avg_headings_count: avgHeadingsCount,
+          common_h2_patterns: commonH2,
+          outlines
+        });
+        auditLog({ tool: name, action: 'extract_outline', status: 'success', latency_ms: Date.now() - t0, params: { category_id, post_type: outlinePostType, limit: outlineLimit } });
+        break;
+      }
+
+      // ── wp_audit_readability ──
+      case 'wp_audit_readability': {
+        validateInput(args, {
+          limit: { type: 'number', min: 1, max: 200 },
+          post_type: { type: 'string', enum: ['post', 'page'] },
+          category_id: { type: 'number' },
+          min_words: { type: 'number', min: 0 }
+        });
+        const { limit: arLimit = 50, post_type: arPostType = 'post', category_id: arCatId, min_words: arMinWords = 100 } = args;
+        const arEndpoint = arPostType === 'page' ? '/pages' : '/posts';
+        let arUrl = `${arEndpoint}?per_page=${Math.min(arLimit, 200)}&status=publish&_fields=id,title,content,slug,link,categories,meta`;
+        if (arCatId && arPostType !== 'page') arUrl += `&categories=${arCatId}`;
+        const arPosts = await wpApiCall(arUrl);
+
+        const arResults = [];
+        for (const p of arPosts) {
+          const html = p.content?.rendered || '';
+          const wc = countWords(html);
+          if (wc < arMinWords) continue;
+          const plainText = strip(html);
+          const readabilityResult = calculateReadabilityScore(html);
+          const transitionResult = extractTransitionWords(plainText);
+          const passiveResult = countPassiveSentences(plainText);
+
+          const issues = [];
+          if (readabilityResult.score < 20) issues.push('very_low_readability');
+          else if (readabilityResult.score < 40) issues.push('low_readability');
+          if (transitionResult.count === 0) issues.push('no_transition_words');
+          else if (transitionResult.density < 0.1) issues.push('low_transition_density');
+          if (passiveResult.ratio > 0.3) issues.push('high_passive_ratio');
+
+          arResults.push({
+            id: p.id,
+            title: strip(p.title?.rendered || ''),
+            slug: p.slug,
+            link: p.link,
+            word_count: wc,
+            readability: {
+              score: readabilityResult.score,
+              level: readabilityResult.level,
+              avg_words_per_sentence: readabilityResult.avg_words_per_sentence,
+              avg_syllables_per_word: readabilityResult.avg_syllables_per_word
+            },
+            transition_density: transitionResult.density,
+            passive_ratio: passiveResult.ratio,
+            issues
+          });
+        }
+
+        // Sort by score ASC (worst first)
+        arResults.sort((a, b) => a.readability.score - b.readability.score);
+
+        // Aggregation
+        const arTotal = arResults.length;
+        const arAvgScore = arTotal > 0 ? Math.round(arResults.reduce((s, r) => s + r.readability.score, 0) / arTotal * 10) / 10 : 0;
+        const arAvgTD = arTotal > 0 ? Math.round(arResults.reduce((s, r) => s + r.transition_density, 0) / arTotal * 1000) / 1000 : 0;
+        const arAvgPR = arTotal > 0 ? Math.round(arResults.reduce((s, r) => s + r.passive_ratio, 0) / arTotal * 1000) / 1000 : 0;
+        const distribution = { 'très facile': 0, 'facile': 0, 'standard': 0, 'difficile': 0, 'très difficile': 0 };
+        for (const r of arResults) { distribution[r.readability.level] = (distribution[r.readability.level] || 0) + 1; }
+
+        result = json({
+          total_analyzed: arTotal,
+          avg_readability_score: arAvgScore,
+          distribution,
+          avg_transition_density: arAvgTD,
+          avg_passive_ratio: arAvgPR,
+          posts: arResults
+        });
+        auditLog({ tool: name, action: 'audit_readability', status: 'success', latency_ms: Date.now() - t0, params: { limit: arLimit, post_type: arPostType, category_id: arCatId, min_words: arMinWords } });
+        break;
+      }
+
+      // ── wp_audit_update_frequency ──
+      case 'wp_audit_update_frequency': {
+        validateInput(args, {
+          days_threshold: { type: 'number', min: 1 },
+          limit: { type: 'number', min: 1, max: 200 },
+          post_type: { type: 'string', enum: ['post', 'page'] },
+          include_seo_score: { type: 'boolean' }
+        });
+        const { days_threshold: aufDays = 180, limit: aufLimit = 50, post_type: aufPostType = 'post', include_seo_score: aufIncludeSeo = true } = args;
+        const aufEndpoint = aufPostType === 'page' ? '/pages' : '/posts';
+        const aufUrl = `${aufEndpoint}?per_page=${Math.min(aufLimit, 200)}&status=publish&_fields=id,title,slug,link,date,modified,content,meta,categories`;
+        const aufAllPosts = await wpApiCall(aufUrl);
+
+        const aufNow = Date.now();
+        const aufFiltered = [];
+
+        for (const p of aufAllPosts) {
+          const daysSince = Math.floor((aufNow - new Date(p.modified).getTime()) / 86400000);
+          if (daysSince < aufDays) continue;
+
+          const meta = p.meta || {};
+          const html = p.content?.rendered || '';
+          const wc = countWords(html);
+
+          let seoScore = null;
+          const issues = ['outdated_180d'];
+          if (daysSince >= 365) issues.push('outdated_365d');
+          if (wc < 300) issues.push('thin_content');
+
+          if (aufIncludeSeo) {
+            const seoTitle = meta.rank_math_title || meta._yoast_wpseo_title || meta._seopress_titles_title || meta._aioseo_title || null;
+            const seoDesc = meta.rank_math_description || meta._yoast_wpseo_metadesc || meta._seopress_titles_desc || meta._aioseo_description || null;
+            const focusKw = extractFocusKeyword(meta);
+            seoScore = 100;
+            if (!seoTitle) { seoScore -= 30; issues.push('missing_seo_title'); }
+            if (!seoDesc) { seoScore -= 30; issues.push('missing_meta_description'); }
+            if (!focusKw) seoScore -= 20;
+            if (seoTitle && focusKw && !seoTitle.toLowerCase().includes(focusKw.toLowerCase())) seoScore -= 10;
+            if (seoScore < 70) issues.push('low_seo_score');
+          }
+
+          const priority = daysSince * (aufIncludeSeo && seoScore !== null ? (100 - seoScore) / 100 : 1) * (wc < 300 ? 1.5 : 1);
+
+          aufFiltered.push({
+            id: p.id,
+            title: strip(p.title?.rendered || ''),
+            slug: p.slug,
+            link: p.link,
+            date: p.date,
+            modified: p.modified,
+            days_since_modified: daysSince,
+            word_count: wc,
+            seo_score: seoScore,
+            priority_score: Math.round(priority * 10) / 10,
+            issues
+          });
+        }
+
+        aufFiltered.sort((a, b) => b.priority_score - a.priority_score);
+
+        result = json({
+          days_threshold: aufDays,
+          total_published: aufAllPosts.length,
+          outdated_count: aufFiltered.length,
+          outdated_ratio: aufAllPosts.length > 0 ? Math.round(aufFiltered.length / aufAllPosts.length * 100) / 100 : 0,
+          posts: aufFiltered
+        });
+        auditLog({ tool: name, action: 'audit_update_frequency', status: 'success', latency_ms: Date.now() - t0, params: { days_threshold: aufDays, limit: aufLimit, post_type: aufPostType, include_seo_score: aufIncludeSeo } });
+        break;
+      }
+
+      // ── wp_build_link_map ──
+      case 'wp_build_link_map': {
+        validateInput(args, {
+          post_type: { type: 'string', enum: ['post', 'page', 'both'] },
+          limit: { type: 'number', min: 1, max: 200 },
+          category_id: { type: 'number' }
+        });
+        const { post_type: lmPostType = 'post', limit: lmLimit = 50, category_id: lmCatId } = args;
+        const { url: lmSiteUrl } = getActiveAuth();
+        const perPage = Math.min(lmLimit, 200);
+        const fields = '_fields=id,title,slug,link,content,categories';
+
+        let lmPosts = [];
+        if (lmPostType === 'both') {
+          let postsUrl = `/posts?per_page=${perPage}&status=publish&${fields}`;
+          if (lmCatId) postsUrl += `&categories=${lmCatId}`;
+          const [posts, pages] = await Promise.all([
+            wpApiCall(postsUrl),
+            wpApiCall(`/pages?per_page=${perPage}&status=publish&${fields}`)
+          ]);
+          lmPosts = [...posts, ...pages];
+        } else {
+          const ep = lmPostType === 'page' ? '/pages' : '/posts';
+          let postsUrl = `${ep}?per_page=${perPage}&status=publish&${fields}`;
+          if (lmCatId && lmPostType !== 'page') postsUrl += `&categories=${lmCatId}`;
+          lmPosts = await wpApiCall(postsUrl);
+        }
+
+        // Build lookup maps
+        const postMap = new Map();
+        const slugToId = new Map();
+        for (const p of lmPosts) {
+          postMap.set(p.id, {
+            id: p.id,
+            title: strip(p.title?.rendered || ''),
+            slug: p.slug,
+            link: p.link,
+            outbound_links: [],
+            inbound_count: 0,
+            unresolved_links: 0
+          });
+          slugToId.set(p.slug, p.id);
+          if (p.link) {
+            try { slugToId.set(new URL(p.link).pathname.replace(/\/+$/, ''), p.id); } catch { /* skip */ }
+          }
+        }
+
+        // Extract links and resolve targets
+        let totalLinks = 0;
+        const linkMatrix = {};
+
+        for (const p of lmPosts) {
+          const html = p.content?.rendered || '';
+          const internalLinks = extractInternalLinks(html, lmSiteUrl);
+          const resolvedTargets = [];
+          let unresolvedCount = 0;
+
+          for (const link of internalLinks) {
+            let targetId = null;
+            // Try to match by URL path
+            try {
+              const linkPath = new URL(link.url || link).pathname.replace(/\/+$/, '');
+              targetId = slugToId.get(linkPath) || null;
+              if (!targetId) {
+                // Try matching just the last segment as slug
+                const lastSeg = linkPath.split('/').filter(Boolean).pop();
+                if (lastSeg) targetId = slugToId.get(lastSeg) || null;
+              }
+            } catch { /* skip */ }
+
+            if (targetId && targetId !== p.id && postMap.has(targetId)) {
+              const target = postMap.get(targetId);
+              resolvedTargets.push({
+                target_id: targetId,
+                target_title: target.title,
+                anchor_text: link.anchor_text || link.text || ''
+              });
+              target.inbound_count++;
+              totalLinks++;
+            } else {
+              unresolvedCount++;
+            }
+          }
+
+          const entry = postMap.get(p.id);
+          entry.outbound_links = resolvedTargets;
+          entry.unresolved_links = unresolvedCount;
+          if (resolvedTargets.length > 0) {
+            linkMatrix[p.id] = resolvedTargets.map(l => l.target_id);
+          }
+        }
+
+        // Simplified PageRank (10 iterations, damping 0.85)
+        const N = lmPosts.length;
+        const damping = 0.85;
+        let scores = new Map();
+        for (const p of lmPosts) scores.set(p.id, 1 / N);
+
+        for (let iter = 0; iter < 10; iter++) {
+          const newScores = new Map();
+          for (const p of lmPosts) newScores.set(p.id, (1 - damping) / N);
+          for (const p of lmPosts) {
+            const entry = postMap.get(p.id);
+            const outCount = entry.outbound_links.length;
+            if (outCount > 0) {
+              const share = (damping * scores.get(p.id)) / outCount;
+              for (const link of entry.outbound_links) {
+                newScores.set(link.target_id, (newScores.get(link.target_id) || 0) + share);
+              }
+            }
+          }
+          scores = newScores;
+        }
+
+        // Normalize to 0-100
+        let maxScore = 0;
+        for (const s of scores.values()) { if (s > maxScore) maxScore = s; }
+        const normalizedScores = new Map();
+        for (const [id, s] of scores) {
+          normalizedScores.set(id, maxScore > 0 ? Math.round((s / maxScore) * 100 * 10) / 10 : 0);
+        }
+
+        // Build result array
+        const lmResults = [];
+        for (const [id, entry] of postMap) {
+          lmResults.push({
+            id,
+            title: entry.title,
+            slug: entry.slug,
+            link: entry.link,
+            outbound_count: entry.outbound_links.length,
+            inbound_count: entry.inbound_count,
+            pagerank_score: normalizedScores.get(id) || 0,
+            is_orphan: entry.inbound_count === 0,
+            outbound_links: entry.outbound_links,
+            unresolved_links: entry.unresolved_links
+          });
+        }
+
+        lmResults.sort((a, b) => b.pagerank_score - a.pagerank_score);
+
+        const orphanCount = lmResults.filter(r => r.is_orphan).length;
+        result = json({
+          total_analyzed: lmPosts.length,
+          total_internal_links: totalLinks,
+          avg_outbound_per_post: lmPosts.length > 0 ? Math.round(totalLinks / lmPosts.length * 10) / 10 : 0,
+          orphan_posts: orphanCount,
+          posts: lmResults,
+          link_matrix: linkMatrix
+        });
+        auditLog({ tool: name, action: 'build_link_map', status: 'success', latency_ms: Date.now() - t0, params: { post_type: lmPostType, limit: lmLimit, category_id: lmCatId } });
+        break;
+      }
+
+      // ── wp_audit_anchor_texts ──
+      case 'wp_audit_anchor_texts': {
+        validateInput(args, {
+          limit: { type: 'number', min: 1, max: 200 },
+          post_type: { type: 'string', enum: ['post', 'page', 'both'] }
+        });
+        const { limit: aatLimit = 50, post_type: aatPostType = 'post' } = args;
+        const { url: aatSiteUrl } = getActiveAuth();
+        const aatPerPage = Math.min(aatLimit, 200);
+        const aatFields = '_fields=id,title,slug,link,content';
+
+        let aatPosts = [];
+        if (aatPostType === 'both') {
+          const [posts, pages] = await Promise.all([
+            wpApiCall(`/posts?per_page=${aatPerPage}&status=publish&${aatFields}`),
+            wpApiCall(`/pages?per_page=${aatPerPage}&status=publish&${aatFields}`)
+          ]);
+          aatPosts = [...posts, ...pages];
+        } else {
+          const ep = aatPostType === 'page' ? '/pages' : '/posts';
+          aatPosts = await wpApiCall(`${ep}?per_page=${aatPerPage}&status=publish&${aatFields}`);
+        }
+
+        const GENERIC_ANCHORS = ['cliquez ici', 'click here', 'lire la suite', 'read more', 'en savoir plus', 'learn more', 'ici', 'here', 'lien', 'link', 'voir', 'see', 'plus', 'more', 'article', 'page', 'ce lien', 'this link', 'cet article', 'this article'];
+
+        // Corpus-wide anchor map: anchor_text_lower → { count, posts: Set, targets: Set }
+        const anchorMap = new Map();
+        const postAnchors = new Map(); // postId → { anchors: [{text,type}], total, unique }
+
+        let totalInternalLinks = 0;
+
+        for (const p of aatPosts) {
+          const html = p.content?.rendered || '';
+          const links = extractInternalLinks(html, aatSiteUrl);
+          const postAnchorList = [];
+
+          for (const link of links) {
+            const text = (link.anchor_text || '').trim();
+            const lower = text.toLowerCase();
+            totalInternalLinks++;
+
+            postAnchorList.push({ text, lower, href: link.url });
+
+            if (!anchorMap.has(lower)) {
+              anchorMap.set(lower, { count: 0, posts: new Set(), targets: new Set() });
+            }
+            const entry = anchorMap.get(lower);
+            entry.count++;
+            entry.posts.add(p.id);
+            entry.targets.add(link.url);
+          }
+
+          postAnchors.set(p.id, postAnchorList);
+        }
+
+        // Classify each anchor
+        const anchorHealth = { healthy: 0, generic: 0, over_optimized: 0, image_link: 0 };
+        const genericAnchorsMap = new Map(); // text → { count, post_ids }
+        const overOptimized = [];
+
+        for (const [lower, entry] of anchorMap) {
+          if (lower === '' || /^\s*$/.test(lower)) {
+            anchorHealth.image_link += entry.count;
+          } else if (GENERIC_ANCHORS.includes(lower)) {
+            anchorHealth.generic += entry.count;
+            genericAnchorsMap.set(lower, { text: lower, count: entry.count, post_ids: [...entry.posts] });
+          } else if (entry.count > 3 && entry.targets.size > 1) {
+            anchorHealth.over_optimized += entry.count;
+            overOptimized.push({ text: lower, count: entry.count, target_count: entry.targets.size, post_ids: [...entry.posts] });
+          } else {
+            anchorHealth.healthy += entry.count;
+          }
+        }
+
+        // Top 10 generic anchors sorted by count DESC
+        const genericAnchors = [...genericAnchorsMap.values()].sort((a, b) => b.count - a.count).slice(0, 10);
+
+        // Per-post results
+        const aatResults = [];
+        for (const p of aatPosts) {
+          const anchors = postAnchors.get(p.id) || [];
+          const total = anchors.length;
+          const uniqueTexts = new Set(anchors.map(a => a.lower));
+          const unique = uniqueTexts.size;
+          const ds = total > 0 ? unique / total : 1;
+
+          const issues = [];
+          const hasGeneric = anchors.some(a => GENERIC_ANCHORS.includes(a.lower));
+          const hasOverOpt = anchors.some(a => {
+            const e = anchorMap.get(a.lower);
+            return e && e.count > 3 && e.targets.size > 1 && a.lower !== '' && !GENERIC_ANCHORS.includes(a.lower);
+          });
+          const hasImageLink = anchors.some(a => a.lower === '' || /^\s*$/.test(a.lower));
+          if (hasGeneric) issues.push('has_generic_anchors');
+          if (hasOverOpt) issues.push('has_over_optimized_anchors');
+          if (hasImageLink) issues.push('has_image_links');
+          if (total > 0 && ds < 0.5) issues.push('low_anchor_diversity');
+
+          aatResults.push({
+            id: p.id,
+            title: strip(p.title?.rendered || ''),
+            slug: p.slug,
+            internal_links_count: total,
+            unique_anchors_count: unique,
+            diversity_score: Math.round(ds * 100) / 100,
+            issues
+          });
+        }
+
+        aatResults.sort((a, b) => a.diversity_score - b.diversity_score);
+
+        result = json({
+          total_analyzed: aatPosts.length,
+          total_internal_links: totalInternalLinks,
+          total_unique_anchors: anchorMap.size,
+          anchor_health: anchorHealth,
+          generic_anchors: genericAnchors,
+          over_optimized_anchors: overOptimized,
+          posts: aatResults
+        });
+        auditLog({ tool: name, action: 'audit_anchor_texts', status: 'success', latency_ms: Date.now() - t0, params: { limit: aatLimit, post_type: aatPostType } });
+        break;
+      }
+
+      // ── wp_audit_schema_markup ──
+      case 'wp_audit_schema_markup': {
+        validateInput(args, {
+          limit: { type: 'number', min: 1, max: 200 },
+          post_type: { type: 'string', enum: ['post', 'page', 'both'] }
+        });
+        const { limit: asmLimit = 50, post_type: asmPostType = 'post' } = args;
+        const asmPerPage = Math.min(asmLimit, 200);
+        const asmFields = '_fields=id,title,slug,link,content';
+
+        let asmPosts = [];
+        if (asmPostType === 'both') {
+          const [posts, pages] = await Promise.all([
+            wpApiCall(`/posts?per_page=${asmPerPage}&status=publish&${asmFields}`),
+            wpApiCall(`/pages?per_page=${asmPerPage}&status=publish&${asmFields}`)
+          ]);
+          asmPosts = [...posts, ...pages];
+        } else {
+          const ep = asmPostType === 'page' ? '/pages' : '/posts';
+          asmPosts = await wpApiCall(`${ep}?per_page=${asmPerPage}&status=publish&${asmFields}`);
+        }
+
+        const SCHEMA_REQUIRED_FIELDS = {
+          'Article': ['headline', 'datePublished', 'author'],
+          'NewsArticle': ['headline', 'datePublished', 'author'],
+          'BlogPosting': ['headline', 'datePublished', 'author'],
+          'FAQPage': ['mainEntity'],
+          'HowTo': ['name', 'step'],
+          'LocalBusiness': ['name', 'address'],
+          'BreadcrumbList': ['itemListElement'],
+          'Organization': ['name'],
+          'WebPage': ['name']
+        };
+        const ARTICLE_TYPES = ['Article', 'NewsArticle', 'BlogPosting'];
+
+        const typeDist = {};
+        let totalSchemas = 0;
+        let validCount = 0;
+        let invalidCount = 0;
+        let postsWithSchema = 0;
+        let postsWithout = 0;
+
+        const ldJsonRegex = /<script\s+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+        const asmResults = [];
+        for (const p of asmPosts) {
+          const html = p.content?.rendered || '';
+          const schemas = [];
+          const issues = [];
+          let hasInvalidJson = false;
+          let hasArticleSchema = false;
+
+          let ldMatch;
+          ldJsonRegex.lastIndex = 0;
+          while ((ldMatch = ldJsonRegex.exec(html)) !== null) {
+            const raw = ldMatch[1].trim();
+            let parsed;
+            try {
+              parsed = JSON.parse(raw);
+            } catch {
+              schemas.push({ type: 'unknown', valid: false, missing_fields: [], raw_type: 'parse_error' });
+              hasInvalidJson = true;
+              invalidCount++;
+              totalSchemas++;
+              continue;
+            }
+
+            const types = Array.isArray(parsed['@type']) ? parsed['@type'] : [parsed['@type'] || 'unknown'];
+            for (const t of types) {
+              const required = SCHEMA_REQUIRED_FIELDS[t];
+              if (ARTICLE_TYPES.includes(t)) hasArticleSchema = true;
+
+              if (required) {
+                const missing = required.filter(f => {
+                  const val = parsed[f];
+                  if (val === undefined || val === null) return true;
+                  if (Array.isArray(val) && val.length === 0) return true;
+                  return false;
+                });
+                const isValid = missing.length === 0;
+                schemas.push({ type: t, valid: isValid, missing_fields: missing, raw_type: t });
+                if (isValid) validCount++; else invalidCount++;
+                if (!isValid) issues.push('missing_required_fields');
+                typeDist[t] = (typeDist[t] || 0) + 1;
+              } else {
+                schemas.push({ type: t, valid: true, missing_fields: [], raw_type: t });
+                validCount++;
+                typeDist['other'] = (typeDist['other'] || 0) + 1;
+              }
+              totalSchemas++;
+            }
+          }
+
+          if (schemas.length === 0) {
+            issues.push('no_schema');
+            postsWithout++;
+          } else {
+            postsWithSchema++;
+          }
+          if (hasInvalidJson) issues.push('invalid_json');
+          if (!hasArticleSchema && schemas.length > 0) issues.push('no_article_schema');
+
+          asmResults.push({
+            id: p.id,
+            title: strip(p.title?.rendered || ''),
+            slug: p.slug,
+            link: p.link,
+            schemas_found: schemas.length,
+            schemas,
+            issues
+          });
+        }
+
+        // Sort: posts with issues first, by issue count DESC
+        asmResults.sort((a, b) => b.issues.length - a.issues.length);
+
+        result = json({
+          total_analyzed: asmPosts.length,
+          posts_with_schema: postsWithSchema,
+          posts_without_schema: postsWithout,
+          schema_type_distribution: typeDist,
+          total_schemas_found: totalSchemas,
+          total_valid: validCount,
+          total_invalid: invalidCount,
+          posts: asmResults
+        });
+        auditLog({ tool: name, action: 'audit_schema_markup', status: 'success', latency_ms: Date.now() - t0, params: { limit: asmLimit, post_type: asmPostType } });
+        break;
+      }
+
+      // ── wp_audit_content_structure ──
+      case 'wp_audit_content_structure': {
+        validateInput(args, {
+          limit: { type: 'number', min: 1, max: 200 },
+          post_type: { type: 'string', enum: ['post', 'page', 'both'] },
+          category_id: { type: 'number' }
+        });
+        const { limit: acsLimit = 50, post_type: acsPostType = 'post', category_id: acsCatId } = args;
+        const acsPerPage = Math.min(acsLimit, 200);
+        const acsFields = '_fields=id,title,slug,link,content,categories';
+
+        let acsPosts = [];
+        if (acsPostType === 'both') {
+          let postsUrl = `/posts?per_page=${acsPerPage}&status=publish&${acsFields}`;
+          if (acsCatId) postsUrl += `&categories=${acsCatId}`;
+          const [posts, pages] = await Promise.all([
+            wpApiCall(postsUrl),
+            wpApiCall(`/pages?per_page=${acsPerPage}&status=publish&${acsFields}`)
+          ]);
+          acsPosts = [...posts, ...pages];
+        } else {
+          const ep = acsPostType === 'page' ? '/pages' : '/posts';
+          let postsUrl = `${ep}?per_page=${acsPerPage}&status=publish&${acsFields}`;
+          if (acsCatId && acsPostType !== 'page') postsUrl += `&categories=${acsCatId}`;
+          acsPosts = await wpApiCall(postsUrl);
+        }
+
+        let totalScore = 0;
+        const distribution = { excellent: 0, good: 0, average: 0, poor: 0 };
+        const featureCounts = { intro: 0, conclusion: 0, faq: 0, toc: 0, lists: 0, tables: 0, images: 0, blockquotes: 0 };
+
+        const acsResults = [];
+        for (const p of acsPosts) {
+          const html = p.content?.rendered || '';
+          const sections = detectContentSections(html);
+          const wc = countWords(html);
+
+          // Paragraphs count (non-empty <p>)
+          const pMatches = html.match(/<p[^>]*>(?!\s*<\/p>)/gi) || [];
+          const paragraphsCount = pMatches.length || 1;
+          const avgParagraphLength = Math.round(wc / paragraphsCount);
+
+          // TOC detection
+          const hasToc = /<[^>]+(?:id|class)=["'][^"']*(?:toc|table-of-contents|table-des-matieres)[^"']*["'][^>]*>/i.test(html);
+
+          // Blockquotes and code blocks
+          const blockquotesCount = (html.match(/<blockquote\b/gi) || []).length;
+          const codeBlocksCount = (html.match(/<(?:pre|code)\b/gi) || []).length;
+
+          // Heading density: headings per 300 words
+          const headingDensity = wc > 0 ? sections.headings_count / (wc / 300) : 0;
+
+          // Structure score (0-100)
+          let score = 0;
+          if (sections.has_intro) score += 15;
+          if (sections.has_conclusion) score += 10;
+          if (sections.headings_count >= 3) score += 15;
+          if (headingDensity >= 0.5 && headingDensity <= 2.0) score += 10;
+          if (sections.lists_count >= 1) score += 10;
+          if (sections.images_count >= 1) score += 10;
+          if (sections.has_faq) score += 10;
+          if (sections.tables_count >= 1) score += 5;
+          if (hasToc) score += 5;
+          if (blockquotesCount > 0 || codeBlocksCount > 0) score += 5;
+          if (avgParagraphLength < 100) score += 5;
+
+          totalScore += score;
+
+          if (score >= 80) distribution.excellent++;
+          else if (score >= 60) distribution.good++;
+          else if (score >= 40) distribution.average++;
+          else distribution.poor++;
+
+          // Feature coverage tracking
+          if (sections.has_intro) featureCounts.intro++;
+          if (sections.has_conclusion) featureCounts.conclusion++;
+          if (sections.has_faq) featureCounts.faq++;
+          if (hasToc) featureCounts.toc++;
+          if (sections.lists_count >= 1) featureCounts.lists++;
+          if (sections.tables_count >= 1) featureCounts.tables++;
+          if (sections.images_count >= 1) featureCounts.images++;
+          if (blockquotesCount > 0) featureCounts.blockquotes++;
+
+          // Issues
+          const issues = [];
+          if (!sections.has_intro) issues.push('no_intro');
+          if (!sections.has_conclusion) issues.push('no_conclusion');
+          if (sections.headings_count === 0) issues.push('no_headings');
+          if (headingDensity < 0.3 && wc > 100) issues.push('low_heading_density');
+          if (headingDensity > 3.0) issues.push('high_heading_density');
+          if (sections.images_count === 0) issues.push('no_images');
+          if (sections.lists_count === 0) issues.push('no_lists');
+          if (avgParagraphLength > 150) issues.push('long_paragraphs');
+          if (score < 40) issues.push('poor_structure');
+
+          acsResults.push({
+            id: p.id,
+            title: strip(p.title?.rendered || ''),
+            slug: p.slug,
+            link: p.link,
+            word_count: wc,
+            structure_score: score,
+            features: {
+              has_intro: sections.has_intro,
+              has_conclusion: sections.has_conclusion,
+              has_faq: sections.has_faq,
+              has_toc: hasToc,
+              headings_count: sections.headings_count,
+              lists_count: sections.lists_count,
+              tables_count: sections.tables_count,
+              images_count: sections.images_count,
+              paragraphs_count: paragraphsCount,
+              avg_paragraph_length: avgParagraphLength,
+              blockquotes_count: blockquotesCount,
+              code_blocks_count: codeBlocksCount,
+              heading_density: Math.round(headingDensity * 100) / 100
+            },
+            issues
+          });
+        }
+
+        acsResults.sort((a, b) => a.structure_score - b.structure_score);
+
+        const acsTotal = acsPosts.length;
+        const featureCoverage = {};
+        for (const [key, count] of Object.entries(featureCounts)) {
+          featureCoverage[key] = acsTotal > 0 ? Math.round(count / acsTotal * 100) : 0;
+        }
+
+        result = json({
+          total_analyzed: acsTotal,
+          avg_structure_score: acsTotal > 0 ? Math.round(totalScore / acsTotal * 10) / 10 : 0,
+          distribution,
+          feature_coverage: featureCoverage,
+          posts: acsResults
+        });
+        auditLog({ tool: name, action: 'audit_content_structure', status: 'success', latency_ms: Date.now() - t0, params: { limit: acsLimit, post_type: acsPostType, category_id: acsCatId } });
+        break;
+      }
+
+      // ── wp_find_duplicate_content ──
+      case 'wp_find_duplicate_content': {
+        validateInput(args, {
+          limit: { type: 'number', min: 1, max: 100 },
+          post_type: { type: 'string', enum: ['post', 'page'] },
+          category_id: { type: 'number' },
+          similarity_threshold: { type: 'number', min: 0, max: 1 }
+        });
+        const { limit: fdcLimit = 50, post_type: fdcPostType = 'post', category_id: fdcCatId, similarity_threshold: fdcThreshold = 0.7 } = args;
+        const fdcPerPage = Math.min(fdcLimit, 100);
+        const fdcFields = '_fields=id,title,content,slug,link';
+
+        const fdcEp = fdcPostType === 'page' ? '/pages' : '/posts';
+        let fdcUrl = `${fdcEp}?per_page=${fdcPerPage}&status=publish&${fdcFields}`;
+        if (fdcCatId && fdcPostType !== 'page') fdcUrl += `&categories=${fdcCatId}`;
+
+        const fdcPosts = await wpApiCall(fdcUrl);
+
+        const fdcDocs = [];
+        const fdcPostMap = new Map();
+        for (const p of fdcPosts) {
+          const text = strip(p.content?.rendered || '');
+          const wc = countWords(p.content?.rendered || '');
+          fdcPostMap.set(p.id, { id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, word_count: wc });
+          if (wc >= 50) {
+            fdcDocs.push({ id: p.id, title: strip(p.title?.rendered || ''), text });
+          }
+        }
+
+        const fdcPairs = findDuplicatePairs(fdcDocs, fdcThreshold);
+
+        const formattedPairs = fdcPairs
+          .sort((a, b) => b.similarity - a.similarity)
+          .map(pair => {
+            const p1 = fdcPostMap.get(pair.doc1_id);
+            const p2 = fdcPostMap.get(pair.doc2_id);
+            const sim = Math.round(pair.similarity * 1000) / 1000;
+            return {
+              post1: { id: p1.id, title: p1.title, slug: p1.slug, word_count: p1.word_count },
+              post2: { id: p2.id, title: p2.title, slug: p2.slug, word_count: p2.word_count },
+              similarity: sim,
+              severity: sim >= 0.9 ? 'critical' : sim >= 0.8 ? 'high' : 'medium'
+            };
+          });
+
+        // Union-find clustering
+        const ufParent = new Map();
+        const ufFind = (x) => {
+          if (!ufParent.has(x)) ufParent.set(x, x);
+          if (ufParent.get(x) !== x) ufParent.set(x, ufFind(ufParent.get(x)));
+          return ufParent.get(x);
+        };
+        const ufUnion = (a, b) => { ufParent.set(ufFind(a), ufFind(b)); };
+
+        for (const pair of fdcPairs) ufUnion(pair.doc1_id, pair.doc2_id);
+
+        const clusterMap = new Map();
+        const idsInPairs = new Set();
+        for (const pair of fdcPairs) { idsInPairs.add(pair.doc1_id); idsInPairs.add(pair.doc2_id); }
+        for (const id of idsInPairs) {
+          const root = ufFind(id);
+          if (!clusterMap.has(root)) clusterMap.set(root, { posts: [], maxSim: 0 });
+          const info = fdcPostMap.get(id);
+          clusterMap.get(root).posts.push({ id: info.id, title: info.title, slug: info.slug });
+        }
+        for (const pair of fdcPairs) {
+          const root = ufFind(pair.doc1_id);
+          const cluster = clusterMap.get(root);
+          if (pair.similarity > cluster.maxSim) cluster.maxSim = pair.similarity;
+        }
+
+        let fdcClusterId = 0;
+        const clusters = [...clusterMap.values()].map(c => ({
+          cluster_id: ++fdcClusterId,
+          posts: c.posts,
+          max_similarity: Math.round(c.maxSim * 1000) / 1000
+        }));
+
+        result = json({
+          total_analyzed: fdcPosts.length,
+          similarity_threshold: fdcThreshold,
+          duplicate_pairs_found: formattedPairs.length,
+          duplicate_clusters: clusters.length,
+          pairs: formattedPairs,
+          clusters
+        });
+        auditLog({ tool: name, action: 'find_duplicate_content', status: 'success', latency_ms: Date.now() - t0, params: { limit: fdcLimit, post_type: fdcPostType, category_id: fdcCatId, similarity_threshold: fdcThreshold } });
+        break;
+      }
+
+      // ── wp_find_content_gaps ──
+      case 'wp_find_content_gaps': {
+        validateInput(args, {
+          min_posts: { type: 'number', min: 1, max: 50 },
+          taxonomy: { type: 'string', enum: ['category', 'post_tag', 'both'] },
+          exclude_empty: { type: 'boolean' }
+        });
+        const { min_posts: fcgMinPosts = 3, taxonomy: fcgTaxonomy = 'both', exclude_empty: fcgExcludeEmpty = false } = args;
+
+        let fcgCategories = [];
+        let fcgTags = [];
+
+        if (fcgTaxonomy === 'category' || fcgTaxonomy === 'both') {
+          fcgCategories = await wpApiCall('/categories?per_page=100&_fields=id,name,slug,count,description,parent');
+        }
+        if (fcgTaxonomy === 'post_tag' || fcgTaxonomy === 'both') {
+          fcgTags = await wpApiCall('/tags?per_page=100&_fields=id,name,slug,count');
+        }
+
+        const catMap = new Map();
+        for (const c of fcgCategories) catMap.set(c.id, c);
+
+        const fcgGaps = [];
+        const fcgWellCovered = [];
+
+        for (const c of fcgCategories) {
+          if (fcgExcludeEmpty && c.count === 0) continue;
+          if (c.count < fcgMinPosts) {
+            const parentInfo = c.parent ? catMap.get(c.parent) : null;
+            fcgGaps.push({
+              taxonomy: 'category', id: c.id, name: c.name, slug: c.slug,
+              current_count: c.count, deficit: fcgMinPosts - c.count,
+              parent_name: parentInfo ? parentInfo.name : null,
+              parent_count: parentInfo ? parentInfo.count : null,
+              severity: c.count === 0 ? 'empty' : 'underrepresented',
+              suggestion: c.count === 0
+                ? `Create ${fcgMinPosts} posts for "${c.name}"`
+                : `Add ${fcgMinPosts - c.count} more posts for "${c.name}"`
+            });
+          } else {
+            fcgWellCovered.push({ taxonomy: 'category', id: c.id, name: c.name, count: c.count });
+          }
+        }
+
+        for (const t of fcgTags) {
+          if (fcgExcludeEmpty && t.count === 0) continue;
+          if (t.count < fcgMinPosts) {
+            fcgGaps.push({
+              taxonomy: 'post_tag', id: t.id, name: t.name, slug: t.slug,
+              current_count: t.count, deficit: fcgMinPosts - t.count,
+              parent_name: null, parent_count: null,
+              severity: t.count === 0 ? 'empty' : 'underrepresented',
+              suggestion: t.count === 0
+                ? `Create ${fcgMinPosts} posts for "${t.name}"`
+                : `Add ${fcgMinPosts - t.count} more posts for "${t.name}"`
+            });
+          } else {
+            fcgWellCovered.push({ taxonomy: 'post_tag', id: t.id, name: t.name, count: t.count });
+          }
+        }
+
+        fcgGaps.sort((a, b) => b.deficit - a.deficit || a.current_count - b.current_count);
+        fcgWellCovered.sort((a, b) => b.count - a.count);
+
+        const catGaps = fcgGaps.filter(g => g.taxonomy === 'category');
+        const tagGaps = fcgGaps.filter(g => g.taxonomy === 'post_tag');
+
+        result = json({
+          min_posts_threshold: fcgMinPosts,
+          total_terms_analyzed: fcgCategories.length + fcgTags.length,
+          gaps_found: fcgGaps.length,
+          gaps_by_taxonomy: { categories: catGaps.length, tags: tagGaps.length },
+          gaps: fcgGaps,
+          well_covered: fcgWellCovered.slice(0, 10)
+        });
+        auditLog({ tool: name, action: 'find_content_gaps', status: 'success', latency_ms: Date.now() - t0, params: { min_posts: fcgMinPosts, taxonomy: fcgTaxonomy, exclude_empty: fcgExcludeEmpty } });
+        break;
+      }
+
+      // ── wp_extract_faq_blocks ──
+      case 'wp_extract_faq_blocks': {
+        validateInput(args, {
+          limit: { type: 'number', min: 1, max: 200 },
+          post_type: { type: 'string', enum: ['post', 'page', 'both'] }
+        });
+        const { limit: efbLimit = 50, post_type: efbPostType = 'post' } = args;
+        const efbPerPage = Math.min(efbLimit, 200);
+        const efbFields = '_fields=id,title,slug,link,content';
+
+        let efbPosts = [];
+        if (efbPostType === 'both') {
+          const [posts, pages] = await Promise.all([
+            wpApiCall(`/posts?per_page=${efbPerPage}&status=publish&${efbFields}`),
+            wpApiCall(`/pages?per_page=${efbPerPage}&status=publish&${efbFields}`)
+          ]);
+          efbPosts = [...posts, ...pages];
+        } else {
+          const ep = efbPostType === 'page' ? '/pages' : '/posts';
+          efbPosts = await wpApiCall(`${ep}?per_page=${efbPerPage}&status=publish&${efbFields}`);
+        }
+
+        const efbLdRegex = /<script\s+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+        const efbYoastRegex = /<!-- wp:yoast\/faq-block -->([\s\S]*?)<!-- \/wp:yoast\/faq-block -->/gi;
+        const efbRankMathRegex = /<!-- wp:rank-math\/faq-block -->([\s\S]*?)<!-- \/wp:rank-math\/faq-block -->/gi;
+        const efbFaqHeadingRegex = /<h[2-4][^>]*>[^<]*(?:FAQ|Questions fréquentes|Questions courantes|Foire aux questions)[^<]*<\/h[2-4]>/gi;
+
+        let efbTotalQ = 0;
+        let efbPostsWithFaq = 0;
+        const efbBySource = { 'json-ld': 0, 'gutenberg-block': 0, 'html-pattern': 0 };
+
+        const efbResults = [];
+        for (const p of efbPosts) {
+          const html = p.content?.rendered || '';
+          const faqBlocks = [];
+
+          // Type A: JSON-LD FAQPage
+          efbLdRegex.lastIndex = 0;
+          let ldMatch;
+          while ((ldMatch = efbLdRegex.exec(html)) !== null) {
+            try {
+              const parsed = JSON.parse(ldMatch[1].trim());
+              const pType = Array.isArray(parsed['@type']) ? parsed['@type'] : [parsed['@type']];
+              if (pType.includes('FAQPage') && Array.isArray(parsed.mainEntity)) {
+                const questions = parsed.mainEntity
+                  .filter(q => q['@type'] === 'Question' && q.name)
+                  .map(q => ({ question: q.name, answer: (q.acceptedAnswer?.text || '').slice(0, 200) }));
+                if (questions.length > 0) {
+                  faqBlocks.push({ source: 'json-ld', plugin: null, questions_count: questions.length, questions });
+                  efbBySource['json-ld'] += questions.length;
+                  efbTotalQ += questions.length;
+                }
+              }
+            } catch { /* invalid JSON */ }
+          }
+
+          // Type B: Gutenberg FAQ blocks
+          const processGutenberg = (regex, plugin) => {
+            regex.lastIndex = 0;
+            let gMatch;
+            while ((gMatch = regex.exec(html)) !== null) {
+              const blockHtml = gMatch[1];
+              const questions = [];
+              const qRegex = /<(?:strong|h3)[^>]*class=["'][^"']*faq-question[^"']*["'][^>]*>([\s\S]*?)<\/(?:strong|h3)>/gi;
+              const aRegex = /<(?:p|div)[^>]*class=["'][^"']*faq-answer[^"']*["'][^>]*>([\s\S]*?)<\/(?:p|div)>/gi;
+              const qs = [];
+              const as = [];
+              let qm;
+              while ((qm = qRegex.exec(blockHtml)) !== null) qs.push(strip(qm[1]));
+              let am;
+              while ((am = aRegex.exec(blockHtml)) !== null) as.push(strip(am[1]).slice(0, 200));
+              for (let i = 0; i < qs.length; i++) {
+                questions.push({ question: qs[i], answer: as[i] || '' });
+              }
+              if (questions.length > 0) {
+                faqBlocks.push({ source: 'gutenberg-block', plugin, questions_count: questions.length, questions });
+                efbBySource['gutenberg-block'] += questions.length;
+                efbTotalQ += questions.length;
+              }
+            }
+          };
+          processGutenberg(efbYoastRegex, 'yoast');
+          processGutenberg(efbRankMathRegex, 'rankmath');
+
+          // Type C: HTML pattern FAQ
+          efbFaqHeadingRegex.lastIndex = 0;
+          if (efbFaqHeadingRegex.test(html)) {
+            const questions = [];
+            const h3pRegex = /<h3[^>]*>([\s\S]*?)<\/h3>\s*<p[^>]*>([\s\S]*?)<\/p>/gi;
+            const dtddRegex = /<dt[^>]*>([\s\S]*?)<\/dt>\s*<dd[^>]*>([\s\S]*?)<\/dd>/gi;
+            let hm;
+            while ((hm = h3pRegex.exec(html)) !== null) {
+              const q = strip(hm[1]);
+              if (q) questions.push({ question: q, answer: strip(hm[2]).slice(0, 200) });
+            }
+            if (questions.length === 0) {
+              while ((hm = dtddRegex.exec(html)) !== null) {
+                const q = strip(hm[1]);
+                if (q) questions.push({ question: q, answer: strip(hm[2]).slice(0, 200) });
+              }
+            }
+            if (questions.length > 0) {
+              faqBlocks.push({ source: 'html-pattern', plugin: null, questions_count: questions.length, questions });
+              efbBySource['html-pattern'] += questions.length;
+              efbTotalQ += questions.length;
+            }
+          }
+
+          const hasFaq = faqBlocks.length > 0;
+          if (hasFaq) efbPostsWithFaq++;
+
+          efbResults.push({
+            id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, link: p.link,
+            has_faq: hasFaq, faq_blocks: faqBlocks
+          });
+        }
+
+        let efbFiltered = efbPosts.length <= 10
+          ? efbResults
+          : efbResults.filter(r => r.has_faq);
+
+        efbFiltered.sort((a, b) => {
+          const qA = a.faq_blocks.reduce((s, f) => s + f.questions_count, 0);
+          const qB = b.faq_blocks.reduce((s, f) => s + f.questions_count, 0);
+          return qB - qA;
+        });
+
+        result = json({
+          total_analyzed: efbPosts.length,
+          posts_with_faq: efbPostsWithFaq,
+          total_questions: efbTotalQ,
+          faq_by_source: efbBySource,
+          posts: efbFiltered
+        });
+        auditLog({ tool: name, action: 'extract_faq_blocks', status: 'success', latency_ms: Date.now() - t0, params: { limit: efbLimit, post_type: efbPostType } });
+        break;
+      }
+
+      // ── wp_audit_cta_presence ──
+      case 'wp_audit_cta_presence': {
+        validateInput(args, {
+          limit: { type: 'number', min: 1, max: 200 },
+          post_type: { type: 'string', enum: ['post', 'page', 'both'] },
+          category_id: { type: 'number' }
+        });
+        const { limit: acpLimit = 50, post_type: acpPostType = 'post', category_id: acpCatId } = args;
+        const acpPerPage = Math.min(acpLimit, 200);
+        const acpFields = '_fields=id,title,slug,link,content,categories';
+
+        let acpPosts = [];
+        if (acpPostType === 'both') {
+          let postsUrl = `/posts?per_page=${acpPerPage}&status=publish&${acpFields}`;
+          if (acpCatId) postsUrl += `&categories=${acpCatId}`;
+          const [posts, pages] = await Promise.all([
+            wpApiCall(postsUrl),
+            wpApiCall(`/pages?per_page=${acpPerPage}&status=publish&${acpFields}`)
+          ]);
+          acpPosts = [...posts, ...pages];
+        } else {
+          const ep = acpPostType === 'page' ? '/pages' : '/posts';
+          let postsUrl = `${ep}?per_page=${acpPerPage}&status=publish&${acpFields}`;
+          if (acpCatId && acpPostType !== 'page') postsUrl += `&categories=${acpCatId}`;
+          acpPosts = await wpApiCall(postsUrl);
+        }
+
+        const CTA_CONTACT_HREFS = ['/contact', '/nous-contacter', '/contactez-nous', 'mailto:'];
+        const CTA_CONTACT_ANCHORS = ['contactez', 'contact', 'nous contacter'];
+        const CTA_FORM_PATTERNS = ['wpforms', 'cf7', 'gravity', 'elementor-form', 'formulaire', 'form'];
+        const CTA_BUTTON_TEXTS = ['devis', 'essai', 'commencer', 'inscription', "s'inscrire", 'acheter', 'commander', 'réserver', 'télécharger', 'download', 'get started', 'sign up', 'buy', 'order', 'book', 'subscribe'];
+        const CTA_QUOTE_TEXTS = ['devis', 'demande de devis', 'quote', 'request a quote', 'estimation'];
+        const CTA_SIGNUP_HREFS = ['/inscription', '/register', '/signup', '/trial', '/essai'];
+
+        let acpWithCta = 0;
+        let acpWithoutCta = 0;
+        const ctaTypeDist = { contact_link: 0, form: 0, button_cta: 0, phone_link: 0, quote_request: 0, signup_link: 0 };
+
+        const acpResults = [];
+        for (const p of acpPosts) {
+          const html = p.content?.rendered || '';
+          const lower = html.toLowerCase();
+          const ctas = [];
+          const ctaTypesFound = new Set();
+
+          // Scan all links
+          const linkRegex = /<a\b[^>]*href=["']([^"']*)["'][^>]*>([\s\S]*?)<\/a>/gi;
+          let lm;
+          while ((lm = linkRegex.exec(html)) !== null) {
+            const href = lm[1].toLowerCase();
+            const anchor = strip(lm[2]).toLowerCase();
+
+            if (CTA_CONTACT_HREFS.some(pat => href.includes(pat)) || CTA_CONTACT_ANCHORS.some(txt => anchor.includes(txt))) {
+              ctas.push({ type: 'contact_link', text: strip(lm[2]), href: lm[1] });
+              ctaTypesFound.add('contact_link');
+            }
+            if (href.startsWith('tel:')) {
+              ctas.push({ type: 'phone_link', text: strip(lm[2]), href: lm[1] });
+              ctaTypesFound.add('phone_link');
+            }
+            if (CTA_SIGNUP_HREFS.some(pat => href.includes(pat))) {
+              ctas.push({ type: 'signup_link', text: strip(lm[2]), href: lm[1] });
+              ctaTypesFound.add('signup_link');
+            }
+            if (CTA_QUOTE_TEXTS.some(txt => anchor.includes(txt))) {
+              ctas.push({ type: 'quote_request', text: strip(lm[2]), href: lm[1] });
+              ctaTypesFound.add('quote_request');
+            }
+          }
+
+          // Forms
+          if (/<form\b/i.test(html) || CTA_FORM_PATTERNS.some(pat => lower.includes(pat))) {
+            const formElement = CTA_FORM_PATTERNS.find(pat => lower.includes(pat)) || 'form';
+            ctas.push({ type: 'form', element: formElement });
+            ctaTypesFound.add('form');
+          }
+
+          // Button CTAs (by class)
+          const btnClassRegex = /<(?:button|a)\b[^>]*class=["'][^"']*(?:cta|btn-cta|call-to-action|bouton-action)[^"']*["'][^>]*>([\s\S]*?)<\/(?:button|a)>/gi;
+          let bm;
+          while ((bm = btnClassRegex.exec(html)) !== null) {
+            ctas.push({ type: 'button_cta', text: strip(bm[1]) });
+            ctaTypesFound.add('button_cta');
+          }
+          // Button CTAs (by text)
+          if (!ctaTypesFound.has('button_cta')) {
+            const btnTextRegex = /<button\b[^>]*>([\s\S]*?)<\/button>/gi;
+            let btm;
+            while ((btm = btnTextRegex.exec(html)) !== null) {
+              const btnText = strip(btm[1]).toLowerCase();
+              if (CTA_BUTTON_TEXTS.some(txt => btnText.includes(txt))) {
+                ctas.push({ type: 'button_cta', text: strip(btm[1]) });
+                ctaTypesFound.add('button_cta');
+                break;
+              }
+            }
+          }
+
+          const uniqueTypes = ctaTypesFound.size;
+          let ctaScore = 0;
+          if (uniqueTypes >= 3) ctaScore = 100;
+          else if (uniqueTypes === 2) ctaScore = 70;
+          else if (uniqueTypes === 1) ctaScore = 40;
+
+          const issues = [];
+          if (uniqueTypes === 0) { issues.push('no_cta'); acpWithoutCta++; }
+          else { acpWithCta++; }
+          if (uniqueTypes === 1) issues.push('single_cta_type');
+
+          for (const ct of ctaTypesFound) ctaTypeDist[ct]++;
+
+          acpResults.push({
+            id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, link: p.link,
+            cta_score: ctaScore, cta_count: ctas.length, cta_types: [...ctaTypesFound],
+            ctas, issues
+          });
+        }
+
+        acpResults.sort((a, b) => a.cta_score - b.cta_score);
+
+        const acpTotal = acpPosts.length;
+        result = json({
+          total_analyzed: acpTotal,
+          posts_with_cta: acpWithCta,
+          posts_without_cta: acpWithoutCta,
+          cta_coverage: acpTotal > 0 ? Math.round(acpWithCta / acpTotal * 100) : 0,
+          cta_type_distribution: ctaTypeDist,
+          posts: acpResults
+        });
+        auditLog({ tool: name, action: 'audit_cta_presence', status: 'success', latency_ms: Date.now() - t0, params: { limit: acpLimit, post_type: acpPostType, category_id: acpCatId } });
+        break;
+      }
+
+      // ── CONTENT INTELLIGENCE v4.4 Batch 4B ──
+
+      case 'wp_extract_entities': {
+        validateInput(args, { limit: { type: 'number', min: 1, max: 100 }, post_type: { type: 'string', enum: ['post', 'page'] }, min_occurrences: { type: 'number', min: 1 } });
+        const eeLimit = args.limit || 20;
+        const eePostType = args.post_type || 'post';
+        const eeMinOcc = args.min_occurrences || 2;
+
+        const eePosts = await wpApiCall(`/${eePostType}s?per_page=${eeLimit}&status=publish&_fields=id,title,content,slug`);
+
+        const globalEntities = new Map(); // name -> { type, count, post_ids, contexts }
+        const postResults = [];
+
+        for (const p of eePosts) {
+          const text = strip(p.content?.rendered || '');
+          const entities = extractEntities(text);
+          const localEntities = [];
+
+          for (const ent of entities) {
+            localEntities.push({ name: ent.name, type: ent.type, count: ent.count });
+            if (!globalEntities.has(ent.name)) {
+              globalEntities.set(ent.name, { type: ent.type, count: 0, post_ids: new Set(), contexts: [] });
+            }
+            const g = globalEntities.get(ent.name);
+            g.count += ent.count;
+            g.post_ids.add(p.id);
+            for (const ctx of ent.contexts) {
+              if (g.contexts.length < 2) g.contexts.push(ctx);
+            }
+          }
+
+          postResults.push({
+            id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug,
+            entities_count: localEntities.length,
+            entities: localEntities
+          });
+        }
+
+        // Filter by min_occurrences and build aggregated results
+        const filteredEntities = [...globalEntities.entries()]
+          .filter(([, v]) => v.count >= eeMinOcc)
+          .sort((a, b) => b[1].count - a[1].count);
+
+        const byType = { brand: 0, location: 0, person: 0, organization: 0, unknown: 0 };
+        for (const [, v] of filteredEntities) {
+          if (byType[v.type] !== undefined) byType[v.type]++;
+        }
+
+        result = json({
+          total_analyzed: eePosts.length,
+          total_entities_found: filteredEntities.length,
+          entities_by_type: byType,
+          top_entities: filteredEntities.slice(0, 20).map(([name, v]) => ({
+            name, type: v.type, total_count: v.count, post_ids: [...v.post_ids], contexts: v.contexts
+          })),
+          posts: postResults
+        });
+        auditLog({ tool: name, action: 'extract_entities', status: 'success', latency_ms: Date.now() - t0, params: { limit: eeLimit, post_type: eePostType, min_occurrences: eeMinOcc } });
+        break;
+      }
+
+      case 'wp_get_publishing_velocity': {
+        validateInput(args, { periods: { type: 'string' }, post_type: { type: 'string', enum: ['post', 'page'] }, limit: { type: 'number', min: 1, max: 500 } });
+        const pvPeriodsStr = args.periods || '30,90,180';
+        const pvPostType = args.post_type || 'post';
+        const pvLimit = args.limit || 200;
+
+        const periodDays = pvPeriodsStr.split(',').map(s => parseInt(s.trim(), 10)).filter(n => n > 0);
+        if (periodDays.length === 0) throw new Error('Invalid periods: must be comma-separated positive integers');
+
+        const pvPosts = await wpApiCall(`/${pvPostType}s?per_page=${pvLimit}&status=publish&orderby=date&order=desc&_fields=id,title,date,author,categories`);
+        const pvAuthors = await wpApiCall('/users?per_page=100&_fields=id,name');
+        const pvCategories = await wpApiCall('/categories?per_page=100&_fields=id,name');
+
+        const authorMap = new Map(pvAuthors.map(a => [a.id, a.name]));
+        const catMap = new Map(pvCategories.map(c => [c.id, c.name]));
+        const now = Date.now();
+
+        const periodsResult = periodDays.map(p => {
+          const cutoff = now - p * 86400000;
+          const inPeriod = pvPosts.filter(post => new Date(post.date).getTime() >= cutoff);
+          const velocity = Math.round(inPeriod.length / (p / 30) * 10) / 10;
+
+          // By author
+          const authorCounts = new Map();
+          for (const post of inPeriod) {
+            authorCounts.set(post.author, (authorCounts.get(post.author) || 0) + 1);
+          }
+          const byAuthor = [...authorCounts.entries()]
+            .map(([id, count]) => ({ id, name: authorMap.get(id) || `Author ${id}`, posts_count: count, velocity_per_month: Math.round(count / (p / 30) * 10) / 10 }))
+            .sort((a, b) => b.velocity_per_month - a.velocity_per_month);
+
+          // By category
+          const catCounts = new Map();
+          for (const post of inPeriod) {
+            for (const catId of (post.categories || [])) {
+              catCounts.set(catId, (catCounts.get(catId) || 0) + 1);
+            }
+          }
+          const byCategory = [...catCounts.entries()]
+            .map(([id, count]) => ({ id, name: catMap.get(id) || `Category ${id}`, posts_count: count, velocity_per_month: Math.round(count / (p / 30) * 10) / 10 }))
+            .sort((a, b) => b.velocity_per_month - a.velocity_per_month);
+
+          return { days: p, posts_count: inPeriod.length, velocity_per_month: velocity, by_author: byAuthor, by_category: byCategory };
+        });
+
+        // Trend calculation
+        const sortedPeriods = [...periodsResult].sort((a, b) => a.days - b.days);
+        const shortV = sortedPeriods[0].velocity_per_month;
+        const longV = sortedPeriods[sortedPeriods.length - 1].velocity_per_month;
+        const changePct = longV > 0 ? Math.round(((shortV - longV) / longV) * 100) : 0;
+        let direction = 'stable';
+        if (changePct > 20) direction = 'accelerating';
+        else if (changePct < -20) direction = 'decelerating';
+
+        // Top authors/categories from shortest period
+        const shortPeriod = sortedPeriods[0];
+
+        result = json({
+          total_posts_fetched: pvPosts.length,
+          post_type: pvPostType,
+          periods: periodsResult,
+          trend: { direction, short_period_velocity: shortV, long_period_velocity: longV, change_percent: changePct },
+          top_authors: shortPeriod.by_author.slice(0, 10),
+          top_categories: shortPeriod.by_category.slice(0, 10)
+        });
+        auditLog({ tool: name, action: 'publishing_velocity', status: 'success', latency_ms: Date.now() - t0, params: { periods: periodDays, post_type: pvPostType, limit: pvLimit } });
+        break;
+      }
+
+      case 'wp_compare_revisions_diff': {
+        validateInput(args, { post_id: { type: 'number', required: true }, revision_id_from: { type: 'number', required: true }, revision_id_to: { type: 'number' }, post_type: { type: 'string', enum: ['post', 'page'] } });
+        const crdPostId = args.post_id;
+        const crdRevFrom = args.revision_id_from;
+        const crdRevTo = args.revision_id_to;
+        const crdPostType = args.post_type || 'post';
+
+        const revFrom = await wpApiCall(`/${crdPostType}s/${crdPostId}/revisions/${crdRevFrom}?_fields=id,date,content,title`);
+        let revTo;
+        let revToId;
+        if (crdRevTo) {
+          revTo = await wpApiCall(`/${crdPostType}s/${crdPostId}/revisions/${crdRevTo}?_fields=id,date,content,title`);
+          revToId = crdRevTo;
+        } else {
+          revTo = await wpApiCall(`/${crdPostType}s/${crdPostId}?_fields=id,content,title,modified`);
+          revToId = 'current';
+        }
+
+        const textFrom = strip(revFrom.content?.rendered || revFrom.content || '');
+        const textTo = strip(revTo.content?.rendered || revTo.content || '');
+        const diff = computeTextDiff(textFrom, textTo);
+
+        const wcFrom = countWords(revFrom.content?.rendered || revFrom.content || '');
+        const wcTo = countWords(revTo.content?.rendered || revTo.content || '');
+
+        const headingsFrom = extractHeadingsOutline(revFrom.content?.rendered || revFrom.content || '');
+        const headingsTo = extractHeadingsOutline(revTo.content?.rendered || revTo.content || '');
+        const headingsFromSet = new Set(headingsFrom.map(h => `${h.level}:${h.text}`));
+        const headingsToSet = new Set(headingsTo.map(h => `${h.level}:${h.text}`));
+        const headingsAdded = headingsTo.filter(h => !headingsFromSet.has(`${h.level}:${h.text}`));
+        const headingsRemoved = headingsFrom.filter(h => !headingsToSet.has(`${h.level}:${h.text}`));
+
+        const amplitude = diff.change_ratio >= 0.5 ? 'major' : diff.change_ratio >= 0.2 ? 'moderate' : 'minor';
+
+        result = json({
+          post_id: crdPostId,
+          from: {
+            revision_id: crdRevFrom,
+            date: revFrom.date,
+            title: strip(revFrom.title?.rendered || revFrom.title || ''),
+            word_count: wcFrom
+          },
+          to: {
+            revision_id: revToId,
+            date: revTo.date || revTo.modified,
+            title: strip(revTo.title?.rendered || revTo.title || ''),
+            word_count: wcTo
+          },
+          diff: {
+            lines_added: diff.lines_added,
+            lines_removed: diff.lines_removed,
+            lines_unchanged: diff.lines_unchanged,
+            words_added: diff.words_added,
+            words_removed: diff.words_removed,
+            word_count_change: wcTo - wcFrom,
+            change_ratio: Math.round(diff.change_ratio * 1000) / 1000,
+            amplitude
+          },
+          headings_diff: { added: headingsAdded, removed: headingsRemoved },
+          sample_changes: {
+            added: diff.added_lines.slice(0, 10),
+            removed: diff.removed_lines.slice(0, 10)
+          }
+        });
+        auditLog({ tool: name, action: 'compare_revisions_diff', status: 'success', latency_ms: Date.now() - t0, params: { post_id: crdPostId, revision_id_from: crdRevFrom, revision_id_to: crdRevTo } });
+        break;
+      }
+
+      case 'wp_list_posts_by_word_count': {
+        validateInput(args, { limit: { type: 'number', min: 1, max: 500 }, post_type: { type: 'string', enum: ['post', 'page', 'both'] }, order: { type: 'string', enum: ['asc', 'desc'] }, category_id: { type: 'number' } });
+        const wclLimit = args.limit || 100;
+        const wclPostType = args.post_type || 'post';
+        const wclOrder = args.order || 'desc';
+        const wclCatId = args.category_id;
+
+        let wclPosts;
+        if (wclPostType === 'both') {
+          const catParam = wclCatId ? `&categories=${wclCatId}` : '';
+          const [postsArr, pagesArr] = await Promise.all([
+            wpApiCall(`/posts?per_page=${wclLimit}&status=publish&_fields=id,title,slug,link,content,date,modified,categories${catParam}`),
+            wpApiCall(`/pages?per_page=${wclLimit}&status=publish&_fields=id,title,slug,link,content,date,modified,categories`)
+          ]);
+          wclPosts = [...postsArr, ...pagesArr];
+        } else {
+          const catParam = wclCatId ? `&categories=${wclCatId}` : '';
+          wclPosts = await wpApiCall(`/${wclPostType}s?per_page=${wclLimit}&status=publish&_fields=id,title,slug,link,content,date,modified,categories${catParam}`);
+        }
+
+        const postsWithWc = wclPosts.map(p => {
+          const wc = countWords(p.content?.rendered || '');
+          let segment;
+          if (wc < 300) segment = 'very_short';
+          else if (wc < 600) segment = 'short';
+          else if (wc < 1000) segment = 'medium';
+          else if (wc < 2000) segment = 'standard';
+          else if (wc < 3000) segment = 'long';
+          else segment = 'very_long';
+
+          return {
+            id: p.id, title: strip(p.title?.rendered || ''), slug: p.slug, link: p.link,
+            word_count: wc, segment,
+            date: p.date, modified: p.modified,
+            categories: p.categories || []
+          };
+        });
+
+        postsWithWc.sort((a, b) => wclOrder === 'asc' ? a.word_count - b.word_count : b.word_count - a.word_count);
+
+        const counts = postsWithWc.map(p => p.word_count);
+        const total = counts.length || 1;
+        const avg = counts.reduce((s, c) => s + c, 0) / total;
+        const sorted = [...counts].sort((a, b) => a - b);
+        const median = sorted.length % 2 === 0 ? (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2 : sorted[Math.floor(sorted.length / 2)];
+
+        const dist = { very_short: 0, short: 0, medium: 0, standard: 0, long: 0, very_long: 0 };
+        for (const p of postsWithWc) dist[p.segment]++;
+        const distribution = {};
+        for (const [seg, count] of Object.entries(dist)) {
+          distribution[seg] = { count, percent: Math.round(count / total * 100) };
+        }
+
+        result = json({
+          total_analyzed: postsWithWc.length,
+          avg_word_count: Math.round(avg),
+          median_word_count: median,
+          min_word_count: sorted[0] || 0,
+          max_word_count: sorted[sorted.length - 1] || 0,
+          distribution,
+          posts: postsWithWc
+        });
+        auditLog({ tool: name, action: 'list_by_word_count', status: 'success', latency_ms: Date.now() - t0, params: { limit: wclLimit, post_type: wclPostType, order: wclOrder, category_id: wclCatId } });
+        break;
+      }
+
       default:
         throw new Error(`Unknown tool: "${name}".`);
     }
@@ -1364,4 +4484,4 @@ if (process.env.NODE_ENV !== 'test') {
   main().catch((error) => { log.error(`Fatal: ${error.message}`); process.exit(1); });
 }
 
-export { server };
+export { server, getActiveControls, getControlSources, _testSetTarget };