@respira/wordpress-mcp-server 6.11.12 → 6.12.0

package/dist/server.js

@@ -6,11 +6,37 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
 import { WordPressClient } from './wordpress-client.js';
 import { RespiraVersionChecker } from './version-checker.js';
 import { getBricksTools, dispatchBricksTool } from './bricks-tools.js';
 import { getElementorTools, dispatchElementorTool } from './elementor-tools.js';
 import { getAcfTools, ACF_TOOL_NAMES } from './acf-tools.js';
+/**
+ * Read the server version from package.json at module load time so the
+ * MCP handshake, the `instructions` block, and the version-checker all
+ * report the actual installed version instead of a stale hard-coded
+ * string. K.B. on the customer site reported v6.11.13 self-identifying
+ * as 6.11.4 because the constant below was last hand-bumped at the
+ * 6.11.4 release and never tracked subsequent npm publishes. Mirrors
+ * the existing MCP_CLIENT_VERSION helper in wordpress-client.ts.
+ */
+const MCP_SERVER_VERSION = (() => {
+    try {
+        const currentDir = dirname(fileURLToPath(import.meta.url));
+        const packageJsonPath = resolve(currentDir, '../package.json');
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        if (typeof packageJson.version === 'string' && packageJson.version.trim()) {
+            return packageJson.version.trim();
+        }
+    }
+    catch {
+        // Fall through to the literal fallback below.
+    }
+    return 'unknown';
+})();
 /**
  * Thrown by the per-call watchdog when a tool handler exceeds its deadline.
  * Surfaces as a structured `tool_timeout` response so the stdio loop stays
@@ -32,6 +58,43 @@ class ToolTimeoutError extends Error {
 function getMaxToolTimeoutMs() {
     return Math.max(5000, parseInt(process.env.RESPIRA_MAX_TOOL_TIMEOUT_MS || '120000', 10));
 }
+/**
+ * v6.12.0: Tool names that do NOT receive the optional site_id input parameter.
+ * These tools operate on global Respira config or pre-site setup state, so a
+ * per-call site override doesn't apply:
+ *   - list_sites: returns all configured sites
+ *   - get_active_site: returns the global current site (a per-call override
+ *     would be meaningless here; if you want a specific site's summary, look
+ *     at list_sites)
+ *   - switch_site: already takes site_id with the explicit semantics of
+ *     flipping the global current site (different intent from per-call override)
+ *   - redeem_token: pre-site setup; no site exists yet
+ */
+const SITE_AGNOSTIC_TOOLS = new Set([
+    'wordpress_list_sites',
+    'wordpress_get_active_site',
+    'wordpress_switch_site',
+    'wordpress_redeem_token',
+    'respira_list_sites',
+    'respira_get_active_site',
+    'respira_switch_site',
+    'respira_redeem_token',
+]);
+/**
+ * v6.12.0: Schema fragment auto-injected into every non-agnostic tool's
+ * inputSchema.properties. Lets callers override the active site on a single
+ * tool call without flipping the global current site.
+ *
+ * Solves the Cowork multi-chat contamination: when Cowork runs many chat
+ * sessions through one shared MCP server process, switch_site mutates the
+ * global current site for all sessions. Passing site_id per call sidesteps
+ * the shared state entirely. T.S. (studioscaler) reported the symptom
+ * 2026-05-16 across his multi-site workflow.
+ */
+const SITE_ID_PROPERTY = {
+    type: 'string',
+    description: 'Optional. Override the active site for this single call without changing the global current site. Use this when running multiple Cowork chats against different WordPress sites in parallel so each chat can pin its own target site per tool call.',
+};
 export class RespiraWordPressServer {
     server;
     currentSite = null;
@@ -43,7 +106,7 @@ export class RespiraWordPressServer {
     allowedSites = null;
     /** Whether the plugin version warning has already been shown this session. */
     versionWarningShown = false;
-    static MCP_SERVER_VERSION = '6.11.4';
+    static MCP_SERVER_VERSION = MCP_SERVER_VERSION;
     /**
      * Normalize a tool name: respira_* → wordpress_* for switch dispatch.
      * Tracks whether the deprecated wordpress_* name was used.
@@ -333,6 +396,35 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
         }
         return this.getSiteSummary(this.currentSite);
     }
+    /**
+     * Resolve which WordPressClient should service this tool call.
+     *
+     * Order:
+     *   1) explicit args.site_id (per-call override; introduced in v6.12.0)
+     *   2) the global current site (`this.currentSite`)
+     *
+     * Throws if neither is set, or if the supplied site_id is unknown / not
+     * allowed for this MCP configuration group.
+     *
+     * @since 6.12.0
+     */
+    resolveClient(args) {
+        if (args && typeof args.site_id === 'string' && args.site_id.length > 0) {
+            const explicit = this.sites.get(args.site_id);
+            if (!explicit) {
+                const available = Array.from(this.sites.keys()).join(', ') || '(none configured)';
+                throw new Error(`Site with ID "${args.site_id}" not found in this MCP configuration. Available: ${available}`);
+            }
+            if (!this.isSiteAllowed(explicit)) {
+                throw new Error(`Site "${args.site_id}" is not in this MCP configuration group.`);
+            }
+            return explicit;
+        }
+        if (!this.currentSite) {
+            throw new Error('No active site. Either pass site_id on this tool call or run respira_switch_site / respira_redeem_token first.');
+        }
+        return this.currentSite;
+    }
     /** Check if a site is visible given RESPIRA_SITES filtering. */
     isSiteAllowed(site) {
         if (!this.allowedSites)
@@ -1137,20 +1229,20 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
             },
             {
                 name: 'wordpress_extract_builder_content',
-                description: 'Extract the full structured content from a page as builder-native JSON. Use this to see the complete page layout with all sections, columns, and widgets. For targeted searches, prefer find_element (faster). For a lightweight overview, prefer find_builder_targets. Returns the raw builder data structure that can be modified and passed back to inject_builder_content.',
+                description: 'Extract the full structured content from a page as builder-native JSON. Use this to see the complete page layout with all sections, columns, and widgets. For targeted searches, prefer find_element (faster). For a lightweight overview, prefer find_builder_targets. Returns the raw builder data structure that can be modified and passed back to inject_builder_content. Works on any post type (pages, posts, custom post types). The `builder` arg is optional — if omitted, the active site builder is auto-detected via get_builder_info.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         builder: {
                             type: 'string',
-                            description: 'Builder name. Use exactly: gutenberg, divi, elementor, bricks, beaver, oxygen, breakdance, brizy, thrive, visual-composer, wpbakery. Use get_builder_info to discover the active builder first.',
+                            description: 'Optional. Builder name. Use exactly: gutenberg, divi, elementor, bricks, beaver, oxygen, breakdance, brizy, thrive, visual-composer, wpbakery. Omit to auto-detect the active site builder.',
                         },
                         page_id: {
                             type: 'number',
-                            description: 'Page ID',
+                            description: 'Page or post ID (works with any post type, including custom post types)',
                         },
                     },
-                    required: ['builder', 'page_id'],
+                    required: ['page_id'],
                 },
                 readOnlyHint: true,
             },
@@ -1183,7 +1275,7 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
             },
             {
                 name: 'wordpress_inject_builder_content',
-                description: 'REPLACE (or append to) the entire page builder layout. WARNING: By default this REPLACES all existing content — use mode:"append" to add content without destroying existing elements. For editing a single module, use wordpress_update_module instead. Use exactly: gutenberg, divi, elementor, bricks, beaver, oxygen, breakdance, brizy, thrive, visual-composer, wpbakery. For Divi, divi_version is required ("4" or "5").',
+                description: 'REPLACE (or append to) the entire page builder layout. WARNING: By default this REPLACES all existing content — use mode:"append" to add content without destroying existing elements. For editing a single module, use wordpress_update_module instead. Use exactly: gutenberg, divi, elementor, bricks, beaver, oxygen, breakdance, brizy, thrive, visual-composer, wpbakery. For Divi, divi_version is required ("4" or "5"). Starting in plugin v7.0.16, calling this against a page that already has content with mode="replace" (the default) without also passing confirm_replace=true returns a 409 respira_replace_confirmation_required — pass mode="append" to add to existing content, pass mode="replace" AND confirm_replace=true to overwrite, or pass edit_target="live" to overwrite the live page directly (plugin v7.0.22+ accepts an authorized live edit as the confirmation). The gate prevents silent data loss.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -1201,9 +1293,13 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                         },
                         mode: {
                             type: 'string',
-                            description: 'replace (default): OVERWRITES all existing page content. append: adds new content after existing elements, preserving the current layout.',
+                            description: 'replace (default): OVERWRITES all existing page content. append: adds new content after existing elements, preserving the current layout. As of plugin v7.0.16, replace against a page with existing content requires confirm_replace=true.',
                             enum: ['replace', 'append'],
                         },
+                        confirm_replace: {
+                            type: 'boolean',
+                            description: 'Required when mode="replace" (or unset, since replace is the default) AND the page already has content. Pass true only when you genuinely want to overwrite the existing structure. Without it, the plugin returns 409 respira_replace_confirmation_required so the agent can decide between mode="append" (preserve) and mode="replace"+confirm_replace=true (overwrite).',
+                        },
                         edit_target: {
                             type: 'string',
                             description: 'When editing an original, choose ask, live, or duplicate. Defaults to ask when direct editing is enabled.',
@@ -2821,6 +2917,18 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
         if (await this.isAcfAvailable()) {
             tools.push(...getAcfTools());
         }
+        // v6.12.0: inject optional site_id into every non-agnostic tool schema.
+        // Agnostic tools (list_sites, get_active_site, switch_site, redeem_token)
+        // skip the injection because they operate on global state.
+        for (const t of tools) {
+            if (SITE_AGNOSTIC_TOOLS.has(t.name))
+                continue;
+            if (!t.inputSchema || t.inputSchema.type !== 'object')
+                continue;
+            const props = (t.inputSchema.properties ||= {});
+            if (!props.site_id)
+                props.site_id = SITE_ID_PROPERTY;
+        }
         // Generate respira_* aliases for all wordpress_* tools.
         const allTools = this.generateDualTools(tools);
         // Context-aware tool filtering: expose only relevant tools based on
@@ -3288,9 +3396,11 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
         return args;
     }
     async handleToolCall(name, args) {
-        if (!this.currentSite) {
-            throw new Error('No WordPress site configured');
-        }
+        // v6.12.0: relaxed top-of-handler guard. dispatchToolCall / resolveClient
+        // now decides whether a site is needed for THIS call (some tools are
+        // site-agnostic, others accept a per-call site_id override). The old
+        // eager `if (!this.currentSite) throw` blocked the new "call with just
+        // site_id on a server with no default site" path.
         // Normalize respira_* ↔ wordpress_* names.
         const { canonical, deprecated } = this.normalizeToolName(name);
         // mcp-v6.11.1: snake_case sweep across tool catalog. Schemas advertise
@@ -3308,14 +3418,15 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
         return result;
     }
     async dispatchToolCall(name, args) {
-        if (!this.currentSite) {
-            throw new Error('No WordPress site configured');
-        }
+        // v6.12.0: per-call site resolution. Agnostic tools work without a
+        // resolved client; everything else requires either args.site_id or a
+        // global currentSite. resolveClient throws cleanly if neither is set.
+        const client = SITE_AGNOSTIC_TOOLS.has(name) ? this.currentSite : this.resolveClient(args);
         switch (name) {
             case 'wordpress_get_site_context':
                 return args.detail === 'full'
-                    ? await this.currentSite.getSiteContext()
-                    : await this.currentSite.getCompactSiteContext();
+                    ? await client.getSiteContext()
+                    : await client.getCompactSiteContext();
             case 'wordpress_list_sites': {
                 const allSites = Array.from(this.sites.values());
                 const visibleSites = allSites.filter((site) => this.isSiteAllowed(site));
@@ -3329,21 +3440,21 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                     site: this.getActiveSiteSummary(),
                 };
             case 'wordpress_get_theme_docs':
-                return await this.currentSite.getThemeDocs();
+                return await client.getThemeDocs();
             case 'wordpress_get_builder_info':
-                return await this.currentSite.getBuilderInfo({ debug: Boolean(args?.debug) });
+                return await client.getBuilderInfo({ debug: Boolean(args?.debug) });
             case 'wordpress_list_pages':
-                return await this.currentSite.listPages(args);
+                return await client.listPages(args);
             case 'wordpress_read_page':
-                return await this.currentSite.getPage(args.id, args.include);
+                return await client.getPage(args.id, args.include);
             case 'wordpress_create_page_duplicate':
                 return {
-                    ...(await this.currentSite.duplicatePage(args.original_id, args.suffix, args.include)),
-                    respira_approvals_url: this.currentSite.getApprovalsUrl(),
+                    ...(await client.duplicatePage(args.original_id, args.suffix, args.include)),
+                    respira_approvals_url: client.getApprovalsUrl(),
                 };
             case 'wordpress_update_page': {
-                const approvalsUrl = this.currentSite.getApprovalsUrl();
-                const page = await this.currentSite.updatePage(args.id, args);
+                const approvalsUrl = client.getApprovalsUrl();
+                const page = await client.updatePage(args.id, args);
                 // Check if Respira created a duplicate
                 if (page.__respira_duplicate_info) {
                     const info = page.__respira_duplicate_info;
@@ -3364,19 +3475,19 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                 };
             }
             case 'wordpress_delete_page':
-                return await this.currentSite.deletePage(args.id, args.force);
+                return await client.deletePage(args.id, args.force);
             case 'wordpress_list_posts':
-                return await this.currentSite.listPosts(args);
+                return await client.listPosts(args);
             case 'wordpress_read_post':
-                return await this.currentSite.getPost(args.id, args.include);
+                return await client.getPost(args.id, args.include);
             case 'wordpress_create_post_duplicate':
                 return {
-                    ...(await this.currentSite.duplicatePost(args.original_id, args.suffix, args.include)),
-                    respira_approvals_url: this.currentSite.getApprovalsUrl(),
+                    ...(await client.duplicatePost(args.original_id, args.suffix, args.include)),
+                    respira_approvals_url: client.getApprovalsUrl(),
                 };
             case 'wordpress_update_post': {
-                const approvalsUrl = this.currentSite.getApprovalsUrl();
-                const post = await this.currentSite.updatePost(args.id, args);
+                const approvalsUrl = client.getApprovalsUrl();
+                const post = await client.updatePost(args.id, args);
                 // Check if Respira created a duplicate
                 if (post.__respira_duplicate_info) {
                     const info = post.__respira_duplicate_info;
@@ -3397,27 +3508,27 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                 };
             }
             case 'wordpress_delete_post':
-                return await this.currentSite.deletePost(args.id, args.force);
+                return await client.deletePost(args.id, args.force);
             case 'wordpress_list_media':
-                return await this.currentSite.listMedia(args);
+                return await client.listMedia(args);
             case 'wordpress_upload_media':
-                return await this.currentSite.uploadMedia(args.file, args.filename, args.mime_type, args.title, args.alt, args.caption);
+                return await client.uploadMedia(args.file, args.filename, args.mime_type, args.title, args.alt, args.caption);
             case 'wordpress_extract_builder_content':
-                return await this.currentSite.extractBuilderContent(args.builder, args.page_id);
+                return await client.extractBuilderContent(args.builder, args.page_id);
             case 'wordpress_find_builder_targets':
-                return await this.currentSite.findBuilderTargets(args.builder, args.page_id, args.query, args.limit);
+                return await client.findBuilderTargets(args.builder, args.page_id, args.query, args.limit);
             case 'wordpress_inject_builder_content':
                 return {
-                    ...(await this.currentSite.injectBuilderContent(args.builder, args.page_id, args.content, args.divi_version, args.edit_target, args.mode)),
-                    respira_approvals_url: this.currentSite.getApprovalsUrl(),
+                    ...(await client.injectBuilderContent(args.builder, args.page_id, args.content, args.divi_version, args.edit_target, args.mode, args.confirm_replace)),
+                    respira_approvals_url: client.getApprovalsUrl(),
                 };
             case 'wordpress_update_module':
                 return {
-                    ...(await this.currentSite.updateModule(args.builder, args.page_id, args.module_identifier, args.updates, args.edit_target)),
-                    respira_approvals_url: this.currentSite.getApprovalsUrl(),
+                    ...(await client.updateModule(args.builder, args.page_id, args.module_identifier, args.updates, args.edit_target)),
+                    respira_approvals_url: client.getApprovalsUrl(),
                 };
             case 'wordpress_validate_security':
-                return await this.currentSite.validateSecurity(args.content);
+                return await client.validateSecurity(args.content);
             case 'wordpress_switch_site': {
                 const newSite = this.sites.get(args.site_id);
                 if (!newSite) {
@@ -3435,7 +3546,7 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                 };
             }
             case 'wordpress_diagnose_connection':
-                return await this.currentSite.diagnoseConnection({ post_id: args.post_id });
+                return await client.diagnoseConnection({ post_id: args.post_id });
             // Canonical name (normalizeToolName rewrites respira_* → wordpress_*
             // before this switch runs). The early-route guard in setRequestHandler
             // catches the redeem call before we ever land here when no site is
@@ -3445,245 +3556,245 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                 return await this.redeemInstallToken(String(args.token || ''));
             // Page Speed Analysis
             case 'wordpress_analyze_performance':
-                return await this.currentSite.analyzePerformance(args.page_id);
+                return await client.analyzePerformance(args.page_id);
             case 'wordpress_get_core_web_vitals':
-                return await this.currentSite.getCoreWebVitals(args.page_id);
+                return await client.getCoreWebVitals(args.page_id);
             case 'wordpress_analyze_images':
-                return await this.currentSite.analyzeImages(args.page_id);
+                return await client.analyzeImages(args.page_id);
             // SEO Analysis
             case 'wordpress_analyze_seo':
-                return await this.currentSite.analyzeSEO(args.page_id);
+                return await client.analyzeSEO(args.page_id);
             case 'wordpress_check_seo_issues':
-                return await this.currentSite.checkSEOIssues(args.page_id);
+                return await client.checkSEOIssues(args.page_id);
             case 'wordpress_analyze_readability':
-                return await this.currentSite.analyzeReadability(args.page_id);
+                return await client.analyzeReadability(args.page_id);
             case 'wordpress_analyze_rankmath':
-                return await this.currentSite.analyzeRankMath(args.post_id);
+                return await client.analyzeRankMath(args.post_id);
             // AEO Analysis
             case 'wordpress_analyze_aeo':
-                return await this.currentSite.analyzeAEO(args.page_id);
+                return await client.analyzeAEO(args.page_id);
             case 'wordpress_check_structured_data':
-                return await this.currentSite.checkStructuredData(args.page_id);
+                return await client.checkStructuredData(args.page_id);
             // Accessibility
             case 'wordpress_list_accessibility_scans':
-                return await this.currentSite.listAccessibilityScans();
+                return await client.listAccessibilityScans();
             case 'wordpress_get_accessibility_scan':
-                return await this.currentSite.getAccessibilityScan(args.scan_id);
+                return await client.getAccessibilityScan(args.scan_id);
             case 'wordpress_scan_page_accessibility':
-                return await this.currentSite.scanPageAccessibility(args.page_id, args.standard);
+                return await client.scanPageAccessibility(args.page_id, args.standard);
             case 'wordpress_apply_accessibility_fixes':
-                return await this.currentSite.applyAccessibilityFixes(args.scan_id, args.rule_ids);
+                return await client.applyAccessibilityFixes(args.scan_id, args.rule_ids);
             // Plugin Management (EXPERIMENTAL)
             case 'wordpress_list_plugins':
-                return await this.currentSite.listPlugins();
+                return await client.listPlugins();
             case 'wordpress_install_plugin':
-                return await this.currentSite.installPlugin(args.slug_or_url, args.source || 'wordpress.org', args.approval_token);
+                return await client.installPlugin(args.slug_or_url, args.source || 'wordpress.org', args.approval_token);
             case 'wordpress_activate_plugin':
-                return await this.currentSite.activatePlugin(args.slug, args.approval_token);
+                return await client.activatePlugin(args.slug, args.approval_token);
             case 'wordpress_deactivate_plugin':
-                return await this.currentSite.deactivatePlugin(args.slug, args.approval_token);
+                return await client.deactivatePlugin(args.slug, args.approval_token);
             case 'wordpress_update_plugin':
-                return await this.currentSite.updatePlugin(args.slug, args.approval_token);
+                return await client.updatePlugin(args.slug, args.approval_token);
             case 'wordpress_delete_plugin':
-                return await this.currentSite.deletePlugin(args.slug, args.approval_token);
+                return await client.deletePlugin(args.slug, args.approval_token);
             // Users Management
             case 'wordpress_list_users':
-                return await this.currentSite.listUsers(args);
+                return await client.listUsers(args);
             case 'wordpress_get_user':
-                return await this.currentSite.getUser(args.id);
+                return await client.getUser(args.id);
             case 'wordpress_create_user':
-                return await this.currentSite.createUser(args);
+                return await client.createUser(args);
             case 'wordpress_update_user':
-                return await this.currentSite.updateUser(args.id, args);
+                return await client.updateUser(args.id, args);
             case 'wordpress_delete_user':
-                return await this.currentSite.deleteUser(args.id, args.reassign);
+                return await client.deleteUser(args.id, args.reassign);
             // Comments
             case 'wordpress_list_comments':
-                return await this.currentSite.listComments(args);
+                return await client.listComments(args);
             case 'wordpress_get_comment':
-                return await this.currentSite.getComment(args.id);
+                return await client.getComment(args.id);
             case 'wordpress_create_comment':
-                return await this.currentSite.createComment(args);
+                return await client.createComment(args);
             case 'wordpress_update_comment':
-                return await this.currentSite.updateComment(args.id, args);
+                return await client.updateComment(args.id, args);
             case 'wordpress_delete_comment':
-                return await this.currentSite.deleteComment(args.id);
+                return await client.deleteComment(args.id);
             // Taxonomies
             case 'wordpress_list_taxonomies':
-                return await this.currentSite.listTaxonomies();
+                return await client.listTaxonomies();
             case 'wordpress_get_taxonomy':
-                return await this.currentSite.getTaxonomy(args.taxonomy);
+                return await client.getTaxonomy(args.taxonomy);
             case 'wordpress_list_terms':
-                return await this.currentSite.listTerms(args.taxonomy, args);
+                return await client.listTerms(args.taxonomy, args);
             case 'wordpress_get_term':
-                return await this.currentSite.getTerm(args.taxonomy, args.id);
+                return await client.getTerm(args.taxonomy, args.id);
             case 'wordpress_create_term':
-                return await this.currentSite.createTerm(args.taxonomy, args);
+                return await client.createTerm(args.taxonomy, args);
             case 'wordpress_update_term':
-                return await this.currentSite.updateTerm(args.taxonomy, args.id, args);
+                return await client.updateTerm(args.taxonomy, args.id, args);
             case 'wordpress_delete_term':
-                return await this.currentSite.deleteTerm(args.taxonomy, args.id);
+                return await client.deleteTerm(args.taxonomy, args.id);
             // Custom Post Types
             case 'wordpress_list_post_types':
-                return await this.currentSite.listPostTypes();
+                return await client.listPostTypes();
             case 'wordpress_get_post_type':
-                return await this.currentSite.getPostType(args.type);
+                return await client.getPostType(args.type);
             case 'wordpress_list_custom_posts':
-                return await this.currentSite.listCustomPosts(args.type, args);
+                return await client.listCustomPosts(args.type, args);
             case 'wordpress_get_custom_post':
-                return await this.currentSite.getCustomPost(args.type, args.id, args.include);
+                return await client.getCustomPost(args.type, args.id, args.include);
             case 'wordpress_create_custom_post':
-                return await this.currentSite.createCustomPost(args.type, args);
+                return await client.createCustomPost(args.type, args);
             case 'wordpress_update_custom_post':
-                return await this.currentSite.updateCustomPost(args.type, args.id, args);
+                return await client.updateCustomPost(args.type, args.id, args);
             case 'wordpress_delete_custom_post':
-                return await this.currentSite.deleteCustomPost(args.type, args.id);
+                return await client.deleteCustomPost(args.type, args.id);
             // Options
             case 'wordpress_list_options':
-                return await this.currentSite.listOptions(args.search);
+                return await client.listOptions(args.search);
             case 'wordpress_get_option':
-                return await this.currentSite.getOption(args.option);
+                return await client.getOption(args.option);
             case 'wordpress_update_option':
-                return await this.currentSite.updateOption(args.option, args.value);
+                return await client.updateOption(args.option, args.value);
             case 'wordpress_delete_option':
-                return await this.currentSite.deleteOption(args.option);
+                return await client.deleteOption(args.option);
             // Media enhancements
             case 'wordpress_get_media':
-                return await this.currentSite.getMedia(args.id);
+                return await client.getMedia(args.id);
             case 'wordpress_update_media':
-                return await this.currentSite.updateMedia(args.id, args);
+                return await client.updateMedia(args.id, args);
             case 'wordpress_update_media_batch':
-                return await this.currentSite.updateMediaBatch(args.items);
+                return await client.updateMediaBatch(args.items);
             case 'wordpress_delete_media':
-                return await this.currentSite.deleteMedia(args.id);
+                return await client.deleteMedia(args.id);
             // Menu Management
             case 'wordpress_list_menus':
-                return await this.currentSite.listMenus();
+                return await client.listMenus();
             case 'wordpress_get_menu':
-                return await this.currentSite.getMenu(args.id);
+                return await client.getMenu(args.id);
             case 'wordpress_create_menu':
-                return await this.currentSite.createMenu(args);
+                return await client.createMenu(args);
             case 'wordpress_update_menu':
-                return await this.currentSite.updateMenu(args.id, args);
+                return await client.updateMenu(args.id, args);
             case 'wordpress_delete_menu':
-                return await this.currentSite.deleteMenu(args.id);
+                return await client.deleteMenu(args.id);
             // Menu Locations
             case 'wordpress_list_menu_locations':
-                return await this.currentSite.listMenuLocations();
+                return await client.listMenuLocations();
             case 'wordpress_assign_menu_location':
-                return await this.currentSite.assignMenuToLocation(args.location, args.menu_id);
+                return await client.assignMenuToLocation(args.location, args.menu_id);
             // Menu Items
             case 'wordpress_list_menu_items':
-                return await this.currentSite.listMenuItems(args.menu_id);
+                return await client.listMenuItems(args.menu_id);
             case 'wordpress_create_menu_item':
-                return await this.currentSite.createMenuItem(args.menu_id, args);
+                return await client.createMenuItem(args.menu_id, args);
             case 'wordpress_get_menu_item':
-                return await this.currentSite.getMenuItem(args.item_id);
+                return await client.getMenuItem(args.item_id);
             case 'wordpress_update_menu_item':
-                return await this.currentSite.updateMenuItem(args.item_id, args);
+                return await client.updateMenuItem(args.item_id, args);
             case 'wordpress_delete_menu_item':
-                return await this.currentSite.deleteMenuItem(args.item_id);
+                return await client.deleteMenuItem(args.item_id);
             case 'wordpress_list_snapshots':
-                return await this.currentSite.listSnapshots(args);
+                return await client.listSnapshots(args);
             case 'wordpress_get_snapshot':
-                return await this.currentSite.getSnapshot(args.snapshot_uuid);
+                return await client.getSnapshot(args.snapshot_uuid);
             case 'wordpress_diff_snapshots':
-                return await this.currentSite.diffSnapshots(args.snapshot_uuid_a, args.snapshot_uuid_b);
+                return await client.diffSnapshots(args.snapshot_uuid_a, args.snapshot_uuid_b);
             case 'wordpress_restore_snapshot':
-                return await this.currentSite.restoreSnapshot(args.snapshot_uuid);
+                return await client.restoreSnapshot(args.snapshot_uuid);
             case 'wordpress_apply_builder_patch':
-                return await this.currentSite.applyBuilderPatch(args.builder, args.post_id, args.operations, args.include, args.edit_target);
+                return await client.applyBuilderPatch(args.builder, args.post_id, args.operations, args.include, args.edit_target);
             case 'woocommerce_list_products':
-                return await this.currentSite.woocommerceListProducts(args);
+                return await client.woocommerceListProducts(args);
             case 'woocommerce_get_product':
-                return await this.currentSite.woocommerceGetProduct(args.id);
+                return await client.woocommerceGetProduct(args.id);
             case 'woocommerce_create_product':
-                return await this.currentSite.woocommerceCreateProduct(args);
+                return await client.woocommerceCreateProduct(args);
             case 'woocommerce_update_product': {
                 const { id, ...payload } = args;
-                return await this.currentSite.woocommerceUpdateProduct(id, payload);
+                return await client.woocommerceUpdateProduct(id, payload);
             }
             case 'woocommerce_duplicate_product':
-                return await this.currentSite.woocommerceDuplicateProduct(args.id);
+                return await client.woocommerceDuplicateProduct(args.id);
             case 'woocommerce_list_categories':
-                return await this.currentSite.woocommerceListCategories(args);
+                return await client.woocommerceListCategories(args);
             case 'woocommerce_get_category':
-                return await this.currentSite.woocommerceGetCategory(args.id);
+                return await client.woocommerceGetCategory(args.id);
             case 'woocommerce_create_category':
-                return await this.currentSite.woocommerceCreateCategory(args);
+                return await client.woocommerceCreateCategory(args);
             case 'woocommerce_update_category': {
                 const { id, ...payload } = args;
-                return await this.currentSite.woocommerceUpdateCategory(id, payload);
+                return await client.woocommerceUpdateCategory(id, payload);
             }
             case 'woocommerce_delete_category':
-                return await this.currentSite.woocommerceDeleteCategory(args.id);
+                return await client.woocommerceDeleteCategory(args.id);
             case 'woocommerce_list_tags':
-                return await this.currentSite.woocommerceListTags(args);
+                return await client.woocommerceListTags(args);
             case 'woocommerce_get_tag':
-                return await this.currentSite.woocommerceGetTag(args.id);
+                return await client.woocommerceGetTag(args.id);
             case 'woocommerce_create_tag':
-                return await this.currentSite.woocommerceCreateTag(args);
+                return await client.woocommerceCreateTag(args);
             case 'woocommerce_update_tag': {
                 const { id, ...payload } = args;
-                return await this.currentSite.woocommerceUpdateTag(id, payload);
+                return await client.woocommerceUpdateTag(id, payload);
             }
             case 'woocommerce_delete_tag':
-                return await this.currentSite.woocommerceDeleteTag(args.id);
+                return await client.woocommerceDeleteTag(args.id);
             case 'woocommerce_list_orders':
-                return await this.currentSite.woocommerceListOrders(args);
+                return await client.woocommerceListOrders(args);
             case 'woocommerce_get_order':
-                return await this.currentSite.woocommerceGetOrder(args.id);
+                return await client.woocommerceGetOrder(args.id);
             case 'woocommerce_update_order_status':
-                return await this.currentSite.woocommerceUpdateOrderStatus(args.id, args.status);
+                return await client.woocommerceUpdateOrderStatus(args.id, args.status);
             case 'woocommerce_get_stock_status':
-                return await this.currentSite.woocommerceGetStockStatus();
+                return await client.woocommerceGetStockStatus();
             case 'woocommerce_update_stock': {
                 const { id, ...payload } = args;
-                return await this.currentSite.woocommerceUpdateStock(id, payload);
+                return await client.woocommerceUpdateStock(id, payload);
             }
             case 'woocommerce_sales_report':
-                return await this.currentSite.woocommerceSalesReport(args);
+                return await client.woocommerceSalesReport(args);
             // --- v5.2.0 Elemental tools ---
             case 'wordpress_find_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/find/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/find/${post_id}`, rest);
             }
             case 'wordpress_update_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/update/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/update/${post_id}`, rest);
             }
             case 'wordpress_move_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/move/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/move/${post_id}`, rest);
             }
             case 'wordpress_duplicate_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/duplicate/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/duplicate/${post_id}`, rest);
             }
             case 'wordpress_remove_element': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/remove/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/remove/${post_id}`, rest);
             }
             case 'wordpress_batch_update': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/batch/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/batch/${post_id}`, rest);
             }
             case 'wordpress_reorder_elements': {
                 const { post_id, ...rest } = args;
-                return await this.currentSite.callRestV2('POST', `/builder/elements/reorder/${post_id}`, rest);
+                return await client.callRestV2('POST', `/builder/elements/reorder/${post_id}`, rest);
             }
             case 'wordpress_build_page':
-                return await this.currentSite.callRestV2('POST', '/builder/build', args);
+                return await client.callRestV2('POST', '/builder/build', args);
             case 'wordpress_convert_html_to_builder':
-                return await this.currentSite.callRestV2('POST', '/builder/convert', args);
+                return await client.callRestV2('POST', '/builder/convert', args);
             case 'wordpress_bulk_pages_operation':
-                return await this.currentSite.callRestV2('POST', '/builder/bulk', args);
+                return await client.callRestV2('POST', '/builder/bulk', args);
             case 'wordpress_search_stock_images':
-                return await this.currentSite.callRestV2('GET', '/stock-images/search', args);
+                return await client.callRestV2('GET', '/stock-images/search', args);
             case 'wordpress_sideload_image':
-                return await this.currentSite.callRestV2('POST', '/stock-images/sideload', args);
+                return await client.callRestV2('POST', '/stock-images/sideload', args);
             case 'wordpress_get_server_compatibility':
-                return await this.currentSite.callRestV2('GET', '/server/compatibility');
+                return await client.callRestV2('GET', '/server/compatibility');
             // Widget shortcuts and Bricks tools — dynamic dispatch.
             default: {
                 // Check if this is a Bricks deep tool.
@@ -3715,7 +3826,7 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                         throw new Error(`Widget shortcut "${shortcutName}" requires a post_id parameter.`);
                     }
                     const { post_id: _pid, ...settings } = args;
-                    return await this.currentSite.callRestV2('POST', `/builder/widget/${shortcutName}/${postId}`, settings);
+                    return await client.callRestV2('POST', `/builder/widget/${shortcutName}/${postId}`, settings);
                 }
                 // Return isError result instead of throwing — unknown tool is an execution
                 // error, not a protocol error. This lets LLMs self-correct gracefully.
@@ -3757,7 +3868,7 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
             },
             {
                 name: 'wordpress_update_element',
-                description: 'Update settings or content on a specific element in a page. This is the PRIMARY tool for making content changes — use it for text edits, style changes, image swaps, link updates, etc. Works with all 12 page builders. First use find_element to locate the element, then pass the same identifier here with the updates object containing the new values.',
+                description: 'Update settings or content on a specific element in a page. This is the PRIMARY tool for making content changes — use it for text edits, style changes, image swaps, link updates, etc. Works with all 12 page builders. First use find_element to locate the element, then pass the same identifier here with the updates object containing the new values. Response includes target_id, original_id, edit_target ("live" or "duplicate"), is_duplicate, duplicate_created and post_status so the caller can never mistake a duplicate-routed write for a live-page change.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -3771,6 +3882,11 @@ Use respira_get_builder_info first to detect which builder is active. Then use t
                             type: 'object',
                             description: 'Key-value pairs of settings to update on the matched element',
                         },
+                        editTarget: {
+                            type: 'string',
+                            enum: ['live', 'duplicate'],
+                            description: 'Optional. "duplicate" (default) routes the write to the Respira duplicate of the post (or auto-creates one) so changes go through the Respira → Changes approval flow before they reach the public page. "live" writes straight to the published original — requires Respira → Settings → Allow direct edit, or the post to be a draft / existing Respira duplicate. The response always reports the resolved target so you know exactly which post received the write.',
+                        },
                     },
                     required: ['post_id', 'identifier_type', 'identifier_value', 'updates'],
                 },