friday-mcp-v2 2.0.5 → 2.1.0

package/dist/mcp-server.js

@@ -10,61 +10,553 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { FridayWPClient, ConnectionRegistry } from "./wordpress-api.js";
 import fetch from "node-fetch";
+import { readFileSync, statSync, realpathSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { resolve as resolvePath, sep, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+// package.json からバージョンを取得
+const __pkg_dirname = dirname(fileURLToPath(import.meta.url));
+const SERVER_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(resolvePath(__pkg_dirname, '..', 'package.json'), 'utf-8'));
+        return pkg.version || '0.0.0';
+    } catch { return '0.0.0'; }
+})();
+
+// .env 読み込み（FRIDAY_WORKSPACE 配下の .env を自動ロード）
+// .mcp.json の env が優先され、.env は未設定キーの補完のみ
+const _envWorkspace = process.env.FRIDAY_WORKSPACE;
+if (_envWorkspace) {
+    try {
+        const _envPath = resolvePath(_envWorkspace, '.env');
+        const _envContent = readFileSync(_envPath, 'utf-8');
+        for (const _line of _envContent.split('\n')) {
+            const _trimmed = _line.trim();
+            if (!_trimmed || _trimmed.startsWith('#')) continue;
+            const _eqIdx = _trimmed.indexOf('=');
+            if (_eqIdx === -1) continue;
+            const _key = _trimmed.slice(0, _eqIdx).trim();
+            const _val = _trimmed.slice(_eqIdx + 1).trim();
+            if (!process.env[_key]) {
+                process.env[_key] = _val;
+            }
+        }
+    } catch (_e) {
+        // .env がなくても起動は続行
+    }
+}
 
 const registry = new ConnectionRegistry();
 
+// Sticky site キャッシュ: 自動検出した接続先を短時間記憶
+const statusCache = {
+    _entries: new Map(),
+    _lastSite: null,
+    TTL: 15_000,
+
+    /**
+     * 指定サイトのキャッシュを取得（TTL 切れなら自動破棄）
+     * @param {string} site
+     * @returns {{ site: string, client: FridayWPClient, postId: number, checkedAt: number } | null}
+     */
+    get(site) {
+        const entry = this._entries.get(site);
+        if (!entry) return null;
+        if ((Date.now() - entry.checkedAt) >= this.TTL) {
+            this._entries.delete(site);
+            if (this._lastSite === site) this._lastSite = null;
+            return null;
+        }
+        return { site, ...entry };
+    },
+
+    /**
+     * 最後に set されたサイトのキャッシュを返す（sticky 参照用）
+     * 現行の isValid() + 単一スロット参照と同じセマンティクスを維持する。
+     * Map 走査順に依存せず、明示的に _lastSite を追跡することで
+     * 既存の検出限界（キャッシュ/default ヒット時は複数 editor 未検出）を含めて維持する。
+     */
+    getLast() {
+        if (!this._lastSite) return null;
+        return this.get(this._lastSite);
+    },
+
+    set(site, client, postId) {
+        this._entries.set(site, { client, postId, checkedAt: Date.now() });
+        this._lastSite = site;
+    },
+
+    /**
+     * @param {string} [site] 指定時はそのサイトのみ破棄。省略時は全破棄。
+     */
+    clear(site) {
+        if (site) {
+            this._entries.delete(site);
+            if (this._lastSite === site) this._lastSite = null;
+        } else {
+            this._entries.clear();
+            this._lastSite = null;
+        }
+    }
+};
+
 // ヘルパー関数: 正規表現用に文字列をエスケープ
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 /**
- * Editor/Headless モード判定ヘルパー
- * @returns {{ mode: 'editor'|'headless'|'error', postId?: number, message?: string, client?: FridayWPClient }}
+ * OS のデフォルトブラウザで URL を開く（execFile でシェル非経由）
  */
-async function resolveMode(args) {
-    let client;
+function openInBrowser(url) {
+    return new Promise((resolve, reject) => {
+        let cmd, args;
+        switch (process.platform) {
+            case 'win32':
+                cmd = 'rundll32';
+                args = ['url.dll,FileProtocolHandler', url];
+                break;
+            case 'darwin':
+                cmd = 'open';
+                args = [url];
+                break;
+            default:
+                cmd = 'xdg-open';
+                args = [url];
+                break;
+        }
+        execFile(cmd, args, (error) => {
+            if (error) reject(error);
+            else resolve();
+        });
+    });
+}
+
+/**
+ * URL バリデーション（http/https のみ許可）
+ */
+function isValidHttpUrl(url) {
     try {
-        client = registry.get(args?.site);
-    } catch (e) {
-        return { mode: 'error', message: e.message };
+        const parsed = new URL(url);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * filePath からHTMLを読み込む共通ユーティリティ
+ * FRIDAY_WORKSPACE 環境変数で許可ディレクトリを制限
+ */
+function readHTMLFromFile(filePath, maxSizeBytes = 2 * 1024 * 1024) {
+    const resolved = resolvePath(filePath);
+
+    const workspace = process.env.FRIDAY_WORKSPACE;
+    if (!workspace) {
+        throw new Error('FRIDAY_WORKSPACE 環境変数が未設定です。.mcp.json の env で設定してください。');
+    }
+
+    // セキュリティ: 実体パスで比較（シンボリックリンク/ジャンクション経由の迂回を防止）
+    let realPath;
+    try { realPath = realpathSync(resolved); }
+    catch (e) {
+        if (e.code === 'ENOENT') throw new Error(`ファイルが見つかりません: ${resolved}`);
+        throw new Error(`ファイルアクセスエラー: ${resolved} (${e.message})`);
+    }
+    let realRoot;
+    try { realRoot = realpathSync(resolvePath(workspace)); }
+    catch (e) {
+        throw new Error(`FRIDAY_WORKSPACE のパスが無効です: ${workspace} (${e.message})`);
+    }
+    if (!realPath.startsWith(realRoot + sep) && realPath !== realRoot) {
+        throw new Error(`許可されたディレクトリ外です: ${realPath} (FRIDAY_WORKSPACE: ${realRoot})`);
     }
 
+    let stat;
+    try { stat = statSync(realPath); }
+    catch (e) {
+        throw new Error(`ファイルアクセスエラー: ${realPath} (${e.message})`);
+    }
+    if (stat.size > maxSizeBytes) {
+        throw new Error(`ファイルサイズ超過: ${(stat.size / 1048576).toFixed(1)}MB (上限: ${(maxSizeBytes / 1048576).toFixed(1)}MB)`);
+    }
+    let html;
+    try { html = readFileSync(realPath, 'utf-8'); }
+    catch (e) { throw new Error(`ファイル読み込み失敗: ${realPath} (${e.message})`); }
+    if (!html.trim()) throw new Error(`ファイルが空です: ${realPath}`);
+    return { html };
+}
+
+/**
+ * 単一クライアントの Editor/Headless 判定
+ * @returns {{ mode: 'editor'|'headless'|'error', postId?: number, message?: string, client?: FridayWPClient }}
+ */
+async function checkSingleClient(client, args) {
     try {
-        const status = await client.getStatus();
+        const rawPostId = args?.postId;
+        const numPostId = rawPostId != null ? Number(rawPostId) : null;
+        const isNumeric = numPostId != null && Number.isFinite(numPostId) && numPostId > 0;
+        // getStatus の checkPostId は数値のみ意味がある。スラッグ/空文字時は null
+        const status = await client.getStatus(isNumeric ? numPostId : null);
+
         if (status.editorConnected && status.postId) {
-            const argPostId = args?.postId;
-            if (argPostId && argPostId !== status.postId) {
-                return { mode: 'headless', postId: argPostId, client };
+            if (rawPostId != null) {
+                if (isNumeric) {
+                    if (numPostId === Number(status.postId) || status.checkedEditorConnected) {
+                        return {
+                            mode: 'error',
+                            errorCode: 'editor_conflict',
+                            client,
+                            message: `postId ${numPostId} はエディタで開かれています。postId を省略してエディタ経由で操作するか、エディタを閉じてから Headless モードを使用してください。`
+                        };
+                    }
+                    return { mode: 'headless', postId: numPostId, client };
+                }
+                // スラッグ指定 → headless（ID 解決 + 競合チェックは resolvePostId で行う）
+                return { mode: 'headless', postId: null, client };
             }
             return { mode: 'editor', postId: status.postId, client };
         }
-        const postId = args?.postId;
-        if (!postId) {
-            return { mode: 'error', message: 'エディタ未接続です。postId を指定して Headless モードを使用してください。' };
+
+        if (isNumeric && status.checkedEditorConnected) {
+            return {
+                mode: 'error',
+                errorCode: 'editor_conflict',
+                client,
+                message: `postId ${numPostId} はエディタで開かれています。postId を省略してエディタ経由で操作するか、エディタを閉じてから Headless モードを使用してください。`
+            };
         }
-        return { mode: 'headless', postId, client };
-    } catch (e) {
-        const postId = args?.postId;
-        if (postId) {
-            return { mode: 'headless', postId, client };
+
+        if (rawPostId == null) {
+            return { mode: 'error', message: 'エディタ未接続' };
+        }
+        if (isNumeric) {
+            return { mode: 'headless', postId: numPostId, client };
         }
+        // スラッグ指定
+        return { mode: 'headless', postId: null, client };
+    } catch (e) {
         return { mode: 'error', message: `接続エラー: ${e.message}` };
     }
 }
 
+/**
+ * Editor/Headless モード判定ヘルパー（複数接続自動検出対応）
+ * @returns {{ mode: 'editor'|'headless'|'error', postId?: number, message?: string, client?: FridayWPClient }}
+ */
+async function resolveMode(args) {
+    // site 明示指定
+    if (args?.site) {
+        let client;
+        try { client = registry.get(args.site); }
+        catch (e) { return { mode: 'error', message: e.message }; }
+        const result = await checkSingleClient(client, args);
+        return { ...result, siteName: args.site };
+    }
+
+    const allConns = registry.getAll();
+    const isMultiSite = allConns.length > 1;
+
+    // 単一接続 → 従来通り
+    if (!isMultiSite) {
+        const result = await checkSingleClient(registry.get(), args);
+        return { ...result, siteName: allConns[0].name };
+    }
+
+    // 複数接続 + sticky キャッシュ有効
+    const cached = statusCache.getLast();
+    if (cached) {
+        const cachedResult = await checkSingleClient(cached.client, args);
+        if (cachedResult.mode === 'editor') {
+            return { ...cachedResult, siteName: cached.site };
+        }
+        statusCache.clear(cached.site);
+    }
+
+    // default を先に確認
+    const defaultClient = registry.get();
+    const defaultName = allConns.find(c => c.client === defaultClient)?.name || 'default';
+    const defaultResult = await checkSingleClient(defaultClient, args);
+    if (defaultResult.mode === 'editor') {
+        statusCache.set(defaultName, defaultClient, defaultResult.postId);
+        return { ...defaultResult, siteName: defaultName };
+    }
+    // defaultResult.mode === 'headless' の場合:
+    // 他の接続にエディタが接続中の可能性があるため、並列スキャンに進む
+
+    // 全接続並列探索（各接続 5秒タイムアウト付き）
+    const SCAN_TIMEOUT = 5000;
+    const statusResults = await Promise.allSettled(
+        allConns.map(async ({ name, client }) => {
+            const status = await Promise.race([
+                client.getStatus(),
+                new Promise((_, reject) =>
+                    setTimeout(() => reject(new Error('timeout')), SCAN_TIMEOUT)
+                )
+            ]);
+            return { name, client, status };
+        })
+    );
+
+    const connected = statusResults
+        .filter(r => r.status === 'fulfilled')
+        .map(r => r.value)
+        .filter(r => r.status.editorConnected && r.status.postId);
+
+    if (connected.length === 1) {
+        const { name, client, status } = connected[0];
+        if (args?.postId != null) {
+            const numPid = Number(args.postId);
+            const isNum = Number.isFinite(numPid) && numPid > 0;
+            if (!isNum || numPid !== Number(status.postId)) {
+                // postId 不一致またはスラッグ: エディタは別記事を開いている → site 必須エラー
+                const connNames = allConns.map(c => c.name).join(', ');
+                return {
+                    mode: 'error',
+                    message: `複数サイトが登録されています。Headless モードでは site の指定が必須です。\n利用可能: ${connNames}`,
+                };
+            }
+        }
+
+        statusCache.set(name, client, status.postId);
+        return { mode: 'editor', postId: status.postId, client, siteName: name };
+    }
+
+    if (connected.length > 1) {
+        const list = connected.map(c =>
+            `  ${c.name}: postId ${c.status.postId} (${c.client.wpUrl})`
+        ).join('\n');
+        return {
+            mode: 'error',
+            message: `複数のエディタが接続中です。site パラメータで接続先を指定してください。\n\n接続中:\n${list}\n\n例: get_article_structure({ site: "${connected[0].name}" })`
+        };
+    }
+
+    // どれも未接続 + postId 指定あり → Headless だが site 未指定
+    if (args?.postId != null) {
+        const connNames = allConns.map(c => c.name).join(', ');
+        return {
+            mode: 'error',
+            message: `複数サイトが登録されています。Headless モードでは site の指定が必須です。\n利用可能: ${connNames}`,
+        };
+    }
+
+    // どれも未接続 + postId なし
+    return {
+        mode: 'error',
+        message: 'エディタ未接続です。postId を指定して Headless モードを使用するか、エディタで記事を開いてください。\n接続一覧の確認: list_connections()'
+    };
+}
+
+/**
+ * postId を解決する（数値はそのまま、文字列は slug として検索）
+ * slug 解決後にエディタ競合チェックも実施
+ */
+async function resolvePostId(rawPostId, client, { skipConflictCheck = false } = {}) {
+    if (rawPostId == null) return { postId: null };
+
+    // 数値判定（"" → 0 を除外するため num > 0）
+    const num = Number(rawPostId);
+    if (Number.isFinite(num) && num > 0) return { postId: num };
+
+    // 空文字チェック（Number("") === 0 で上を通過するため、ここで明示エラー）
+    let slug = String(rawPostId).trim();
+    if (!slug) return { error: '❌ postId が空です。' };
+
+    // URL → スラッグ抽出（query/hash を除去）
+    if (slug.includes('/')) {
+        try {
+            const url = new URL(slug);
+            slug = url.pathname.replace(/\/+$/, '').split('/').pop() || '';
+        } catch {
+            // URL パース失敗 → 相対パスとして末尾を取る
+            slug = slug.split('?')[0].split('#')[0].replace(/\/+$/, '').split('/').pop() || '';
+        }
+    }
+    if (!slug) return { error: '❌ URL からスラッグを抽出できませんでした。' };
+
+    // slug → ID 解決
+    const { data: posts } = await client.listPosts({ slug, status: 'any' });
+    if (!posts || posts.length === 0) {
+        return { error: `❌ スラッグ "${slug}" に一致する投稿が見つかりません。` };
+    }
+    const resolvedId = posts[0].id;
+
+    // ★ エディタ競合チェック（slug 経由でも既存と同等のガードを維持）
+    if (!skipConflictCheck) {
+        const status = await client.getStatus(resolvedId);
+        if (status.editorConnected &&
+            (resolvedId === Number(status.postId) || status.checkedEditorConnected)) {
+            return {
+                error: `❌ postId ${resolvedId}（${slug}）はエディタで開かれています。postId を省略してエディタ経由で操作するか、エディタを閉じてから Headless モードを使用してください。`
+            };
+        }
+    }
+
+    return { postId: resolvedId };
+}
+
 // postId パラメータ定義（Headless 対応ツール共通）
 const postIdParam = {
-    type: "number",
-    description: "投稿ID（エディタ未接続時は必須）",
+    oneOf: [
+        { type: "number" },
+        { type: "string" }
+    ],
+    description: "投稿ID（数値）またはスラッグ（文字列, URLパス末尾。例: 'madear'）。URLも可（自動抽出）。スラッグ指定時は自動的にIDを解決。エディタ未接続時は必須。",
 };
 
 // site パラメータ定義（マルチ接続共通）
 const siteParam = {
     type: "string",
-    description: "接続名（複数サイト/ユーザー設定時に指定。省略でデフォルト接続）",
+    description: "接続名(複数サイト/ユーザー設定時に指定。省略でデフォルト接続。Headless + 複数サイト時は必須)",
+};
+
+// ========================================
+// ターゲット / インサート 共通スキーマ & ヘルパー
+// ========================================
+
+const targetSchema = {
+    type: "object",
+    properties: {
+        selected: {
+            type: "boolean",
+            description: "Set true to target the block currently selected by the user in WordPress editor. Cannot be used in Headless mode.",
+        },
+        index: {
+            type: "number",
+            description: "Single block index (0-based flattened position including nested blocks).",
+        },
+        indices: {
+            type: "array",
+            items: { type: "number" },
+            description: "Multiple block indices (0-based flattened).",
+        },
+        range: {
+            type: "object",
+            properties: {
+                start: { type: "number", description: "Start index (inclusive)." },
+                end: { type: "number", description: "End index (inclusive)." },
+            },
+            required: ["start", "end"],
+            description: "Contiguous range of block indices.",
+        },
+        section: {
+            type: "string",
+            description: "Target section by heading text (partial match). Combines with blockType/contains.",
+        },
+        blockType: {
+            type: "string",
+            description: "Filter by block type (e.g. core/table). Combines with section/contains.",
+        },
+        nth: {
+            type: "number",
+            description: "N-th block of the specified blockType (0-based). Use with blockType.",
+        },
+        contains: {
+            type: "string",
+            description: "Target blocks containing this text.",
+        },
+        heading: {
+            type: "object",
+            properties: {
+                level: { type: "number", description: "Heading level (2, 3, 4)." },
+                contains: { type: "string", description: "Heading text to match (partial)." },
+            },
+            required: ["level", "contains"],
+            description: "Section selection by heading level and text. Selects from the heading to the next same-level heading.",
+        },
+    },
+    description: "Block targeting criteria. Use one primary selector (selected/index/indices/range/heading) optionally combined with filters (blockType/contains/section).",
+};
+
+const targetSchemaNoSelected = {
+    ...targetSchema,
+    properties: { ...targetSchema.properties },
+};
+delete targetSchemaNoSelected.properties.selected;
+targetSchemaNoSelected.description = "Block targeting criteria. Use one primary selector (index/range/heading) optionally combined with filters (blockType/contains/section).";
+
+const insertSchema = {
+    type: "object",
+    properties: {
+        position: {
+            type: ["number", "string"],
+            description: "Insert position. 'before', 'after' (default), or block index number. Only with newHTML.",
+        },
+    },
+    description: "Insert mode: keep existing blocks and add newHTML as new blocks. Presence of this parameter enables insert mode.",
 };
 
+/**
+ * 新形式の target オブジェクトを下流用のフラット形式に変換する。
+ * @param {object} target - 新形式 target (e.g. { selected: true }, { index: 3 })
+ * @returns {object} フラット形式 (e.g. { target: "selected" }, { index: 3 })
+ * @throws {Error} primary selector が複数指定された場合
+ */
+function normalizeTarget(target) {
+    if (!target || typeof target !== "object") return {};
+
+    // --- 排他バリデーション ---
+    const primaries = [
+        target.selected && 'selected',
+        target.index !== undefined && 'index',
+        target.indices && 'indices',
+        target.range && 'range',
+        target.heading && 'heading',
+    ].filter(Boolean);
+    if (primaries.length > 1) {
+        throw new Error(`target に複数の primary selector が指定されています: ${primaries.join(', ')}。1つだけ指定してください。`);
+    }
+
+    const result = {};
+    if (target.selected) result.target = "selected";
+    if (target.index !== undefined) result.index = target.index;
+    if (target.indices) result.indices = target.indices;
+    if (target.range) {
+        const s = target.range.start;
+        const e = target.range.end;
+        if (s === undefined || s === null || e === undefined || e === null ||
+            typeof s !== "number" || typeof e !== "number" ||
+            !Number.isInteger(s) || !Number.isInteger(e) || s < 0 || e < 0) {
+            throw new Error("range.start と range.end は 0 以上の整数で両方指定してください。");
+        }
+        result.startIndex = s;
+        result.endIndex = e;
+    }
+    if (target.section) result.section = target.section;
+    if (target.blockType) result.blockType = target.blockType;
+    if (target.nth !== undefined) result.typeIndex = target.nth;
+    if (target.contains) result.contains = target.contains;
+    if (target.heading) {
+        const lv = target.heading.level;
+        const ct = target.heading.contains;
+        if (lv === undefined || typeof lv !== "number" || !ct || typeof ct !== "string") {
+            throw new Error("heading には level（数値）と contains（非空文字列）の両方が必要です。");
+        }
+        result.headingLevel = lv;
+        result.headingContains = ct;
+    }
+    return result;
+}
+
+/**
+ * 新形式の insert オブジェクトを下流用のフラット形式に変換する。
+ * @param {object} insert - 新形式 insert (e.g. { position: "after" })
+ * @returns {object} フラット形式 { insertOnly, insertPosition }
+ * @throws {Error} position の値が不正な場合
+ */
+function normalizeInsert(insert) {
+    if (!insert) return { insertOnly: false };
+    const pos = insert.position ?? "after";
+    if (pos !== "before" && pos !== "after" && typeof pos !== "number") {
+        throw new Error(`insert.position の値が不正です: ${pos}。'before', 'after', または数値を指定してください。`);
+    }
+    if (typeof pos === "number" && (!Number.isInteger(pos) || pos < 0)) {
+        throw new Error(`insert.position は 0 以上の整数を指定してください: ${pos}`);
+    }
+    return { insertOnly: true, insertPosition: pos };
+}
+
 // フィードバック送信ヘルパー
 const FEEDBACK_URL = process.env.FRIDAY_FEEDBACK_URL || '';
 async function sendFeedback(data) {
@@ -73,7 +565,7 @@ async function sendFeedback(data) {
         await fetch(FEEDBACK_URL, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ ...data, version: '2.0.0' }),
+            body: JSON.stringify({ ...data, version: SERVER_VERSION }),
         });
     } catch (_) {
         // フィードバック送信失敗は無視（本体の動作に影響させない）
@@ -104,7 +596,7 @@ function timeoutResponse(toolName, client, site) {
 // MCPサーバーの定義
 const server = new Server({
     name: "friday-mcp-v2",
-    version: "2.0.0",
+    version: SERVER_VERSION,
 }, {
     capabilities: {
         tools: {},
@@ -163,39 +655,9 @@ const tools = [
             type: "object",
             properties: {
                 site: siteParam,
-                index: {
-                    type: "number",
-                    description: "Block index (0-based, flattened including nested blocks)",
-                },
-                blockType: {
-                    type: "string",
-                    description: "Block type (e.g. core/table)",
-                },
-                typeIndex: {
-                    type: "number",
-                    description: "N-th block of the type (0-based)",
-                },
-                contains: {
-                    type: "string",
-                    description: "Search text in block content",
-                },
-                startIndex: {
-                    type: "number",
-                    description: "Range selection start",
-                },
-                endIndex: {
-                    type: "number",
-                    description: "Range selection end",
-                },
-                headingLevel: {
-                    type: "number",
-                    description: "Heading level for section selection (2, 3, 4)",
-                },
-                headingContains: {
-                    type: "string",
-                    description: "Heading text for section selection",
-                },
+                target: targetSchemaNoSelected,
             },
+            required: ["target"],
         },
     },
     {
@@ -214,7 +676,7 @@ const tools = [
     },
     {
         name: "move_block",
-        description: "Move a block to a different position. Use from/to for top-level blocks, or fromFlat/toFlat for any block (including nested).",
+        description: "Move block(s) to a different position. Use from/to for top-level blocks, or fromFlat/toFlat for any block (including nested). Use count to move consecutive blocks.",
         inputSchema: {
             type: "object",
             properties: {
@@ -224,6 +686,7 @@ const tools = [
                 to: { type: "number", description: "Target position (0-based, can be length for end)" },
                 fromFlat: { type: "number", description: "Source flattened block index (0-based, supports nested blocks)" },
                 toFlat: { type: "number", description: "Target flattened position (pre-move basis, can be blockCount for end)" },
+                count: { type: "integer", description: "Number of consecutive blocks to move (default: 1)" },
             },
         },
     },
@@ -303,13 +766,14 @@ const tools = [
     },
     {
         name: "list_posts",
-        description: "Search and list WordPress posts. Use to find postId for Headless mode operations. Default returns only published posts; use status='any' to include drafts. Search matches both title and content; use short single keywords for best results.",
+        description: "Search and list WordPress posts. Use to find postId for other tools. For exact lookup, use 'slug' (from URL path e.g. 'my-post' from example.com/my-post/); slug auto-sets status='any' and returns exactly 1 result. For broad search, use 'search' keyword. slug and search are mutually exclusive.",
         inputSchema: {
             type: "object",
             properties: {
                 site: siteParam,
-                search: { type: "string", description: "Search keyword (title/content)" },
-                status: { type: "string", enum: ["publish", "draft", "pending", "private", "any"], description: "Filter by status (default: publish)" },
+                slug: { type: "string", description: "Post slug for exact match (from URL path e.g. 'comparison' from example.com/comparison). Mutually exclusive with search." },
+                search: { type: "string", description: "Search keyword (title/content). Mutually exclusive with slug." },
+                status: { type: "string", enum: ["publish", "draft", "pending", "private", "any"], description: "Filter by status (default: publish; auto-set to 'any' when slug is specified)" },
                 categories: { type: "array", items: { type: "number" }, description: "Category IDs to filter by" },
                 tags: { type: "array", items: { type: "number" }, description: "Tag IDs to filter by" },
                 per_page: { type: "integer", description: "Results per page (1-100, default: 10)", minimum: 1, maximum: 100 },
@@ -339,17 +803,15 @@ const tools = [
     },
     {
         name: "insert_block",
-        description: "Insert a new block at the specified position. If index is omitted, inserts at the end.",
+        description: "Insert Gutenberg HTML at the specified position. If index is omitted, appends to end. HTML can be provided directly via rawHTML or loaded from a local file via filePath.",
         inputSchema: {
             type: "object",
             properties: {
                 postId: postIdParam,
                 site: siteParam,
-                blockType: { type: "string", description: "Block type (e.g. core/paragraph, core/heading, core/list)" },
-                content: { type: "string", description: "Block content (HTML or plain text depending on block type)" },
+                rawHTML: { type: "string", description: "Gutenberg markup HTML to insert. Mutually exclusive with filePath." },
+                filePath: { type: "string", description: "Absolute path to a local file containing Gutenberg HTML. Read as UTF-8. Mutually exclusive with rawHTML." },
                 index: { type: "number", description: "Insert position (0-based flattened index). If omitted, appends to end." },
-                blocks: { type: "array", items: { type: "object", properties: { blockType: { type: "string" }, content: { type: "string" } }, required: ["blockType", "content"] }, description: "Multiple blocks to insert. Cannot be used with blockType/content." },
-                rawHTML: { type: "string", description: "Gutenberg markup HTML to insert directly. Cannot be used with blockType/content or blocks." },
             },
         },
     },
@@ -371,49 +833,9 @@ const tools = [
             properties: {
                 postId: postIdParam,
                 site: siteParam,
-                target: {
-                    type: "string",
-                    enum: ["selected"],
-                    description: "Use 'selected' to target the block currently selected by the user in WordPress editor.",
-                },
-                index: {
-                    type: "number",
-                    description: "Single block index (0-based flattened).",
-                },
-                indices: {
-                    type: "array",
-                    items: { type: "number" },
-                    description: "Multiple block indices (0-based flattened).",
-                },
-                startIndex: {
-                    type: "number",
-                    description: "Range selection start index.",
-                },
-                endIndex: {
-                    type: "number",
-                    description: "Range selection end index.",
-                },
-                section: {
-                    type: "string",
-                    description: "Target section by heading text (partial match). Combines with blockType.",
-                },
-                blockType: {
-                    type: "string",
-                    description: "Filter by block type (e.g. core/table). Combines with section.",
-                },
-                typeIndex: {
-                    type: "number",
-                    description: "N-th block of the specified blockType (0-based). Use with blockType.",
-                },
-                headingLevel: {
-                    type: "number",
-                    description: "Heading level for section selection (2, 3, 4). Use with headingContains.",
-                },
-                headingContains: {
-                    type: "string",
-                    description: "Heading text for section selection. Use with headingLevel.",
-                },
+                target: targetSchema,
             },
+            required: ["target"],
         },
     },
     {
@@ -424,52 +846,7 @@ const tools = [
             properties: {
                 postId: postIdParam,
                 site: siteParam,
-                target: {
-                    type: "string",
-                    enum: ["selected"],
-                    description: "Use 'selected' to target the block currently selected by the user in WordPress editor.",
-                },
-                index: {
-                    type: "number",
-                    description: "Single block index (0-based flattened).",
-                },
-                indices: {
-                    type: "array",
-                    items: { type: "number" },
-                    description: "Multiple block indices (0-based flattened).",
-                },
-                startIndex: {
-                    type: "number",
-                    description: "Range selection start index.",
-                },
-                endIndex: {
-                    type: "number",
-                    description: "Range selection end index.",
-                },
-                section: {
-                    type: "string",
-                    description: "Target section by heading text (partial match). Combines with blockType/contains.",
-                },
-                blockType: {
-                    type: "string",
-                    description: "Filter by block type (e.g. core/table). Combines with section/contains.",
-                },
-                typeIndex: {
-                    type: "number",
-                    description: "N-th block of the specified blockType (0-based). Use with blockType.",
-                },
-                contains: {
-                    type: "string",
-                    description: "Target blocks containing this text.",
-                },
-                headingLevel: {
-                    type: "number",
-                    description: "Heading level for section selection (2, 3, 4). Use with headingContains.",
-                },
-                headingContains: {
-                    type: "string",
-                    description: "Heading text for section selection. Use with headingLevel.",
-                },
+                target: targetSchema,
                 replacements: {
                     type: "array",
                     items: {
@@ -485,7 +862,11 @@ const tools = [
                 },
                 newHTML: {
                     type: "string",
-                    description: "Full HTML replacement (Gutenberg markup). Only for contiguous targets (index/startIndex+endIndex/target:selected).",
+                    description: "Full HTML replacement (Gutenberg markup). Only for contiguous targets. Mutually exclusive with filePath.",
+                },
+                filePath: {
+                    type: "string",
+                    description: "Absolute path to a local file containing Gutenberg HTML. Read as UTF-8. Mutually exclusive with newHTML. Cannot be used with replacements or attributeUpdates.",
                 },
                 attributeUpdates: {
                     type: "object",
@@ -495,24 +876,18 @@ const tools = [
                     },
                     description: "Direct attribute updates via updateBlockAttributes API.",
                 },
-                insertOnly: {
-                    type: "boolean",
-                    description: "Keep existing blocks, insert newHTML as new blocks. Only with newHTML.",
-                },
-                insertPosition: {
-                    type: ["number", "string"],
-                    description: "Insert position when insertOnly=true. 'before', 'after' (default), or number.",
-                },
+                insert: insertSchema,
                 dryRun: {
                     type: "boolean",
                     description: "Preview changes without applying.",
                 },
             },
+            required: ["target"],
         },
     },
     {
         name: "table_operations",
-        description: "Perform structured operations on core/table blocks (get structure, update cells, add/delete rows/columns, style cells/rows).",
+        description: "Perform structured operations on core/table blocks (get structure, update/move cells/rows/columns, add/delete rows/columns).",
         inputSchema: {
             type: "object",
             properties: {
@@ -524,7 +899,7 @@ const tools = [
                 },
                 action: {
                     type: "string",
-                    enum: ["get_structure", "update_cell", "add_row", "delete_row", "add_column", "delete_column", "style_cell", "style_row"],
+                    enum: ["get_structure", "update_cell", "add_row", "delete_row", "add_column", "delete_column", "move_row", "move_column", "update_row", "update_column"],
                     description: "Operation type.",
                 },
                 row: {
@@ -541,28 +916,33 @@ const tools = [
                 },
                 position: {
                     type: "number",
-                    description: "Insert position for add_row/add_column. Omit for end.",
+                    description: "Position index. add_row/add_column: insert-before index (omit for end). move_row/move_column: destination index after move (required).",
                 },
                 cells: {
                     type: "array",
                     items: { type: "string" },
-                    description: "Cell contents for new row (add_row). Omit for empty cells.",
-                },
-                style: {
-                    type: "object",
-                    properties: {
-                        backgroundColor: { type: "string", description: "Background color (e.g. #ff0000)" },
-                        color: { type: "string", description: "Text color" },
-                        fontWeight: { type: "string", description: "Font weight (bold, normal)" },
-                        textAlign: { type: "string", description: "Text alignment (left, center, right)" },
-                        fontSize: { type: "string", description: "Font size (e.g. 14px)" },
-                    },
-                    description: "Style for style_cell/style_row.",
+                    description: "Cell contents array. add_row: new row cells. add_column: initial column values. update_row/update_column: replacement values. Omit for empty cells.",
                 },
             },
             required: ["index", "action"],
         },
     },
+    {
+        name: "open_in_browser",
+        description: "Open post in the OS default browser. Opens editor (wp-admin) or front page. Uses the user's default browser profile (logged-in session).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                target: {
+                    type: "string",
+                    enum: ["editor", "front"],
+                    description: "Open target. 'editor' = wp-admin edit screen, 'front' = public permalink page. Default: 'editor'.",
+                },
+            },
+        },
+    },
     {
         name: "list_connections",
         description: "List available site/user connections.",
@@ -601,20 +981,327 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools };
 });
 
+/**
+ * update_blocks ツールの共通ハンドラ（insert_block からの委譲にも対応）
+ * @param {object} args - ツール引数
+ * @param {string} toolName - 呼び出し元ツール名（レスポンス表示用）
+ */
+async function handleUpdateBlocksTool(args, toolName) {
+    const name = toolName || "update_blocks";
+    const { mode, postId: _postId, message, client } = await resolveMode(args);
+    if (mode === 'error') {
+        return errorResponse(name, message, args?.site);
+    }
+
+    // slug → postId 解決（headless モード時のみ）
+    const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+    if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+    const postId = _resolved.postId ?? _postId;
+
+    // --- 旧フラットパラメータの混在を検出（後方互換なし方針） ---
+    const legacyKeys = ['insertOnly', 'insertPosition', 'startIndex', 'endIndex',
+        'headingLevel', 'headingContains', 'typeIndex'];
+    const foundLegacy = legacyKeys.filter(k => args?.[k] !== undefined);
+    if (foundLegacy.length > 0) {
+        return {
+            content: [{ type: "text", text: `❌ 旧パラメータ形式は廃止されました: ${foundLegacy.join(', ')}。target / insert オブジェクトを使用してください。` }],
+            isError: true,
+        };
+    }
+
+    // --- normalizeTarget / normalizeInsert ---
+    let tp, ins;
+    try {
+        tp = normalizeTarget(args?.target);
+        ins = normalizeInsert(args?.insert);
+    } catch (e) {
+        return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+    }
+
+    const { target, index, indices, startIndex, endIndex, section, blockType, typeIndex,
+            contains, headingLevel, headingContains } = tp;
+    const { insertOnly, insertPosition } = ins;
+    const { replacements, attributeUpdates, dryRun,
+            _fromInsertBlock, appendToEnd } = (args || {});
+    let { newHTML } = (args || {});
+
+    // --- filePath → newHTML 解決（update_blocks 直接呼び出し時） ---
+    if (args?.filePath) {
+        if (newHTML) {
+            return { content: [{ type: "text", text: "❌ newHTML と filePath は同時に指定できません。どちらか一方を指定してください。" }], isError: true };
+        }
+        if (replacements && replacements.length > 0) {
+            return { content: [{ type: "text", text: "❌ filePath は replacements と併用できません。" }], isError: true };
+        }
+        if (attributeUpdates) {
+            return { content: [{ type: "text", text: "❌ filePath は attributeUpdates と併用できません。" }], isError: true };
+        }
+        try {
+            newHTML = readHTMLFromFile(args.filePath).html;
+        } catch (e) {
+            return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+        }
+    }
+
+    // --- insert 排他チェック ---
+    if (insertOnly && (replacements?.length > 0 || attributeUpdates)) {
+        return {
+            content: [{ type: "text", text: "❌ insert は newHTML 専用です。replacements や attributeUpdates と併用できません。" }],
+            isError: true,
+        };
+    }
+    if (insertOnly && !newHTML) {
+        return {
+            content: [{ type: "text", text: "❌ insert には newHTML が必要です。" }],
+            isError: true,
+        };
+    }
+
+    // Headless モードで target: "selected" はエラー
+    if (mode === 'headless' && target === 'selected') {
+        return {
+            content: [{ type: "text", text: "❌ target:'selected' はエディタ接続時のみ使用可能です。index を指定してください。" }],
+            isError: true,
+        };
+    }
+
+    // --- ターゲットチェック（appendToEnd 時は不要） ---
+    const hasTarget = target || index !== undefined || indices ||
+        startIndex !== undefined || section || blockType || contains ||
+        (headingLevel && headingContains);
+    if (!hasTarget && !(appendToEnd && insertOnly)) {
+        return {
+            content: [{ type: "text", text: "❌ ターゲットが指定されていません。\ntarget, index, indices, section, blockType, contains 等のいずれかを指定してください。" }],
+            isError: true,
+        };
+    }
+
+    const hasUpdate = (replacements && replacements.length > 0) || newHTML || attributeUpdates;
+    if (!hasUpdate) {
+        return {
+            content: [{ type: "text", text: "❌ 変更内容が指定されていません。\nreplacements, newHTML, attributeUpdates のいずれかを指定してください。" }],
+            isError: true,
+        };
+    }
+
+    // --- insertOnly 非推奨警告（外部呼び出し時のみ） ---
+    let deprecationWarning = '';
+    if (insertOnly && !_fromInsertBlock) {
+        deprecationWarning = '\n⚠️ update_blocks の insertOnly は非推奨です。insert_block ツールを使用してください。';
+        console.error('[DEPRECATED] update_blocks: insertOnly は非推奨です。insert_block を使用してください。');
+    }
+
+    // ========================================
+    // Headless モード
+    // ========================================
+    if (mode === 'headless') {
+        // appendToEnd: ターゲット不要の末尾追加
+        if (appendToEnd && insertOnly && newHTML) {
+            const result = await client.headlessUpdate(postId, {
+                newHTML,
+                insertOnly: true,
+                appendToEnd: true,
+                _fromInsertBlock: _fromInsertBlock || false,
+            });
+            const count = result.results?.[0]?.count || 1;
+            return { content: [{ type: "text", text: `✅ ${count}ブロック挿入 at end${deprecationWarning}` }] };
+        }
+
+        const result = await client.headlessUpdate(postId, {
+            index, indices, startIndex, endIndex,
+            section, blockType, typeIndex, contains,
+            headingLevel, headingContains,
+            replacements, newHTML, attributeUpdates,
+            insertOnly: insertOnly || false,
+            insertPosition,
+            dryRun: dryRun || false,
+            _fromInsertBlock: _fromInsertBlock || false,
+        });
+
+        if (result.dryRun && result.results) {
+            const previewText = result.results
+                .map(r => {
+                    const label = r.index !== undefined ? `[${r.index}]` :
+                                  r.indices ? `[${r.indices.join(', ')}]` : '[?]';
+                    return `  ${label}: ${r.preview ? 'プレビューあり' : 'N/A'}`;
+                })
+                .join('\n');
+            return { content: [{ type: "text", text: `🔍 プレビュー\n\n対象: ${result.results.length} ブロック\n\n${previewText}${deprecationWarning}` }] };
+        }
+
+        if (result.results) {
+            const successCount = result.results.filter(r => r.success).length;
+            const failCount = result.results.filter(r => !r.success).length;
+            return { content: [{ type: "text", text: `✅ 完了\n\n成功: ${successCount} / 失敗: ${failCount}${deprecationWarning}` }] };
+        }
+
+        return { content: [{ type: "text", text: `✅ 更新完了${deprecationWarning}` }] };
+    }
+
+    // ========================================
+    // Editor モード
+    // ========================================
+
+    // appendToEnd: ターゲット不要の末尾追加
+    if (appendToEnd && insertOnly && newHTML) {
+        const result = await client.sendEditorCommand("update_blocks", {
+            newHTML,
+            insertOnly: true,
+            appendToEnd: true,
+        }, 10000);
+        if (!result) return timeoutResponse(name, client, args?.site);
+        if (!result.success) return errorResponse(name, result.error, args?.site);
+        const count = result.inserted || 1;
+        return { content: [{ type: "text", text: `✅ ${count}ブロック挿入 at end${deprecationWarning}` }] };
+    }
+
+    // target: "selected" の場合 → エディタ状態から選択情報を取得してMCP側で処理
+    if (target === "selected") {
+        const state = await client.getEditorState();
+        const sel = state.selectedBlock;
+
+        if (!sel || (!sel.blockId && !sel.blockIds)) {
+            return {
+                content: [{ type: "text", text: "❌ ブロックが選択されていません。" }],
+                isError: true,
+            };
+        }
+
+        const blockIndices = sel.isMultiSelect ? sel.blockIndices : [sel.blockIndex];
+
+        // replacementsの場合、MCP側でカーソル選択ピンポイント差分を適用
+        if (replacements && replacements.length > 0) {
+            if (!sel.blockHTML) {
+                return {
+                    content: [{ type: "text", text: "❌ 選択中ブロックのHTML情報がありません。" }],
+                    isError: true,
+                };
+            }
+            let finalHTML = sel.blockHTML;
+            const hasTextSelection = sel.textSelection && sel.textSelection.text;
+            for (const replacement of replacements) {
+                if (!replacement.old || !replacement.new) continue;
+                if (hasTextSelection && sel.textSelection) {
+                    const { text: selText, context } = sel.textSelection;
+                    const searchPattern = context.before + selText + context.after;
+                    if (finalHTML.includes(searchPattern)) {
+                        const replacedPattern = context.before + replacement.new + context.after;
+                        finalHTML = finalHTML.replace(searchPattern, replacedPattern);
+                    } else {
+                        finalHTML = finalHTML.replace(new RegExp(escapeRegExp(replacement.old), 'g'), replacement.new);
+                    }
+                } else {
+                    finalHTML = finalHTML.replace(new RegExp(escapeRegExp(replacement.old), 'g'), replacement.new);
+                }
+            }
+            const result = await client.sendEditorCommand("update_blocks", {
+                mode: "html_replace_by_index",
+                blockIndices,
+                newHTML: finalHTML,
+                insertOnly: insertOnly || false,
+                insertPosition,
+            }, 10000);
+            if (!result)
+                return timeoutResponse(name, client, args?.site);
+            if (!result.success)
+                return errorResponse(name, result.error, args?.site);
+            return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了${hasTextSelection ? "（カーソル選択モード）" : "（差分）"}${deprecationWarning}` }] };
+        }
+
+        // newHTMLの場合
+        if (newHTML) {
+            const result = await client.sendEditorCommand("update_blocks", {
+                mode: "html_replace_by_index",
+                blockIndices,
+                newHTML,
+                insertOnly: insertOnly || false,
+                insertPosition,
+            }, 10000);
+            if (!result)
+                return timeoutResponse(name, client, args?.site);
+            if (!result.success)
+                return errorResponse(name, result.error, args?.site);
+            return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了${deprecationWarning}` }] };
+        }
+
+        // attributeUpdatesの場合
+        const result = await client.sendEditorCommand("update_blocks", {
+            mode: "attribute_update_by_index",
+            blockIndices,
+            attributeUpdates,
+            dryRun: dryRun || false,
+        }, 10000);
+        if (!result)
+            return timeoutResponse(name, client, args?.site);
+        if (!result.success)
+            return errorResponse(name, result.error, args?.site);
+        return { content: [{ type: "text", text: `✅ 属性更新完了${deprecationWarning}` }] };
+    }
+
+    // その他のターゲット → 全てWP側で解決＆実行
+    const maxWait = (section || blockType || contains) ? 15000 : 10000;
+    const result = await client.sendEditorCommand("update_blocks", {
+        index, indices, startIndex, endIndex,
+        section, blockType, typeIndex, contains,
+        headingLevel, headingContains,
+        replacements, newHTML, attributeUpdates,
+        insertOnly: insertOnly || false,
+        insertPosition,
+        dryRun: dryRun || false,
+        _fromInsertBlock: _fromInsertBlock || false,
+    }, maxWait);
+    if (!result)
+        return timeoutResponse(name, client, args?.site);
+    if (!result.success)
+        return errorResponse(name, result.error, args?.site);
+
+    // 結果フォーマット
+    if (dryRun && result.results) {
+        const previewText = result.results
+            .filter(r => r.preview)
+            .map(r => {
+                if (Array.isArray(r.preview)) {
+                    return `  [${r.index}]\n${r.preview.map(p => `    "${p.old}" → "${p.new}" (${p.count}箇所)`).join('\n')}`;
+                } else if (r.preview?.willUpdate) {
+                    return `  [${r.index}]: 属性更新予定 ${JSON.stringify(r.preview.willUpdate)}`;
+                } else if (r.preview?.skipped) {
+                    return `  [${r.index}]: スキップ (${r.preview.skipped})`;
+                }
+                return `  [${r.index}]: プレビュー不可`;
+            })
+            .join('\n');
+        return { content: [{ type: "text", text: `🔍 プレビュー\n\n対象: ${result.results.length} ブロック\n\n${previewText || "(対象なし)"}${deprecationWarning}` }] };
+    }
+
+    if (result.results) {
+        const successCount = result.results.filter(r => r.success && !r.skipped).length;
+        const skipCount = result.results.filter(r => r.skipped).length;
+        const failCount = result.results.filter(r => !r.success).length;
+        const detailText = result.results.filter(r => r.success && r.replaceCount > 0).map(r => `  [${r.index}]: ${r.replaceCount}箇所`).join('\n');
+        return { content: [{ type: "text", text: `✅ 完了\n\n成功: ${successCount} / スキップ: ${skipCount} / 失敗: ${failCount}\n\n${detailText}${deprecationWarning}` }] };
+    }
+
+    return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了${deprecationWarning}` }] };
+}
+
 // ツール実行のハンドラ
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
         switch (name) {
             case "get_article_structure": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client, siteName } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
                 const { blockType, section, headingLevel, expand, contains, full, limit, offset } = (args || {});
 
                 // 使用パラメータを特定
+                const siteLabel = siteName || 'default';
                 const usedParams = [];
                 if (section) usedParams.push("section");
                 if (blockType) usedParams.push("blockType");
@@ -624,7 +1311,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (full) usedParams.push("full");
                 if (limit && limit > 0) usedParams.push(`limit=${limit}`);
                 if (offset && offset > 0) usedParams.push(`offset=${offset}`);
-                const paramLabel = usedParams.length > 0 ? usedParams.join(" + ") : "default";
+                const paramLabel = usedParams.length > 0
+                    ? `${siteLabel}, ${usedParams.join(" + ")}`
+                    : siteLabel;
 
                 // Headless / Editor でデータ取得を分岐
                 let state;
@@ -1035,13 +1724,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     return { content: [{ type: "text", text: `❌ select_block はエディタ接続時のみ使用可能です。` }], isError: true };
                 }
 
-                const { index, blockType, typeIndex, contains, startIndex, endIndex, headingLevel, headingContains } = (args || {});
-
                 try {
-                    await client.selectBlock({
-                        index, blockType, typeIndex, contains,
-                        startIndex, endIndex, headingLevel, headingContains
-                    });
+                    const tp = normalizeTarget(args?.target);
+
+                    // BUG-3: select_block では selected は使用不可
+                    if (tp.target === "selected") {
+                        return {
+                            content: [{ type: "text", text: "❌ select_block では selected は使用できません。index, blockType, range 等を指定してください。" }],
+                            isError: true,
+                        };
+                    }
+
+                    // BUG-2: hasTarget チェック
+                    const { target, index, indices, startIndex, endIndex, section, blockType,
+                            typeIndex, contains, headingLevel, headingContains } = tp;
+                    const hasTarget = target || index !== undefined || indices ||
+                        startIndex !== undefined || section || blockType || contains ||
+                        (headingLevel && headingContains);
+                    if (!hasTarget) {
+                        return {
+                            content: [{ type: "text", text: "❌ ターゲットが指定されていません。index, blockType, range, heading, contains 等のいずれかを指定してください。" }],
+                            isError: true,
+                        };
+                    }
+
+                    await client.selectBlock(tp);
 
                     return {
                         content: [{
@@ -1061,10 +1768,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
 
             case "delete_block": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
                 const { index, count, indices } = args;
 
@@ -1119,12 +1829,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
 
             case "move_block": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
                 const { from, to, fromFlat, toFlat } = args;
+                const count = args.count ?? 1;
+
+                // count バリデーション
+                if (!Number.isInteger(count) || count < 1) {
+                    return { content: [{ type: "text", text: "❌ count は1以上の整数を指定してください。" }], isError: true };
+                }
 
                 // 排他バリデーション
                 const hasTopLevel = from !== undefined || to !== undefined;
@@ -1136,26 +1855,36 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     return { content: [{ type: "text", text: "❌ from/to または fromFlat/toFlat を指定してください。" }], isError: true };
                 }
 
+                // 移動結果のレスポンス生成ヘルパー
+                const moveMsg = (moved) => {
+                    if (moved?.noop) return `✅ 移動不要（同じ位置）`;
+                    const typeLabel = moved?.types ? moved.types.join(', ') : moved?.type ?? 'unknown';
+                    const countLabel = (moved?.count ?? 1) > 1 ? `${moved.count}ブロック` : '';
+                    return countLabel
+                        ? `✅ ${countLabel}移動 (${typeLabel})`
+                        : `✅ ブロック移動 (${typeLabel})`;
+                };
+
                 // fromFlat/toFlat モード（フラットインデックス移動）
                 if (hasFlat) {
                     if (fromFlat === undefined || toFlat === undefined) {
                         return { content: [{ type: "text", text: "❌ fromFlat と toFlat の両方を指定してください。" }], isError: true };
                     }
-                    if (fromFlat === toFlat) {
-                        return { content: [{ type: "text", text: "❌ fromFlat と toFlat が同じ位置です。" }], isError: true };
+                    if (fromFlat === toFlat || toFlat === fromFlat + count) {
+                        return { content: [{ type: "text", text: `✅ 移動不要（同じ位置）` }] };
                     }
 
                     if (mode === 'headless') {
-                        const result = await client.headlessMoveFlat(postId, fromFlat, toFlat);
-                        return { content: [{ type: "text", text: `✅ ブロック移動: flat[${fromFlat}] → flat[${toFlat}] (${result.moved.type})` }] };
+                        const result = await client.headlessMoveFlat(postId, fromFlat, toFlat, count);
+                        return { content: [{ type: "text", text: moveMsg(result.moved) }] };
                     }
 
-                    const result = await client.sendEditorCommand("move_block", { fromFlat, toFlat });
+                    const result = await client.sendEditorCommand("move_block", { fromFlat, toFlat, count });
                     if (!result)
                         return timeoutResponse(name, client, args?.site);
                     if (!result.success)
                         return errorResponse(name, result.error, args?.site);
-                    return { content: [{ type: "text", text: `✅ ブロック移動: flat[${fromFlat}] → flat[${toFlat}] (${result.moved.type})` }] };
+                    return { content: [{ type: "text", text: moveMsg(result.moved) }] };
                 }
 
                 // 既存モード（from/to トップレベル）
@@ -1164,18 +1893,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
 
                 if (mode === 'headless') {
-                    const result = await client.headlessMove(postId, from, to);
-                    return { content: [{ type: "text", text: `✅ ブロック移動: [${from}] → [${to}] (${result.moved.type})` }] };
+                    const result = await client.headlessMove(postId, from, to, count);
+                    return { content: [{ type: "text", text: moveMsg(result.moved) }] };
                 }
 
-                const result = await client.sendEditorCommand("move_block", { from, to });
+                const result = await client.sendEditorCommand("move_block", { from, to, count });
                 if (!result)
                     return timeoutResponse(name, client, args?.site);
                 if (!result.success)
                     return errorResponse(name, result.error, args?.site);
-                if (result.moved?.noop)
-                    return { content: [{ type: "text", text: `✅ 移動不要（同じ位置）` }] };
-                return { content: [{ type: "text", text: `✅ ブロック移動: [${from}] → [${to}] (${result.moved.type})` }] };
+                return { content: [{ type: "text", text: moveMsg(result.moved) }] };
             }
 
             case "undo": {
@@ -1211,10 +1938,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
 
             case "duplicate_block": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
                 const { index } = args;
 
@@ -1235,10 +1965,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
 
             case "save_post": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
                 if (mode === 'headless') {
                     // Headless モードでは即 DB 書き込みのため save は不要
@@ -1254,10 +1987,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
 
             case "get_post_meta": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
                 let m;
                 if (mode === 'headless') {
@@ -1293,10 +2029,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
 
             case "update_post_meta": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
                 const updateData = {};
                 if (args.title !== undefined) updateData.title = args.title;
@@ -1330,7 +2069,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 } catch (e) {
                     return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
                 }
-                const { data: posts, total, totalPages } = await client.listPosts(args || {});
+
+                // slug/search の空白正規化
+                const slug = args?.slug?.trim() || undefined;
+                const search = args?.search?.trim() || undefined;
+
+                // slug と search の排他チェック
+                if (slug && search) {
+                    return { content: [{ type: "text", text: "❌ slug と search は同時に指定できません。slug（完全一致）または search（キーワード検索）のいずれかを使用してください。" }], isError: true };
+                }
+
+                // listArgs を構築（slug 指定時: status 未指定なら 'any' に自動設定）
+                const listArgs = { ...(args || {}), slug, search };
+                if (slug && !listArgs.status) {
+                    listArgs.status = 'any';
+                }
+
+                const { data: posts, total, totalPages } = await client.listPosts(listArgs);
 
                 if (!posts || posts.length === 0) {
                     return { content: [{ type: "text", text: "📋 該当する投稿はありません。" }] };
@@ -1393,77 +2148,54 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
 
             case "insert_block": {
-                const { mode, postId, message, client } = await resolveMode(args);
-                if (mode === 'error') {
-                    return errorResponse(name, message, args?.site);
-                }
-
-                const { blockType, content, index, blocks, rawHTML } = args;
+                let { rawHTML, filePath, index } = (args || {});
 
-                // 排他バリデーション
-                const hasLegacy = blockType !== undefined || content !== undefined;
-                const hasBlocks = blocks !== undefined;
-                const hasRawHTML = rawHTML !== undefined;
-                const modeCount = [hasLegacy, hasBlocks, hasRawHTML].filter(Boolean).length;
-                if (modeCount === 0) {
-                    return { content: [{ type: "text", text: "❌ blockType+content、blocks、rawHTML のいずれかを指定してください。" }], isError: true };
+                // 排他チェック
+                if (rawHTML && filePath) {
+                    return { content: [{ type: "text", text: "❌ rawHTML と filePath は同時に指定できません。どちらか一方を指定してください。" }], isError: true };
                 }
-                if (modeCount > 1) {
-                    return { content: [{ type: "text", text: "❌ blockType+content、blocks、rawHTML は同時に指定できません。" }], isError: true };
-                }
-
-                // 複数挿入モード (blocks / rawHTML)
-                if (hasBlocks || hasRawHTML) {
-                    if (hasBlocks && (!Array.isArray(blocks) || blocks.length === 0)) {
-                        return { content: [{ type: "text", text: "❌ blocks は1つ以上の要素を含む配列で指定してください。" }], isError: true };
-                    }
 
-                    if (mode === 'headless') {
-                        const params = { index };
-                        if (hasBlocks) params.blocks = blocks;
-                        if (hasRawHTML) params.rawHTML = rawHTML;
-                        const result = await client.headlessInsert(postId, params);
-                        const count = result.insertedIndices ? result.insertedIndices.length : result.count || 1;
-                        return { content: [{ type: "text", text: `✅ ${count}ブロック挿入 at ${index ?? 'end'}` }] };
-                    }
-
-                    const cmdParams = { index };
-                    if (hasBlocks) cmdParams.blocks = blocks;
-                    if (hasRawHTML) cmdParams.rawHTML = rawHTML;
-                    const result = await client.sendEditorCommand("insert_block", cmdParams);
-                    if (!result)
-                        return timeoutResponse(name, client, args?.site);
-                    if (!result.success)
-                        return errorResponse(name, result.error, args?.site);
-                    const count = result.insertedCount || result.inserted?.length || 1;
-                    return { content: [{ type: "text", text: `✅ ${count}ブロック挿入 at ${index ?? 'end'}` }] };
+                // filePath → rawHTML 解決
+                if (filePath) {
+                    try { rawHTML = readHTMLFromFile(filePath).html; }
+                    catch (e) { return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true }; }
                 }
-
-                // 既存モード（単一 blockType + content）
-                if (!blockType || content === undefined) {
-                    return { content: [{ type: "text", text: "❌ blockType と content は必須です" }], isError: true };
+                if (!rawHTML) {
+                    return { content: [{ type: "text", text: "❌ rawHTML または filePath を指定してください。Gutenberg HTML 形式のブロックマークアップが必要です。" }], isError: true };
                 }
 
-                if (mode === 'headless') {
-                    const result = await client.headlessInsert(postId, { blockType, content, index });
-                    return { content: [{ type: "text", text: `✅ ブロック挿入: ${blockType} at ${result.newIndex}` }] };
+                // index バリデーション（現行 Editor 互換: 整数 >= 0）
+                if (index !== undefined && (!Number.isInteger(index) || index < 0)) {
+                    return { content: [{ type: "text", text: `❌ Invalid index: ${index}` }], isError: true };
                 }
 
-                const result = await client.sendEditorCommand("insert_block", { blockType, content, index });
-                if (!result)
-                    return timeoutResponse(name, client, args?.site);
-                if (!result.success)
-                    return errorResponse(name, result.error, args?.site);
-                return { content: [{ type: "text", text: `✅ ブロック挿入: ${result.inserted.type} at ${result.inserted.index}` }] };
+                // update_blocks コードパスに委譲（新形式 target/insert を使用）
+                const delegatedArgs = {
+                    postId: args.postId,
+                    site: args.site,
+                    newHTML: rawHTML,
+                    insert: { position: 'before' },
+                    _fromInsertBlock: true,
+                    appendToEnd: index === undefined,
+                };
+                if (index !== undefined) delegatedArgs.target = { index };
+                return await handleUpdateBlocksTool(delegatedArgs, name);
             }
 
             case "get_block_html": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
-                const { target, index, indices, startIndex, endIndex, section, blockType, typeIndex, headingLevel, headingContains } = (args || {});
+                let tp;
+                try { tp = normalizeTarget(args?.target); }
+                catch (e) { return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true }; }
+
+                const { target, index, indices, startIndex, endIndex, section, blockType, typeIndex, contains, headingLevel, headingContains } = tp;
 
                 if (mode === 'headless' && target === 'selected') {
                     return {
@@ -1473,7 +2205,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
 
                 const hasTarget = target || index !== undefined || indices ||
-                    startIndex !== undefined || section || blockType ||
+                    startIndex !== undefined || section || blockType || contains ||
                     (headingLevel && headingContains);
                 if (!hasTarget) {
                     return {
@@ -1486,12 +2218,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (mode === 'headless') {
                     const result = await client.headlessGetBlockHtml(postId, {
                         index, indices, startIndex, endIndex,
-                        section, blockType, typeIndex,
+                        section, blockType, typeIndex, contains,
                         headingLevel, headingContains,
                     });
                     blocks = result.blocks || [];
                 } else {
-                    const result = await client.sendEditorCommand("get_block_html", { target, index, indices, startIndex, endIndex, section, blockType, typeIndex, headingLevel, headingContains }, 10000);
+                    const result = await client.sendEditorCommand("get_block_html", {
+                        target, index, indices, startIndex, endIndex,
+                        section, blockType, typeIndex, contains,
+                        headingLevel, headingContains,
+                    }, 10000);
                     if (!result) {
                         return timeoutResponse(name, client, args?.site);
                     }
@@ -1545,210 +2281,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
 
             case "update_blocks": {
-                const { mode, postId: modePostId, message, client } = await resolveMode(args);
-                if (mode === 'error') {
-                    return errorResponse(name, message, args?.site);
-                }
-
-                const { target, index, indices, startIndex, endIndex, section, blockType, typeIndex, contains, headingLevel, headingContains, replacements, newHTML, attributeUpdates, insertOnly, insertPosition, dryRun } = (args || {});
-
-                // Headless モードで target: "selected" はエラー
-                if (mode === 'headless' && target === 'selected') {
-                    return {
-                        content: [{ type: "text", text: "❌ target:'selected' はエディタ接続時のみ使用可能です。index を指定してください。" }],
-                        isError: true,
-                    };
-                }
-
-                const hasTarget = target || index !== undefined || indices ||
-                    startIndex !== undefined || section || blockType || contains ||
-                    (headingLevel && headingContains);
-                if (!hasTarget) {
-                    return {
-                        content: [{ type: "text", text: "❌ ターゲットが指定されていません。\ntarget, index, indices, section, blockType, contains 等のいずれかを指定してください。" }],
-                        isError: true,
-                    };
-                }
-
-                const hasUpdate = (replacements && replacements.length > 0) || newHTML || attributeUpdates;
-                if (!hasUpdate) {
-                    return {
-                        content: [{ type: "text", text: "❌ 変更内容が指定されていません。\nreplacements, newHTML, attributeUpdates のいずれかを指定してください。" }],
-                        isError: true,
-                    };
-                }
-
-                // ========================================
-                // Headless モード
-                // ========================================
-                if (mode === 'headless') {
-                    const result = await client.headlessUpdate(modePostId, {
-                        index, indices, startIndex, endIndex,
-                        section, blockType, typeIndex, contains,
-                        headingLevel, headingContains,
-                        replacements, newHTML, attributeUpdates,
-                        insertOnly: insertOnly || false,
-                        insertPosition,
-                        dryRun: dryRun || false,
-                    });
-
-                    if (result.dryRun && result.results) {
-                        const previewText = result.results
-                            .map(r => {
-                                const label = r.index !== undefined ? `[${r.index}]` :
-                                              r.indices ? `[${r.indices.join(', ')}]` : '[?]';
-                                return `  ${label}: ${r.preview ? 'プレビューあり' : 'N/A'}`;
-                            })
-                            .join('\n');
-                        return { content: [{ type: "text", text: `🔍 プレビュー\n\n対象: ${result.results.length} ブロック\n\n${previewText}` }] };
-                    }
-
-                    if (result.results) {
-                        const successCount = result.results.filter(r => r.success).length;
-                        const failCount = result.results.filter(r => !r.success).length;
-                        return { content: [{ type: "text", text: `✅ 完了\n\n成功: ${successCount} / 失敗: ${failCount}` }] };
-                    }
-
-                    return { content: [{ type: "text", text: `✅ 更新完了` }] };
-                }
-
-                // ========================================
-                // Editor モード（現行ロジック）
-                // ========================================
-
-                // target: "selected" の場合 → エディタ状態から選択情報を取得してMCP側で処理
-                if (target === "selected") {
-                    const state = await client.getEditorState();
-                    const sel = state.selectedBlock;
-
-                    if (!sel || (!sel.blockId && !sel.blockIds)) {
-                        return {
-                            content: [{ type: "text", text: "❌ ブロックが選択されていません。" }],
-                            isError: true,
-                        };
-                    }
-
-                    const blockIndices = sel.isMultiSelect ? sel.blockIndices : [sel.blockIndex];
-
-                    // replacementsの場合、MCP側でカーソル選択ピンポイント差分を適用
-                    if (replacements && replacements.length > 0) {
-                        if (!sel.blockHTML) {
-                            return {
-                                content: [{ type: "text", text: "❌ 選択中ブロックのHTML情報がありません。" }],
-                                isError: true,
-                            };
-                        }
-                        let finalHTML = sel.blockHTML;
-                        const hasTextSelection = sel.textSelection && sel.textSelection.text;
-                        for (const replacement of replacements) {
-                            if (!replacement.old || !replacement.new) continue;
-                            if (hasTextSelection && sel.textSelection) {
-                                const { text: selText, context } = sel.textSelection;
-                                const searchPattern = context.before + selText + context.after;
-                                if (finalHTML.includes(searchPattern)) {
-                                    const replacedPattern = context.before + replacement.new + context.after;
-                                    finalHTML = finalHTML.replace(searchPattern, replacedPattern);
-                                } else {
-                                    finalHTML = finalHTML.replace(new RegExp(escapeRegExp(replacement.old), 'g'), replacement.new);
-                                }
-                            } else {
-                                finalHTML = finalHTML.replace(new RegExp(escapeRegExp(replacement.old), 'g'), replacement.new);
-                            }
-                        }
-                        const result = await client.sendEditorCommand("update_blocks", {
-                            mode: "html_replace_by_index",
-                            blockIndices,
-                            newHTML: finalHTML,
-                            insertOnly: insertOnly || false,
-                            insertPosition,
-                        }, 10000);
-                        if (!result)
-                            return timeoutResponse(name, client, args?.site);
-                        if (!result.success)
-                            return errorResponse(name, result.error, args?.site);
-                        return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了${hasTextSelection ? "（カーソル選択モード）" : "（差分）"}` }] };
-                    }
-
-                    // newHTMLの場合
-                    if (newHTML) {
-                        const result = await client.sendEditorCommand("update_blocks", {
-                            mode: "html_replace_by_index",
-                            blockIndices,
-                            newHTML,
-                            insertOnly: insertOnly || false,
-                            insertPosition,
-                        }, 10000);
-                        if (!result)
-                            return timeoutResponse(name, client, args?.site);
-                        if (!result.success)
-                            return errorResponse(name, result.error, args?.site);
-                        return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了` }] };
-                    }
-
-                    // attributeUpdatesの場合
-                    const result = await client.sendEditorCommand("update_blocks", {
-                        mode: "attribute_update_by_index",
-                        blockIndices,
-                        attributeUpdates,
-                        dryRun: dryRun || false,
-                    }, 10000);
-                    if (!result)
-                        return timeoutResponse(name, client, args?.site);
-                    if (!result.success)
-                        return errorResponse(name, result.error, args?.site);
-                    return { content: [{ type: "text", text: `✅ 属性更新完了` }] };
-                }
-
-                // その他のターゲット → 全てWP側で解決＆実行
-                const maxWait = (section || blockType || contains) ? 15000 : 10000;
-                const result = await client.sendEditorCommand("update_blocks", {
-                    index, indices, startIndex, endIndex,
-                    section, blockType, typeIndex, contains,
-                    headingLevel, headingContains,
-                    replacements, newHTML, attributeUpdates,
-                    insertOnly: insertOnly || false,
-                    insertPosition,
-                    dryRun: dryRun || false,
-                }, maxWait);
-                if (!result)
-                    return timeoutResponse(name, client, args?.site);
-                if (!result.success)
-                    return errorResponse(name, result.error, args?.site);
-
-                // 結果フォーマット
-                if (dryRun && result.results) {
-                    const previewText = result.results
-                        .filter(r => r.preview)
-                        .map(r => {
-                            if (Array.isArray(r.preview)) {
-                                return `  [${r.index}]\n${r.preview.map(p => `    "${p.old}" → "${p.new}" (${p.count}箇所)`).join('\n')}`;
-                            } else if (r.preview?.willUpdate) {
-                                return `  [${r.index}]: 属性更新予定 ${JSON.stringify(r.preview.willUpdate)}`;
-                            } else if (r.preview?.skipped) {
-                                return `  [${r.index}]: スキップ (${r.preview.skipped})`;
-                            }
-                            return `  [${r.index}]: プレビュー不可`;
-                        })
-                        .join('\n');
-                    return { content: [{ type: "text", text: `🔍 プレビュー\n\n対象: ${result.results.length} ブロック\n\n${previewText || "(対象なし)"}` }] };
-                }
-
-                if (result.results) {
-                    const successCount = result.results.filter(r => r.success && !r.skipped).length;
-                    const skipCount = result.results.filter(r => r.skipped).length;
-                    const failCount = result.results.filter(r => !r.success).length;
-                    const detailText = result.results.filter(r => r.success && r.replaceCount > 0).map(r => `  [${r.index}]: ${r.replaceCount}箇所`).join('\n');
-                    return { content: [{ type: "text", text: `✅ 完了\n\n成功: ${successCount} / スキップ: ${skipCount} / 失敗: ${failCount}\n\n${detailText}` }] };
-                }
-
-                return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了` }] };
+                return await handleUpdateBlocksTool(args, name);
             }
 
             case "table_operations": {
-                const { mode, postId, message, client } = await resolveMode(args);
+                const { mode, postId: _postId, message, client } = await resolveMode(args);
                 if (mode === 'error') {
                     return errorResponse(name, message, args?.site);
                 }
+                const _resolved = mode === 'headless' ? await resolvePostId(args?.postId, client) : { postId: _postId };
+                if (_resolved.error) return { content: [{ type: "text", text: _resolved.error }], isError: true };
+                const postId = _resolved.postId ?? _postId;
 
                 const { index, action } = (args || {});
                 if (index === undefined) {
@@ -1762,7 +2305,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     index, action,
                     row: args.row, col: args.col,
                     content: args.content, position: args.position,
-                    cells: args.cells, style: args.style,
+                    cells: args.cells,
                 };
 
                 // get_structure の結果をフォーマットするヘルパー
@@ -1775,7 +2318,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         for (const row of section.rows) {
                             const cellTexts = row.cells.map((c, ci) => {
                                 const content = c.content.replace(/<[^>]*>/g, '').trim();
-                                return `[${row.globalRow},${ci}] ${content || '(空)'}`;
+                                const flags = [];
+                                if (/<img\b/i.test(c.content)) flags.push('img');
+                                if (/<a[\s>]/i.test(c.content)) flags.push('a');
+                                if (c.style) flags.push('style');
+                                const flagStr = flags.length > 0 ? ` [${flags.join(',')}]` : '';
+                                return `[${row.globalRow},${ci}] ${content || '(空)'}${flagStr}`;
                             });
                             text += `  行${row.globalRow}: ${cellTexts.join(' | ')}\n`;
                         }
@@ -1804,9 +2352,57 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: `✅ ${action} 完了: ${JSON.stringify(result.detail || {})}` }] };
             }
 
+            case "open_in_browser": {
+                const target = args?.target || 'editor';
+                if (target !== 'editor' && target !== 'front') {
+                    return { content: [{ type: "text", text: `❌ target は "editor" または "front" を指定してください（指定値: "${target}"）` }], isError: true };
+                }
+
+                let { mode, postId: _postId, message, client, errorCode } = await resolveMode(args);
+
+                // Editor conflict は読み取り専用なので無視して続行
+                if (mode === 'error' && errorCode === 'editor_conflict') {
+                    mode = 'headless';
+                } else if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                let postId;
+                if (mode === 'editor') {
+                    postId = _postId;
+                } else {
+                    const resolved = await resolvePostId(args?.postId, client, { skipConflictCheck: true });
+                    if (resolved.error) return { content: [{ type: "text", text: resolved.error }], isError: true };
+                    postId = resolved.postId ?? _postId;
+                }
+
+                let url;
+                if (target === 'front') {
+                    const meta = await client.headlessGetMeta(postId);
+                    url = meta.link;
+                } else {
+                    url = `${client.wpUrl.replace(/\/$/, '')}/wp-admin/post.php?post=${postId}&action=edit`;
+                }
+
+                if (!isValidHttpUrl(url)) {
+                    return { content: [{ type: "text", text: `❌ 無効なURLです: ${url}` }], isError: true };
+                }
+
+                try {
+                    await openInBrowser(url);
+                    const label = target === 'front' ? 'フロントページ' : 'エディタ';
+                    return { content: [{ type: "text", text: `🌐 ${label}をブラウザで開きました\nURL: ${url}` }] };
+                } catch (e) {
+                    return { content: [{ type: "text", text: `⚠️ ブラウザの起動に失敗しました。URLを手動で開いてください:\n${url}\n\nエラー: ${e.message}` }], isError: true };
+                }
+            }
+
             case "list_connections": {
                 const conns = registry.list();
-                const text = conns.map(c => `  ${c.name}: ${c.url} (${c.user})`).join('\n');
+                const text = conns.map(c => {
+                    const mark = c.isDefault ? ' (default)' : '';
+                    return `  ${c.name}${mark}: ${c.url} (${c.user})`;
+                }).join('\n');
                 return { content: [{ type: "text", text: `🔗 接続一覧 (${conns.length}件)\n\n${text}` }] };
             }