@adsim/wordpress-mcp-server 3.0.0 → 4.4.0

package/tests/unit/tools/contentIntelligence.test.js

@@ -0,0 +1,2168 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall, _testSetTarget } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+let consoleSpy;
+beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); _testSetTarget(null); });
+
+// =========================================================================
+// Helpers
+// =========================================================================
+
+function makeWpPost(id, content = '<p>Content</p>', extras = {}) {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    content: { rendered: content },
+    excerpt: { rendered: `Excerpt ${id}` },
+    status: 'publish',
+    date: '2025-06-01',
+    modified: '2025-06-02',
+    link: `https://test.example.com/post-${id}`,
+    slug: `post-${id}`,
+    categories: [3, 5],
+    tags: [7, 9],
+    author: 1,
+    featured_media: 42,
+    comment_status: 'open',
+    meta: {
+      rank_math_title: 'SEO Title',
+      rank_math_description: 'SEO Desc',
+      rank_math_focus_keyword: 'wordpress seo',
+      rank_math_canonical_url: 'https://test.example.com/post-1'
+    },
+    ...extras
+  };
+}
+
+const CATEGORY_RESPONSE = [
+  { id: 3, name: 'Tutorials' },
+  { id: 5, name: 'SEO' }
+];
+
+const TAG_RESPONSE = [
+  { id: 7, name: 'wordpress' },
+  { id: 9, name: 'guide' }
+];
+
+// =========================================================================
+// wp_get_content_brief
+// =========================================================================
+
+describe('wp_get_content_brief', () => {
+  it('NOMINAL — returns complete brief with all sections', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p>Introduction text for the post with enough content.</p><h2>Section One</h2><p>Body content here. <a href="https://test.example.com/other/">internal</a> <a href="https://external.com/page">ext</a></p><ul><li>Item</li></ul>';
+    mockSuccess(makeWpPost(1, html));     // post
+    mockSuccess(CATEGORY_RESPONSE);       // categories
+    mockSuccess(TAG_RESPONSE);            // tags
+
+    const res = await call('wp_get_content_brief', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data.id).toBe(1);
+    expect(data.title).toBe('Post 1');
+    expect(data.slug).toBe('post-1');
+    expect(data.word_count).toBeGreaterThan(0);
+    expect(data.readability).toHaveProperty('score');
+    expect(data.readability).toHaveProperty('level');
+    expect(data.seo).toHaveProperty('focus_keyword');
+    expect(data.structure).toHaveProperty('headings');
+    expect(data.structure).toHaveProperty('has_intro');
+    expect(data.categories).toHaveLength(2);
+    expect(data.tags).toHaveLength(2);
+    expect(data.internal_links).toHaveProperty('count');
+    expect(data.external_links).toHaveProperty('count');
+    expect(data.featured_media).toBe(42);
+  });
+
+  it('SEO — RankMath meta extracted correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(makeWpPost(1));
+    mockSuccess(CATEGORY_RESPONSE);
+    mockSuccess(TAG_RESPONSE);
+
+    const res = await call('wp_get_content_brief', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data.seo.title).toBe('SEO Title');
+    expect(data.seo.description).toBe('SEO Desc');
+    expect(data.seo.focus_keyword).toBe('wordpress seo');
+    expect(data.seo.canonical).toBe('https://test.example.com/post-1');
+  });
+
+  it('STRUCTURE — headings + lists + FAQ detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p>Intro paragraph with enough text for detection.</p><h2>First</h2><p>Text.</p><h2>FAQ</h2><p>Questions.</p><ul><li>A</li></ul><ol><li>B</li></ol><table><tr><td>C</td></tr></table>';
+    mockSuccess(makeWpPost(1, html));
+    mockSuccess(CATEGORY_RESPONSE);
+    mockSuccess(TAG_RESPONSE);
+
+    const res = await call('wp_get_content_brief', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data.structure.headings.length).toBeGreaterThan(0);
+    expect(data.structure.has_faq).toBe(true);
+    expect(data.structure.lists_count).toBe(2);
+    expect(data.structure.tables_count).toBe(1);
+  });
+
+  it('WORD COUNT and READABILITY calculated', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p>Le chat mange la souris. Le chien dort. Il fait beau.</p>';
+    mockSuccess(makeWpPost(1, html));
+    mockSuccess(CATEGORY_RESPONSE);
+    mockSuccess(TAG_RESPONSE);
+
+    const res = await call('wp_get_content_brief', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data.word_count).toBeGreaterThan(5);
+    expect(data.readability.score).toBeGreaterThan(0);
+    expect(typeof data.readability.avg_words_per_sentence).toBe('number');
+  });
+
+  it('CATEGORIES and TAGS resolved to names', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(makeWpPost(1));
+    mockSuccess(CATEGORY_RESPONSE);
+    mockSuccess(TAG_RESPONSE);
+
+    const res = await call('wp_get_content_brief', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data.categories).toEqual([{ id: 3, name: 'Tutorials' }, { id: 5, name: 'SEO' }]);
+    expect(data.tags).toEqual([{ id: 7, name: 'wordpress' }, { id: 9, name: 'guide' }]);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(makeWpPost(1));
+    mockSuccess(CATEGORY_RESPONSE);
+    mockSuccess(TAG_RESPONSE);
+
+    await call('wp_get_content_brief', { id: 1 });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_get_content_brief');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('content_brief');
+  });
+
+  it('ERROR — 404 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(404, '{"code":"rest_post_invalid_id","message":"Invalid post ID."}');
+
+    const res = await call('wp_get_content_brief', { id: 99999 });
+    expect(res.isError).toBe(true);
+  });
+
+  it('VALIDATION — missing id returns error', async () => {
+    const res = await call('wp_get_content_brief', {});
+    expect(res.isError).toBe(true);
+  });
+
+  it('PAGE — works with post_type page', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const pagePost = makeWpPost(10, '<p>Page content.</p>', { categories: [], tags: [] });
+    mockSuccess(pagePost);
+
+    const res = await call('wp_get_content_brief', { id: 10, post_type: 'page' });
+    const data = parseResult(res);
+
+    expect(data.id).toBe(10);
+    // Verify API was called with /pages/ endpoint
+    const fetchCalls = fetch.mock.calls;
+    expect(fetchCalls[0][0]).toContain('/pages/');
+  });
+});
+
+// =========================================================================
+// wp_extract_post_outline
+// =========================================================================
+
+describe('wp_extract_post_outline', () => {
+  function makeOutlinePost(id, headingsHtml, wordCount = 200) {
+    const words = Array(wordCount).fill('mot').join(' ');
+    return {
+      id,
+      title: { rendered: `Post ${id}` },
+      content: { rendered: `${headingsHtml}<p>${words}</p>` },
+      slug: `post-${id}`,
+      link: `https://test.example.com/post-${id}`,
+      meta: {}
+    };
+  }
+
+  it('NOMINAL — outlines + aggregated stats for 3 posts', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeOutlinePost(1, '<h2>Intro</h2><h3>Sub A</h3><h2>Body</h2>', 300),
+      makeOutlinePost(2, '<h2>Intro</h2><h2>Details</h2><h2>Body</h2>', 400),
+      makeOutlinePost(3, '<h2>Overview</h2><h2>Body</h2>', 200)
+    ]);
+
+    const res = await call('wp_extract_post_outline', { category_id: 5 });
+    const data = parseResult(res);
+
+    expect(data.category_id).toBe(5);
+    expect(data.posts_analyzed).toBe(3);
+    expect(data.avg_word_count).toBeGreaterThan(0);
+    expect(data.avg_headings_count).toBeGreaterThan(0);
+    expect(data.outlines).toHaveLength(3);
+    expect(data.outlines[0].headings.length).toBeGreaterThan(0);
+  });
+
+  it('COMMON H2 — recurring H2 patterns detected and ranked', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeOutlinePost(1, '<h2>Introduction</h2><h2>Conclusion</h2>'),
+      makeOutlinePost(2, '<h2>Introduction</h2><h2>Méthode</h2>'),
+      makeOutlinePost(3, '<h2>Introduction</h2><h2>Résultats</h2>')
+    ]);
+
+    const res = await call('wp_extract_post_outline', { category_id: 5 });
+    const data = parseResult(res);
+
+    expect(data.common_h2_patterns[0].text).toBe('introduction');
+    expect(data.common_h2_patterns[0].frequency).toBe(3);
+  });
+
+  it('AVG WORD COUNT calculated correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeOutlinePost(1, '<h2>A</h2>', 100),
+      makeOutlinePost(2, '<h2>B</h2>', 300)
+    ]);
+
+    const res = await call('wp_extract_post_outline', { category_id: 5 });
+    const data = parseResult(res);
+
+    // Word count includes heading text + words, so approximately 100-300 range per post
+    expect(data.avg_word_count).toBeGreaterThan(0);
+  });
+
+  it('POST WITHOUT HEADINGS — headings array is empty', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeOutlinePost(1, '', 100)]);
+
+    const res = await call('wp_extract_post_outline', { category_id: 5 });
+    const data = parseResult(res);
+
+    expect(data.outlines[0].headings).toEqual([]);
+    expect(data.outlines[0].headings_count).toBe(0);
+  });
+
+  it('EMPTY CATEGORY — 0 posts analyzed', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([]);
+
+    const res = await call('wp_extract_post_outline', { category_id: 999 });
+    const data = parseResult(res);
+
+    expect(data.posts_analyzed).toBe(0);
+    expect(data.outlines).toEqual([]);
+    expect(data.avg_word_count).toBe(0);
+    expect(data.common_h2_patterns).toEqual([]);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeOutlinePost(1, '<h2>A</h2>')]);
+
+    await call('wp_extract_post_outline', { category_id: 5 });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_extract_post_outline');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('extract_outline');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_extract_post_outline', { category_id: 5 });
+    expect(res.isError).toBe(true);
+  });
+
+  it('VALIDATION — missing category_id returns error', async () => {
+    const res = await call('wp_extract_post_outline', {});
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// Shared mock data for Week 2 tools
+// =========================================================================
+
+const SIMPLE_TEXT = '<p>Le chat mange la souris. Le chien dort dans le jardin. Il fait beau aujourd\'hui.</p>';
+const COMPLEX_TEXT = '<p>Nonobstant les considérations susmentionnées, l\'implémentation des mécanismes algorithmiques nécessite une compréhension approfondie des paradigmes computationnels contemporains utilisés dans les sciences et les humanités numériques modernes.</p>';
+const TEXT_WITH_TRANSITIONS = '<p>Le produit est bon. Cependant, il est cher. De plus, la livraison est lente. En effet, le délai est trop long. Toutefois, le service client est excellent.</p>';
+const PASSIVE_TEXT = '<p>Le rapport est rédigé par le comité. La décision a été prise hier. Le produit est vendu en ligne. Le contrat est signé par les parties.</p>';
+
+function makeReadabilityPost(id, content, extras = {}) {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    content: { rendered: content },
+    slug: `post-${id}`,
+    link: `https://test.example.com/post-${id}`,
+    categories: [3],
+    meta: {},
+    ...extras
+  };
+}
+
+function makeUpdateFreqPost(id, modified, meta = {}, content = '<p>' + Array(100).fill('mot').join(' ') + '</p>') {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    slug: `post-${id}`,
+    link: `https://test.example.com/post-${id}`,
+    date: '2024-01-01T00:00:00',
+    modified,
+    content: { rendered: content },
+    meta,
+    categories: [3]
+  };
+}
+
+function makeLinkMapPost(id, content) {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    slug: `post-${id}`,
+    link: `https://test.example.com/post-${id}`,
+    content: { rendered: content },
+    categories: [3]
+  };
+}
+
+// =========================================================================
+// wp_audit_readability
+// =========================================================================
+
+describe('wp_audit_readability', () => {
+  it('NOMINAL — 3 posts scored and sorted ASC', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const pad = ' ' + Array(120).fill('mot').join(' ');
+    mockSuccess([
+      makeReadabilityPost(1, SIMPLE_TEXT + pad),
+      makeReadabilityPost(2, COMPLEX_TEXT + pad),
+      makeReadabilityPost(3, TEXT_WITH_TRANSITIONS + pad)
+    ]);
+
+    const res = await call('wp_audit_readability');
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBeGreaterThan(0);
+    expect(data.avg_readability_score).toBeGreaterThan(0);
+    // Should be sorted ASC (worst first)
+    if (data.posts.length >= 2) {
+      expect(data.posts[0].readability.score).toBeLessThanOrEqual(data.posts[data.posts.length - 1].readability.score);
+    }
+  });
+
+  it('DISTRIBUTION — level buckets populated', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeReadabilityPost(1, SIMPLE_TEXT),
+      makeReadabilityPost(2, COMPLEX_TEXT)
+    ]);
+
+    const res = await call('wp_audit_readability');
+    const data = parseResult(res);
+
+    expect(data.distribution).toBeDefined();
+    const totalDist = Object.values(data.distribution).reduce((s, n) => s + n, 0);
+    expect(totalDist).toBe(data.total_analyzed);
+  });
+
+  it('ISSUES — low_readability detected for score < 40', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeReadabilityPost(1, COMPLEX_TEXT)]);
+
+    const res = await call('wp_audit_readability');
+    const data = parseResult(res);
+
+    if (data.posts.length > 0) {
+      const post = data.posts.find(p => p.readability.score < 40);
+      if (post) {
+        expect(post.issues).toEqual(expect.arrayContaining([expect.stringMatching(/low_readability/)]));
+      }
+    }
+  });
+
+  it('ISSUES — high_passive_ratio detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeReadabilityPost(1, PASSIVE_TEXT)]);
+
+    const res = await call('wp_audit_readability');
+    const data = parseResult(res);
+
+    if (data.posts.length > 0 && data.posts[0].passive_ratio > 0.3) {
+      expect(data.posts[0].issues).toContain('high_passive_ratio');
+    }
+  });
+
+  it('ISSUES — low_transition_density detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const noTransitions = '<p>' + Array(50).fill('Le chat dort.').join(' ') + '</p>';
+    mockSuccess([makeReadabilityPost(1, noTransitions)]);
+
+    const res = await call('wp_audit_readability');
+    const data = parseResult(res);
+
+    if (data.posts.length > 0) {
+      expect(data.posts[0].issues).toEqual(expect.arrayContaining([expect.stringMatching(/transition/)]));
+    }
+  });
+
+  it('FILTER — min_words excludes short posts', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeReadabilityPost(1, '<p>Court.</p>'),
+      makeReadabilityPost(2, '<p>' + Array(200).fill('mot').join(' ') + '</p>')
+    ]);
+
+    const res = await call('wp_audit_readability', { min_words: 100 });
+    const data = parseResult(res);
+
+    // Short post should be filtered out
+    expect(data.total_analyzed).toBe(1);
+  });
+
+  it('FILTER — category_id passed to API', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeReadabilityPost(1, '<p>' + Array(150).fill('mot').join(' ') + '</p>')]);
+
+    await call('wp_audit_readability', { category_id: 7 });
+
+    const fetchCalls = fetch.mock.calls;
+    expect(fetchCalls[0][0]).toContain('categories=7');
+  });
+
+  it('EMPTY — no posts matching → total_analyzed: 0', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeReadabilityPost(1, '<p>Court.</p>')]);
+
+    const res = await call('wp_audit_readability', { min_words: 9999 });
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(0);
+    expect(data.posts).toEqual([]);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeReadabilityPost(1, '<p>' + Array(150).fill('mot').join(' ') + '</p>')]);
+
+    await call('wp_audit_readability');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_readability');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_readability');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_readability');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_audit_update_frequency
+// =========================================================================
+
+describe('wp_audit_update_frequency', () => {
+  const recentDate = new Date().toISOString();
+  const oldDate200 = new Date(Date.now() - 200 * 86400000).toISOString();
+  const oldDate400 = new Date(Date.now() - 400 * 86400000).toISOString();
+
+  it('NOMINAL — filters and sorts by priority', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeUpdateFreqPost(1, recentDate),
+      makeUpdateFreqPost(2, oldDate200, {}),
+      makeUpdateFreqPost(3, oldDate400, {})
+    ]);
+
+    const res = await call('wp_audit_update_frequency');
+    const data = parseResult(res);
+
+    expect(data.total_published).toBe(3);
+    expect(data.outdated_count).toBe(2);
+    // Post 3 (400d) should have higher priority than post 2 (200d)
+    expect(data.posts[0].days_since_modified).toBeGreaterThan(data.posts[1].days_since_modified);
+  });
+
+  it('PRIORITY — old post + bad SEO → high priority', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeUpdateFreqPost(1, oldDate200, { rank_math_title: 'Title', rank_math_description: 'Desc', rank_math_focus_keyword: 'kw' }),
+      makeUpdateFreqPost(2, oldDate200, {})
+    ]);
+
+    const res = await call('wp_audit_update_frequency');
+    const data = parseResult(res);
+
+    // Post 2 (no SEO meta) should have higher priority than post 1 (good SEO)
+    const p1 = data.posts.find(p => p.id === 1);
+    const p2 = data.posts.find(p => p.id === 2);
+    expect(p2.priority_score).toBeGreaterThan(p1.priority_score);
+  });
+
+  it('ISSUES — outdated_365d for posts > 1 year', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeUpdateFreqPost(1, oldDate400, {})]);
+
+    const res = await call('wp_audit_update_frequency');
+    const data = parseResult(res);
+
+    expect(data.posts[0].issues).toContain('outdated_365d');
+  });
+
+  it('ISSUES — thin_content for word_count < 300', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeUpdateFreqPost(1, oldDate200, {}, '<p>Short content only.</p>')]);
+
+    const res = await call('wp_audit_update_frequency');
+    const data = parseResult(res);
+
+    expect(data.posts[0].issues).toContain('thin_content');
+  });
+
+  it('ISSUES — missing_seo_title detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeUpdateFreqPost(1, oldDate200, {})]);
+
+    const res = await call('wp_audit_update_frequency');
+    const data = parseResult(res);
+
+    expect(data.posts[0].issues).toContain('missing_seo_title');
+    expect(data.posts[0].issues).toContain('missing_meta_description');
+  });
+
+  it('SEO DISABLED — include_seo_score=false → seo_score null', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeUpdateFreqPost(1, oldDate200, {})]);
+
+    const res = await call('wp_audit_update_frequency', { include_seo_score: false });
+    const data = parseResult(res);
+
+    expect(data.posts[0].seo_score).toBeNull();
+    expect(data.posts[0].issues).not.toContain('missing_seo_title');
+  });
+
+  it('CUSTOM THRESHOLD — days_threshold=90 filters correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const oldDate100 = new Date(Date.now() - 100 * 86400000).toISOString();
+    mockSuccess([
+      makeUpdateFreqPost(1, recentDate),
+      makeUpdateFreqPost(2, oldDate100)
+    ]);
+
+    const res = await call('wp_audit_update_frequency', { days_threshold: 90 });
+    const data = parseResult(res);
+
+    expect(data.outdated_count).toBe(1);
+    expect(data.posts[0].id).toBe(2);
+  });
+
+  it('NONE OUTDATED — outdated_count: 0', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeUpdateFreqPost(1, recentDate)]);
+
+    const res = await call('wp_audit_update_frequency');
+    const data = parseResult(res);
+
+    expect(data.outdated_count).toBe(0);
+    expect(data.posts).toEqual([]);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeUpdateFreqPost(1, oldDate200)]);
+
+    await call('wp_audit_update_frequency');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_update_frequency');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_update_frequency');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_update_frequency');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_build_link_map
+// =========================================================================
+
+describe('wp_build_link_map', () => {
+  // Post A links to B and C, Post B links to A, Post C has no outbound links
+  const postA = makeLinkMapPost(1, '<p>Text <a href="https://test.example.com/post-2">link to B</a> and <a href="https://test.example.com/post-3">link to C</a></p>');
+  const postB = makeLinkMapPost(2, '<p>Text <a href="https://test.example.com/post-1">link to A</a></p>');
+  const postC = makeLinkMapPost(3, '<p>Text with no internal links.</p>');
+
+  it('NOMINAL — 3 posts with cross-links → matrix + PageRank', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA, postB, postC]);
+
+    const res = await call('wp_build_link_map');
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(3);
+    expect(data.total_internal_links).toBeGreaterThan(0);
+    expect(data.avg_outbound_per_post).toBeGreaterThan(0);
+    expect(data.posts).toHaveLength(3);
+    expect(data.link_matrix).toBeDefined();
+  });
+
+  it('ORPHAN — post C has no outbound, is not orphan (linked from A)', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA, postB, postC]);
+
+    const res = await call('wp_build_link_map');
+    const data = parseResult(res);
+
+    const pC = data.posts.find(p => p.id === 3);
+    expect(pC.inbound_count).toBeGreaterThan(0);
+    expect(pC.is_orphan).toBe(false);
+  });
+
+  it('PAGERANK — most-linked post has highest score', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // Post A is linked from B, Post B is linked from A, Post C is linked from A
+    mockSuccess([postA, postB, postC]);
+
+    const res = await call('wp_build_link_map');
+    const data = parseResult(res);
+
+    // Posts are sorted by pagerank DESC
+    expect(data.posts[0].pagerank_score).toBeGreaterThanOrEqual(data.posts[data.posts.length - 1].pagerank_score);
+  });
+
+  it('OUTBOUND — resolved links have target_id and target_title', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA, postB, postC]);
+
+    const res = await call('wp_build_link_map');
+    const data = parseResult(res);
+
+    const pA = data.posts.find(p => p.id === 1);
+    expect(pA.outbound_count).toBe(2);
+    expect(pA.outbound_links[0].target_id).toBeDefined();
+    expect(pA.outbound_links[0].target_title).toBeDefined();
+  });
+
+  it('UNRESOLVED — links to posts outside corpus counted', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const postWithExtCorpus = makeLinkMapPost(1, '<p><a href="https://test.example.com/unknown-post">link</a></p>');
+    mockSuccess([postWithExtCorpus]);
+
+    const res = await call('wp_build_link_map');
+    const data = parseResult(res);
+
+    expect(data.posts[0].unresolved_links).toBeGreaterThan(0);
+  });
+
+  it('BOTH — post_type=both triggers 2 API calls', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA]);  // posts
+    mockSuccess([postC]);  // pages
+
+    const res = await call('wp_build_link_map', { post_type: 'both' });
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(2);
+    // Verify 2 API calls were made
+    expect(fetch.mock.calls.length).toBe(2);
+    expect(fetch.mock.calls[0][0]).toContain('/posts');
+    expect(fetch.mock.calls[1][0]).toContain('/pages');
+  });
+
+  it('CATEGORY — category_id passed in query string', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA]);
+
+    await call('wp_build_link_map', { category_id: 5 });
+
+    expect(fetch.mock.calls[0][0]).toContain('categories=5');
+  });
+
+  it('MATRIX — link_matrix sparse format correct', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA, postB, postC]);
+
+    const res = await call('wp_build_link_map');
+    const data = parseResult(res);
+
+    // Post A (id:1) links to 2 and 3
+    expect(data.link_matrix['1']).toEqual(expect.arrayContaining([2, 3]));
+    // Post B (id:2) links to 1
+    expect(data.link_matrix['2']).toEqual([1]);
+    // Post C should not be in matrix (no outbound)
+    expect(data.link_matrix['3']).toBeUndefined();
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA, postB]);
+
+    await call('wp_build_link_map');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_build_link_map');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('build_link_map');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_build_link_map');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// Shared mock data for Week 3 tools
+// =========================================================================
+
+function makeAnchorPost(id, content) {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    slug: `post-${id}`,
+    link: `https://test.example.com/post-${id}`,
+    content: { rendered: content },
+    categories: [3]
+  };
+}
+
+function makeSchemaPost(id, content) {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    slug: `post-${id}`,
+    link: `https://test.example.com/post-${id}`,
+    content: { rendered: content },
+    categories: [3]
+  };
+}
+
+function makeStructurePost(id, content, extras = {}) {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    slug: `post-${id}`,
+    link: `https://test.example.com/post-${id}`,
+    content: { rendered: content },
+    categories: [3],
+    ...extras
+  };
+}
+
+// =========================================================================
+// wp_audit_anchor_texts
+// =========================================================================
+
+describe('wp_audit_anchor_texts', () => {
+  const postA = makeAnchorPost(1, '<p>Text <a href="https://test.example.com/post-2">guide SEO complet</a> and <a href="https://test.example.com/post-3">cliquez ici</a></p>');
+  const postB = makeAnchorPost(2, '<p>Text <a href="https://test.example.com/post-1">guide SEO complet</a> and <a href="https://test.example.com/post-3">autre ancre</a></p>');
+  const postC = makeAnchorPost(3, '<p>Text with no internal links.</p>');
+
+  it('NOMINAL — 3 posts with internal links → anchor health calculated', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA, postB, postC]);
+
+    const res = await call('wp_audit_anchor_texts');
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(3);
+    expect(data.total_internal_links).toBeGreaterThan(0);
+    expect(data.total_unique_anchors).toBeGreaterThan(0);
+    expect(data.anchor_health).toBeDefined();
+    expect(data.posts).toHaveLength(3);
+  });
+
+  it('GENERIC — "cliquez ici" detected as generic', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA]);
+
+    const res = await call('wp_audit_anchor_texts');
+    const data = parseResult(res);
+
+    expect(data.anchor_health.generic).toBeGreaterThan(0);
+    expect(data.generic_anchors.some(a => a.text === 'cliquez ici')).toBe(true);
+    const pA = data.posts.find(p => p.id === 1);
+    expect(pA.issues).toContain('has_generic_anchors');
+  });
+
+  it('OVER-OPTIMIZED — same anchor > 3 times to different targets', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // 4+ occurrences of "mot clé" to different targets
+    const overOpt = makeAnchorPost(4, '<p>' +
+      '<a href="https://test.example.com/post-1">mot clé</a> ' +
+      '<a href="https://test.example.com/post-2">mot clé</a> ' +
+      '<a href="https://test.example.com/post-3">mot clé</a> ' +
+      '<a href="https://test.example.com/post-5">mot clé</a>' +
+      '</p>');
+    const target5 = makeAnchorPost(5, '<p>Target.</p>');
+    mockSuccess([overOpt, postA, postB, postC, target5]);
+
+    const res = await call('wp_audit_anchor_texts');
+    const data = parseResult(res);
+
+    expect(data.anchor_health.over_optimized).toBeGreaterThan(0);
+    expect(data.over_optimized_anchors.length).toBeGreaterThan(0);
+  });
+
+  it('IMAGE LINK — empty anchor detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const imagePost = makeAnchorPost(10, '<p><a href="https://test.example.com/post-2"><img src="img.jpg"/></a></p>');
+    mockSuccess([imagePost, makeAnchorPost(2, '<p>No links.</p>')]);
+
+    const res = await call('wp_audit_anchor_texts');
+    const data = parseResult(res);
+
+    expect(data.anchor_health.image_link).toBeGreaterThan(0);
+    const pImg = data.posts.find(p => p.id === 10);
+    expect(pImg.issues).toContain('has_image_links');
+  });
+
+  it('DIVERSITY — score calculated correctly (unique/total)', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // Post with 4 links, 2 unique anchor texts → diversity = 0.5
+    const dupPost = makeAnchorPost(20, '<p>' +
+      '<a href="https://test.example.com/post-1">ancre A</a> ' +
+      '<a href="https://test.example.com/post-2">ancre A</a> ' +
+      '<a href="https://test.example.com/post-3">ancre B</a> ' +
+      '<a href="https://test.example.com/post-4">ancre B</a>' +
+      '</p>');
+    mockSuccess([dupPost, makeAnchorPost(1, ''), makeAnchorPost(2, ''), makeAnchorPost(3, ''), makeAnchorPost(4, '')]);
+
+    const res = await call('wp_audit_anchor_texts');
+    const data = parseResult(res);
+
+    const p20 = data.posts.find(p => p.id === 20);
+    expect(p20.diversity_score).toBe(0.5);
+  });
+
+  it('LOW DIVERSITY — diversity_score < 0.5 → issue flagged', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // 4 links, all same anchor → diversity = 0.25
+    const lowDiv = makeAnchorPost(30, '<p>' +
+      '<a href="https://test.example.com/post-1">same</a> ' +
+      '<a href="https://test.example.com/post-2">same</a> ' +
+      '<a href="https://test.example.com/post-3">same</a> ' +
+      '<a href="https://test.example.com/post-4">same</a>' +
+      '</p>');
+    mockSuccess([lowDiv, makeAnchorPost(1, ''), makeAnchorPost(2, ''), makeAnchorPost(3, ''), makeAnchorPost(4, '')]);
+
+    const res = await call('wp_audit_anchor_texts');
+    const data = parseResult(res);
+
+    const p30 = data.posts.find(p => p.id === 30);
+    expect(p30.diversity_score).toBeLessThan(0.5);
+    expect(p30.issues).toContain('low_anchor_diversity');
+  });
+
+  it('BOTH — post_type=both → 2 API calls', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA]); // posts
+    mockSuccess([postC]); // pages
+
+    await call('wp_audit_anchor_texts', { post_type: 'both' });
+
+    const urls = fetch.mock.calls.map(c => c[0]);
+    expect(urls.some(u => u.includes('/posts'))).toBe(true);
+    expect(urls.some(u => u.includes('/pages'))).toBe(true);
+  });
+
+  it('NO LINKS — corpus without internal links → total: 0', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeAnchorPost(1, '<p>No links here.</p>')]);
+
+    const res = await call('wp_audit_anchor_texts');
+    const data = parseResult(res);
+
+    expect(data.total_internal_links).toBe(0);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([postA]);
+
+    await call('wp_audit_anchor_texts');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_anchor_texts');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_anchor_texts');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_anchor_texts');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_audit_schema_markup
+// =========================================================================
+
+describe('wp_audit_schema_markup', () => {
+  const validArticle = '<script type="application/ld+json">{"@type":"Article","headline":"Test","datePublished":"2024-01-01","author":{"@type":"Person","name":"Georges"}}</script>';
+  const validFaq = '<script type="application/ld+json">{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Q1","acceptedAnswer":{"@type":"Answer","text":"A1"}}]}</script>';
+  const invalidFaq = '<script type="application/ld+json">{"@type":"FAQPage"}</script>';
+  const brokenJson = '<script type="application/ld+json">{invalid json here</script>';
+
+  it('NOMINAL — Article with valid JSON-LD → valid: true', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeSchemaPost(1, `<p>Content.</p>${validArticle}`)]);
+
+    const res = await call('wp_audit_schema_markup');
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(1);
+    expect(data.posts_with_schema).toBe(1);
+    expect(data.posts[0].schemas[0].type).toBe('Article');
+    expect(data.posts[0].schemas[0].valid).toBe(true);
+    expect(data.total_valid).toBe(1);
+  });
+
+  it('FAQPAGE — valid FAQPage schema detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeSchemaPost(1, `<p>Content.</p>${validFaq}`)]);
+
+    const res = await call('wp_audit_schema_markup');
+    const data = parseResult(res);
+
+    expect(data.posts[0].schemas[0].type).toBe('FAQPage');
+    expect(data.posts[0].schemas[0].valid).toBe(true);
+    expect(data.schema_type_distribution['FAQPage']).toBe(1);
+  });
+
+  it('FAQPAGE INVALID — missing mainEntity → missing_required_fields', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeSchemaPost(1, `<p>Content.</p>${invalidFaq}`)]);
+
+    const res = await call('wp_audit_schema_markup');
+    const data = parseResult(res);
+
+    expect(data.posts[0].schemas[0].valid).toBe(false);
+    expect(data.posts[0].schemas[0].missing_fields).toContain('mainEntity');
+    expect(data.posts[0].issues).toContain('missing_required_fields');
+  });
+
+  it('INVALID JSON — malformed JSON-LD → invalid_json issue', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeSchemaPost(1, `<p>Content.</p>${brokenJson}`)]);
+
+    const res = await call('wp_audit_schema_markup');
+    const data = parseResult(res);
+
+    expect(data.posts[0].issues).toContain('invalid_json');
+    expect(data.total_invalid).toBeGreaterThan(0);
+  });
+
+  it('NO SCHEMA — post without JSON-LD → no_schema issue', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeSchemaPost(1, '<p>Just plain content.</p>')]);
+
+    const res = await call('wp_audit_schema_markup');
+    const data = parseResult(res);
+
+    expect(data.posts_without_schema).toBe(1);
+    expect(data.posts[0].issues).toContain('no_schema');
+  });
+
+  it('MULTIPLE — post with 2 schemas → both listed', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeSchemaPost(1, `<p>Content.</p>${validArticle}${validFaq}`)]);
+
+    const res = await call('wp_audit_schema_markup');
+    const data = parseResult(res);
+
+    expect(data.posts[0].schemas_found).toBe(2);
+    expect(data.total_schemas_found).toBe(2);
+  });
+
+  it('NO ARTICLE — post with schema but no Article type → no_article_schema', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeSchemaPost(1, `<p>Content.</p>${validFaq}`)]);
+
+    const res = await call('wp_audit_schema_markup');
+    const data = parseResult(res);
+
+    expect(data.posts[0].issues).toContain('no_article_schema');
+  });
+
+  it('OTHER TYPE — unrecognized @type → valid: true, classified as other', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const otherSchema = '<script type="application/ld+json">{"@type":"Product","name":"Widget"}</script>';
+    mockSuccess([makeSchemaPost(1, `<p>Content.</p>${otherSchema}`)]);
+
+    const res = await call('wp_audit_schema_markup');
+    const data = parseResult(res);
+
+    expect(data.posts[0].schemas[0].valid).toBe(true);
+    expect(data.schema_type_distribution['other']).toBe(1);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeSchemaPost(1, '<p>Content.</p>')]);
+
+    await call('wp_audit_schema_markup');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_schema_markup');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_schema_markup');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_schema_markup');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_audit_content_structure
+// =========================================================================
+
+describe('wp_audit_content_structure', () => {
+  const wellStructured = '<p>Introduction du guide avec assez de contenu pour être détecté comme introduction.</p>' +
+    '<h2>Première partie</h2><p>Contenu de la première partie.</p>' +
+    '<ul><li>Item 1</li><li>Item 2</li></ul>' +
+    '<h2>Deuxième partie</h2><p>Contenu.</p><img src="test.jpg"/>' +
+    '<h2>FAQ</h2><p>Questions fréquentes.</p>' +
+    '<h2>Conclusion</h2><p>En conclusion, voici le résumé final de cet article.</p>';
+
+  const poorStructure = '<h2>Titre direct</h2><p>' + Array(200).fill('mot').join(' ') + '</p>';
+
+  it('NOMINAL — well-structured post → score >= 60', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeStructurePost(1, wellStructured)]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(1);
+    expect(data.posts[0].structure_score).toBeGreaterThanOrEqual(60);
+    expect(data.posts[0].features).toBeDefined();
+  });
+
+  it('HIGH SCORE — intro + conclusion + headings + images + lists → >= 80', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const rich = '<p>Introduction longue avec assez de contenu pour être détecté.</p>' +
+      '<h2>Section 1</h2><p>Texte.</p>' +
+      '<h2>Section 2</h2><p>Texte.</p><ul><li>A</li></ul><img src="a.jpg"/>' +
+      '<h2>Section 3</h2><p>Texte.</p><table><tr><td>X</td></tr></table>' +
+      '<h2>FAQ</h2><p>Questions.</p>' +
+      '<div class="toc"><a href="#s1">S1</a></div>' +
+      '<blockquote>Citation</blockquote>' +
+      '<h2>Conclusion</h2><p>Résumé final.</p>';
+    mockSuccess([makeStructurePost(1, rich)]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.posts[0].structure_score).toBeGreaterThanOrEqual(80);
+  });
+
+  it('FEATURE COVERAGE — percentages calculated correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // 1 post with intro + conclusion, 1 post without
+    mockSuccess([
+      makeStructurePost(1, wellStructured),
+      makeStructurePost(2, poorStructure)
+    ]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.feature_coverage).toBeDefined();
+    expect(typeof data.feature_coverage.intro).toBe('number');
+    expect(data.feature_coverage.intro).toBeGreaterThanOrEqual(0);
+    expect(data.feature_coverage.intro).toBeLessThanOrEqual(100);
+  });
+
+  it('NO INTRO — content starting with H2 → no_intro issue', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeStructurePost(1, poorStructure)]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.posts[0].features.has_intro).toBe(false);
+    expect(data.posts[0].issues).toContain('no_intro');
+  });
+
+  it('NO IMAGES — post without img tag → no_images issue', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeStructurePost(1, '<p>Intro text with enough words.</p><h2>Title</h2><p>Body content.</p>')]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.posts[0].features.images_count).toBe(0);
+    expect(data.posts[0].issues).toContain('no_images');
+  });
+
+  it('LONG PARAGRAPHS — avg > 150 → long_paragraphs issue', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // Single paragraph with 300+ words
+    const longPara = '<p>' + Array(300).fill('mot').join(' ') + '</p>';
+    mockSuccess([makeStructurePost(1, longPara)]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.posts[0].features.avg_paragraph_length).toBeGreaterThan(150);
+    expect(data.posts[0].issues).toContain('long_paragraphs');
+  });
+
+  it('LOW HEADING DENSITY — long post without headings → low_heading_density', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // 500+ words, 0 headings
+    const longNoHeadings = '<p>' + Array(500).fill('mot').join(' ') + '</p>';
+    mockSuccess([makeStructurePost(1, longNoHeadings)]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.posts[0].features.heading_density).toBeLessThan(0.3);
+    expect(data.posts[0].issues).toContain('low_heading_density');
+  });
+
+  it('TOC DETECTION — bloc with class "toc" detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const withToc = '<p>Intro.</p><div class="toc"><a href="#s1">Section 1</a></div><h2>Section 1</h2><p>Text.</p>';
+    mockSuccess([makeStructurePost(1, withToc)]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.posts[0].features.has_toc).toBe(true);
+  });
+
+  it('CATEGORY FILTER — category_id passed in query string', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeStructurePost(1, wellStructured)]);
+
+    await call('wp_audit_content_structure', { category_id: 7 });
+
+    const fetchCalls = fetch.mock.calls;
+    expect(fetchCalls[0][0]).toContain('categories=7');
+  });
+
+  it('DISTRIBUTION — buckets populated correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeStructurePost(1, wellStructured),
+      makeStructurePost(2, poorStructure)
+    ]);
+
+    const res = await call('wp_audit_content_structure');
+    const data = parseResult(res);
+
+    expect(data.distribution).toBeDefined();
+    const totalDist = data.distribution.excellent + data.distribution.good + data.distribution.average + data.distribution.poor;
+    expect(totalDist).toBe(data.total_analyzed);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeStructurePost(1, wellStructured)]);
+
+    await call('wp_audit_content_structure');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_content_structure');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_content_structure');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_content_structure');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// Helpers — Batch 4A
+// =========================================================================
+
+const dupContent1 = '<p>Le marketing digital est essentiel pour les entreprises modernes dans le monde actuel. La transformation numérique permet aux entreprises de développer leur présence en ligne et atteindre de nouveaux clients potentiels via les canaux numériques comme les moteurs de recherche, les réseaux sociaux et les campagnes publicitaires. Une stratégie marketing efficace combine le référencement naturel, le marketing de contenu et les publicités payantes pour maximiser la visibilité en ligne et générer des conversions significatives pour améliorer le retour sur investissement global.</p>';
+const dupContent2 = '<p>Le marketing digital est essentiel pour les sociétés modernes dans le monde actuel. La transformation numérique permet aux sociétés de développer leur présence sur internet et atteindre de nouveaux clients potentiels via les canaux numériques comme les moteurs de recherche, les réseaux sociaux et les campagnes publicitaires. Une stratégie marketing efficace combine le référencement naturel, le marketing de contenu et les publicités payantes pour maximiser la visibilité sur internet et générer des résultats significatifs pour améliorer le retour sur investissement global.</p>';
+const dupContent3 = '<p>La cuisine française est réputée dans le monde entier pour sa créativité et son raffinement exceptionnel. Les chefs français utilisent des techniques sophistiquées héritées de traditions centenaires pour préparer des plats exceptionnels avec des ingrédients frais et locaux au cœur de chaque recette depuis les entrées légères jusqu aux desserts élaborés. Chaque région possède ses spécialités culinaires qui reflètent le terroir et la culture locale avec une attention particulière aux saveurs authentiques et au patrimoine gastronomique régional.</p>';
+
+function makeDupPost(id, content) {
+  return { id, title: { rendered: `Post ${id}` }, slug: `post-${id}`, link: `https://test.example.com/post-${id}`, content: { rendered: content }, categories: [3] };
+}
+
+function makeFaqPost(id, content) {
+  return { id, title: { rendered: `Post ${id}` }, slug: `post-${id}`, link: `https://test.example.com/post-${id}`, content: { rendered: content }, categories: [3] };
+}
+
+function makeCtaPost(id, content) {
+  return { id, title: { rendered: `Post ${id}` }, slug: `post-${id}`, link: `https://test.example.com/post-${id}`, content: { rendered: content }, categories: [3] };
+}
+
+// =========================================================================
+// wp_find_duplicate_content
+// =========================================================================
+
+describe('wp_find_duplicate_content', () => {
+  it('NOMINAL — detects near-duplicate pair', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeDupPost(1, dupContent1), makeDupPost(2, dupContent2), makeDupPost(3, dupContent3)]);
+
+    const res = await call('wp_find_duplicate_content', { similarity_threshold: 0.6 });
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(3);
+    expect(data.duplicate_pairs_found).toBeGreaterThanOrEqual(1);
+    const pair12 = data.pairs.find(p => (p.post1.id === 1 && p.post2.id === 2) || (p.post1.id === 2 && p.post2.id === 1));
+    expect(pair12).toBeDefined();
+    expect(pair12.similarity).toBeGreaterThan(0.5);
+  });
+
+  it('SEVERITY — high similarity → critical', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // Same content = similarity ~1.0
+    mockSuccess([makeDupPost(1, dupContent1), makeDupPost(2, dupContent1)]);
+
+    const res = await call('wp_find_duplicate_content');
+    const data = parseResult(res);
+
+    expect(data.pairs[0].severity).toBe('critical');
+    expect(data.pairs[0].similarity).toBeGreaterThanOrEqual(0.9);
+  });
+
+  it('CLUSTERING — A~B and B~C → cluster {A,B,C}', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // 3 identical posts → all in one cluster
+    mockSuccess([makeDupPost(1, dupContent1), makeDupPost(2, dupContent1), makeDupPost(3, dupContent1)]);
+
+    const res = await call('wp_find_duplicate_content');
+    const data = parseResult(res);
+
+    expect(data.duplicate_clusters).toBe(1);
+    expect(data.clusters[0].posts).toHaveLength(3);
+  });
+
+  it('THRESHOLD — custom 0.95 → fewer pairs', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeDupPost(1, dupContent1), makeDupPost(2, dupContent2)]);
+
+    const res = await call('wp_find_duplicate_content', { similarity_threshold: 0.95 });
+    const data = parseResult(res);
+
+    // Not identical enough for 0.95 threshold
+    expect(data.duplicate_pairs_found).toBe(0);
+  });
+
+  it('SHORT POSTS — < 50 words filtered out', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const short = '<p>Très court.</p>';
+    mockSuccess([makeDupPost(1, short), makeDupPost(2, short)]);
+
+    const res = await call('wp_find_duplicate_content');
+    const data = parseResult(res);
+
+    expect(data.duplicate_pairs_found).toBe(0);
+  });
+
+  it('NO DUPLICATES — different content → 0 pairs', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeDupPost(1, dupContent1), makeDupPost(2, dupContent3)]);
+
+    const res = await call('wp_find_duplicate_content');
+    const data = parseResult(res);
+
+    expect(data.duplicate_pairs_found).toBe(0);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeDupPost(1, dupContent1)]);
+
+    await call('wp_find_duplicate_content');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_find_duplicate_content');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('find_duplicate_content');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_find_duplicate_content');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_find_content_gaps
+// =========================================================================
+
+const gapCategories = [
+  { id: 1, name: 'Tech', slug: 'tech', count: 10, description: '', parent: 0 },
+  { id: 2, name: 'SEO', slug: 'seo', count: 1, description: '', parent: 0 },
+  { id: 3, name: 'Empty Cat', slug: 'empty-cat', count: 0, description: '', parent: 1 }
+];
+
+const gapTags = [
+  { id: 10, name: 'wordpress', slug: 'wordpress', count: 8 },
+  { id: 11, name: 'seo-tips', slug: 'seo-tips', count: 2 },
+  { id: 12, name: 'unused', slug: 'unused', count: 0 }
+];
+
+describe('wp_find_content_gaps', () => {
+  it('NOMINAL — category with 1 post flagged as gap', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(gapCategories); // categories
+    mockSuccess(gapTags);       // tags
+
+    const res = await call('wp_find_content_gaps');
+    const data = parseResult(res);
+
+    expect(data.gaps_found).toBeGreaterThan(0);
+    const seoGap = data.gaps.find(g => g.name === 'SEO');
+    expect(seoGap).toBeDefined();
+    expect(seoGap.severity).toBe('underrepresented');
+    expect(seoGap.deficit).toBe(2); // min_posts=3 - count=1
+  });
+
+  it('EMPTY — category with 0 posts → severity empty', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(gapCategories);
+    mockSuccess(gapTags);
+
+    const res = await call('wp_find_content_gaps');
+    const data = parseResult(res);
+
+    const emptyGap = data.gaps.find(g => g.name === 'Empty Cat');
+    expect(emptyGap).toBeDefined();
+    expect(emptyGap.severity).toBe('empty');
+    expect(emptyGap.current_count).toBe(0);
+  });
+
+  it('EXCLUDE EMPTY — exclude_empty=true filters zero-count terms', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(gapCategories);
+    mockSuccess(gapTags);
+
+    const res = await call('wp_find_content_gaps', { exclude_empty: true });
+    const data = parseResult(res);
+
+    const emptyNames = data.gaps.map(g => g.name);
+    expect(emptyNames).not.toContain('Empty Cat');
+    expect(emptyNames).not.toContain('unused');
+  });
+
+  it('TAGS — under-represented tags detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(gapCategories);
+    mockSuccess(gapTags);
+
+    const res = await call('wp_find_content_gaps');
+    const data = parseResult(res);
+
+    expect(data.gaps_by_taxonomy.tags).toBeGreaterThan(0);
+    const tagGap = data.gaps.find(g => g.taxonomy === 'post_tag' && g.name === 'seo-tips');
+    expect(tagGap).toBeDefined();
+  });
+
+  it('TAXONOMY FILTER — taxonomy=category → only categories', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(gapCategories);
+
+    const res = await call('wp_find_content_gaps', { taxonomy: 'category' });
+    const data = parseResult(res);
+
+    expect(data.gaps_by_taxonomy.tags).toBe(0);
+    expect(data.gaps.every(g => g.taxonomy === 'category')).toBe(true);
+  });
+
+  it('WELL COVERED — high-count term in well_covered', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(gapCategories);
+    mockSuccess(gapTags);
+
+    const res = await call('wp_find_content_gaps');
+    const data = parseResult(res);
+
+    const techCovered = data.well_covered.find(w => w.name === 'Tech');
+    expect(techCovered).toBeDefined();
+    expect(techCovered.count).toBe(10);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(gapCategories);
+    mockSuccess(gapTags);
+
+    await call('wp_find_content_gaps');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_find_content_gaps');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('find_content_gaps');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_find_content_gaps');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_extract_faq_blocks
+// =========================================================================
+
+const faqJsonLd = '<script type="application/ld+json">{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What is SEO?","acceptedAnswer":{"@type":"Answer","text":"SEO stands for Search Engine Optimization."}},{"@type":"Question","name":"Why is SEO important?","acceptedAnswer":{"@type":"Answer","text":"SEO helps websites rank higher."}}]}</script>';
+
+const faqGutenbergYoast = '<!-- wp:yoast/faq-block --><div class="schema-faq"><div class="schema-faq-section"><strong class="schema-faq-question">How to install?</strong><p class="schema-faq-answer">Download and run the installer.</p></div></div><!-- /wp:yoast/faq-block -->';
+
+const faqHtmlPattern = '<h2>FAQ</h2><h3>Is it free?</h3><p>Yes, it is completely free.</p><h3>Where to download?</h3><p>Visit our website to download.</p>';
+
+describe('wp_extract_faq_blocks', () => {
+  it('JSON-LD — FAQPage questions extracted correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeFaqPost(1, faqJsonLd)]);
+
+    const res = await call('wp_extract_faq_blocks');
+    const data = parseResult(res);
+
+    expect(data.posts_with_faq).toBe(1);
+    expect(data.total_questions).toBe(2);
+    expect(data.faq_by_source['json-ld']).toBe(2);
+    const post = data.posts.find(p => p.id === 1);
+    expect(post.faq_blocks[0].source).toBe('json-ld');
+    expect(post.faq_blocks[0].questions).toHaveLength(2);
+    expect(post.faq_blocks[0].questions[0].question).toBe('What is SEO?');
+  });
+
+  it('GUTENBERG — Yoast FAQ block detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeFaqPost(1, faqGutenbergYoast)]);
+
+    const res = await call('wp_extract_faq_blocks');
+    const data = parseResult(res);
+
+    expect(data.posts_with_faq).toBe(1);
+    expect(data.faq_by_source['gutenberg-block']).toBeGreaterThan(0);
+    const block = data.posts[0].faq_blocks.find(b => b.source === 'gutenberg-block');
+    expect(block).toBeDefined();
+    expect(block.plugin).toBe('yoast');
+  });
+
+  it('HTML PATTERN — FAQ heading + H3/P questions extracted', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeFaqPost(1, faqHtmlPattern)]);
+
+    const res = await call('wp_extract_faq_blocks');
+    const data = parseResult(res);
+
+    expect(data.posts_with_faq).toBe(1);
+    expect(data.faq_by_source['html-pattern']).toBe(2);
+    const block = data.posts[0].faq_blocks.find(b => b.source === 'html-pattern');
+    expect(block.questions[0].question).toBe('Is it free?');
+  });
+
+  it('NO FAQ — post without FAQ → has_faq false', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeFaqPost(1, '<p>Just some regular content.</p>')]);
+
+    const res = await call('wp_extract_faq_blocks');
+    const data = parseResult(res);
+
+    expect(data.posts_with_faq).toBe(0);
+    // With <= 10 posts, all are included
+    expect(data.posts[0].has_faq).toBe(false);
+  });
+
+  it('MULTIPLE SOURCES — all listed in one post', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const combined = faqJsonLd + faqHtmlPattern;
+    mockSuccess([makeFaqPost(1, combined)]);
+
+    const res = await call('wp_extract_faq_blocks');
+    const data = parseResult(res);
+
+    const sources = data.posts[0].faq_blocks.map(b => b.source);
+    expect(sources).toContain('json-ld');
+    expect(sources).toContain('html-pattern');
+  });
+
+  it('ANSWER TRUNCATED — answer > 200 chars truncated', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const longAnswer = 'A'.repeat(300);
+    const jsonLd = `<script type="application/ld+json">{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Q?","acceptedAnswer":{"@type":"Answer","text":"${longAnswer}"}}]}</script>`;
+    mockSuccess([makeFaqPost(1, jsonLd)]);
+
+    const res = await call('wp_extract_faq_blocks');
+    const data = parseResult(res);
+
+    expect(data.posts[0].faq_blocks[0].questions[0].answer.length).toBeLessThanOrEqual(200);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeFaqPost(1, '<p>Content</p>')]);
+
+    await call('wp_extract_faq_blocks');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_extract_faq_blocks');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('extract_faq_blocks');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_extract_faq_blocks');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_audit_cta_presence
+// =========================================================================
+
+describe('wp_audit_cta_presence', () => {
+  it('NOMINAL — contact link + form → cta_score 70', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p>Text <a href="/contact">Contactez-nous</a></p><div class="wpforms-container">form</div>';
+    mockSuccess([makeCtaPost(1, html)]);
+
+    const res = await call('wp_audit_cta_presence');
+    const data = parseResult(res);
+
+    expect(data.posts_with_cta).toBe(1);
+    expect(data.posts[0].cta_score).toBe(70);
+    expect(data.posts[0].cta_types).toContain('contact_link');
+    expect(data.posts[0].cta_types).toContain('form');
+  });
+
+  it('NO CTA — post without CTA → score 0, no_cta issue', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeCtaPost(1, '<p>Just regular text without any call to action.</p>')]);
+
+    const res = await call('wp_audit_cta_presence');
+    const data = parseResult(res);
+
+    expect(data.posts_without_cta).toBe(1);
+    expect(data.posts[0].cta_score).toBe(0);
+    expect(data.posts[0].issues).toContain('no_cta');
+  });
+
+  it('BUTTON CTA — button with "devis" text detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p>Info</p><button>Demander un devis</button>';
+    mockSuccess([makeCtaPost(1, html)]);
+
+    const res = await call('wp_audit_cta_presence');
+    const data = parseResult(res);
+
+    expect(data.posts[0].cta_types).toContain('button_cta');
+    expect(data.cta_type_distribution.button_cta).toBe(1);
+  });
+
+  it('PHONE LINK — href="tel:" detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p>Call us: <a href="tel:+33123456789">+33 1 23 45 67 89</a></p>';
+    mockSuccess([makeCtaPost(1, html)]);
+
+    const res = await call('wp_audit_cta_presence');
+    const data = parseResult(res);
+
+    expect(data.posts[0].cta_types).toContain('phone_link');
+    expect(data.cta_type_distribution.phone_link).toBe(1);
+  });
+
+  it('FORM DETECTION — wpforms class detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p>Fill the form:</p><div class="wpforms-form">...</div>';
+    mockSuccess([makeCtaPost(1, html)]);
+
+    const res = await call('wp_audit_cta_presence');
+    const data = parseResult(res);
+
+    expect(data.posts[0].cta_types).toContain('form');
+    expect(data.posts[0].ctas.find(c => c.type === 'form').element).toBe('wpforms');
+  });
+
+  it('SINGLE CTA TYPE — 1 type → single_cta_type issue', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p><a href="/contact">Contact</a></p>';
+    mockSuccess([makeCtaPost(1, html)]);
+
+    const res = await call('wp_audit_cta_presence');
+    const data = parseResult(res);
+
+    expect(data.posts[0].cta_score).toBe(40);
+    expect(data.posts[0].issues).toContain('single_cta_type');
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeCtaPost(1, '<p>Content</p>')]);
+
+    await call('wp_audit_cta_presence');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_cta_presence');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_cta_presence');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_cta_presence');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_extract_entities (tool #76)
+// =========================================================================
+
+function makeEntityPost(id, content) {
+  return {
+    id, title: { rendered: `Post ${id}` }, content: { rendered: content },
+    slug: `post-${id}`, status: 'publish'
+  };
+}
+
+const entityContent1 = '<p>Google Analytics est un outil puissant pour le marketing digital. À Bruxelles, Marie Martin utilise Google Analytics pour ses clients. L\'agence AdSim est basée en Belgique.</p>';
+const entityContent2 = '<p>WordPress et WooCommerce sont des plateformes très populaires. Jean Dupont travaille chez Microsoft à Paris depuis cinq ans.</p>';
+
+describe('wp_extract_entities', () => {
+  it('NOMINAL — extracts entities with correct types', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeEntityPost(1, entityContent1), makeEntityPost(2, entityContent2)]);
+
+    const res = await call('wp_extract_entities', { min_occurrences: 1 });
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(2);
+    expect(data.total_entities_found).toBeGreaterThan(0);
+    expect(data.entities_by_type).toBeDefined();
+    expect(data.top_entities.length).toBeGreaterThan(0);
+    expect(data.posts).toHaveLength(2);
+  });
+
+  it('BRAND — detects known brand entities', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeEntityPost(1, entityContent2)]);
+
+    const res = await call('wp_extract_entities', { min_occurrences: 1 });
+    const data = parseResult(res);
+
+    const brands = data.top_entities.filter(e => e.type === 'brand');
+    const brandNames = brands.map(e => e.name);
+    expect(brandNames.some(n => n.includes('WordPress') || n.includes('WooCommerce') || n.includes('Microsoft'))).toBe(true);
+  });
+
+  it('LOCATION — detects known location entities', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeEntityPost(1, entityContent1)]);
+
+    const res = await call('wp_extract_entities', { min_occurrences: 1 });
+    const data = parseResult(res);
+
+    const locs = data.top_entities.filter(e => e.type === 'location');
+    expect(locs.some(e => e.name === 'Bruxelles' || e.name === 'Belgique')).toBe(true);
+  });
+
+  it('PERSON — detects person entities', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeEntityPost(1, entityContent2)]);
+
+    const res = await call('wp_extract_entities', { min_occurrences: 1 });
+    const data = parseResult(res);
+
+    const persons = data.top_entities.filter(e => e.type === 'person');
+    expect(persons.some(e => e.name === 'Jean Dupont')).toBe(true);
+  });
+
+  it('MIN_OCCURRENCES — filters entities below threshold', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeEntityPost(1, '<p>Le site utilise Shopify pour vendre en ligne.</p>')]);
+
+    const res = await call('wp_extract_entities', { min_occurrences: 5 });
+    const data = parseResult(res);
+
+    expect(data.total_entities_found).toBe(0);
+  });
+
+  it('DEDUPLICATION — same entity counted multiple times', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeEntityPost(1, entityContent1)]);
+
+    const res = await call('wp_extract_entities', { min_occurrences: 1 });
+    const data = parseResult(res);
+
+    const ga = data.top_entities.find(e => e.name === 'Google Analytics');
+    if (ga) {
+      expect(ga.total_count).toBeGreaterThanOrEqual(2);
+    }
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeEntityPost(1, entityContent1)]);
+
+    await call('wp_extract_entities', { min_occurrences: 1 });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_extract_entities');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('extract_entities');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_extract_entities');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_get_publishing_velocity (tool #77)
+// =========================================================================
+
+function makeDatedPost(id, daysAgo, author = 1, categories = [1]) {
+  const d = new Date(Date.now() - daysAgo * 86400000);
+  return {
+    id, title: { rendered: `Post ${id}` },
+    date: d.toISOString(),
+    author,
+    categories
+  };
+}
+
+const pvAuthors = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+const pvCategories = [{ id: 1, name: 'Tech' }, { id: 2, name: 'Marketing' }];
+
+describe('wp_get_publishing_velocity', () => {
+  it('NOMINAL — calculates velocity by period', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // posts, authors, categories
+    mockSuccess([
+      makeDatedPost(1, 5, 1, [1]), makeDatedPost(2, 10, 1, [1]),
+      makeDatedPost(3, 20, 2, [2]), makeDatedPost(4, 60, 1, [1]),
+      makeDatedPost(5, 100, 2, [2]), makeDatedPost(6, 150, 1, [2])
+    ]);
+    mockSuccess(pvAuthors);
+    mockSuccess(pvCategories);
+
+    const res = await call('wp_get_publishing_velocity');
+    const data = parseResult(res);
+
+    expect(data.total_posts_fetched).toBe(6);
+    expect(data.periods).toHaveLength(3); // default 30,90,180
+    expect(data.periods[0].days).toBe(30);
+    expect(data.periods[0].velocity_per_month).toBeGreaterThan(0);
+    expect(data.trend).toBeDefined();
+    expect(['accelerating', 'stable', 'decelerating']).toContain(data.trend.direction);
+  });
+
+  it('BY AUTHOR — authors have different velocities', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeDatedPost(1, 5, 1, [1]), makeDatedPost(2, 10, 1, [1]),
+      makeDatedPost(3, 20, 1, [1]), makeDatedPost(4, 25, 2, [2])
+    ]);
+    mockSuccess(pvAuthors);
+    mockSuccess(pvCategories);
+
+    const res = await call('wp_get_publishing_velocity', { periods: '30' });
+    const data = parseResult(res);
+
+    const period = data.periods[0];
+    expect(period.by_author.length).toBeGreaterThan(0);
+    // Alice (author 1) should have more posts
+    const alice = period.by_author.find(a => a.name === 'Alice');
+    expect(alice).toBeDefined();
+    expect(alice.posts_count).toBe(3);
+  });
+
+  it('BY CATEGORY — categories counted correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeDatedPost(1, 5, 1, [1]), makeDatedPost(2, 10, 1, [2]),
+      makeDatedPost(3, 20, 2, [1])
+    ]);
+    mockSuccess(pvAuthors);
+    mockSuccess(pvCategories);
+
+    const res = await call('wp_get_publishing_velocity', { periods: '30' });
+    const data = parseResult(res);
+
+    const period = data.periods[0];
+    const tech = period.by_category.find(c => c.name === 'Tech');
+    expect(tech).toBeDefined();
+    expect(tech.posts_count).toBe(2);
+  });
+
+  it('TREND ACCELERATING — more recent posts', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // 5 posts in last 30 days, only 5 total in 180 days → short velocity much higher
+    mockSuccess([
+      makeDatedPost(1, 2), makeDatedPost(2, 5), makeDatedPost(3, 10),
+      makeDatedPost(4, 15), makeDatedPost(5, 25)
+    ]);
+    mockSuccess(pvAuthors);
+    mockSuccess(pvCategories);
+
+    const res = await call('wp_get_publishing_velocity', { periods: '30,180' });
+    const data = parseResult(res);
+
+    // All 5 posts are within 30 days, so short and long velocity are the same
+    // For accelerating, we need more in short period vs long period avg
+    expect(data.trend).toBeDefined();
+  });
+
+  it('CUSTOM PERIODS — parses correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeDatedPost(1, 3)]);
+    mockSuccess(pvAuthors);
+    mockSuccess(pvCategories);
+
+    const res = await call('wp_get_publishing_velocity', { periods: '7,30,60' });
+    const data = parseResult(res);
+
+    expect(data.periods).toHaveLength(3);
+    expect(data.periods[0].days).toBe(7);
+    expect(data.periods[1].days).toBe(30);
+    expect(data.periods[2].days).toBe(60);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeDatedPost(1, 5)]);
+    mockSuccess(pvAuthors);
+    mockSuccess(pvCategories);
+
+    await call('wp_get_publishing_velocity');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_get_publishing_velocity');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('publishing_velocity');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_get_publishing_velocity');
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_compare_revisions_diff (tool #78)
+// =========================================================================
+
+const revisionFrom = {
+  id: 101, date: '2025-05-01T10:00:00',
+  content: { rendered: 'Paragraphe original.\nTitre original\nContenu original.\nLigne quatre.\nLigne cinq.\nLigne six.\nLigne sept.\nLigne huit.\nLigne neuf.\nLigne dix.' },
+  title: { rendered: 'Mon Article' }
+};
+
+const revisionTo = {
+  id: 102, date: '2025-06-01T10:00:00',
+  content: { rendered: 'Paragraphe modifié.\nTitre original\n<h2>Nouveau titre</h2>\nContenu original.\nNouveau paragraphe ajouté.\nLigne quatre.\nLigne cinq.\nLigne six modifiée.\nLigne sept.\nLigne huit.\nLigne neuf.\nLigne dix.' },
+  title: { rendered: 'Mon Article Mis à Jour' }
+};
+
+const revisionMinor = {
+  id: 103, date: '2025-06-01T10:00:00',
+  content: { rendered: 'Paragraphe original.\nTitre original\nContenu original.\nLigne quatre.\nLigne cinq.\nLigne six.\nLigne sept.\nLigne huit.\nLigne neuf modifiée.\nLigne dix.' },
+  title: { rendered: 'Mon Article' }
+};
+
+describe('wp_compare_revisions_diff', () => {
+  it('NOMINAL — diff between two revisions', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(revisionFrom);
+    mockSuccess(revisionTo);
+
+    const res = await call('wp_compare_revisions_diff', { post_id: 1, revision_id_from: 101, revision_id_to: 102 });
+    const data = parseResult(res);
+
+    expect(data.post_id).toBe(1);
+    expect(data.from.revision_id).toBe(101);
+    expect(data.to.revision_id).toBe(102);
+    expect(data.diff.lines_added).toBeGreaterThan(0);
+    expect(data.diff.change_ratio).toBeGreaterThan(0);
+    expect(data.diff.amplitude).toBeDefined();
+  });
+
+  it('AMPLITUDE MAJOR — large changes', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const bigFrom = { id: 101, date: '2025-05-01', content: { rendered: '<p>Ancien contenu complet.</p>' }, title: { rendered: 'Old' } };
+    const bigTo = { id: 102, date: '2025-06-01', content: { rendered: '<p>Tout nouveau contenu entièrement réécrit avec beaucoup plus de texte.</p><p>Deuxième paragraphe ajouté.</p><p>Troisième paragraphe.</p>' }, title: { rendered: 'New' } };
+    mockSuccess(bigFrom);
+    mockSuccess(bigTo);
+
+    const res = await call('wp_compare_revisions_diff', { post_id: 1, revision_id_from: 101, revision_id_to: 102 });
+    const data = parseResult(res);
+
+    expect(data.diff.amplitude).toBe('major');
+  });
+
+  it('AMPLITUDE MINOR — small changes', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(revisionFrom);
+    mockSuccess(revisionMinor);
+
+    const res = await call('wp_compare_revisions_diff', { post_id: 1, revision_id_from: 101, revision_id_to: 103 });
+    const data = parseResult(res);
+
+    expect(data.diff.amplitude).toBe('minor');
+  });
+
+  it('HEADINGS DIFF — detects added headings', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(revisionFrom);
+    mockSuccess(revisionTo);
+
+    const res = await call('wp_compare_revisions_diff', { post_id: 1, revision_id_from: 101, revision_id_to: 102 });
+    const data = parseResult(res);
+
+    expect(data.headings_diff.added.length).toBeGreaterThan(0);
+    expect(data.headings_diff.added.some(h => h.text === 'Nouveau titre')).toBe(true);
+  });
+
+  it('CURRENT POST — omitting revision_id_to compares with current', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(revisionFrom);
+    mockSuccess({ id: 1, content: { rendered: '<p>Contenu actuel du post.</p>' }, title: { rendered: 'Current' }, modified: '2025-06-15T10:00:00' });
+
+    const res = await call('wp_compare_revisions_diff', { post_id: 1, revision_id_from: 101 });
+    const data = parseResult(res);
+
+    expect(data.to.revision_id).toBe('current');
+    expect(data.to.date).toBe('2025-06-15T10:00:00');
+  });
+
+  it('WORD COUNT — change calculated correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(revisionFrom);
+    mockSuccess(revisionTo);
+
+    const res = await call('wp_compare_revisions_diff', { post_id: 1, revision_id_from: 101, revision_id_to: 102 });
+    const data = parseResult(res);
+
+    expect(typeof data.from.word_count).toBe('number');
+    expect(typeof data.to.word_count).toBe('number');
+    expect(data.diff.word_count_change).toBe(data.to.word_count - data.from.word_count);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(revisionFrom);
+    mockSuccess(revisionTo);
+
+    await call('wp_compare_revisions_diff', { post_id: 1, revision_id_from: 101, revision_id_to: 102 });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_compare_revisions_diff');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('compare_revisions_diff');
+  });
+
+  it('ERROR — 404 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(404, '{"code":"rest_post_invalid_id","message":"Invalid revision ID"}');
+
+    const res = await call('wp_compare_revisions_diff', { post_id: 1, revision_id_from: 999 });
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_list_posts_by_word_count (tool #79)
+// =========================================================================
+
+function makeWordCountPost(id, wordCount) {
+  // Generate content with approximately wordCount words
+  const words = Array(wordCount).fill('mot').join(' ');
+  return {
+    id, title: { rendered: `Post ${id}` },
+    content: { rendered: `<p>${words}</p>` },
+    slug: `post-${id}`, link: `https://test.example.com/post-${id}`,
+    date: '2025-06-01', modified: '2025-06-02',
+    categories: [1]
+  };
+}
+
+describe('wp_list_posts_by_word_count', () => {
+  it('NOMINAL — posts sorted by word count DESC', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeWordCountPost(1, 100), makeWordCountPost(2, 450),
+      makeWordCountPost(3, 800), makeWordCountPost(4, 1500), makeWordCountPost(5, 3500)
+    ]);
+
+    const res = await call('wp_list_posts_by_word_count');
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(5);
+    expect(data.posts[0].word_count).toBeGreaterThanOrEqual(data.posts[1].word_count);
+    expect(data.posts[1].word_count).toBeGreaterThanOrEqual(data.posts[2].word_count);
+  });
+
+  it('ORDER ASC — posts sorted ascending', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeWordCountPost(1, 500), makeWordCountPost(2, 100), makeWordCountPost(3, 2000)]);
+
+    const res = await call('wp_list_posts_by_word_count', { order: 'asc' });
+    const data = parseResult(res);
+
+    expect(data.posts[0].word_count).toBeLessThanOrEqual(data.posts[1].word_count);
+    expect(data.posts[1].word_count).toBeLessThanOrEqual(data.posts[2].word_count);
+  });
+
+  it('DISTRIBUTION — segments calculated correctly', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeWordCountPost(1, 100),   // very_short
+      makeWordCountPost(2, 450),   // short
+      makeWordCountPost(3, 800),   // medium
+      makeWordCountPost(4, 1500),  // standard
+      makeWordCountPost(5, 3500)   // very_long
+    ]);
+
+    const res = await call('wp_list_posts_by_word_count');
+    const data = parseResult(res);
+
+    expect(data.distribution.very_short.count).toBe(1);
+    expect(data.distribution.short.count).toBe(1);
+    expect(data.distribution.medium.count).toBe(1);
+    expect(data.distribution.standard.count).toBe(1);
+    expect(data.distribution.very_long.count).toBe(1);
+  });
+
+  it('STATS — avg, median, min, max correct', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makeWordCountPost(1, 100), makeWordCountPost(2, 200), makeWordCountPost(3, 300)
+    ]);
+
+    const res = await call('wp_list_posts_by_word_count');
+    const data = parseResult(res);
+
+    expect(data.min_word_count).toBeLessThanOrEqual(data.max_word_count);
+    expect(data.avg_word_count).toBeGreaterThan(0);
+    expect(data.median_word_count).toBeGreaterThan(0);
+  });
+
+  it('POST_TYPE BOTH — fetches posts and pages', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeWordCountPost(1, 500), makeWordCountPost(2, 800)]); // posts
+    mockSuccess([makeWordCountPost(3, 300)]); // pages
+
+    const res = await call('wp_list_posts_by_word_count', { post_type: 'both' });
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(3);
+  });
+
+  it('CATEGORY — filter passed to query', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeWordCountPost(1, 500)]);
+
+    const res = await call('wp_list_posts_by_word_count', { category_id: 5 });
+    const data = parseResult(res);
+
+    expect(data.total_analyzed).toBe(1);
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeWordCountPost(1, 500)]);
+
+    await call('wp_list_posts_by_word_count');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_list_posts_by_word_count');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('list_by_word_count');
+  });
+
+  it('ERROR — 403 returns isError', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_list_posts_by_word_count');
+    expect(res.isError).toBe(true);
+  });
+});