@hiai-gg/docsmint 0.9.4 → 1.0.1

package/dist/mcp-cli.js

@@ -1,26 +1,11 @@
 #!/usr/bin/env bun
 // @bun
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
 
 // ../mcp-server/src/index.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 
 // ../mcp-server/src/server.ts
 import { McpServer } from "@modelcontextprotocol/server";
-import { z as z15 } from "zod";
 
 // dist/client.js
 var docsApiErrorBrand = Symbol.for("io.github.hiai-gg.docsmint.DocsApiError");
@@ -590,8 +575,8 @@ var RESOURCE_PERMISSIONS = new Set([
   "edit",
   "write"
 ]);
-// ../mcp-server/src/lifecycle.ts
-import { z as z2 } from "zod";
+// ../mcp-server/src/compact.ts
+import { z as z3 } from "zod";
 
 // ../mcp-server/src/output-schemas.ts
 import { z } from "zod";
@@ -768,7 +753,7 @@ var deleteAcknowledgmentSchema = z.looseObject({
   id: z.string().uuid(),
   deleted: z.literal(true)
 });
-var toolOutputSchemas = {
+var operationOutputSchemas = {
   search_documents: z.looseObject({
     items: z.array(searchResultSchema),
     total: z.number(),
@@ -820,314 +805,78 @@ var toolOutputSchemas = {
   restore_trashed_document: z.looseObject({ success: z.literal(true) }),
   permanently_delete_document: deleteAcknowledgmentSchema
 };
+var variant = (operation, result) => z.object({ operation: z.literal(operation), result });
+var toolOutputSchemas = {
+  delete_document: operationOutputSchemas.delete_document,
+  delete_folder: operationOutputSchemas.delete_folder,
+  delete_category: operationOutputSchemas.delete_category,
+  delete_tag: operationOutputSchemas.delete_tag,
+  create_snapshot: operationOutputSchemas.create_snapshot,
+  restore_document_version: operationOutputSchemas.restore_document_version,
+  get_document_index_status: operationOutputSchemas.get_document_index_status,
+  refresh_document_index: operationOutputSchemas.refresh_document_index,
+  list_trash: operationOutputSchemas.list_trash,
+  restore_trashed_document: operationOutputSchemas.restore_trashed_document,
+  permanently_delete_document: operationOutputSchemas.permanently_delete_document,
+  find_documents: z.union([
+    variant("list", operationOutputSchemas.list_documents),
+    variant("search", operationOutputSchemas.search_documents)
+  ]),
+  read_document: z.union([
+    variant("detail", operationOutputSchemas.get_document),
+    variant("markdown", operationOutputSchemas.export_document),
+    variant("versions", operationOutputSchemas.get_version_history)
+  ]),
+  save_document: z.union([
+    variant("create", operationOutputSchemas.create_document),
+    variant("update", operationOutputSchemas.update_document)
+  ]),
+  list_workspace_structure: z.union([
+    variant("folders", operationOutputSchemas.list_folders),
+    variant("categories", operationOutputSchemas.list_categories),
+    variant("tags", operationOutputSchemas.list_tags)
+  ]),
+  save_folder: z.union([
+    variant("create", operationOutputSchemas.create_folder),
+    variant("update", operationOutputSchemas.update_folder)
+  ]),
+  save_category: z.union([
+    variant("create", operationOutputSchemas.create_category),
+    variant("update", operationOutputSchemas.update_category)
+  ]),
+  save_tag: z.union([
+    variant("create", operationOutputSchemas.create_tag),
+    variant("update", operationOutputSchemas.update_tag)
+  ]),
+  set_document_tag: z.union([
+    variant("add", operationOutputSchemas.add_tag_to_document),
+    variant("remove", operationOutputSchemas.remove_tag_from_document)
+  ]),
+  explore_graph: z.union([
+    variant("neighbors", operationOutputSchemas.get_related_documents),
+    variant("search", operationOutputSchemas.search_knowledge_graph)
+  ]),
+  batch_documents: z.looseObject({
+    action: z.enum(["move", "set_category", "add_tag", "remove_tag", "trash", "restore", "refresh_index"]),
+    total: z.number().int().min(1).max(25),
+    succeeded: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    aborted: z.boolean(),
+    results: z.array(z.union([
+      z.looseObject({ id: z.string().uuid(), status: z.literal("ok") }),
+      z.looseObject({ id: z.string().uuid(), status: z.literal("error"), error: z.looseObject({ status: z.number().int(), code: z.string(), message: z.string() }) }),
+      z.looseObject({ id: z.string().uuid(), status: z.literal("skipped") })
+    ]))
+  }),
+  get_workspace_item: z.union([
+    variant("folder", folderSchema),
+    variant("category", categoryListItemSchema),
+    variant("tag", tagSchema)
+  ])
+};
 
-// ../mcp-server/src/lifecycle.ts
-function unsupported(name) {
-  throw new Error(`The injected legacy MCP client does not support ${name}; use a public DocsClient.`);
-}
-var annotations = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
-function registerLifecycleCapabilities(server, client, wrap) {
-  const deletions = [
-    {
-      name: "delete_document",
-      description: "Move an existing document to trash; this is a soft delete and does not permanently purge its content or version history. Requires write access in the active workspace/category. Returns {id, deleted:true}. Use only when the user intends to delete it.",
-      action: (id) => client.deleteDocument ? client.deleteDocument(id) : unsupported("delete_document"),
-      idDescription: "UUID of the document to move to trash; obtain it from search_documents, list_documents, or get_document."
-    },
-    {
-      name: "delete_folder",
-      description: "Delete a folder while preserving its documents. Direct child folders and documents are detached according to the server folder rules, and reindexing is queued for affected documents. Requires write access in the active workspace/category. Returns {id, deleted:true}.",
-      action: (id) => client.deleteFolder ? client.deleteFolder(id) : unsupported("delete_folder"),
-      idDescription: "UUID of the folder to delete; obtain it from list_folders. This detaches, but does not delete, the documents inside it."
-    },
-    {
-      name: "delete_category",
-      description: "Delete a category and detach its folders and documents without deleting their content. Requires full workspace write access; category-scoped credentials cannot delete any category, including their configured one. Returns {id, deleted:true}.",
-      action: (id) => client.deleteCategory ? client.deleteCategory(id) : unsupported("delete_category"),
-      idDescription: "UUID of the category to delete; obtain it from list_categories using a workspace-scoped credential."
-    }
-  ];
-  for (const tool of deletions) {
-    server.registerTool(tool.name, {
-      description: tool.description,
-      annotations,
-      inputSchema: z2.object({ id: z2.string().uuid().describe(tool.idDescription) }),
-      outputSchema: toolOutputSchemas[tool.name]
-    }, wrap(tool.name, async ({ id }) => {
-      await tool.action(id);
-      return { id, deleted: true };
-    }));
-  }
-  server.registerTool("restore_document_version", {
-    description: "Restore content for an existing document from a version or named snapshot returned by get_version_history. Requires edit access. The server saves current content in history, records the restoration, and queues indexing. Returns the updated document; it does not recover a trashed document or change folder/category placement.",
-    annotations,
-    inputSchema: z2.object({
-      documentId: z2.string().uuid().describe("UUID of the document whose content should be restored; it must be visible in the active workspace or category."),
-      versionId: z2.string().uuid().describe("UUID of a version belonging to this document, from get_version_history. Use the version ID, not a snapshot label.")
-    }),
-    outputSchema: toolOutputSchemas.restore_document_version
-  }, wrap("restore_document_version", async ({ documentId, versionId }) => client.restoreDocumentVersion ? client.restoreDocumentVersion(documentId, versionId) : unsupported("restore_document_version")));
-}
-
-// ../mcp-server/src/management.ts
-import { z as z3 } from "zod";
-var uuid = z3.string().uuid().describe("UUID of the target object, obtained from the corresponding list tool.");
-var write = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
-var update = { ...write, destructiveHint: true };
-var read = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var purge = { ...write, destructiveHint: true };
-function unsupported2(name) {
-  throw new Error(`The injected legacy MCP client does not support ${name}; use a public DocsClient.`);
-}
-function registerManagementCapabilities(server, client, wrap) {
-  server.registerTool("create_tag", {
-    description: "Create a tag in the active workspace. Requires full workspace write access; category-scoped credentials cannot manage tags. Use add_tag_to_document to assign it.",
-    annotations: write,
-    inputSchema: z3.object({ name: z3.string().min(1).max(100).describe("New tag name, up to 100 characters."), color: z3.string().max(20).optional().describe("Optional display color for the new tag, up to 20 characters.") }),
-    outputSchema: toolOutputSchemas.create_tag
-  }, wrap("create_tag", async (input) => client.createTag ? client.createTag(input) : unsupported2("create_tag")));
-  server.registerTool("update_tag", {
-    description: "Rename or recolor an existing tag. Requires full workspace write access; category-scoped credentials cannot manage tags. Affected documents are reindexed by the API.",
-    annotations: update,
-    inputSchema: z3.object({ id: uuid, name: z3.string().min(1).max(100).optional().describe("Replacement tag name; omit to keep the current name."), color: z3.string().max(20).optional().describe("Replacement display color; omit to keep the current color.") }).refine((value) => value.name !== undefined || value.color !== undefined),
-    outputSchema: toolOutputSchemas.update_tag
-  }, wrap("update_tag", async ({ id, ...input }) => client.updateTag ? client.updateTag(id, input) : unsupported2("update_tag")));
-  server.registerTool("delete_tag", {
-    description: "Delete a tag in the active workspace and remove its document assignments. Requires full workspace write access; category-scoped credentials cannot manage tags.",
-    annotations: purge,
-    inputSchema: z3.object({ id: uuid }),
-    outputSchema: toolOutputSchemas.delete_tag
-  }, wrap("delete_tag", async ({ id }) => {
-    if (!client.deleteTag)
-      return unsupported2("delete_tag");
-    await client.deleteTag(id);
-    return { id, deleted: true };
-  }));
-  server.registerTool("add_tag_to_document", {
-    description: "Assign a tag from list_tags to an existing document. Requires edit access to the document and permission to use the tag.",
-    annotations: write,
-    inputSchema: z3.object({ documentId: uuid.describe("UUID of the document to tag."), tagId: uuid.describe("UUID of the tag returned by list_tags.") }),
-    outputSchema: toolOutputSchemas.add_tag_to_document
-  }, wrap("add_tag_to_document", async ({ documentId, tagId }) => {
-    if (!client.addTagToDocument)
-      return unsupported2("add_tag_to_document");
-    await client.addTagToDocument(documentId, tagId);
-    return { documentId, tagId, assigned: true };
-  }));
-  server.registerTool("remove_tag_from_document", {
-    description: "Remove a tag assignment from a document. Requires edit access; the tag itself is preserved.",
-    annotations: update,
-    inputSchema: z3.object({ documentId: uuid.describe("UUID of the document whose tag assignment changes."), tagId: uuid.describe("UUID of the assigned tag to remove.") }),
-    outputSchema: toolOutputSchemas.remove_tag_from_document
-  }, wrap("remove_tag_from_document", async ({ documentId, tagId }) => {
-    if (!client.removeTagFromDocument)
-      return unsupported2("remove_tag_from_document");
-    await client.removeTagFromDocument(documentId, tagId);
-    return { documentId, tagId, removed: true };
-  }));
-  server.registerTool("update_folder", {
-    description: "Rename or move a folder; changes to category or parent follow API scope rules and trigger reindexing. Requires write access.",
-    annotations: update,
-    inputSchema: z3.object({ id: uuid, name: z3.string().min(1).max(255).optional().describe("Replacement folder name; omit to preserve the name."), parentId: uuid.nullable().optional().describe("New parent folder UUID, or null for a root folder."), categoryId: uuid.nullable().optional().describe("New category UUID, or null to clear the category."), order: z3.number().int().nonnegative().optional().describe("New non-negative order within the containing folder.") }).refine((value) => value.name !== undefined || value.parentId !== undefined || value.categoryId !== undefined || value.order !== undefined),
-    outputSchema: toolOutputSchemas.update_folder
-  }, wrap("update_folder", async ({ id, ...input }) => client.updateFolder ? client.updateFolder(id, input) : unsupported2("update_folder")));
-  server.registerTool("update_category", {
-    description: "Rename or reorder a category. Requires full workspace write access; category-scoped credentials cannot modify categories.",
-    annotations: update,
-    inputSchema: z3.object({ id: uuid, name: z3.string().min(1).max(255).optional().describe("New category name, up to 255 characters."), order: z3.number().int().nonnegative().optional().describe("New non-negative category order.") }).refine((value) => value.name !== undefined || value.order !== undefined),
-    outputSchema: toolOutputSchemas.update_category
-  }, wrap("update_category", async ({ id, ...input }) => client.updateCategory ? client.updateCategory(id, input) : unsupported2("update_category")));
-  server.registerTool("list_trash", {
-    description: "List soft-deleted documents visible to the active workspace/category. Requires read access.",
-    annotations: read,
-    inputSchema: z3.object({}),
-    outputSchema: toolOutputSchemas.list_trash
-  }, wrap("list_trash", async () => client.listTrash ? client.listTrash() : unsupported2("list_trash")));
-  server.registerTool("restore_trashed_document", {
-    description: "Restore a soft-deleted document from list_trash. Requires write access. This is different from restoring a content version.",
-    annotations: write,
-    inputSchema: z3.object({ id: uuid }),
-    outputSchema: toolOutputSchemas.restore_trashed_document
-  }, wrap("restore_trashed_document", async ({ id }) => client.restoreTrashedDocument ? client.restoreTrashedDocument(id) : unsupported2("restore_trashed_document")));
-  server.registerTool("permanently_delete_document", {
-    description: "Irreversibly purge a document already in trash, including its content and version history. Requires write access. Use only on explicit user request after checking list_trash.",
-    annotations: purge,
-    inputSchema: z3.object({ id: uuid }),
-    outputSchema: toolOutputSchemas.permanently_delete_document
-  }, wrap("permanently_delete_document", async ({ id }) => {
-    if (!client.permanentlyDeleteDocument)
-      return unsupported2("permanently_delete_document");
-    await client.permanentlyDeleteDocument(id);
-    return { id, deleted: true };
-  }));
-}
-
-// ../mcp-server/src/capabilities.ts
-import { z as z4 } from "zod";
-function registerExtendedCapabilities(server, client, wrapHandler) {
-  server.registerTool("list_categories", {
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
-    description: "List categories visible in the active workspace or category scope. Requires read access; a category-scoped credential sees only its configured category. Use this before create_document or create_folder when you need an existing category ID.",
-    inputSchema: z4.object({}),
-    outputSchema: toolOutputSchemas.list_categories
-  }, wrapHandler("list_categories", async () => client.listCategories()));
-  server.registerTool("create_category", {
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    },
-    description: "Create a new category for the active workspace. Requires workspace-level write access; category-scoped credentials cannot create categories. Returns the created category. Use list_categories to inspect existing categories.",
-    inputSchema: z4.object({
-      name: z4.string().trim().min(1).max(255).describe("Non-empty display name, up to 255 characters, for example Project notes.")
-    }),
-    outputSchema: toolOutputSchemas.create_category
-  }, wrapHandler("create_category", async (input) => client.createCategory(input)));
-  server.registerTool("list_tags", {
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
-    description: "List tags visible in the active workspace or configured category scope. Requires read access; use returned tag IDs to filter list_documents and returned tag names to filter search_documents.",
-    inputSchema: z4.object({}),
-    outputSchema: toolOutputSchemas.list_tags
-  }, wrapHandler("list_tags", async () => client.listTags()));
-  server.registerTool("get_related_documents", {
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
-    description: "Traverse graph relations from one readable document without a text query. Requires read access and returns related document IDs plus relation metadata. Use search_knowledge_graph to rank graph neighbors with query text, or search_documents for normal hybrid retrieval. Results stay in the active scope and may be empty when graph data is unavailable.",
-    inputSchema: z4.object({
-      documentId: z4.string().min(1).describe("Document ID returned by search_documents or list_documents; it must be readable in the active scope."),
-      limit: z4.number().int().min(1).max(100).optional().describe("Maximum related documents to return, from 1 to 100. Omit to use the server default.")
-    }),
-    outputSchema: toolOutputSchemas.get_related_documents
-  }, wrapHandler("get_related_documents", async ({ documentId, limit }) => client.getRelatedDocuments(documentId, limit)));
-  server.registerTool("search_knowledge_graph", {
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
-    description: "Search graph relations from one or more readable seed documents, optionally using query text to filter and rank related documents. Requires read access and returns seed entities plus relatedDocs. Use search_documents first to obtain authorized seed IDs; use get_related_documents for one-seed neighbors without graph search. Results stay in the active scope and graph data may be empty when unavailable.",
-    inputSchema: z4.object({
-      query: z4.string().max(2000).optional().describe("Optional search text up to 2,000 characters to filter and rank graph-related documents; omit it to inspect relations without query filtering."),
-      docIds: z4.array(z4.string().min(1)).min(1).max(50).describe("Between 1 and 50 document IDs returned by search_documents or list_documents; each seed must be readable in the active scope."),
-      limit: z4.number().int().min(1).max(100).optional().describe("Maximum related documents to return, from 1 to 100. Omit to use the server default.")
-    }),
-    outputSchema: toolOutputSchemas.search_knowledge_graph
-  }, wrapHandler("search_knowledge_graph", async (input) => client.searchGraph(input)));
-  server.registerTool("get_document_index_status", {
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
-    description: "Read indexing and knowledge-pipeline status for an existing document without starting work. Requires read access. Use after a save or refresh_document_index to check progress or failures.",
-    inputSchema: z4.object({
-      documentId: z4.string().uuid().describe("UUID of a document returned by search_documents or list_documents; it must be readable in the active scope.")
-    }),
-    outputSchema: toolOutputSchemas.get_document_index_status
-  }, wrapHandler("get_document_index_status", async ({ documentId }) => client.getDocumentIndexStatus(documentId)));
-  server.registerTool("refresh_document_index", {
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    },
-    description: "Queue an explicit reindex for an existing document; processing is asynchronous and the response acknowledges the generation. Requires write access. Normal content and placement changes schedule indexing when needed, so use get_document_index_status first and refresh only when a retry is intended.",
-    inputSchema: z4.object({
-      documentId: z4.string().uuid().describe("UUID of the document to refresh, obtained from search_documents or list_documents and visible in the active scope.")
-    }),
-    outputSchema: toolOutputSchemas.refresh_document_index
-  }, wrapHandler("refresh_document_index", async ({ documentId }) => client.refreshDocumentIndex(documentId)));
-  server.registerPrompt("organize_workspace", {
-    description: "Plan safe document organization using DocsMint categories and folders.",
-    argsSchema: z4.object({
-      objective: z4.string(),
-      language: z4.string().optional()
-    })
-  }, ({ objective, language }) => ({
-    messages: [
-      {
-        role: "user",
-        content: {
-          type: "text",
-          text: `Organize this DocsMint workspace for: ${objective}. Work in ${language ?? "the document language"}. Inspect categories, folders, tags, and documents before proposing or applying changes. Preserve document content and obey the API key scope.`
-        }
-      }
-    ]
-  }));
-  server.registerPrompt("research_workspace", {
-    description: "Research a question with hybrid search and GraphRAG while citing DocsMint document IDs.",
-    argsSchema: z4.object({
-      question: z4.string(),
-      language: z4.string().optional()
-    })
-  }, ({ question, language }) => ({
-    messages: [
-      {
-        role: "user",
-        content: {
-          type: "text",
-          text: `Answer this question from DocsMint: ${question}. Respond in ${language ?? "the question language"}. Start with hybrid search, use graph traversal only from authorized result documents, and cite document IDs. Distinguish retrieved facts from inference.`
-        }
-      }
-    ]
-  }));
-  server.registerResource("editor-guide", "docsmint://guide/editor", {}, async (uri) => ({
-    contents: [
-      {
-        uri: uri.href,
-        mimeType: "text/markdown",
-        text: `# DocsMint editing rules
-
-Read a document before updating it. Preserve its language, title intent, TipTap/Markdown structure, category, folder, and tags unless the user explicitly requests a change. After content changes, verify index status and request refresh only when needed.`
-      }
-    ]
-  }));
-  server.registerResource("search-guide", "docsmint://guide/search", {}, async (uri) => ({
-    contents: [
-      {
-        uri: uri.href,
-        mimeType: "text/markdown",
-        text: `# DocsMint retrieval rules
-
-Use search_documents for normal retrieval. Use get_related_documents or search_knowledge_graph only with document IDs already authorized by the active API key. Keep multilingual queries in their original language and cite document IDs in answers.`
-      }
-    ]
-  }));
-  server.registerResource("workspace-catalog", "docsmint://workspace/catalog", {}, async (uri) => {
-    const [categories, folders, tags] = await Promise.all([
-      client.listCategories(),
-      client.listFolders({}),
-      client.listTags()
-    ]);
-    return {
-      contents: [
-        {
-          uri: uri.href,
-          mimeType: "application/json",
-          text: JSON.stringify({ categories, folders, tags }, null, 2)
-        }
-      ]
-    };
-  });
-}
+// ../mcp-server/src/batch-workspace.ts
+import { z as z2 } from "zod";
 
 // ../mcp-server/src/client.ts
 var DEFAULT_BASE_URL = "http://localhost:50700";
@@ -1167,6 +916,7 @@ function sanitizeMcpRequestContext(context) {
 function createMcpDocsClient(docsClient, requestContext) {
   const context = sanitizeMcpRequestContext(requestContext);
   return {
+    getFolder: (id) => docsClient.getFolder(id, context),
     createTag: (input) => docsClient.createTag(input, context),
     updateTag: (id, input) => docsClient.updateTag(id, input, context),
     deleteTag: (id) => docsClient.deleteTag(id, context),
@@ -1220,236 +970,298 @@ var client = new Proxy({}, {
   }
 });
 
-// ../mcp-server/src/tools/create-document.ts
-var exports_create_document = {};
-__export(exports_create_document, {
-  createHandler: () => createHandler,
-  definition: () => definition,
-  handler: () => handler
-});
-import { z as z5 } from "zod";
-var definition = {
-  name: "create_document",
-  description: "Create a new DocsMint document when no existing document should be modified. Optionally set a title, initial Markdown content, and folder or category placement; an omitted title defaults to \u201CUntitled\u201D. Requires write access in the target scope. A category-scoped credential must create inside its configured category, by selecting that category or a folder within it. Normal creation schedules indexing asynchronously and returns the created document. Use update_document for an existing document.",
-  inputSchema: {
-    title: z5.string().min(1).max(500).optional().describe("Optional title from 1 to 500 characters; omit to use the API default \u201CUntitled\u201D."),
-    content: z5.string().optional().describe("Optional initial Markdown content; omit to create an empty document."),
-    folderId: z5.string().uuid().optional().describe("Optional folder UUID from list_folders; the folder must be writable in the active workspace or category."),
-    categoryId: z5.string().uuid().nullable().optional().describe("Optional category UUID from list_categories; omit or pass null to leave the explicit category unset. A categorized folder still supplies the document\u2019s effective category; without one the document remains uncategorized. Category-scoped credentials stay bound to their configured category.")
-  }
-};
-var createHandler = (api) => async function createDocument(args) {
-  return await api.createDocument(args);
-};
-var handler = createHandler(client);
-
-// ../mcp-server/src/tools/create-folder.ts
-var exports_create_folder = {};
-__export(exports_create_folder, {
-  createHandler: () => createHandler2,
-  definition: () => definition2,
-  handler: () => handler2
-});
-import { z as z6 } from "zod";
-var definition2 = {
-  name: "create_folder",
-  description: "Create a new folder in the active workspace or category scope. Requires write access and returns the created folder. A nested folder inherits its parent category; for a root folder, pass categoryId when using a category-scoped credential. Category-scoped credentials cannot create outside their configured category.",
-  inputSchema: {
-    name: z6.string().min(1).max(255).describe("Non-empty folder name up to 255 characters."),
-    parentId: z6.string().uuid().nullable().optional().describe("Optional parent folder UUID from list_folders; omit or pass null to create a root-level folder."),
-    categoryId: z6.string().uuid().nullable().optional().describe("Optional category UUID from list_categories for a root-level folder. A nested folder inherits its parent category; category-scoped credentials cannot escape their configured category.")
-  }
-};
-var createHandler2 = (api) => async function createFolder(args) {
-  return await api.createFolder(args);
-};
-var handler2 = createHandler2(client);
-
-// ../mcp-server/src/tools/create-snapshot.ts
-var exports_create_snapshot = {};
-__export(exports_create_snapshot, {
-  createHandler: () => createHandler3,
-  definition: () => definition3,
-  handler: () => handler3
-});
-import { z as z7 } from "zod";
-var definition3 = {
-  name: "create_snapshot",
-  description: "Save a named, retained snapshot of an existing document\u2019s current content before a planned change. Requires edit access and adds an entry to get_version_history without changing the document itself. Use restore_document_version with the returned version ID to restore its content later.",
-  inputSchema: {
-    documentId: z7.string().uuid().describe("UUID of the existing document, obtained from search_documents or list_documents and visible in the active scope."),
-    label: z7.string().min(1).max(200).describe("Non-empty snapshot label up to 200 characters, for example 'v1.0-release'."),
-    description: z7.string().max(1000).optional().describe("Optional snapshot note up to 1,000 characters; omit if not needed.")
-  }
-};
-var createHandler3 = (api) => async function createSnapshot(args) {
-  const { documentId, ...input } = args;
-  return await api.createSnapshot(documentId, input);
-};
-var handler3 = createHandler3(client);
-
-// ../mcp-server/src/tools/export-document.ts
-var exports_export_document = {};
-__export(exports_export_document, {
-  createHandler: () => createHandler4,
-  definition: () => definition4,
-  handler: () => handler4
-});
-import { z as z8 } from "zod";
-var definition4 = {
-  name: "export_document",
-  description: "Render one readable document as portable Markdown and return a markdown string in the response object. Does not modify the document or include its complete metadata; use get_document to inspect the editable document.",
-  inputSchema: {
-    id: z8.string().uuid().describe("UUID of the readable document to export, obtained from search_documents or list_documents.")
-  }
-};
-var createHandler4 = (api) => async function exportDocument(args) {
-  return await api.exportDocument(args.id);
-};
-var handler4 = createHandler4(client);
+// ../mcp-server/src/batch-workspace.ts
+var uuid = z2.string().uuid().describe("UUID of an item visible to the active API key.");
+var documentIds = z2.array(uuid).min(1).max(25).refine((ids) => new Set(ids).size === ids.length, "Document IDs must be unique.").describe("One to 25 distinct document UUIDs, explicitly selected by the user; no search expansion.");
+var base = { documentIds };
+var batchInput = z2.discriminatedUnion("action", [
+  z2.strictObject({ ...base, action: z2.literal("move").describe("Move each document to the same folder."), folderId: uuid.nullable().describe("Destination folder UUID, or null for no folder.") }),
+  z2.strictObject({ ...base, action: z2.literal("set_category").describe("Set one explicit category on every document."), categoryId: uuid.nullable().describe("Category UUID, or null to clear explicit category.") }),
+  z2.strictObject({ ...base, action: z2.literal("add_tag").describe("Assign one existing tag to every document."), tagId: uuid.describe("Existing tag UUID to assign to each document.") }),
+  z2.strictObject({ ...base, action: z2.literal("remove_tag").describe("Remove one tag assignment from every document."), tagId: uuid.describe("Existing tag UUID to unassign from each document.") }),
+  z2.strictObject({ ...base, action: z2.literal("trash").describe("Move every document to trash without permanent deletion.") }),
+  z2.strictObject({ ...base, action: z2.literal("restore").describe("Restore every selected document from trash.") }),
+  z2.strictObject({ ...base, action: z2.literal("refresh_index").describe("Request explicit indexing retry for every document.") })
+]);
+function required(method, name) {
+  if (!method)
+    throw new Error(`The injected legacy MCP client does not support ${name}; use a public DocsClient.`);
+  return method;
+}
+function registerBatchAndWorkspaceCapabilities(server, client2, wrap) {
+  async function batch(input) {
+    const results = [];
+    let aborted = false;
+    for (const id of input.documentIds) {
+      if (aborted) {
+        results.push({ id, status: "skipped" });
+        continue;
+      }
+      try {
+        switch (input.action) {
+          case "move":
+            await client2.updateDocument(id, { folderId: input.folderId });
+            break;
+          case "set_category":
+            await client2.updateDocument(id, { categoryId: input.categoryId });
+            break;
+          case "add_tag":
+            await required(client2.addTagToDocument, "add_tag")(id, input.tagId);
+            break;
+          case "remove_tag":
+            await required(client2.removeTagFromDocument, "remove_tag")(id, input.tagId);
+            break;
+          case "trash":
+            await required(client2.deleteDocument, "trash")(id);
+            break;
+          case "restore":
+            await required(client2.restoreTrashedDocument, "restore")(id);
+            break;
+          case "refresh_index":
+            await client2.refreshDocumentIndex(id);
+            break;
+        }
+        results.push({ id, status: "ok" });
+      } catch (error) {
+        const known = isDocsApiError(error) || error instanceof HiaiDocsError;
+        const status = known ? error.status : 500;
+        const code = known ? error.code : "INTERNAL_ERROR";
+        results.push({ id, status: "error", error: { status, code, message: known ? error.message : "Document operation failed" } });
+        if (status === 401 || status === 429)
+          aborted = true;
+      }
+    }
+    const succeeded = results.filter((result) => result.status === "ok").length;
+    return { action: input.action, total: input.documentIds.length, succeeded, failed: results.filter((result) => result.status === "error").length, aborted, results };
+  }
+  server.registerTool("batch_documents", {
+    description: "Apply one action to 1\u201325 explicitly selected document IDs. Supports move, set_category, add_tag, remove_tag, trash, restore, or refresh_index. Processes sequentially through the existing API so each document keeps its own workspace and category permission check. Returns per-ID success or error; partial success is possible. Stops after authentication or rate-limit failure. Permanent purge and version restore are intentionally separate tools.",
+    inputSchema: batchInput,
+    outputSchema: toolOutputSchemas.batch_documents,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }
+  }, wrap("batch_documents", batch, toolOutputSchemas.batch_documents));
+  server.registerTool("get_workspace_item", {
+    description: "Read one visible folder, category, or tag by UUID. Folder uses its direct API getter; category and tag lookup uses the complete permission-filtered lists. An absent or out-of-scope ID is reported as not found. Use list_workspace_structure to discover IDs first.",
+    inputSchema: z2.strictObject({ kind: z2.enum(["folder", "category", "tag"]).describe("The workspace resource type to read by ID."), id: uuid }),
+    outputSchema: toolOutputSchemas.get_workspace_item,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  }, wrap("get_workspace_item", async ({ kind, id }) => {
+    if (kind === "folder")
+      return { operation: kind, result: await required(client2.getFolder, "get_workspace_item(folder)")(id) };
+    const listed = kind === "category" ? await client2.listCategories() : await client2.listTags();
+    const result = Array.isArray(listed) ? listed.find((item) => item.id === id) : undefined;
+    if (!result)
+      throw new HiaiDocsError(`${kind} not found`, 404, null, "NOT_FOUND");
+    return { operation: kind, result };
+  }, toolOutputSchemas.get_workspace_item));
+}
 
-// ../mcp-server/src/tools/get-document.ts
-var exports_get_document = {};
-__export(exports_get_document, {
-  createHandler: () => createHandler5,
-  definition: () => definition5,
-  handler: () => handler5
-});
-import { z as z9 } from "zod";
-var definition5 = {
-  name: "get_document",
-  description: "Read an existing document by UUID with its content, metadata, and tags before editing or citing it. Requires read access in the active workspace/category. Use export_document when you only need the portable Markdown body.",
-  inputSchema: {
-    id: z9.string().uuid().describe("UUID of the document, obtained from search_documents or list_documents, and visible in the active scope.")
-  }
-};
-var createHandler5 = (api) => async function getDocument(args) {
-  return await api.getDocument(args.id);
-};
-var handler5 = createHandler5(client);
+// ../mcp-server/src/compact.ts
+var uuid2 = z3.string().uuid().describe("UUID returned by the corresponding list or read operation.");
+var text = z3.string().min(1).describe("Non-empty human-readable name or title.");
+var title = z3.string().min(1).max(500).describe("Document title, from 1 to 500 characters.");
+var content = z3.string().describe("Markdown document content; an empty string clears the content on update.");
+var read = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var write = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var destructive = { ...write, destructiveHint: true };
+function required2(value, name) {
+  if (!value)
+    throw new Error(`The injected legacy MCP client does not support ${name}; use a public DocsClient.`);
+  return value;
+}
+function registerCompactCapabilities(server, client2, wrap) {
+  function register(name, description, inputSchema, annotations, handler) {
+    server.registerTool(name, { description, inputSchema, outputSchema: toolOutputSchemas[name], annotations }, wrap(name, handler, toolOutputSchemas[name]));
+  }
+  register("find_documents", "Find readable documents in the active scope. Use mode=list for paginated browsing by folder or tag UUID; use mode=search for hybrid text and semantic retrieval with tag names.", z3.discriminatedUnion("mode", [
+    z3.strictObject({ mode: z3.literal("list").describe("Select the list operation explicitly."), folderId: uuid2.optional(), tag: uuid2.optional(), page: z3.number().int().min(1).optional().describe("One-based page number; defaults to the API first page."), limit: z3.number().int().min(1).max(1000).optional().describe("Maximum documents per page, up to 1000.") }),
+    z3.strictObject({ mode: z3.literal("search").describe("Select the search operation explicitly."), query: text.describe("Text to search in the original language."), folder: z3.string().optional().describe("Optional folder UUID filter for search."), tags: z3.array(z3.string()).optional().describe("Optional tag names; all supplied names must match."), limit: z3.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") })
+  ]), read, async (input) => input.mode === "list" ? { operation: "list", result: await client2.listDocuments(input) } : { operation: "search", result: await client2.search(input) });
+  register("read_document", "Read one document by UUID. Choose detail for content and metadata, markdown for portable export, or versions for saved revisions and snapshots. All views are read-only.", z3.discriminatedUnion("view", [
+    z3.strictObject({ view: z3.literal("detail").describe("Select the detail operation explicitly."), id: uuid2 }),
+    z3.strictObject({ view: z3.literal("markdown").describe("Select the markdown operation explicitly."), id: uuid2 }),
+    z3.strictObject({ view: z3.literal("versions").describe("Select the versions operation explicitly."), id: uuid2, onlySnapshots: z3.boolean().optional().describe("When true, return only named snapshots.") })
+  ]), read, async (input) => {
+    if (input.view === "detail")
+      return { operation: "detail", result: await client2.getDocument(input.id) };
+    if (input.view === "markdown")
+      return { operation: "markdown", result: await client2.exportDocument(input.id) };
+    return { operation: "versions", result: await client2.getVersionHistory(input.id, input.onlySnapshots) };
+  });
+  register("save_document", "Create a new document or update an existing document. action=create requires write access; action=update requires edit access for content, and placement changes may require write access. Content or placement changes queue normal indexing.", z3.discriminatedUnion("action", [
+    z3.strictObject({ action: z3.literal("create").describe("Select the create operation explicitly."), title: title.optional(), content: content.optional(), folderId: uuid2.optional(), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }),
+    z3.strictObject({ action: z3.literal("update").describe("Select the update operation explicitly."), id: uuid2, title: title.optional(), content: content.optional(), folderId: uuid2.nullable().optional().describe("Optional folder UUID; null clears the placement on update."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }).refine((value) => value.title !== undefined || value.content !== undefined || value.folderId !== undefined || value.categoryId !== undefined)
+  ]), destructive, async (input) => {
+    if (input.action === "create") {
+      const { action: _action2, ...data2 } = input;
+      return { operation: "create", result: await client2.createDocument(data2) };
+    }
+    const { action: _action, id, ...data } = input;
+    return { operation: "update", result: await client2.updateDocument(id, data) };
+  });
+  register("delete_document", "Move a writable document to trash without purging content or versions. Use only on an explicit delete request; permanently_delete_document is a separate irreversible action.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+    await required2(client2.deleteDocument, "delete_document")(id);
+    return { id, deleted: true };
+  });
+  register("list_workspace_structure", "List visible folders, categories, or tags in the active workspace or category scope. Set kind=folders to inspect root folders or children of parentId.", z3.discriminatedUnion("kind", [
+    z3.strictObject({ kind: z3.literal("folders").describe("Select the folders operation explicitly."), parentId: uuid2.optional() }),
+    z3.strictObject({ kind: z3.literal("categories").describe("Select the categories operation explicitly.") }),
+    z3.strictObject({ kind: z3.literal("tags").describe("Select the tags operation explicitly.") })
+  ]), read, async (input) => {
+    if (input.kind === "folders")
+      return { operation: "folders", result: await client2.listFolders({ parentId: input.parentId }) };
+    if (input.kind === "categories")
+      return { operation: "categories", result: await client2.listCategories() };
+    return { operation: "tags", result: await client2.listTags() };
+  });
+  register("save_folder", "Create or update a folder. action=update can rename or move an existing folder; the API enforces category boundaries and queues affected documents for reindexing.", z3.discriminatedUnion("action", [
+    z3.strictObject({ action: z3.literal("create").describe("Select the create operation explicitly."), name: text.max(255), parentId: uuid2.nullable().optional().describe("Optional parent folder UUID; null selects the root."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category.") }),
+    z3.strictObject({ action: z3.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(255).optional(), parentId: uuid2.nullable().optional().describe("Optional parent folder UUID; null selects the root."), categoryId: uuid2.nullable().optional().describe("Optional category UUID; null clears the explicit category."), order: z3.number().int().nonnegative().optional().describe("New non-negative display order.") }).refine((value) => value.name !== undefined || value.parentId !== undefined || value.categoryId !== undefined || value.order !== undefined)
+  ]), destructive, async (input) => {
+    if (input.action === "create") {
+      const { action: _action2, ...data2 } = input;
+      return { operation: "create", result: await client2.createFolder(data2) };
+    }
+    const { action: _action, id, ...data } = input;
+    return { operation: "update", result: await required2(client2.updateFolder, "update_folder")(id, data) };
+  });
+  register("delete_folder", "Delete a folder while preserving its documents; child folders and documents are detached under the API rules. Requires write access.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+    await required2(client2.deleteFolder, "delete_folder")(id);
+    return { id, deleted: true };
+  });
+  register("save_category", "Create or update a workspace category. Full workspace write access is required; category-scoped credentials cannot manage categories.", z3.discriminatedUnion("action", [
+    z3.strictObject({ action: z3.literal("create").describe("Select the create operation explicitly."), name: text.max(255) }),
+    z3.strictObject({ action: z3.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(255).optional(), order: z3.number().int().nonnegative().optional().describe("New non-negative display order.") }).refine((value) => value.name !== undefined || value.order !== undefined)
+  ]), destructive, async (input) => {
+    if (input.action === "create")
+      return { operation: "create", result: await client2.createCategory({ name: input.name }) };
+    const { action: _action, id, ...data } = input;
+    return { operation: "update", result: await required2(client2.updateCategory, "update_category")(id, data) };
+  });
+  register("delete_category", "Delete a workspace category and detach its documents without deleting them. Requires full workspace write access; category-scoped credentials are denied.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+    await required2(client2.deleteCategory, "delete_category")(id);
+    return { id, deleted: true };
+  });
+  register("save_tag", "Create or update a workspace tag. Full workspace write access is required; renaming or recoloring a tag causes affected documents to be reindexed.", z3.discriminatedUnion("action", [
+    z3.strictObject({ action: z3.literal("create").describe("Select the create operation explicitly."), name: text.max(100), color: z3.string().max(20).optional().describe("Optional tag color, at most 20 characters.") }),
+    z3.strictObject({ action: z3.literal("update").describe("Select the update operation explicitly."), id: uuid2, name: text.max(100).optional(), color: z3.string().max(20).optional().describe("Optional tag color, at most 20 characters.") }).refine((value) => value.name !== undefined || value.color !== undefined)
+  ]), destructive, async (input) => {
+    if (input.action === "create")
+      return { operation: "create", result: await required2(client2.createTag, "create_tag")({ name: input.name, color: input.color }) };
+    const { action: _action, id, ...data } = input;
+    return { operation: "update", result: await required2(client2.updateTag, "update_tag")(id, data) };
+  });
+  register("delete_tag", "Delete a workspace tag and remove its document assignments. Full workspace write access is required; documents themselves remain.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+    await required2(client2.deleteTag, "delete_tag")(id);
+    return { id, deleted: true };
+  });
+  register("set_document_tag", "Add or remove one existing tag assignment on a readable document. Requires edit access to that document; action=remove preserves the tag itself.", z3.strictObject({ action: z3.enum(["add", "remove"]).describe("Add or remove exactly one tag assignment."), documentId: uuid2, tagId: uuid2 }), destructive, async ({ action, documentId, tagId }) => {
+    if (action === "add") {
+      await required2(client2.addTagToDocument, "add_tag_to_document")(documentId, tagId);
+      return { operation: "add", result: { documentId, tagId, assigned: true } };
+    }
+    await required2(client2.removeTagFromDocument, "remove_tag_from_document")(documentId, tagId);
+    return { operation: "remove", result: { documentId, tagId, removed: true } };
+  });
+  register("create_snapshot", "Save a named snapshot of an existing document before a planned change. The snapshot can later be restored with restore_document_version.", z3.strictObject({ documentId: uuid2, label: text.max(200).describe("Snapshot label, from 1 to 200 characters."), description: z3.string().max(1000).optional().describe("Optional snapshot note, at most 1000 characters.") }), write, async ({ documentId, label, description }) => client2.createSnapshot(documentId, { label, description }));
+  register("restore_document_version", "Restore content from a version or snapshot listed by read_document(view=versions). This changes current content and queues indexing; it does not restore a trashed document.", z3.strictObject({ documentId: uuid2, versionId: uuid2 }), destructive, async ({ documentId, versionId }) => required2(client2.restoreDocumentVersion, "restore_document_version")(documentId, versionId));
+  register("explore_graph", "Explore graph relations from readable seed documents. mode=neighbors traverses one document without a query; mode=search ranks relations from one or more seed IDs with optional query text.", z3.discriminatedUnion("mode", [
+    z3.strictObject({ mode: z3.literal("neighbors").describe("Select the neighbors operation explicitly."), documentId: uuid2, limit: z3.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") }),
+    z3.strictObject({ mode: z3.literal("search").describe("Select the search operation explicitly."), docIds: z3.array(uuid2).min(1).max(50).describe("One to 50 authorized seed document UUIDs."), query: z3.string().max(2000).optional().describe("Optional graph relevance query, at most 2000 characters."), limit: z3.number().int().min(1).max(100).optional().describe("Maximum results to return, up to 100.") })
+  ]), read, async (input) => input.mode === "neighbors" ? { operation: "neighbors", result: await client2.getRelatedDocuments(input.documentId, input.limit) } : { operation: "search", result: await client2.searchGraph(input) });
+  register("get_document_index_status", "Read current indexing and pipeline status for one document without starting work. Use refresh_document_index only when an explicit retry is intended.", z3.strictObject({ documentId: uuid2 }), read, async ({ documentId }) => client2.getDocumentIndexStatus(documentId));
+  register("refresh_document_index", "Queue an explicit asynchronous reindex for one document. Routine content and placement changes already schedule indexing; check get_document_index_status first.", z3.strictObject({ documentId: uuid2 }), write, async ({ documentId }) => client2.refreshDocumentIndex(documentId));
+  register("list_trash", "List soft-deleted documents visible to the active workspace or category scope. Requires read access and does not restore or purge anything.", z3.strictObject({}), read, async () => required2(client2.listTrash, "list_trash")());
+  register("restore_trashed_document", "Return one soft-deleted document to the active library. This restores the document itself, unlike restore_document_version which changes content.", z3.strictObject({ id: uuid2 }), write, async ({ id }) => required2(client2.restoreTrashedDocument, "restore_trashed_document")(id));
+  register("permanently_delete_document", "Irreversibly purge a document already in trash, including its version history. Use only on an explicit user request after checking list_trash.", z3.strictObject({ id: uuid2 }), destructive, async ({ id }) => {
+    await required2(client2.permanentlyDeleteDocument, "permanently_delete_document")(id);
+    return { id, deleted: true };
+  });
+  registerBatchAndWorkspaceCapabilities(server, client2, wrap);
+}
 
-// ../mcp-server/src/tools/list-documents.ts
-var exports_list_documents = {};
-__export(exports_list_documents, {
-  createHandler: () => createHandler6,
-  definition: () => definition6,
-  handler: () => handler6
-});
-import { z as z10 } from "zod";
-var definition6 = {
-  name: "list_documents",
-  description: "List readable documents in the active workspace or category with page-based results. Optionally filter by folder or tag; page defaults to 1 and limit to 20 (maximum 1,000). Use search_documents for text or semantic retrieval.",
-  inputSchema: {
-    folderId: z10.string().uuid().optional().describe("Optional folder UUID from list_folders to limit the listing."),
-    tag: z10.string().uuid().optional().describe("Optional tag UUID from list_tags to filter the documents."),
-    page: z10.number().int().min(1).optional().describe("1-indexed result page; defaults to 1."),
-    limit: z10.number().int().min(1).max(1000).optional().describe("Number of documents per page, from 1 to 1,000; defaults to 20.")
-  }
-};
-var createHandler6 = (api) => async function listDocuments(args) {
-  return await api.listDocuments(args);
-};
-var handler6 = createHandler6(client);
+// ../mcp-server/src/prompts-resources.ts
+import { z as z4 } from "zod";
+function registerPromptsAndResources(server, client2) {
+  server.registerPrompt("organize_workspace", {
+    description: "Plan safe document organization using DocsMint categories and folders.",
+    argsSchema: z4.object({
+      objective: z4.string(),
+      language: z4.string().optional()
+    })
+  }, ({ objective, language }) => ({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `Organize this DocsMint workspace for: ${objective}. Work in ${language ?? "the document language"}. Inspect categories, folders, tags, and documents before proposing or applying changes. Preserve document content and obey the API key scope.`
+        }
+      }
+    ]
+  }));
+  server.registerPrompt("research_workspace", {
+    description: "Research a question with hybrid search and GraphRAG while citing DocsMint document IDs.",
+    argsSchema: z4.object({
+      question: z4.string(),
+      language: z4.string().optional()
+    })
+  }, ({ question, language }) => ({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `Answer this question from DocsMint: ${question}. Respond in ${language ?? "the question language"}. Start with hybrid search, use graph traversal only from authorized result documents, and cite document IDs. Distinguish retrieved facts from inference.`
+        }
+      }
+    ]
+  }));
+  server.registerResource("editor-guide", "docsmint://guide/editor", {}, async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "text/markdown",
+        text: `# DocsMint editing rules
 
-// ../mcp-server/src/tools/list-folders.ts
-var exports_list_folders = {};
-__export(exports_list_folders, {
-  createHandler: () => createHandler7,
-  definition: () => definition7,
-  handler: () => handler7
-});
-import { z as z11 } from "zod";
-var definition7 = {
-  name: "list_folders",
-  description: "List folders readable in the active workspace/category. Omit parentId to list root folders, or supply a parent UUID to list its immediate children as a flat list. Use create_folder to add a folder.",
-  inputSchema: {
-    parentId: z11.string().uuid().optional().describe("Optional parent folder UUID from list_folders; omit to list root folders.")
-  }
-};
-var createHandler7 = (api) => async function listFolders(args) {
-  return await api.listFolders(args);
-};
-var handler7 = createHandler7(client);
+Read a document before updating it. Preserve its language, title intent, TipTap/Markdown structure, category, folder, and tags unless the user explicitly requests a change. After content changes, verify index status and request refresh only when needed.`
+      }
+    ]
+  }));
+  server.registerResource("search-guide", "docsmint://guide/search", {}, async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "text/markdown",
+        text: `# DocsMint retrieval rules
 
-// ../mcp-server/src/tools/search.ts
-var exports_search = {};
-__export(exports_search, {
-  createHandler: () => createHandler8,
-  definition: () => definition8,
-  handler: () => handler8
-});
-import { z as z12 } from "zod";
-var definition8 = {
-  name: "search_documents",
-  description: "Search readable DocsMint documents with hybrid full-text and semantic retrieval, optionally filtered by folder and tag names. Requires read access and stays within the active workspace/category. Use search_knowledge_graph for graph relations from seed documents or get_related_documents for neighbors without a text query.",
-  inputSchema: {
-    query: z12.string().describe("Text to search for; preserve the language and terms relevant to the user request."),
-    folder: z12.string().optional().describe("Optional folder UUID from list_folders to scope retrieval."),
-    tags: z12.array(z12.string()).optional().describe("Optional tag names as shown by list_tags; documents match when they have any supplied tag name."),
-    limit: z12.number().int().positive().max(100).optional().describe("Maximum result count, from 1 to 100; defaults to 20.")
-  }
-};
-var createHandler8 = (api) => async function searchDocuments(args) {
-  return await api.search({
-    query: args.query,
-    folder: args.folder,
-    tags: args.tags,
-    limit: args.limit
+Use find_documents(mode=search) for normal retrieval. Use explore_graph only with document IDs already authorized by the active API key. Keep multilingual queries in their original language and cite document IDs in answers.`
+      }
+    ]
+  }));
+  server.registerResource("workspace-catalog", "docsmint://workspace/catalog", {}, async (uri) => {
+    const [categories, folders, tags] = await Promise.all([
+      client2.listCategories(),
+      client2.listFolders({}),
+      client2.listTags()
+    ]);
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify({ categories, folders, tags }, null, 2)
+        }
+      ]
+    };
   });
-};
-var handler8 = createHandler8(client);
-
-// ../mcp-server/src/tools/update-document.ts
-var exports_update_document = {};
-__export(exports_update_document, {
-  createHandler: () => createHandler9,
-  definition: () => definition9,
-  handler: () => handler9
-});
-import { z as z13 } from "zod";
-var definition9 = {
-  name: "update_document",
-  description: "Modify an existing document by UUID after reading its current state. Omitted fields remain unchanged; null folderId removes folder placement and null categoryId clears the explicit category, while a categorized folder can still supply the effective category. Changing title or Markdown content requires edit access, while moving placement requires write access in the active workspace/category. The server stores the prior content in version history and queues indexing when content or placement changes. Returns the updated document. Use create_document for new content.",
-  inputSchema: {
-    id: z13.string().uuid().describe("UUID of the existing document, obtained from search_documents, list_documents, or get_document."),
-    title: z13.string().min(1).max(500).optional().describe("Optional replacement title, 1 to 500 characters; omit to leave the current title unchanged."),
-    content: z13.string().optional().describe("New markdown content for the document."),
-    folderId: z13.string().uuid().nullable().optional().describe("Optional destination folder UUID from list_folders; omit to keep current placement or pass null to remove folder placement."),
-    categoryId: z13.string().uuid().nullable().optional().describe("Optional destination category UUID from list_categories; omit to keep the explicit category or pass null to clear it. A categorized folder may still supply the effective category. Category-scoped credentials cannot move outside their configured category.")
-  }
-};
-var createHandler9 = (api) => async function updateDocument(args) {
-  const { id, ...patch } = args;
-  return await api.updateDocument(id, patch);
-};
-var handler9 = createHandler9(client);
-
-// ../mcp-server/src/tools/version-history.ts
-var exports_version_history = {};
-__export(exports_version_history, {
-  createHandler: () => createHandler10,
-  definition: () => definition10,
-  handler: () => handler10
-});
-import { z as z14 } from "zod";
-var definition10 = {
-  name: "get_version_history",
-  description: "Read versions for an existing document, including saved snapshots. Requires read access and returns version IDs with content and timestamps; pass a version ID to restore_document_version when the user asks to restore content. This is read-only and does not change the document.",
-  inputSchema: {
-    documentId: z14.string().uuid().describe("UUID of the readable document whose version history you need; obtain it from search_documents or list_documents."),
-    onlySnapshots: z14.boolean().optional().describe("When true, return only named snapshots and omit auto-saved revisions; omit or use false for the full history.")
-  }
-};
-var createHandler10 = (api) => async function getVersionHistory(args) {
-  return await api.getVersionHistory(args.documentId, args.onlySnapshots);
-};
-var handler10 = createHandler10(client);
+}
 
 // ../mcp-server/src/server.ts
-function wrapHandler(name, handler11, outputSchema) {
+function wrapHandler(name, handler, outputSchema) {
   return async (args) => {
     try {
-      const output = await handler11(args);
+      const output = await handler(args);
       const parsedOutput = outputSchema ? await outputSchema.safeParseAsync(output) : undefined;
       if (parsedOutput && !parsedOutput.success) {
         throw new Error(`Tool '${name}' returned a result outside its published output schema`);
@@ -1484,50 +1296,11 @@ function wrapHandler(name, handler11, outputSchema) {
   };
 }
 function registerDocsmintMcpCapabilities(server, client2) {
-  const register = (name, description, inputSchema, handler11) => {
-    server.registerTool(name, {
-      description,
-      inputSchema: z15.object(inputSchema),
-      annotations: {
-        readOnlyHint: ![
-          "create_document",
-          "update_document",
-          "create_folder",
-          "create_snapshot"
-        ].includes(name),
-        destructiveHint: name === "update_document",
-        idempotentHint: ![
-          "create_document",
-          "update_document",
-          "create_folder",
-          "create_snapshot"
-        ].includes(name),
-        openWorldHint: false
-      },
-      outputSchema: toolOutputSchemas[name]
-    }, wrapHandler(name, handler11, toolOutputSchemas[name]));
-  };
-  const tools = [
-    exports_search,
-    exports_get_document,
-    exports_create_document,
-    exports_update_document,
-    exports_list_documents,
-    exports_list_folders,
-    exports_create_folder,
-    exports_create_snapshot,
-    exports_version_history,
-    exports_export_document
-  ];
-  for (const tool of tools) {
-    register(tool.definition.name, tool.definition.description, tool.definition.inputSchema, tool.createHandler(client2));
-  }
-  registerExtendedCapabilities(server, client2, (name, handler11) => wrapHandler(name, handler11, toolOutputSchemas[name]));
-  registerLifecycleCapabilities(server, client2, (name, handler11) => wrapHandler(name, handler11, toolOutputSchemas[name]));
-  registerManagementCapabilities(server, client2, (name, handler11) => wrapHandler(name, handler11, toolOutputSchemas[name]));
+  registerCompactCapabilities(server, client2, wrapHandler);
+  registerPromptsAndResources(server, client2);
 }
 function createDocsmintMcpServer(options = {}) {
-  const server = new McpServer({ name: "docsmint", version: "0.9.4" });
+  const server = new McpServer({ name: "docsmint", version: "1.0.1" });
   const client2 = options.docsClient ? createMcpDocsClient(options.docsClient, options.requestContext) : options.client ?? createMcpDocsClient(createDefaultDocsClient(), options.requestContext);
   registerDocsmintMcpCapabilities(server, client2);
   return server;