@naumu/mcp 0.13.0 → 0.14.1

package/README.md

@@ -162,6 +162,7 @@ Both transports expose the same tool surface. Tools marked **bot** are only regi
 | `naumu_note_delete_section` | Delete a heading and its body (destructive) |
 | `naumu_note_replace` | Replace an entire note's content (destructive) |
 | `naumu_note_find_replace` | Literal find and replace within a note |
+| `naumu_note_batch` | Apply several note edits in ONE write (one transaction, one update event) |
 
 ### Attachments
 

package/dist/index.js

@@ -15,7 +15,7 @@ var NaumuApiError = class extends Error {
   status;
   upstreamMessage;
 };
-function safeErrorMessage(status, upstream) {
+function safeErrorMessage(status, upstream, retryAfter) {
   if (status === 400 || status === 422) return upstream;
   if (status === 401) return "Unauthorized \u2014 check your API key.";
   if (status === 403 || status === 404) {
@@ -24,13 +24,24 @@ function safeErrorMessage(status, upstream) {
   if (status === 409) return "Conflict with current state.";
   if (status === 410) return "Resource is no longer available.";
   if (status === 413) return "Payload too large.";
-  if (status === 429) return "Rate limit exceeded \u2014 slow down and retry.";
+  if (status === 429) return `Rate limited - wait ${parseRetryAfterSeconds(retryAfter)}s and retry`;
   if (status >= 500) return "Server error \u2014 try again shortly.";
   return `Request failed with status ${status}.`;
 }
+var DEFAULT_RETRY_AFTER_SECONDS = 5;
+function parseRetryAfterSeconds(retryAfter) {
+  if (!retryAfter) return DEFAULT_RETRY_AFTER_SECONDS;
+  const seconds = Number.parseInt(retryAfter, 10);
+  if (Number.isFinite(seconds) && seconds > 0) return seconds;
+  const dateMs = Date.parse(retryAfter);
+  if (Number.isFinite(dateMs)) {
+    return Math.max(1, Math.ceil((dateMs - Date.now()) / 1e3));
+  }
+  return DEFAULT_RETRY_AFTER_SECONDS;
+}
 
 // ../mcp-core/src/version.ts
-var NAUMU_MCP_VERSION = "0.13.0";
+var NAUMU_MCP_VERSION = "0.14.1";
 
 // ../mcp-core/src/client.ts
 var HEADER_VALUE_MAX_LENGTH = 100;
@@ -38,6 +49,12 @@ var sanitizeHeaderValue = (value) => {
   const cleaned = value.replace(/[^\x20-\x7e]/g, "").trim();
   return cleaned.length > 0 ? cleaned.slice(0, HEADER_VALUE_MAX_LENGTH) : void 0;
 };
+function firstString(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return void 0;
+}
 var NaumuClient = class {
   baseUrl;
   apiKey;
@@ -102,14 +119,18 @@ var NaumuClient = class {
       let upstream;
       try {
         const json = JSON.parse(text);
-        upstream = json.message || text;
+        upstream = firstString(json?.error, json?.message) ?? text;
       } catch {
         upstream = text;
       }
       console.error(
         `[mcp] upstream ${res.status}: ${upstream.slice(0, 500)}`
       );
-      throw new NaumuApiError(res.status, safeErrorMessage(res.status, upstream), upstream);
+      throw new NaumuApiError(
+        res.status,
+        safeErrorMessage(res.status, upstream, res.headers.get("retry-after")),
+        upstream
+      );
     }
     return res.json();
   }
@@ -132,7 +153,7 @@ var NaumuClient = class {
       );
       throw new NaumuApiError(
         res.status,
-        safeErrorMessage(res.status, upstream),
+        safeErrorMessage(res.status, upstream, res.headers.get("retry-after")),
         upstream
       );
     }
@@ -165,7 +186,7 @@ var NaumuClient = class {
     );
     throw new NaumuApiError(
       res.status,
-      safeErrorMessage(res.status, upstream),
+      safeErrorMessage(res.status, upstream, res.headers.get("retry-after")),
       upstream
     );
   }
@@ -1256,7 +1277,7 @@ function registerReadThread(server2, client2) {
     {
       title: "Read Thread",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-      description: 'Read messages from a Naumu thread. Returns paginated history ordered newest-first, or oldest-first when you pass `after`; each message carries a `status` (`processing` while @Naumu is still composing, `complete` when done). Use this to pick up an answer after naumu_ask returns status "processing", or to read what naumu_delegate produced. Use `before` (timestamp ms) to page further back, or `after` (timestamp ms) to catch up on what arrived since you last looked. To wait for the next message instead of re-reading on a timer, use naumu_wait_for_activity. Default page size 50, max 200. To read or download a message attachment, pass its `attachments[].id` to naumu_get_attachment.',
+      description: 'Read messages from a Naumu thread. Returns paginated history ordered newest-first, or oldest-first when you pass `after`; each message carries a `status` (`processing` while @Naumu is still composing, `complete` when done). Use this to pick up an answer after naumu_ask returns status "processing", or to read what naumu_delegate produced. Use `before` (timestamp ms) to page further back, or `after` (timestamp ms) to catch up on what arrived since you last looked. To wait for the next message instead of re-reading on a timer, use naumu_wait_for_activity. Default page size 50, max 200. Agent messages carry `memoryScope.line`, a one-line statement of which Memory scope the answer used; surface it under the answer. To read or download a message attachment, pass its `attachments[].id` to naumu_get_attachment.',
       inputSchema: z22.object({
         threadId: z22.string().describe("The thread ID to read from."),
         before: z22.number().optional().describe("Unix timestamp in milliseconds. Returns messages strictly older than this. Omit for the newest page."),
@@ -2124,8 +2145,43 @@ function registerNoteFindReplace(server2, client2) {
   );
 }
 
-// ../mcp-core/src/tools/create-note.ts
+// ../mcp-core/src/tools/note-batch.ts
 import { z as z43 } from "zod";
+var MAX_BATCH_OPS = 20;
+var opSchema = z43.object({
+  op: z43.enum(["append", "insertAfter", "replaceSection", "deleteSection", "replace", "findReplace"]).describe("Which edit to perform."),
+  markdown: z43.string().optional().describe("Markdown payload. Required for append, insertAfter, replaceSection, replace."),
+  heading: z43.string().optional().describe(
+    'Target heading text. Required for insertAfter, replaceSection, deleteSection. Accepts the markdown form ("## Title") or the bare text.'
+  ),
+  keepHeading: z43.boolean().optional().describe("replaceSection only: keep the heading row and replace just its body (default true)."),
+  find: z43.string().optional().describe("findReplace only: literal substring to search for."),
+  replace: z43.string().optional().describe("findReplace only: replacement string. May be empty to delete the match."),
+  all: z43.boolean().optional().describe("findReplace only: replace every occurrence (default true).")
+}).describe("One edit in the batch.");
+function registerNoteBatch(server2, client2) {
+  server2.registerTool(
+    "naumu_note_batch",
+    {
+      title: "Batch Edit Note",
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      description: "Apply several edits to ONE note in a single write. This is the preferred way to make more than one change to the same note: the whole list runs in one document transaction, so readers see one update event instead of one per edit, and you pay one round trip instead of N. Each entry mirrors a single-op note tool - `append` {markdown}, `insertAfter` {heading, markdown}, `replaceSection` {heading, markdown, keepHeading?}, `deleteSection` {heading}, `replace` {markdown}, `findReplace` {find, replace, all?} - and they run in the order given, each seeing the result of the one before. Max " + MAX_BATCH_OPS + " ops. All-or-nothing: the batch is rehearsed first, so if any op fails (most often a heading that does not exist) the note is left completely untouched and the error names the failing index. Media works as in the single-op tools: write `![alt](attachment://<attachmentId>)` on its own line, with an id presigned by `naumu_request_attachment_upload` for this same `noteId`.",
+      inputSchema: z43.object({
+        noteId: z43.string().describe("The note (Thought) ID to edit"),
+        ops: z43.array(opSchema).min(1).max(MAX_BATCH_OPS).describe(`Edits to apply, in order. Max ${MAX_BATCH_OPS}.`)
+      })
+    },
+    async ({ noteId, ops }) => {
+      const data = await client2.post(`/api/notes/${noteId}/batch`, { ops });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/create-note.ts
+import { z as z44 } from "zod";
 function registerCreateNote(server2, client2) {
   server2.registerTool(
     "naumu_create_note",
@@ -2133,12 +2189,12 @@ function registerCreateNote(server2, client2) {
       title: "Create Note",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Create a note in a graph, optionally with its full content already in place. Pass `markdown` to create the note and its body in a single call - the preferred path for imports and for any content you already hold. Returns the new note row including its `id`; use `naumu_note_append` / `naumu_note_replace` for LATER edits, not to fill in content you could have passed here. The returned row is the note as it stood BEFORE the body write landed, so its content may read as empty - the write still succeeded, do not retry the call or re-append the body. `attachment://` refs are not accepted in create-time `markdown`: upload the file after the note exists and embed it with a note write tool. Bots can only create notes in their own graph, and a bot-created note is private (participants only) unless `sharedWithSpace` is set true. Bots cannot file notes into topics - a bot passing `topicIds` is rejected (bots hold no topic membership); use `sharedWithSpace` instead.",
-      inputSchema: z43.object({
-        graphId: z43.string().describe("The graph ID to create the note in"),
-        title: z43.string().optional().describe("Optional title for the note"),
-        markdown: z43.string().optional().describe("Full initial note content as markdown. Provide it here to create the note with its content in a single call - preferred for imports; do not restate large content through extra edit calls."),
-        sharedWithSpace: z43.boolean().optional().describe("Share the note with everyone in the space. Omit (or false) to keep it private to its participants."),
-        topicIds: z43.array(z43.string()).max(8).optional().describe("File the note into these topics (get ids from naumu_list_topics), making it visible to those topics' members. Not available to bots.")
+      inputSchema: z44.object({
+        graphId: z44.string().describe("The graph ID to create the note in"),
+        title: z44.string().optional().describe("Optional title for the note"),
+        markdown: z44.string().optional().describe("Full initial note content as markdown. Provide it here to create the note with its content in a single call - preferred for imports; do not restate large content through extra edit calls."),
+        sharedWithSpace: z44.boolean().optional().describe("Share the note with everyone in the space. Omit (or false) to keep it private to its participants."),
+        topicIds: z44.array(z44.string()).max(8).optional().describe("File the note into these topics (get ids from naumu_list_topics), making it visible to those topics' members. Not available to bots.")
       })
     },
     async ({ graphId, title, markdown, sharedWithSpace, topicIds }) => {
@@ -2151,7 +2207,7 @@ function registerCreateNote(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-schema-violations.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var DEFAULT_EXAMPLE_LIMIT = 5;
 var rowsForKind = (violations, kind) => {
   const rows = [];
@@ -2177,12 +2233,12 @@ function registerListSchemaViolations(server2, client2) {
       title: "List Schema Violations",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Audit a graph against its schema. By default returns a compact summary: total counts plus, for each violation kind, its count and up to 5 example nodes (id/label/type/message) \u2014 small enough not to flood the client. Violation kinds: parent_missing (schema expects a parent edge that does not exist), parent_multiple (more than one parent edge where one is expected), parent_mismatch (parent edge has wrong target type or relation label), parent_not_backbone (an edge uses a backbone/parent relation but is not stored as a backbone edge, so the subtree stays off the hierarchy), unknown_relation (edge uses a relation not in the schema), invalid_connection_target (edge connects to a type the schema does not allow for this source), unknown_type (node carries a type no longer in the schema), disconnected (node heads a group with no backbone path to the main tree). To see every node for one kind, pass `kind` to filter; `limit` caps how many rows are returned (examples in the default summary, or full rows when `kind` is set). Use for audits, import-verification, and CI-style checks after batch writes.",
-      inputSchema: z44.object({
-        graphId: z44.string().describe("The graph ID"),
-        kind: z44.string().optional().describe(
+      inputSchema: z45.object({
+        graphId: z45.string().describe("The graph ID"),
+        kind: z45.string().optional().describe(
           'Drill into one violation kind (e.g. "parent_not_backbone"). Returns the full list of nodes with that kind, up to `limit`, instead of the summary.'
         ),
-        limit: z44.number().int().min(1).optional().describe(
+        limit: z45.number().int().min(1).optional().describe(
           "Max rows to return. When `kind` is set, caps the full drill-down list (default: all). Otherwise caps example nodes per kind in the summary (default: 5)."
         )
       })
@@ -2234,7 +2290,7 @@ function registerListSchemaViolations(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-dense-nodes.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 function registerListDenseNodes(server2, client2) {
   server2.registerTool(
     "naumu_list_dense_nodes",
@@ -2242,10 +2298,10 @@ function registerListDenseNodes(server2, client2) {
       title: "List Dense Nodes",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Return nodes whose child count (children via parent edges; mesh cross-links don\'t count) is \u2265 minConnections, grouped by type; use for /restructure hub detection. Each row includes `same_typed_child_count` - the number of children of the SAME type as the node (the Naumu hub-pattern signal) and `connection_count` - its total children. Sort the response by `same_typed_child_count` descending and route any node with \u226510 same-typed children through a mini-hub split. Pass `nodeTypes` (comma-separated) to restrict to a subset (e.g. ["Type A","Type B"]). Cheap to call - runs a single Cypher aggregation.',
-      inputSchema: z45.object({
-        graphId: z45.string().describe("The graph ID"),
-        minConnections: z45.number().int().min(1).describe("Minimum number of children (parent edges; mesh cross-links excluded). Typical: 10 for hub detection, 11 to count only hubs that exceed the round-4 \u226410 threshold."),
-        nodeTypes: z45.array(z45.string()).optional().describe("Optional list of node types to restrict the scan to.")
+      inputSchema: z46.object({
+        graphId: z46.string().describe("The graph ID"),
+        minConnections: z46.number().int().min(1).describe("Minimum number of children (parent edges; mesh cross-links excluded). Typical: 10 for hub detection, 11 to count only hubs that exceed the round-4 \u226410 threshold."),
+        nodeTypes: z46.array(z46.string()).optional().describe("Optional list of node types to restrict the scan to.")
       })
     },
     async ({ graphId, minConnections, nodeTypes }) => {
@@ -2263,7 +2319,7 @@ function registerListDenseNodes(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-node-connections.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 function registerListNodeConnections(server2, client2) {
   server2.registerTool(
     "naumu_list_node_connections",
@@ -2271,11 +2327,11 @@ function registerListNodeConnections(server2, client2) {
       title: "List Node Connections",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Return a single node\'s edges (non-system) with the connected node on the other side; use during /restructure to confirm mini-hub candidates and verify reparenting outcomes. Filter with `edgeType` (relation label) and `direction` ("in" | "out" | "both", default both). Response: `{ node: {id,label,type}, edges: [{relation, direction, isParent, other: {id,label,type}}] }`.',
-      inputSchema: z46.object({
-        graphId: z46.string().describe("The graph ID"),
-        nodeId: z46.string().describe("The node ID to inspect"),
-        edgeType: z46.string().optional().describe('Restrict to a specific relation label (e.g. "ASSOCIATED_WITH"). Case-insensitive; non-alphanum chars are normalized.'),
-        direction: z46.enum(["in", "out", "both"]).optional().describe('Edge direction filter - "in" (incoming), "out" (outgoing), "both" (default).')
+      inputSchema: z47.object({
+        graphId: z47.string().describe("The graph ID"),
+        nodeId: z47.string().describe("The node ID to inspect"),
+        edgeType: z47.string().optional().describe('Restrict to a specific relation label (e.g. "ASSOCIATED_WITH"). Case-insensitive; non-alphanum chars are normalized.'),
+        direction: z47.enum(["in", "out", "both"]).optional().describe('Edge direction filter - "in" (incoming), "out" (outgoing), "both" (default).')
       })
     },
     async ({ graphId, nodeId, edgeType, direction }) => {
@@ -2293,7 +2349,7 @@ function registerListNodeConnections(server2, client2) {
 }
 
 // ../mcp-core/src/tools/reparent.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 function registerReparent(server2, client2) {
   server2.registerTool(
     "naumu_reparent",
@@ -2301,11 +2357,11 @@ function registerReparent(server2, client2) {
       title: "Reparent Node",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: 'Atomically swap a node\'s parent edge; use to move a child under a different parent (e.g. during /restructure to reparent children under newly-created mini-hubs). Deletes any existing `isParent: true` edges on the node and creates a new one to `newParentId` with relation `newRelation`. Preserves the node\'s id, content, attributes, and embedding - does NOT trigger embedding regeneration because only the parent edge changes. Idempotent: if the node already has the requested parent edge, response is `status: "skipped"`. Response shape: `{nodeId, oldParentId, newParentId, newRelation, status: "moved" | "skipped"}`.',
-      inputSchema: z47.object({
-        graphId: z47.string().describe("The graph ID"),
-        nodeId: z47.string().describe("The child node to reparent"),
-        newParentId: z47.string().describe("The new parent node id"),
-        newRelation: z47.string().describe('The new parent edge relation label (e.g. "PART_OF"). Must be valid per the schema for (child.type, relation, parent.type).')
+      inputSchema: z48.object({
+        graphId: z48.string().describe("The graph ID"),
+        nodeId: z48.string().describe("The child node to reparent"),
+        newParentId: z48.string().describe("The new parent node id"),
+        newRelation: z48.string().describe('The new parent edge relation label (e.g. "PART_OF"). Must be valid per the schema for (child.type, relation, parent.type).')
       })
     },
     async ({ graphId, nodeId, newParentId, newRelation }) => {
@@ -2321,7 +2377,7 @@ function registerReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/batch-reparent.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 function registerBatchReparent(server2, client2) {
   server2.registerTool(
     "naumu_batch_reparent",
@@ -2329,11 +2385,11 @@ function registerBatchReparent(server2, client2) {
       title: "Batch Reparent Nodes",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: 'Reparent 1-25 nodes onto a shared `newParentId` with the same `newRelation`; use to move a same-typed cluster under a freshly-created mini-hub in /restructure. Same semantics as `naumu_reparent` per-node: atomic swap of the isParent edge, preserves id/content/attributes/embedding, no re-embedding. Idempotent per node (already-parented nodes return `status: "skipped"`). Per-node response array: `[{nodeId, oldParentId, newParentId, status: "moved" | "skipped" | "error", error?}]`.',
-      inputSchema: z48.object({
-        graphId: z48.string().describe("The graph ID"),
-        newParentId: z48.string().describe("Parent node id every nodeId in the batch will be parented to"),
-        newRelation: z48.string().describe("Parent edge relation label (must be valid per schema for child.type \u2192 parent.type)"),
-        nodeIds: z48.array(z48.string()).min(1).max(25).describe("1\u201325 child node ids to reparent under `newParentId`")
+      inputSchema: z49.object({
+        graphId: z49.string().describe("The graph ID"),
+        newParentId: z49.string().describe("Parent node id every nodeId in the batch will be parented to"),
+        newRelation: z49.string().describe("Parent edge relation label (must be valid per schema for child.type \u2192 parent.type)"),
+        nodeIds: z49.array(z49.string()).min(1).max(25).describe("1\u201325 child node ids to reparent under `newParentId`")
       })
     },
     async ({ graphId, newParentId, newRelation, nodeIds }) => {
@@ -2350,7 +2406,7 @@ function registerBatchReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-search.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 
 // ../mcp-core/src/public-origin.ts
 function publicOrigin() {
@@ -2404,8 +2460,8 @@ function registerChatgptSearch(server2, client2) {
       title: "Search",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Search across all of the knowledge graphs (spaces) you can access and return the most relevant nodes. Returns `{ results: [{ id, title, url }] }`. Pass each result `id` to the `fetch` tool to read the full node. (This is the cross-space entry point for ChatGPT/Deep Research; within a single space, `naumu_search` exposes more controls.)",
-      inputSchema: z49.object({
-        query: z49.string().describe(
+      inputSchema: z50.object({
+        query: z50.string().describe(
           "A short contiguous phrase \u2014 an entity name, label, or ID. The text half matches it verbatim as a case-insensitive substring; the semantic half matches meaning."
         )
       })
@@ -2439,7 +2495,7 @@ function registerChatgptSearch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-fetch.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 var NON_ATTRIBUTE_PROPS = /* @__PURE__ */ new Set([
   "id",
   "label",
@@ -2533,8 +2589,8 @@ function registerChatgptFetch(server2, client2) {
       title: "Fetch",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Fetch the full contents of a node returned by the `search` tool. Pass the result `id` verbatim (format `<graphId>:<nodeId>`). Returns `{ id, title, text, url }` where `text` is the node content plus its type, attributes, and connections.",
-      inputSchema: z50.object({
-        id: z50.string().describe("A resource id from a previous `search` result, in the form `<graphId>:<nodeId>`.")
+      inputSchema: z51.object({
+        id: z51.string().describe("A resource id from a previous `search` result, in the form `<graphId>:<nodeId>`.")
       })
     },
     async ({ id }) => {
@@ -2577,7 +2633,7 @@ function registerChatgptFetch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/admission-status.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 function registerAdmissionStatus(server2, client2) {
   server2.registerTool(
     "naumu_admission_status",
@@ -2585,8 +2641,8 @@ function registerAdmissionStatus(server2, client2) {
       title: "Admission Status",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Show who can auto-join a Naumu space (graph) and who is waiting for approval: the whitelisted emails (people who join the moment they sign in with that email), the auto-join domain wildcards, and the count of pending join requests. When there are pending requests, this also returns the full list (who requested, their email, git-email hint, and message) so you can act on them with naumu_resolve_join_request. Use it during repo init to review or seed access, or whenever the user asks who has access to a space or who is asking to join.",
-      inputSchema: z51.object({
-        graphId: z51.string().describe("The space (graph) ID to inspect admission for. You must be a member of this space.")
+      inputSchema: z52.object({
+        graphId: z52.string().describe("The space (graph) ID to inspect admission for. You must be a member of this space.")
       })
     },
     async ({ graphId }) => {
@@ -2616,7 +2672,7 @@ function registerAdmissionStatus(server2, client2) {
 }
 
 // ../mcp-core/src/tools/whitelist-members.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 function registerWhitelistMembers(server2, client2) {
   server2.registerTool(
     "naumu_whitelist_members",
@@ -2629,10 +2685,10 @@ function registerWhitelistMembers(server2, client2) {
         openWorldHint: false
       },
       description: "Whitelist emails so those people auto-join a Naumu space (graph) the moment they sign in with that email. Use this during repo init: after you scrub git history, present the curated list of collaborators to the user, and get their explicit confirmation, call this with the confirmed emails. It is silent - it sends no invite emails, it just pre-authorizes those addresses. Returns which entries were created and which were skipped (already whitelisted or already members). Set repoInit true when this call is part of the repo init flow.",
-      inputSchema: z52.object({
-        graphId: z52.string().describe("The space (graph) ID to whitelist emails for. You must be a member of this space."),
-        emails: z52.array(z52.string()).min(1).describe("The emails to whitelist. Each becomes an exact-match auto-join entry. Present these to the user and get confirmation before calling."),
-        repoInit: z52.boolean().optional().describe("Set true when this whitelist is being seeded as part of the repo init flow, so onboarding is tracked correctly.")
+      inputSchema: z53.object({
+        graphId: z53.string().describe("The space (graph) ID to whitelist emails for. You must be a member of this space."),
+        emails: z53.array(z53.string()).min(1).describe("The emails to whitelist. Each becomes an exact-match auto-join entry. Present these to the user and get confirmation before calling."),
+        repoInit: z53.boolean().optional().describe("Set true when this whitelist is being seeded as part of the repo init flow, so onboarding is tracked correctly.")
       })
     },
     async ({ graphId, emails, repoInit }) => {
@@ -2656,7 +2712,7 @@ function registerWhitelistMembers(server2, client2) {
 }
 
 // ../mcp-core/src/tools/resolve-admission.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 function registerResolveAdmission(server2, client2) {
   server2.registerTool(
     "naumu_resolve_admission",
@@ -2669,9 +2725,9 @@ function registerResolveAdmission(server2, client2) {
         openWorldHint: false
       },
       description: "The call a coding agent makes right after connecting when a repo's .naumu references a space the user is not yet a member of. It evaluates whether the user can join and does it: outcome is joined-whitelist or joined-wildcard (the user is now a member - proceed), already-member (nothing to do), request-created (a join request was just filed and is awaiting a member's approval), or request-pending (a request was already open). When the response also carries reason 'seat-limit' on a request-created/request-pending outcome, the user WOULD have auto-joined via a whitelist/domain match but the space is at its seat limit - so their access is pending an admin approving them or upgrading the plan; relay that specific reason honestly, do not just say 'no match'. Pass gitEmailHint from `git config user.email` so a matching whitelist or domain rule can admit them. Relay the outcome to the user honestly: say plainly whether they joined or are waiting for approval - never imply access that is still pending.",
-      inputSchema: z53.object({
-        graphId: z53.string().describe("The space (graph) ID referenced by the repo .naumu file that the user wants to join."),
-        gitEmailHint: z53.string().optional().describe("The email from `git config user.email`, used to match whitelist entries and auto-join domains.")
+      inputSchema: z54.object({
+        graphId: z54.string().describe("The space (graph) ID referenced by the repo .naumu file that the user wants to join."),
+        gitEmailHint: z54.string().optional().describe("The email from `git config user.email`, used to match whitelist entries and auto-join domains.")
       })
     },
     async ({ graphId, gitEmailHint }) => {
@@ -2695,7 +2751,7 @@ function registerResolveAdmission(server2, client2) {
 }
 
 // ../mcp-core/src/tools/resolve-join-request.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 function registerResolveJoinRequest(server2, client2) {
   server2.registerTool(
     "naumu_resolve_join_request",
@@ -2708,10 +2764,10 @@ function registerResolveJoinRequest(server2, client2) {
         openWorldHint: false
       },
       description: "For a member resolving a pending join request surfaced by naumu_admission_status. Approve to add the requester to the space as a member, or deny to reject the request. Get the requestId from naumu_admission_status's pending list, and confirm the decision with the user before calling since approving grants access.",
-      inputSchema: z54.object({
-        graphId: z54.string().describe("The space (graph) ID the request is for. You must be a member of this space."),
-        requestId: z54.string().describe("The pending join request ID, taken from naumu_admission_status."),
-        action: z54.enum(["approve", "deny"]).describe("approve adds the requester as a member; deny rejects the request.")
+      inputSchema: z55.object({
+        graphId: z55.string().describe("The space (graph) ID the request is for. You must be a member of this space."),
+        requestId: z55.string().describe("The pending join request ID, taken from naumu_admission_status."),
+        action: z55.enum(["approve", "deny"]).describe("approve adds the requester as a member; deny rejects the request.")
       })
     },
     async ({ graphId, requestId, action }) => {
@@ -2808,6 +2864,7 @@ var TOOL_REGISTRARS = {
   naumu_note_delete_section: registerNoteDeleteSection,
   naumu_note_replace: registerNoteReplace,
   naumu_note_find_replace: registerNoteFindReplace,
+  naumu_note_batch: registerNoteBatch,
   naumu_create_note: registerCreateNote,
   naumu_list_schema_violations: registerListSchemaViolations,
   naumu_list_dense_nodes: registerListDenseNodes,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@naumu/mcp",
-	"version": "0.13.0",
+	"version": "0.14.1",
 	"description": "MCP server for Naumu - access your knowledge graph from Claude Code, Cursor, and other AI coding agents",
 	"license": "MIT",
 	"author": "Naumu <hello@naumu.ai>",

package/server.json

@@ -3,7 +3,7 @@
 	"name": "ai.naumu/mcp",
 	"title": "Naumu",
 	"description": "Search, extend, and act on your team's Naumu knowledge graph: notes, threads, and nodes.",
-	"version": "0.13.0",
+	"version": "0.14.1",
 	"websiteUrl": "https://naumu.ai",
 	"repository": {
 		"url": "https://github.com/naumu-ai/mcp",
@@ -27,7 +27,7 @@
 			"registryType": "npm",
 			"registryBaseUrl": "https://registry.npmjs.org",
 			"identifier": "@naumu/mcp",
-			"version": "0.13.0",
+			"version": "0.14.1",
 			"runtimeHint": "npx",
 			"transport": { "type": "stdio" },
 			"environmentVariables": [