zuiku-mcp 0.3.0 → 0.3.2

package/README.md

@@ -6,11 +6,12 @@
 
 ## What it exposes
 
-- `zuiku.open`: open Markdown or Mermaid content as a localhost editor session
+- `zuiku.version`: report the running package/server version and update hints
+- `zuiku.open`: open a markdown file, canonical Zuiku Markdown, or Mermaid-only content as a localhost editor session
 - `zuiku.read`: read current Markdown and hash before updating
-- `zuiku.apply`: write Markdown back with hash-based conflict protection
+- `zuiku.apply`: write Mermaid-only or canonical Markdown back as normalized Zuiku Markdown with hash-based conflict protection
 - `zuiku.export`: export Markdown, PNG, or SVG
-- `zuiku.ddl_to_er`: turn a DDL string into ER diagram payloads
+- `zuiku.ddl_to_er`: turn an upstream-acquired DDL string into ER diagram payloads
 
 ## Entry command
 
@@ -18,6 +19,32 @@
 npx -y zuiku-mcp
 ```
 
+## Version and update
+
+Check the currently installed package version:
+
+```bash
+npx -y zuiku-mcp --version
+```
+
+Check the latest published npm version:
+
+```bash
+npm view zuiku-mcp version
+```
+
+Run the latest package one-shot:
+
+```bash
+npx -y zuiku-mcp@latest
+```
+
+Update a global install:
+
+```bash
+npm install -g zuiku-mcp@latest
+```
+
 ## Typical usage
 
 - Codex CLI / Claude Code / Gemini CLI: register it as an MCP server command
@@ -35,7 +62,11 @@ npx -y zuiku-mcp
 ## Notes
 
 - Requires Node.js 20+
+- `zuiku.version` can be called from MCP clients to confirm the running build and show update hints
 - For chat clients, `ZUIKU_MCP_OPEN_BROWSER=0` is usually the better default
+- `zuiku.apply(openAfterApply=true)` can request opening or reusing the local editor session after save
+- Discovery guides are exposed over MCP resources/prompts so AI clients can avoid external lookup
+- After updating, restart the MCP client or IDE session so the new package is launched
 - During preview, CLI and manual MCP setup are the source of truth; optional IDE extension listings can be added on top later
 - Install guide: `https://zuiku.dev/install`
 - Docs: `https://zuiku.dev/docs`

package/bin/zuiku-mcp.mjs

@@ -1,4 +1,14 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+
+if (process.argv.includes("--version") || process.argv.includes("-v") || process.argv[2] === "version") {
+  process.stdout.write(`${packageJson.version}\n`);
+  process.exit(0);
+}
+
 const entryPath = new URL("../dist/zuiku-mcp-server.mjs", import.meta.url);
 
 try {

package/dist/zuiku-mcp-server.mjs

@@ -5,9 +5,19 @@ import path4 from "node:path";
 
 // ../../apps/web/src/lib/mcpContract.ts
 var MCP_TOOL_DEFINITIONS = [
+  {
+    name: "zuiku.version",
+    description: "Return the current zuiku-mcp package/server version and update hints. Use this to confirm which MCP build is currently running.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+      additionalProperties: false
+    }
+  },
   {
     name: "zuiku.open",
-    description: "Open a markdown file or markdown text in the local editor session",
+    description: "Open a markdown file, canonical Zuiku Markdown, or Mermaid-only text in a local editor session. Mermaid-only input is normalized on save, and the result includes editorUrl.",
     inputSchema: {
       type: "object",
       properties: {
@@ -22,7 +32,7 @@ var MCP_TOOL_DEFINITIONS = [
   },
   {
     name: "zuiku.read",
-    description: "Read markdown diagram source",
+    description: "Read the current markdown source and hash before updating an existing Zuiku file.",
     inputSchema: {
       type: "object",
       properties: {
@@ -34,7 +44,7 @@ var MCP_TOOL_DEFINITIONS = [
   },
   {
     name: "zuiku.apply",
-    description: "Apply markdown with hash conflict protection",
+    description: "Apply Mermaid-only or canonical Zuiku Markdown with hash conflict protection. The saved file is normalized to canonical Zuiku Markdown, and openAfterApply can open or reuse the local editor session.",
     inputSchema: {
       type: "object",
       properties: {
@@ -42,7 +52,8 @@ var MCP_TOOL_DEFINITIONS = [
         markdown: { type: "string" },
         expectedHash: { type: "string" },
         mode: { type: "string", enum: ["replace", "current-page"] },
-        targetDiagramId: { type: "string" }
+        targetDiagramId: { type: "string" },
+        openAfterApply: { type: "boolean" }
       },
       required: ["path", "markdown", "expectedHash"],
       additionalProperties: false
@@ -50,7 +61,7 @@ var MCP_TOOL_DEFINITIONS = [
   },
   {
     name: "zuiku.export",
-    description: "Export markdown / svg / png from a markdown source file",
+    description: "Export markdown / svg / png from a saved Zuiku markdown source file.",
     inputSchema: {
       type: "object",
       properties: {
@@ -64,7 +75,7 @@ var MCP_TOOL_DEFINITIONS = [
   },
   {
     name: "zuiku.ddl_to_er",
-    description: "Convert SQL DDL to Mermaid erDiagram + Zuiku markdown/project payload",
+    description: "Convert upstream-acquired SQL DDL to Mermaid erDiagram plus canonical Zuiku markdown/project payload. Zuiku does not fetch the DDL or connect to the database.",
     inputSchema: {
       type: "object",
       properties: {
@@ -98,6 +109,18 @@ function validateMcpToolRequest(input) {
     return invalidRequest("args must be an object");
   }
   const args = input.args;
+  if (tool === "zuiku.version") {
+    if (!hasOnlyKeys(args, [])) {
+      return invalidRequest("zuiku.version.args contains unknown keys");
+    }
+    return {
+      ok: true,
+      value: {
+        tool,
+        args: {}
+      }
+    };
+  }
   if (tool === "zuiku.open") {
     if (!hasOnlyKeys(args, ["path", "markdown", "title", "openInBrowser"])) {
       return invalidRequest("zuiku.open.args contains unknown keys");
@@ -151,7 +174,7 @@ function validateMcpToolRequest(input) {
     return { ok: true, value: { tool, args: { path: path5 } } };
   }
   if (tool === "zuiku.apply") {
-    if (!hasOnlyKeys(args, ["path", "markdown", "expectedHash", "hashAlgorithm", "mode", "targetDiagramId"])) {
+    if (!hasOnlyKeys(args, ["path", "markdown", "expectedHash", "hashAlgorithm", "mode", "targetDiagramId", "openAfterApply"])) {
       return invalidRequest("zuiku.apply.args contains unknown keys");
     }
     const path5 = asNonEmptyString(args.path);
@@ -160,6 +183,7 @@ function validateMcpToolRequest(input) {
     const hashAlgorithm = asString(args.hashAlgorithm);
     const mode = asString(args.mode);
     const targetDiagramId = asString(args.targetDiagramId);
+    const openAfterApply = asBoolean(args.openAfterApply);
     if (!path5) {
       return invalidRequest("zuiku.apply.args.path is required");
     }
@@ -193,6 +217,9 @@ function validateMcpToolRequest(input) {
     if (mode === "current-page" && !targetDiagramId) {
       return invalidRequest("zuiku.apply.args.targetDiagramId is required for current-page mode");
     }
+    if (args.openAfterApply !== void 0 && typeof openAfterApply !== "boolean") {
+      return invalidRequest("zuiku.apply.args.openAfterApply must be boolean");
+    }
     const normalizedHashAlgorithm = hashAlgorithm === "sha256" ? "sha256" : void 0;
     const normalizedMode = mode === "replace" || mode === "current-page" ? mode : void 0;
     return {
@@ -205,7 +232,8 @@ function validateMcpToolRequest(input) {
           expectedHash,
           ...normalizedHashAlgorithm ? { hashAlgorithm: normalizedHashAlgorithm } : {},
           ...normalizedMode ? { mode: normalizedMode } : {},
-          ...targetDiagramId ? { targetDiagramId } : {}
+          ...targetDiagramId ? { targetDiagramId } : {},
+          ...typeof openAfterApply === "boolean" ? { openAfterApply } : {}
         }
       }
     };
@@ -326,6 +354,158 @@ function isDiagramIdLike(value) {
   return /^[A-Za-z0-9_:\-\u3040-\u30ff\u4e00-\u9faf]+$/.test(value);
 }
 
+// ../../apps/web/src/lib/mcpGuidance.ts
+var GUIDE_TEXT_BY_TOPIC = {
+  "format-guide": [
+    "# Zuiku format guide",
+    "",
+    "- \u5165\u529B\u306F `Zuiku Markdown` \u307E\u305F\u306F `Mermaid\u5358\u4F53` \u3092\u53D7\u3051\u3089\u308C\u308B\u3002",
+    "- \u4FDD\u5B58\u3068\u5171\u6709\u306E\u6B63\u898F\u5F62\u306F `H1 -> mermaid -> layout-json` \u306E Markdown 1\u30D5\u30A1\u30A4\u30EB\u3002",
+    "- `zuiku.open` \u306F editor session \u3092\u4F5C\u308A\u3001`editorUrl` \u3092\u8FD4\u3059\u3002",
+    "- `zuiku.apply` \u306F\u4FDD\u5B58\u6642\u306B\u6B63\u898F\u5F62\u3078\u5BC4\u305B\u308B\u3002",
+    "- \u65E2\u5B58\u66F4\u65B0\u306F `zuiku.read -> zuiku.apply(expectedHash=...)`\u3002",
+    "- `openAfterApply=true` \u3067 editor session \u306E\u518D\u5229\u7528\u307E\u305F\u306F\u65B0\u898F open \u3092\u8981\u6C42\u3067\u304D\u308B\u3002",
+    "- DDL \u53D6\u5F97\u3084 DB \u63A5\u7D9A\u306F Zuiku \u306E\u8CAC\u52D9\u3067\u306F\u306A\u3044\u3002"
+  ].join("\n"),
+  "flowchart-example": [
+    "# Zuiku flowchart example",
+    "",
+    "```markdown",
+    "# Sample Flow",
+    "",
+    "```mermaid",
+    "%% diagramId: flow-main",
+    "flowchart LR",
+    "  A[Start] --> B{Check}",
+    "  B -- yes --> C[Run]",
+    "  B -- no --> D[End]",
+    "  C --> D",
+    "```",
+    "",
+    "```layout-json",
+    "{",
+    '  "version": 1,',
+    '  "diagramId": "flow-main",',
+    '  "type": "flowchart",',
+    '  "nodes": {',
+    '    "A": { "x": 80, "y": 120, "w": 140, "h": 56 },',
+    '    "B": { "x": 280, "y": 120, "w": 140, "h": 56 },',
+    '    "C": { "x": 500, "y": 70, "w": 140, "h": 56 },',
+    '    "D": { "x": 500, "y": 170, "w": 140, "h": 56 }',
+    "  },",
+    '  "edges": {',
+    '    "e1": { "from": "A", "to": "B", "points": [] },',
+    '    "e2": { "from": "B", "to": "C", "points": [] },',
+    '    "e3": { "from": "B", "to": "D", "points": [] },',
+    '    "e4": { "from": "C", "to": "D", "points": [] }',
+    "  }",
+    "}",
+    "```",
+    "```"
+  ].join("\n"),
+  "er-from-ddl-guide": [
+    "# ER from DDL guide",
+    "",
+    "- \u307E\u305A\u4E0A\u6D41AI\u304C DB tool / \u5225 MCP / \u8A31\u53EF\u5236 install \u3067 DDL \u3092\u53D6\u5F97\u3059\u308B\u3002",
+    "- Zuiku \u306F DB \u3078\u63A5\u7D9A\u3057\u306A\u3044\u3002`zuiku.ddl_to_er(ddl, ...)` \u3060\u3051\u3092\u62C5\u5F53\u3059\u308B\u3002",
+    "- \u65B0\u898F\u306A\u3089 `zuiku.open(markdown, openInBrowser=true)`\u3002",
+    "- \u65E2\u5B58\u66F4\u65B0\u306A\u3089 `zuiku.read -> zuiku.apply(mode, expectedHash, openAfterApply=true)`\u3002",
+    "- `current-page` \u306F `targetDiagramId` \u5FC5\u9808\u3002",
+    "- \u4FDD\u5B58\u7D50\u679C\u306F Zuiku Markdown \u6B63\u898F\u5F62\u3078\u5BC4\u308B\u3002"
+  ].join("\n"),
+  "edit-existing-guide": [
+    "# Edit existing guide",
+    "",
+    "- \u65E2\u5B58\u56F3\u66F4\u65B0\u524D\u306F\u5FC5\u305A `zuiku.read(path)`\u3002",
+    "- AI \u306F\u65E2\u5B58 diagramId \u3068\u56F3\u7A2E\u3092\u4FDD\u3064\u3002",
+    "- \u5165\u529B\u306F Zuiku Markdown \u3067\u3082 Mermaid\u5358\u4F53\u3067\u3082\u3088\u3044\u3002",
+    "- `zuiku.apply(path, markdown, expectedHash, mode, targetDiagramId?, openAfterApply=true)` \u3092\u4F7F\u3046\u3002",
+    "- `replace` \u306F file \u5168\u4F53\u66F4\u65B0\u3001`current-page` \u306F diagram \u5358\u4F4D\u66F4\u65B0\u3002",
+    "- \u4FDD\u5B58\u6642\u306F\u6B63\u898F Zuiku Markdown \u306B\u6B63\u898F\u5316\u3055\u308C\u308B\u3002"
+  ].join("\n")
+};
+var GUIDE_RESOURCE_DEFINITIONS = [
+  {
+    topic: "format-guide",
+    uri: "zuiku://guide/format-guide",
+    name: "format-guide",
+    description: "Short contract for Zuiku input, save, open, and DDL responsibility boundaries."
+  },
+  {
+    topic: "flowchart-example",
+    uri: "zuiku://guide/flowchart-example",
+    name: "flowchart-example",
+    description: "Minimal flowchart example in canonical Zuiku Markdown."
+  },
+  {
+    topic: "er-from-ddl-guide",
+    uri: "zuiku://guide/er-from-ddl-guide",
+    name: "er-from-ddl-guide",
+    description: "How upstream AI should fetch DDL and hand only the DDL string to Zuiku."
+  },
+  {
+    topic: "edit-existing-guide",
+    uri: "zuiku://guide/edit-existing-guide",
+    name: "edit-existing-guide",
+    description: "Read-before-apply workflow for updating an existing Zuiku file."
+  }
+];
+var MCP_STATIC_RESOURCES = GUIDE_RESOURCE_DEFINITIONS.map((definition) => ({
+  uri: definition.uri,
+  name: definition.name,
+  description: definition.description,
+  mimeType: "text/markdown",
+  text: GUIDE_TEXT_BY_TOPIC[definition.topic]
+}));
+var MCP_RESOURCE_TEMPLATES = [
+  {
+    uriTemplate: "zuiku://guide/{topic}",
+    name: "zuiku-guide",
+    description: "Read a short Zuiku guide for format-guide, flowchart-example, er-from-ddl-guide, or edit-existing-guide.",
+    mimeType: "text/markdown"
+  }
+];
+var MCP_PROMPTS = GUIDE_RESOURCE_DEFINITIONS.map((definition) => ({
+  name: definition.name,
+  description: definition.description
+}));
+function resolveMcpResource(uri) {
+  const exact = MCP_STATIC_RESOURCES.find((resource) => resource.uri === uri);
+  if (exact) {
+    return exact;
+  }
+  const match = uri.match(/^zuiku:\/\/guide\/([^/]+)$/);
+  const topic = match?.[1];
+  if (!topic || !(topic in GUIDE_TEXT_BY_TOPIC)) {
+    return void 0;
+  }
+  return {
+    uri: `zuiku://guide/${topic}`,
+    name: topic,
+    description: `Generated guide for ${topic}.`,
+    mimeType: "text/markdown",
+    text: GUIDE_TEXT_BY_TOPIC[topic]
+  };
+}
+function resolveMcpPrompt(name) {
+  const resource = MCP_STATIC_RESOURCES.find((item) => item.name === name);
+  if (!resource) {
+    return void 0;
+  }
+  return {
+    description: resource.description,
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: resource.text
+        }
+      }
+    ]
+  };
+}
+
 // ../../apps/web/src/lib/mcpStdioRuntime.ts
 import { createHash } from "node:crypto";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
@@ -3064,6 +3244,7 @@ var IMPORT_RECOVERY_AI_PROMPT = [
   "- \u5165\u529B\u306B\u65E2\u5B58\u306E Zuiku Markdown \u304C\u542B\u307E\u308C\u308B\u5834\u5408\u306F\u3001\u305D\u306E\u5185\u5BB9\u30FBdiagramId\u30FB\u65E2\u5B58\u30C7\u30B6\u30A4\u30F3\u3092\u3067\u304D\u308B\u3060\u3051\u4FDD\u3061\u306A\u304C\u3089\u4FEE\u6B63\u3059\u308B\u3002",
   "- \u5165\u529B\u306B\u65E2\u5B58\u306E Zuiku Markdown \u304C\u306A\u3044\u5834\u5408\u306F\u3001\u4F1A\u8A71\u5185\u5BB9\u30FB\u8AAC\u660E\u5185\u5BB9\u3092\u6574\u7406\u3057\u3066\u65B0\u898F\u306B\u56F3\u3092\u751F\u6210\u3059\u308B\u3002",
   "- \u69CB\u9020\u306E\u6B63\u306F `mermaid`\u3001\u898B\u305F\u76EE\u306E\u6B63\u306F `layout-json`\u3002",
+  "- \u5165\u529B\u3068\u3057\u3066 `Mermaid\u5358\u4F53` \u306F\u53D7\u3051\u3089\u308C\u308B\u304C\u3001\u6700\u7D42\u51FA\u529B\u306F\u5FC5\u305A Zuiku Markdown \u6B63\u898F\u5F62\u306B\u3059\u308B\u3002",
   "- \u30E6\u30FC\u30B6\u30FC\u8981\u671B\u304C\u306A\u3044\u9650\u308A\u65E2\u5B58\u30C7\u30B6\u30A4\u30F3\u3092\u8E0F\u8972\u3057\u3001\u8981\u671B\u304C\u3042\u308B\u5834\u5408\u306E\u307F\u30C7\u30B6\u30A4\u30F3\u5909\u66F4\u3059\u308B\u3002",
   "- \u56F3\u30C7\u30FC\u30BF\u672C\u6587\u306F `H1` \u2192 `mermaid` \u2192 `layout-json` \u306E\u9806\u3002",
   "- `mermaid` \u5358\u4F53 / `layout-json` \u5358\u4F53 / JSON\u5358\u4F53 / HTML/CSS/JavaScript \u306E\u51FA\u529B\u306F\u7981\u6B62\u3002",
@@ -3110,6 +3291,7 @@ var IMPORT_RECOVERY_ER_AI_PROMPT = [
   "- \u5165\u529B\u306B\u65E2\u5B58\u306E Zuiku Markdown \u304C\u542B\u307E\u308C\u308B\u5834\u5408\u306F\u3001\u305D\u306E\u5185\u5BB9\u30FBdiagramId\u30FB\u65E2\u5B58\u30C7\u30B6\u30A4\u30F3\u3092\u3067\u304D\u308B\u3060\u3051\u4FDD\u3061\u306A\u304C\u3089\u4FEE\u6B63\u3059\u308B\u3002",
   "- \u5165\u529B\u306B\u65E2\u5B58\u306E Zuiku Markdown \u304C\u306A\u3044\u5834\u5408\u306F\u3001\u4F1A\u8A71\u5185\u5BB9\u30FB\u8AAC\u660E\u5185\u5BB9\u3092\u6574\u7406\u3057\u3066\u65B0\u898F\u306B\u56F3\u3092\u751F\u6210\u3059\u308B\u3002",
   "- \u69CB\u9020\u306E\u6B63\u306F `mermaid`\u3001\u898B\u305F\u76EE\u306E\u6B63\u306F `layout-json`\u3002",
+  "- \u5165\u529B\u3068\u3057\u3066 `Mermaid\u5358\u4F53` \u306F\u53D7\u3051\u3089\u308C\u308B\u304C\u3001\u6700\u7D42\u51FA\u529B\u306F\u5FC5\u305A Zuiku Markdown \u6B63\u898F\u5F62\u306B\u3059\u308B\u3002",
   "- \u30E6\u30FC\u30B6\u30FC\u8981\u671B\u304C\u306A\u3044\u9650\u308A\u65E2\u5B58\u30C7\u30B6\u30A4\u30F3\u3092\u8E0F\u8972\u3057\u3001\u8981\u671B\u304C\u3042\u308B\u5834\u5408\u306E\u307F\u30C7\u30B6\u30A4\u30F3\u5909\u66F4\u3059\u308B\u3002",
   "- \u56F3\u30C7\u30FC\u30BF\u672C\u6587\u306F `H1` \u2192 `mermaid` \u2192 `layout-json` \u306E\u9806\u3002",
   "- \u65E2\u5B58\u56F3\u7A2E\u304C ER \u306E\u3068\u304D\u306F `erDiagram` \u3092\u7DAD\u6301\u3059\u308B\u3002",
@@ -3337,6 +3519,12 @@ function parseZuikuMarkdown(markdown, options = {}) {
   const { blocks, h1Title } = scanMarkdownFences(normalizedMarkdown);
   const rawMermaidBlocks = blocks.filter((block) => block.language === "mermaid");
   const rawLayoutBlocks = blocks.filter((block) => block.language === "layout-json");
+  if (rawMermaidBlocks.length === 0 && rawLayoutBlocks.length === 0) {
+    const syntheticMermaid = buildSyntheticMermaidBlock(normalizedMarkdown, h1Title);
+    if (syntheticMermaid) {
+      rawMermaidBlocks.push(syntheticMermaid);
+    }
+  }
   if (rawMermaidBlocks.length === 0 && rawLayoutBlocks.length === 0) {
     throw new ImportValidationError("not_zuiku_format");
   }
@@ -3344,7 +3532,11 @@ function parseZuikuMarkdown(markdown, options = {}) {
     throw new ImportValidationError("mermaid_block_missing");
   }
   if (rawLayoutBlocks.length === 0) {
-    throw new ImportValidationError("not_zuiku_format");
+    pushImportWarning(warnings, {
+      code: "layout_autogenerated_from_mermaid",
+      severity: "info",
+      message: "layout-json \u304C\u7121\u3044\u305F\u3081\u521D\u671F\u914D\u7F6E\u3092\u81EA\u52D5\u751F\u6210\u3057\u307E\u3057\u305F"
+    });
   }
   const mermaidBlocks = [];
   const layoutBlocks = [];
@@ -3367,10 +3559,10 @@ function parseZuikuMarkdown(markdown, options = {}) {
   const fallbackLayouts = layoutBlocks.filter((layout) => !layout.diagramId);
   const layoutHasDiagramIds = layoutBlocks.some((layout) => Boolean(layout.diagramId));
   const mermaidHasDiagramIds = mermaidBlocks.some((block) => Boolean(block.diagramId));
-  if (layoutHasDiagramIds !== mermaidHasDiagramIds) {
+  if (layoutBlocks.length > 0 && layoutHasDiagramIds !== mermaidHasDiagramIds) {
     throw new ImportValidationError("diagram_id_mismatch");
   }
-  if (layoutHasDiagramIds) {
+  if (layoutBlocks.length > 0 && layoutHasDiagramIds) {
     if (layoutBlocks.some((layout) => !layout.diagramId) || mermaidBlocks.some((block) => !block.diagramId)) {
       throw new ImportValidationError("diagram_id_mismatch");
     }
@@ -3444,7 +3636,7 @@ function exportZuikuMarkdown(project) {
   lines.push("- \u3053\u308C\u306FZuiku\u306B\u3088\u3063\u3066\u751F\u6210\u3055\u308C\u305FMarkdown\u3067\u3059\u3002");
   lines.push("- \u69CB\u9020\u306E\u6B63\u306F `mermaid`\u3001\u898B\u305F\u76EE\u306E\u6B63\u306F `layout-json`\u3002");
   lines.push("- \u30E6\u30FC\u30B6\u30FC\u8981\u671B\u304C\u306A\u3044\u9650\u308A\u65E2\u5B58\u30C7\u30B6\u30A4\u30F3\u3092\u8E0F\u8972\u3057\u3001\u8981\u671B\u304C\u3042\u308B\u5834\u5408\u306E\u307F\u30C7\u30B6\u30A4\u30F3\u5909\u66F4\u3059\u308B\u3002");
-  lines.push("- \u56F3\u30C7\u30FC\u30BF\u672C\u6587\u306F `H1` \u2192 `mermaid` \u2192 `layout-json` \u306E\u9806\u3002");
+  lines.push("- \u5165\u529B\u3068\u3057\u3066\u306F `Mermaid\u5358\u4F53` \u3082\u53D7\u3051\u3089\u308C\u308B\u304C\u3001\u4FDD\u5B58\u30FB\u5171\u6709\u306E\u6B63\u898F\u5F62\u306F `H1` \u2192 `mermaid` \u2192 `layout-json`\u3002");
   lines.push("- `mermaid` \u5358\u4F53 / `layout-json` \u5358\u4F53 / JSON\u5358\u4F53 / HTML/CSS/JavaScript \u306E\u51FA\u529B\u306F\u7981\u6B62\u3002");
   lines.push("- \u7B2C\u4E00\u9078\u629E\u306F `.md` \u30D5\u30A1\u30A4\u30EB1\u4EF6\u306E\u6DFB\u4ED8\uFF08\u5FC5\u9808\uFF09\u3002");
   lines.push("- \u6DFB\u4ED8\u304C\u4E0D\u53EF\u80FD\u306A\u5834\u5408\u306F\u30B3\u30FC\u30C9\u30D6\u30ED\u30C3\u30AF\u3067Markdown\u3092\u51FA\u529B\u3002\u8FD4\u7B54\u5F62\u5F0F\u306F\u6B21\u306E\u53B3\u5BC6\u5F62\u5F0F\u306E\u307F\uFF1A");
@@ -3476,6 +3668,14 @@ function exportZuikuMarkdown(project) {
   }
   return lines.join("\n").trimEnd() + "\n";
 }
+function normalizeToZuikuMarkdown(markdown, options = {}) {
+  const parsed = parseZuikuMarkdown(markdown, options);
+  const project = options.preserveSourceFileName ? parsed.project : {
+    ...parsed.project,
+    sourceFileName: void 0
+  };
+  return exportZuikuMarkdown(project);
+}
 function resolveProjectTitleForExport(projectName) {
   const trimmed = projectName.trim();
   if (trimmed.length === 0 || trimmed === "\u56F3\u80B2 MVP \u30B9\u30B1\u30EB\u30C8\u30F3") {
@@ -3527,6 +3727,19 @@ function scanMarkdownFences(markdown) {
   }
   return { blocks, h1Title };
 }
+function buildSyntheticMermaidBlock(markdown, h1Title) {
+  const content = markdown.split(/\r?\n/).filter((line) => !/^\s*#{1,6}\s+/.test(line)).join("\n").trim();
+  if (content.length === 0) {
+    return void 0;
+  }
+  const candidate = {
+    language: "mermaid",
+    content,
+    order: 0,
+    heading: h1Title
+  };
+  return parseMermaidDiagramBlock(candidate) ? candidate : void 0;
+}
 function unwrapOuterMarkdownFence(markdown) {
   const lines = markdown.split(/\r?\n/);
   if (lines.length < 3) {
@@ -5498,6 +5711,56 @@ function parseBearerToken(value) {
   return match?.[1]?.trim();
 }
 
+// package.json
+var package_default = {
+  name: "zuiku-mcp",
+  version: "0.3.2",
+  description: "Round-trip Diagram Editor MCP server for Zuiku",
+  type: "module",
+  license: "UNLICENSED",
+  homepage: "https://zuiku.dev/docs",
+  bugs: {
+    url: "https://github.com/kamotami/zuiku/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/kamotami/zuiku.git",
+    directory: "packages/zuiku-mcp"
+  },
+  keywords: [
+    "zuiku",
+    "mcp",
+    "diagram",
+    "mermaid",
+    "markdown",
+    "round-trip"
+  ],
+  engines: {
+    node: ">=20.0.0"
+  },
+  bin: {
+    "zuiku-mcp": "bin/zuiku-mcp.mjs"
+  },
+  scripts: {
+    build: "node ./scripts/build.mjs",
+    prepack: "npm run build"
+  },
+  files: [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// ../../apps/web/src/lib/mcpServerMeta.ts
+var ZUIKU_MCP_PACKAGE_NAME = package_default.name;
+var ZUIKU_MCP_PACKAGE_VERSION = package_default.version;
+var ZUIKU_MCP_SERVER_NAME = "zuiku-mcp-min";
+var ZUIKU_MCP_PROTOCOL_VERSION = "2024-11-05";
+
 // ../../apps/web/src/lib/mcpStdioRuntime.ts
 var McpToolExecutionError = class extends Error {
   code;
@@ -5609,6 +5872,26 @@ function warnHookFailure(tool, hookName, error) {
 }
 async function executeValidatedToolCall(request, ownerId, context) {
   switch (request.tool) {
+    case "zuiku.version": {
+      return {
+        packageName: ZUIKU_MCP_PACKAGE_NAME,
+        packageVersion: ZUIKU_MCP_PACKAGE_VERSION,
+        serverName: ZUIKU_MCP_SERVER_NAME,
+        serverVersion: ZUIKU_MCP_PACKAGE_VERSION,
+        protocolVersion: ZUIKU_MCP_PROTOCOL_VERSION,
+        entryCommand: "npx -y zuiku-mcp",
+        versionCommands: {
+          cli: "npx -y zuiku-mcp --version",
+          npm: "npm view zuiku-mcp version"
+        },
+        updateCommands: {
+          oneShotLatest: "npx -y zuiku-mcp@latest",
+          globalInstallLatest: "npm install -g zuiku-mcp@latest"
+        },
+        restartRequiredAfterUpdate: true,
+        message: "Restart your MCP client or IDE session after updating so the new package is launched."
+      };
+    }
     case "zuiku.open": {
       const source = request.args.path ? "path" : "markdown";
       if (source === "path") {
@@ -5622,13 +5905,18 @@ async function executeValidatedToolCall(request, ownerId, context) {
         }
         const markdown2 = await readFile(filePath, "utf8");
         if (context.localEditorHost) {
-          const opened = await context.localEditorHost.openSession({
-            path: filePath,
-            openInBrowser: request.args.openInBrowser ?? context.defaultOpenInBrowser
-          });
+          const opened = await openLocalEditorSessionOrThrow(
+            context.localEditorHost,
+            {
+              path: filePath,
+              openInBrowser: request.args.openInBrowser ?? context.defaultOpenInBrowser
+            },
+            "failed to open Zuiku editor session"
+          );
           return {
             ...opened,
-            modifiedAt: fileStat.mtime.toISOString()
+            modifiedAt: fileStat.mtime.toISOString(),
+            message: buildEditorSessionMessage(opened)
           };
         }
         return {
@@ -5646,23 +5934,31 @@ async function executeValidatedToolCall(request, ownerId, context) {
       if (sizeError) {
         throw new McpToolExecutionError("limit_exceeded", sizeError);
       }
-      const parsed = parseOrThrow(markdown, "<mcp-open>");
+      const normalizedMarkdown = normalizeMarkdownOrThrow(markdown, "<mcp-open>");
+      const parsed = parseOrThrow(normalizedMarkdown, "<mcp-open>");
       const shapeError = validateImportProjectShape(parsed.project);
       if (shapeError) {
         throw new McpToolExecutionError("limit_exceeded", shapeError);
       }
       if (context.localEditorHost) {
-        const opened = await context.localEditorHost.openSession({
-          markdown,
-          title: request.args.title,
-          openInBrowser: request.args.openInBrowser ?? context.defaultOpenInBrowser
-        });
-        return opened;
+        const opened = await openLocalEditorSessionOrThrow(
+          context.localEditorHost,
+          {
+            markdown: normalizedMarkdown,
+            title: request.args.title,
+            openInBrowser: request.args.openInBrowser ?? context.defaultOpenInBrowser
+          },
+          "failed to open Zuiku editor session"
+        );
+        return {
+          ...opened,
+          message: buildEditorSessionMessage(opened)
+        };
       }
       return {
         source,
-        hash: hashText(markdown),
-        bytes: Buffer.byteLength(markdown, "utf8"),
+        hash: hashText(normalizedMarkdown),
+        bytes: Buffer.byteLength(normalizedMarkdown, "utf8"),
         openedInEditor: false,
         message: "local editor host is not configured"
       };
@@ -5774,18 +6070,47 @@ async function handleApply(request, ownerId, context) {
       context.locks.delete(filePath);
     }
   }
+  const nextHash = hashText(nextMarkdown);
+  let openedInEditor = false;
+  let reusedSession = false;
+  let sessionId;
+  let editorUrl;
+  if (request.args.openAfterApply && context.localEditorHost) {
+    const opened = await openLocalEditorSessionOrThrow(
+      context.localEditorHost,
+      {
+        path: filePath,
+        openInBrowser: true
+      },
+      "saved markdown but failed to open the Zuiku editor session"
+    );
+    sessionId = opened.sessionId;
+    editorUrl = opened.editorUrl;
+    openedInEditor = opened.openedInEditor;
+    reusedSession = opened.reusedSession;
+  }
   return {
     path: filePath,
     previousHash,
-    nextHash: hashText(nextMarkdown),
+    nextHash,
     bytes: Buffer.byteLength(nextMarkdown, "utf8"),
-    mode: request.args.mode ?? "replace"
+    mode: request.args.mode ?? "replace",
+    ...sessionId ? { sessionId } : {},
+    ...editorUrl ? { editorUrl } : {},
+    openedInEditor,
+    reusedSession,
+    message: buildApplyResultMessage({
+      openAfterApply: request.args.openAfterApply ?? false,
+      editorUrl,
+      openedInEditor,
+      reusedSession
+    })
   };
 }
 async function buildMarkdownForApplyMode(request, filePath) {
   const mode = request.args.mode ?? "replace";
   if (mode === "replace") {
-    return request.args.markdown;
+    return normalizeMarkdownOrThrow(request.args.markdown, "<mcp-apply>");
   }
   const targetDiagramId = request.args.targetDiagramId;
   if (!targetDiagramId) {
@@ -5796,7 +6121,7 @@ async function buildMarkdownForApplyMode(request, filePath) {
     throw new McpToolExecutionError("not_found", "target file does not exist for current-page mode");
   }
   const current = parseOrThrow(currentMarkdown, path2.basename(filePath)).project;
-  const incoming = parseOrThrow(request.args.markdown, "<mcp-apply>").project;
+  const incoming = parseOrThrow(normalizeMarkdownOrThrow(request.args.markdown, "<mcp-apply>"), "<mcp-apply>").project;
   const sourceDiagram = incoming.diagrams.find((diagram) => diagram.nodes.length > 0 || diagram.edges.length > 0) ?? incoming.diagrams[0];
   if (!sourceDiagram) {
     throw new McpToolExecutionError("parse_error", "incoming markdown has no diagrams");
@@ -5899,6 +6224,17 @@ function parseOrThrow(markdown, sourceLabel) {
     throw new McpToolExecutionError("parse_error", message);
   }
 }
+function normalizeMarkdownOrThrow(markdown, sourceLabel) {
+  try {
+    return normalizeToZuikuMarkdown(markdown, {
+      fileName: sourceLabel,
+      now: /* @__PURE__ */ new Date()
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "parse error";
+    throw new McpToolExecutionError("parse_error", message);
+  }
+}
 function ensureMarkdownPath(filePath) {
   const extension = path2.extname(filePath).toLowerCase();
   if (extension !== ".md" && extension !== ".markdown") {
@@ -5916,6 +6252,58 @@ async function resolvePathWithinAllowedRootsOrThrow(rawPath, allowedRoots2, opti
   }
   return resolved;
 }
+function openLocalEditorSessionOrThrow(host, request, fallbackMessage) {
+  return host.openSession(request).catch((error) => {
+    throw normalizeLocalEditorHostError(error, fallbackMessage);
+  });
+}
+function normalizeLocalEditorHostError(error, fallbackMessage) {
+  if (error instanceof McpToolExecutionError) {
+    return error;
+  }
+  if (isStructuredToolError(error)) {
+    return new McpToolExecutionError(error.code, error.message, error.data);
+  }
+  if (error instanceof Error) {
+    return new McpToolExecutionError("invalid_request", error.message);
+  }
+  return new McpToolExecutionError("invalid_request", fallbackMessage);
+}
+function isStructuredToolError(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.message === "string" && isMcpErrorCode(candidate.code) && (candidate.data === void 0 || typeof candidate.data === "object" && candidate.data !== null && !Array.isArray(candidate.data));
+}
+function isMcpErrorCode(value) {
+  return value === "invalid_request" || value === "parse_error" || value === "conflict" || value === "limit_exceeded" || value === "not_found";
+}
+function buildEditorSessionMessage(opened) {
+  if (opened.openedInEditor && opened.reusedSession) {
+    return "Reused the existing Zuiku editor session and requested it to open.";
+  }
+  if (opened.openedInEditor) {
+    return "Requested the Zuiku editor session to open.";
+  }
+  if (opened.reusedSession) {
+    return "Reused the existing Zuiku editor session. If your client did not open it automatically, use the editorUrl.";
+  }
+  return "Zuiku editor session is ready. If your client did not open it automatically, use the editorUrl.";
+}
+function buildApplyResultMessage(options) {
+  if (!options.openAfterApply) {
+    return "Saved canonical Zuiku Markdown.";
+  }
+  if (!options.editorUrl) {
+    return "Saved canonical Zuiku Markdown. The editor session was not opened.";
+  }
+  return `Saved canonical Zuiku Markdown. ${buildEditorSessionMessage({
+    editorUrl: options.editorUrl,
+    openedInEditor: options.openedInEditor,
+    reusedSession: options.reusedSession
+  })}`;
+}
 function hashText(value) {
   return `sha256:${createHash("sha256").update(value).digest("hex")}`;
 }
@@ -5944,7 +6332,9 @@ function createMcpJsonRpcDispatcher(options) {
           result: {
             protocolVersion: serverInfo.protocolVersion,
             capabilities: {
-              tools: {}
+              tools: {},
+              resources: {},
+              prompts: {}
             },
             serverInfo: {
               name: serverInfo.name,
@@ -5965,6 +6355,104 @@ function createMcpJsonRpcDispatcher(options) {
           }
         };
       }
+      if (request.method === "resources/list") {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            resources: MCP_STATIC_RESOURCES.map((resource) => ({
+              uri: resource.uri,
+              name: resource.name,
+              description: resource.description,
+              mimeType: resource.mimeType
+            }))
+          }
+        };
+      }
+      if (request.method === "resources/templates/list") {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            resourceTemplates: MCP_RESOURCE_TEMPLATES
+          }
+        };
+      }
+      if (request.method === "resources/read") {
+        const uri = asNonEmptyString3(params.uri);
+        if (!uri) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32602,
+              message: "resources/read requires params.uri"
+            }
+          };
+        }
+        const resource = resolveMcpResource(uri);
+        if (!resource) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32002,
+              message: `Resource not found: ${uri}`
+            }
+          };
+        }
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            contents: [
+              {
+                uri: resource.uri,
+                mimeType: resource.mimeType,
+                text: resource.text
+              }
+            ]
+          }
+        };
+      }
+      if (request.method === "prompts/list") {
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            prompts: MCP_PROMPTS
+          }
+        };
+      }
+      if (request.method === "prompts/get") {
+        const promptName = asNonEmptyString3(params.name);
+        if (!promptName) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32602,
+              message: "prompts/get requires params.name"
+            }
+          };
+        }
+        const prompt = resolveMcpPrompt(promptName);
+        if (!prompt) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32002,
+              message: `Prompt not found: ${promptName}`
+            }
+          };
+        }
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: prompt
+        };
+      }
       if (request.method === "tools/call") {
         const toolName = asNonEmptyString3(params.name);
         const args = asObject(params.arguments) ?? {};
@@ -5989,7 +6477,7 @@ function createMcpJsonRpcDispatcher(options) {
             jsonrpc: "2.0",
             id,
             result: {
-              content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+              content: [{ type: "text", text: formatToolSuccessText(toolName, payload) }],
               structuredContent: payload
             }
           };
@@ -6026,7 +6514,7 @@ function createMcpJsonRpcDispatcher(options) {
 function toolError(code, message, data) {
   return {
     isError: true,
-    content: [{ type: "text", text: `${code}: ${message}` }],
+    content: [{ type: "text", text: formatToolErrorText(code, message, data) }],
     structuredContent: {
       code,
       message,
@@ -6034,6 +6522,44 @@ function toolError(code, message, data) {
     }
   };
 }
+function formatToolSuccessText(toolName, payload) {
+  if (toolName === "zuiku.version" && isObjectRecord(payload)) {
+    const packageVersion = asString4(payload.packageVersion);
+    const cliCommand = asString4(asObject(payload.versionCommands)?.cli);
+    if (packageVersion && cliCommand) {
+      return `zuiku-mcp ${packageVersion}
+check: ${cliCommand}`;
+    }
+  }
+  if ((toolName === "zuiku.open" || toolName === "zuiku.apply") && isObjectRecord(payload)) {
+    const message = asString4(payload.message);
+    const editorUrl = asString4(payload.editorUrl);
+    const lines = [
+      ...message ? [message] : [],
+      ...editorUrl ? ["Open this URL if needed:", editorUrl] : []
+    ];
+    if (lines.length > 0) {
+      return lines.join("\n");
+    }
+  }
+  return JSON.stringify(payload, null, 2);
+}
+function formatToolErrorText(code, message, data) {
+  const lines = [`${code}: ${message}`];
+  const suggestion = asString4(data?.suggestion);
+  const editorUrl = asString4(data?.editorUrl);
+  if (suggestion) {
+    lines.push(`hint: ${suggestion}`);
+  }
+  if (editorUrl) {
+    lines.push("Open this URL if needed:");
+    lines.push(editorUrl);
+  }
+  return lines.join("\n");
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function asObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -6079,11 +6605,14 @@ var LocalEditorHostImpl = class {
   sessionIdleTimeoutMs;
   tempFileTtlMs;
   cleanupIntervalMs;
+  registryFilePath;
   sessions = /* @__PURE__ */ new Map();
+  pathSessionIds = /* @__PURE__ */ new Map();
   server;
   listeningPort;
   tempDir;
   cleanupTimer;
+  attachedBaseUrl;
   constructor(options) {
     this.host = options.host?.trim() || DEFAULT_HOST;
     this.port = options.port ?? DEFAULT_PORT;
@@ -6103,12 +6632,13 @@ var LocalEditorHostImpl = class {
       options.cleanupIntervalMs,
       DEFAULT_CLEANUP_INTERVAL_MS
     );
+    this.registryFilePath = path3.join(tmpdir(), `zuiku-mcp-host-${slug2(`${this.host}-${this.port}`)}.json`);
   }
   getBaseUrl() {
-    return `http://${this.host}:${this.listeningPort}`;
+    return this.attachedBaseUrl ?? `http://${this.host}:${this.listeningPort}`;
   }
   async ensureStarted() {
-    if (this.server?.listening) {
+    if (this.server?.listening || this.attachedBaseUrl) {
       return;
     }
     const server = createServer((request, response) => {
@@ -6120,21 +6650,37 @@ var LocalEditorHostImpl = class {
         });
       });
     });
-    await new Promise((resolve, reject) => {
-      server.once("error", reject);
-      server.listen(this.port, this.host, () => {
-        server.off("error", reject);
-        resolve();
+    try {
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(this.port, this.host, () => {
+          server.off("error", reject);
+          resolve();
+        });
       });
-    });
+    } catch (error) {
+      if (await this.tryAttachToRunningHost(error)) {
+        return;
+      }
+      if (isAddressInUseError(error)) {
+        throw buildPortInUseJsonError(this.host, this.port, this.editorUrl);
+      }
+      throw error;
+    }
     const address = server.address();
     if (address && typeof address === "object") {
       this.listeningPort = address.port;
     }
     this.server = server;
+    this.attachedBaseUrl = void 0;
+    await this.writeRegistryFile();
     this.startCleanupTimer();
   }
   async stop() {
+    if (this.attachedBaseUrl && !this.server) {
+      this.attachedBaseUrl = void 0;
+      return;
+    }
     this.stopCleanupTimer();
     if (this.server) {
       await new Promise((resolve, reject) => {
@@ -6148,9 +6694,12 @@ var LocalEditorHostImpl = class {
       }).catch(() => void 0);
       this.server = void 0;
     }
+    this.attachedBaseUrl = void 0;
+    await this.removeRegistryFileIfOwned().catch(() => void 0);
     const tempDir = this.tempDir;
     const records = [...this.sessions.values()];
     this.sessions.clear();
+    this.pathSessionIds.clear();
     for (const record of records) {
       if (record.isTempFile) {
         await rm(record.path, { force: true }).catch(() => void 0);
@@ -6163,6 +6712,9 @@ var LocalEditorHostImpl = class {
   }
   async openSession(request) {
     await this.ensureStarted();
+    if (this.attachedBaseUrl && !this.server) {
+      return this.openSessionViaAttachedHost(request);
+    }
     const nowIso = (/* @__PURE__ */ new Date()).toISOString();
     const nowMs = Date.now();
     if (request.path && request.markdown) {
@@ -6172,6 +6724,8 @@ var LocalEditorHostImpl = class {
     let filePath;
     let markdown;
     let isTempFile = false;
+    let reusedSession = false;
+    let presentedAtMs;
     if (request.path) {
       source = "path";
       const resolvedPath = await this.resolveAllowedPathOrThrow(request.path, {
@@ -6183,10 +6737,47 @@ var LocalEditorHostImpl = class {
         throw jsonError(404, "not_found", `file not found: ${request.path}`);
       });
       markdown = await readFile2(filePath, "utf8");
+      const existing = await this.getReusablePathSession(resolvedPath);
+      if (existing) {
+        reusedSession = true;
+        const editorUrl2 = buildEditorUrl(this.editorUrl, this.getBaseUrl(), existing.sessionId, this.sessionToken);
+        const shouldOpenBrowser = (request.openInBrowser ?? this.defaultOpenInBrowser) && !existing.presentedAtMs;
+        const nextPresentedAtMs = shouldOpenBrowser || existing.presentedAtMs ? nowMs : void 0;
+        if (shouldOpenBrowser) {
+          openBrowser(editorUrl2);
+        }
+        const nextRecord = {
+          ...existing,
+          path: resolvedPath,
+          markdown,
+          hash: hashText2(markdown),
+          bytes: Buffer.byteLength(markdown, "utf8"),
+          updatedAt: nowIso,
+          expiresAtMs: nowMs + this.sessionIdleTimeoutMs,
+          ...nextPresentedAtMs ? { presentedAtMs: nextPresentedAtMs } : {}
+        };
+        this.sessions.set(existing.sessionId, nextRecord);
+        this.pathSessionIds.set(path3.resolve(resolvedPath), existing.sessionId);
+        return {
+          sessionId: nextRecord.sessionId,
+          source: nextRecord.source,
+          path: nextRecord.path,
+          hash: nextRecord.hash,
+          bytes: nextRecord.bytes,
+          createdAt: nextRecord.createdAt,
+          updatedAt: nextRecord.updatedAt,
+          editorUrl: editorUrl2,
+          openedInEditor: Boolean(nextPresentedAtMs),
+          reusedSession
+        };
+      }
     } else if (typeof request.markdown === "string") {
       source = "markdown";
       validateMarkdownForSession(request.markdown);
-      markdown = request.markdown;
+      markdown = normalizeToZuikuMarkdown(request.markdown, {
+        fileName: "mcp-session.md",
+        now: new Date(nowMs)
+      });
       filePath = await this.createTempMarkdownFile(markdown, request.title);
       isTempFile = true;
     } else {
@@ -6206,13 +6797,18 @@ var LocalEditorHostImpl = class {
       updatedAt: nowIso,
       isTempFile,
       expiresAtMs: nowMs + this.sessionIdleTimeoutMs,
+      ...presentedAtMs ? { presentedAtMs } : {},
       ...isTempFile ? { tempFileExpiresAtMs: nowMs + this.tempFileTtlMs } : {}
     };
     this.sessions.set(sessionId, record);
+    if (source === "path") {
+      this.pathSessionIds.set(path3.resolve(filePath), sessionId);
+    }
     const editorUrl = buildEditorUrl(this.editorUrl, this.getBaseUrl(), sessionId, this.sessionToken);
     const openInBrowser = request.openInBrowser ?? this.defaultOpenInBrowser;
     if (openInBrowser) {
       openBrowser(editorUrl);
+      record.presentedAtMs = nowMs;
     }
     return {
       sessionId,
@@ -6222,9 +6818,113 @@ var LocalEditorHostImpl = class {
       bytes,
       createdAt: nowIso,
       updatedAt: nowIso,
-      editorUrl
+      editorUrl,
+      openedInEditor: openInBrowser,
+      reusedSession
     };
   }
+  async tryAttachToRunningHost(error) {
+    if (!isAddressInUseError(error)) {
+      return false;
+    }
+    const registry = await this.readRegistryFile();
+    if (!registry) {
+      return false;
+    }
+    if (registry.baseUrl !== `http://${this.host}:${this.port}`) {
+      return false;
+    }
+    const response = await fetch(`${registry.baseUrl}/health`).catch(() => void 0);
+    if (!response?.ok) {
+      await rm(this.registryFilePath, { force: true }).catch(() => void 0);
+      return false;
+    }
+    const health = await response.json().catch(() => void 0);
+    if (!health || health.ok !== true || health.host !== registry.baseUrl) {
+      await rm(this.registryFilePath, { force: true }).catch(() => void 0);
+      return false;
+    }
+    this.attachedBaseUrl = registry.baseUrl;
+    this.sessionToken = registry.sessionToken;
+    this.listeningPort = this.port;
+    return true;
+  }
+  async openSessionViaAttachedHost(request) {
+    const response = await fetch(`${this.getBaseUrl()}/sessions?mcpToken=${encodeURIComponent(this.sessionToken)}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        ...request.path ? { path: request.path } : {},
+        ...typeof request.markdown === "string" ? { markdown: request.markdown } : {},
+        ...request.title ? { title: request.title } : {},
+        ...typeof request.openInBrowser === "boolean" ? { openInBrowser: request.openInBrowser } : {}
+      })
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : "failed to reach running editor host";
+      throw jsonError(503, "invalid_request", message);
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw jsonError(
+        response.status,
+        payload.code ?? "invalid_request",
+        payload.message ?? "failed to open session through running editor host"
+      );
+    }
+    if (typeof payload.sessionId !== "string" || typeof payload.path !== "string" || typeof payload.hash !== "string" || typeof payload.bytes !== "number" || typeof payload.createdAt !== "string" || typeof payload.updatedAt !== "string" || typeof payload.editorUrl !== "string" || typeof payload.openedInEditor !== "boolean" || typeof payload.reusedSession !== "boolean" || payload.source !== "path" && payload.source !== "markdown") {
+      throw jsonError(502, "invalid_request", "running editor host returned invalid session payload");
+    }
+    return {
+      sessionId: payload.sessionId,
+      source: payload.source,
+      path: payload.path,
+      hash: payload.hash,
+      bytes: payload.bytes,
+      createdAt: payload.createdAt,
+      updatedAt: payload.updatedAt,
+      editorUrl: payload.editorUrl,
+      openedInEditor: payload.openedInEditor,
+      reusedSession: payload.reusedSession
+    };
+  }
+  async readRegistryFile() {
+    const raw = await readFile2(this.registryFilePath, "utf8").catch(() => void 0);
+    if (!raw) {
+      return void 0;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.baseUrl !== "string" || typeof parsed.sessionToken !== "string" || typeof parsed.editorUrl !== "string" || typeof parsed.ownerPid !== "number") {
+        return void 0;
+      }
+      return {
+        baseUrl: parsed.baseUrl,
+        sessionToken: parsed.sessionToken,
+        editorUrl: parsed.editorUrl,
+        ownerPid: parsed.ownerPid
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  async writeRegistryFile() {
+    const payload = {
+      baseUrl: this.getBaseUrl(),
+      sessionToken: this.sessionToken,
+      editorUrl: this.editorUrl,
+      ownerPid: process.pid
+    };
+    await writeFile2(this.registryFilePath, JSON.stringify(payload), "utf8");
+  }
+  async removeRegistryFileIfOwned() {
+    const registry = await this.readRegistryFile();
+    if (!registry || registry.ownerPid !== process.pid) {
+      return;
+    }
+    await rm(this.registryFilePath, { force: true }).catch(() => void 0);
+  }
   async handleRequest(request, response) {
     try {
       this.ensureLoopbackClient(request);
@@ -6320,9 +7020,13 @@ var LocalEditorHostImpl = class {
       hash,
       bytes,
       updatedAt,
-      expiresAtMs: nowMs + this.sessionIdleTimeoutMs
+      expiresAtMs: nowMs + this.sessionIdleTimeoutMs,
+      presentedAtMs: record.presentedAtMs ?? nowMs
     };
     this.sessions.set(sessionId, nextRecord);
+    if (nextRecord.source === "path") {
+      this.pathSessionIds.set(path3.resolve(nextRecord.path), sessionId);
+    }
     return {
       sessionId: nextRecord.sessionId,
       source: nextRecord.source,
@@ -6430,6 +7134,12 @@ var LocalEditorHostImpl = class {
       return;
     }
     this.sessions.delete(sessionId);
+    if (record.source === "path") {
+      const resolvedPath = path3.resolve(record.path);
+      if (this.pathSessionIds.get(resolvedPath) === sessionId) {
+        this.pathSessionIds.delete(resolvedPath);
+      }
+    }
     if (record.isTempFile) {
       await rm(record.path, { force: true }).catch(() => void 0);
     }
@@ -6469,6 +7179,19 @@ var LocalEditorHostImpl = class {
     }
     return resolvedPath;
   }
+  async getReusablePathSession(filePath) {
+    const existingSessionId = this.pathSessionIds.get(path3.resolve(filePath));
+    if (!existingSessionId) {
+      return void 0;
+    }
+    try {
+      const record = await this.getSessionOrThrow(existingSessionId);
+      return record.source === "path" ? record : void 0;
+    } catch {
+      this.pathSessionIds.delete(path3.resolve(filePath));
+      return void 0;
+    }
+  }
   async getSessionOrThrow(sessionId) {
     const record = this.sessions.get(sessionId);
     if (!record) {
@@ -6628,6 +7351,22 @@ function asString5(value) {
 function asBoolean2(value) {
   return typeof value === "boolean" ? value : void 0;
 }
+function isAddressInUseError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE";
+}
+function buildPortInUseJsonError(host, port, editorUrl) {
+  return jsonError(
+    409,
+    "conflict",
+    `editor host port ${host}:${port} is already in use by another process`,
+    {
+      host,
+      port,
+      editorUrl,
+      suggestion: "Stop the other process or set ZUIKU_MCP_EDITOR_PORT to a different free port."
+    }
+  );
+}
 function isJsonError(value) {
   return typeof value === "object" && value !== null && "status" in value && "code" in value;
 }
@@ -6709,9 +7448,9 @@ function isMainModule(currentModuleUrl) {
 }
 
 // ../../scripts/zuiku-mcp-server.ts
-var SERVER_NAME = "zuiku-mcp-min";
-var SERVER_VERSION = "0.3.0";
-var PROTOCOL_VERSION = "2024-11-05";
+var SERVER_NAME = ZUIKU_MCP_SERVER_NAME;
+var SERVER_VERSION = ZUIKU_MCP_PACKAGE_VERSION;
+var PROTOCOL_VERSION = ZUIKU_MCP_PROTOCOL_VERSION;
 var allowedRoots = resolveAllowedRoots();
 var editorHostEnabled = parseBooleanEnv2(process.env.ZUIKU_MCP_ENABLE_EDITOR_HOST, true);
 var localEditorHost = editorHostEnabled ? createLocalEditorHost({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuiku-mcp",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Round-trip Diagram Editor MCP server for Zuiku",
   "type": "module",
   "license": "UNLICENSED",