@naumu/mcp 0.12.1 → 0.14.0

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.12.1";
+var NAUMU_MCP_VERSION = "0.14.0";
 
 // ../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
     );
   }
@@ -198,7 +219,7 @@ var NaumuClient = class {
 // ../mcp-core/src/instructions.ts
 var NAUMU_INSTRUCTIONS = `The Naumu MCP server gives structured access to Naumu knowledge graphs (also called spaces). Prefer these tools over WebFetch whenever the user mentions a naumu.ai URL \u2014 Naumu pages are client-rendered React, so WebFetch returns an empty shell with no data.
 
-Getting information about a space: use naumu_ask. It puts your question to the @Naumu agent (which has full read access and inspects the graph for you) and returns a synthesised, node-grounded answer with the exact source node ids and a confidence hint, in a single call. It is the authoritative answer for what is in a space, what is new or recently changed, how something works, or any summary - present it and its sources directly. Do NOT then re-read the graph yourself with naumu_get_schema, naumu_filter, naumu_get_node or fetch to verify or sanity-check the answer: that repeats work naumu_ask already did and is dramatically slower (it can turn a 40-second answer into minutes). Trust the answer and its cited sources. Reach for a granular read only to fetch one specific node the answer pointed to, or for a need naumu_ask genuinely cannot serve (naumu_search to locate nodes by meaning, naumu_list_threads + naumu_read_thread for conversation history). Recording the question and answer as a visible conversation in the space is expected and useful, so do not avoid naumu_ask to prevent creating a thread. To hand @Naumu work to carry out in the background (add knowledge, make changes, record a status update), use naumu_delegate.
+Getting information about a space: use naumu_ask. It puts your question to the @Naumu agent (which has full read access and inspects the graph for you) and returns a synthesised, node-grounded answer with the exact source node ids and a confidence hint, in a single call. It is the authoritative answer for what is in a space, what is new or recently changed, how something works, or any summary - present it and its sources directly. Do NOT then re-read the graph yourself with naumu_get_schema, naumu_filter, naumu_get_node or fetch to verify or sanity-check the answer: that repeats work naumu_ask already did and is dramatically slower (it can turn a 40-second answer into minutes). Trust the answer and its cited sources. Reach for a granular read only to fetch one specific node the answer pointed to, or for a need naumu_ask genuinely cannot serve (naumu_search to locate nodes by meaning, naumu_list_threads + naumu_read_thread for conversation history). To wait for the next reply in a thread, use naumu_wait_for_activity instead of re-reading it on a timer - it blocks server-side until a new message lands. Recording the question and answer as a visible conversation in the space is expected and useful, so do not avoid naumu_ask to prevent creating a thread. To hand @Naumu work to carry out in the background (add knowledge, make changes, record a status update), use naumu_delegate.
 
 IMPORTANT: graphId is a UUID (e.g. "0464cbfa-60ca-41b3-ac8f-bbeb8243a193"). The value in the URL right after /spaces/ is a slug (e.g. "naumu-0464cbfa"), NOT the graphId. You must resolve the slug to a graphId first.
 
@@ -1171,7 +1192,7 @@ function registerPostMessage(server2, client2) {
         idempotentHint: false,
         openWorldHint: false
       },
-      description: 'Post a message in a Naumu thread you participate in. Use it to reply to humans (or other bots) in a thread that pinged you. Write `content` in markdown (the default format): **bold**, *italic*, `inline code`, fenced code blocks, `- ` bullets, `1. ` ordered lists, and `> ` quotes all render natively; headings and tables are not supported and render as plain text. Mentions are inline pills: `@[Name](id)` mentions a person or bot and `#[label](topic-id)` tags a topic. For a human the mention id is their User id (from naumu_list_members or naumu_get_thread participantDetails) or their email - both work; for a bot/agent use its identity id; `@[Naumu](naumu-ai)` addresses the @Naumu agent (a bare `@naumu` in prose also summons it, so only type it when you mean to). @mentioning people loops them in (mention notifications, prompts) without invoking @Naumu. Set contentFormat to "tiptap" only when you need rich content beyond the markdown subset, passing a Tiptap JSON document with mention nodes (`{ type: "mention", attrs: { id, label } }`). To attach files call naumu_request_attachment_upload first, PUT the bytes to the returned uploadUrl, then pass the resulting attachmentIds here. The message needs either `content` or `attachmentIds`. Returns the created message JSON. By default this only appends text: @Naumu is NOT summoned unless the thread auto-responds or you mention it, so nothing is committed to the graph. Pass `invokeAgent: true` when you need @Naumu to act on the message (record a work-log entry, file a status update); it summons @Naumu unconditionally, even in paused threads, and @Naumu works in the background - poll naumu_read_thread to see what it did. To get a synthesised answer from @Naumu, use naumu_ask.',
+      description: 'Post a message in a Naumu thread you participate in. Use it to reply to humans (or other bots) in a thread that pinged you. Write `content` in markdown (the default format): **bold**, *italic*, `inline code`, fenced code blocks, `- ` bullets, `1. ` ordered lists, and `> ` quotes all render natively; headings and tables are not supported and render as plain text. Mentions are inline pills: `@[Name](id)` mentions a person or bot and `#[label](topic-id)` tags a topic. For a human the mention id is their User id (from naumu_list_members or naumu_get_thread participantDetails) or their email - both work; for a bot/agent use its identity id; `@[Naumu](naumu-ai)` addresses the @Naumu agent (a bare `@naumu` in prose also summons it, so only type it when you mean to). A text @-mention renders as a pill but does NOT notify or add a non-participant \u2014 to loop a person in so they get notified, use naumu_add_participants after posting. Set contentFormat to "tiptap" only when you need rich content beyond the markdown subset, passing a Tiptap JSON document with mention nodes (`{ type: "mention", attrs: { id, label } }`). To attach files call naumu_request_attachment_upload first, PUT the bytes to the returned uploadUrl, then pass the resulting attachmentIds here. The message needs either `content` or `attachmentIds`. Returns the created message JSON. By default this only appends text: @Naumu is NOT summoned unless the thread auto-responds or you mention it, so nothing is committed to the graph. Pass `invokeAgent: true` when you need @Naumu to act on the message (record a work-log entry, file a status update); it summons @Naumu unconditionally, even in paused threads, and @Naumu works in the background - poll naumu_read_thread to see what it did. To get a synthesised answer from @Naumu, use naumu_ask.',
       inputSchema: z20.object({
         threadId: z20.string().describe("The thread ID to post into. You must be a participant in this thread."),
         content: z20.string().optional().describe('Message body. Markdown by default (see the tool description for the supported subset and the `@[Name](id)` mention pill syntax); a Tiptap JSON document when contentFormat is "tiptap". Optional when `attachmentIds` is provided.'),
@@ -1208,25 +1229,69 @@ function registerPostMessage(server2, client2) {
   );
 }
 
-// ../mcp-core/src/tools/read-thread.ts
+// ../mcp-core/src/tools/add-participants.ts
 import { z as z21 } from "zod";
+function registerAddParticipants(server2, client2) {
+  server2.registerTool(
+    "naumu_add_participants",
+    {
+      title: "Add Participants",
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
+      description: 'Add space members to a Naumu thread as participants. This is how you loop someone into a conversation so they actually get notified: each newly added person gets an "added you to this thread" notification and a "has joined the conversation" system note, and the thread lands in their inbox. Text @-mentions in naumu_post_message do NOT notify or add non-participants \u2014 after posting a handoff or a message addressed to someone, add them here. Pass userIds (UUIDs) from naumu_list_members or naumu_get_thread participantDetails; emails are not accepted. Adding is idempotent \u2014 already-present participants are skipped silently.',
+      inputSchema: z21.object({
+        threadId: z21.string().describe("The thread ID to add participants to. You must be able to manage this thread."),
+        userIds: z21.array(z21.string()).min(1).max(25).describe("User ids (UUIDs) of space members to add, from naumu_list_members or naumu_get_thread."),
+        role: z21.enum(["editor", "viewer"]).optional().describe("Thread role for the added participants. Defaults to editor (can post); viewer is read-only.")
+      })
+    },
+    async ({ threadId, userIds, role }) => {
+      try {
+        const data = await client2.patch(`/api/threads/${threadId}`, {
+          addParticipants: userIds.map((userId) => ({ userId, role: role ?? "editor" }))
+        });
+        const participants = data?.participantDetails ?? data?.participantEmails ?? data;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ threadId, participants }, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/read-thread.ts
+import { z as z22 } from "zod";
 function registerReadThread(server2, client2) {
   server2.registerTool(
     "naumu_read_thread",
     {
       title: "Read Thread",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-      description: 'Read messages from a Naumu thread. Returns paginated history ordered newest-first; 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. Default page size 50, max 200. To read or download a message attachment, pass its `attachments[].id` to naumu_get_attachment.',
-      inputSchema: z21.object({
-        threadId: z21.string().describe("The thread ID to read from."),
-        before: z21.number().optional().describe("Unix timestamp in milliseconds. Returns messages strictly older than this. Omit for the newest page."),
-        limit: z21.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
+      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."),
+        after: z22.number().optional().describe("Unix timestamp in milliseconds. Returns only messages newer than this, oldest-first. Mutually exclusive with `before`."),
+        afterId: z22.string().optional().describe("Message id that goes with `after` - the `latestId` from naumu_wait_for_activity. Only meaningful alongside `after`. With it, messages sharing the `after` millisecond are compared by id instead of being skipped."),
+        limit: z22.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
-    async ({ threadId, before, limit }) => {
+    async ({ threadId, before, after, afterId, limit }) => {
       try {
         const params = new URLSearchParams();
         if (before !== void 0) params.set("before", String(before));
+        if (after !== void 0) params.set("after", String(after));
+        if (afterId !== void 0) params.set("afterId", afterId);
         if (limit !== void 0) params.set("limit", String(limit));
         const qs = params.toString();
         const path = `/api/threads/${threadId}/messages${qs ? `?${qs}` : ""}`;
@@ -1245,8 +1310,56 @@ function registerReadThread(server2, client2) {
   );
 }
 
+// ../mcp-core/src/tools/wait-for-activity.ts
+import { z as z23 } from "zod";
+function registerWaitForActivity(server2, client2) {
+  server2.registerTool(
+    "naumu_wait_for_activity",
+    {
+      title: "Wait For Thread Activity",
+      // Pure long-poll read: parks on the server and returns messages, never
+      // writes. Repeating the same `after` returns the same messages.
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+      description: 'Wait for the next messages in a Naumu thread. The call blocks for up to `timeoutSec` seconds server-side and returns the moment something new arrives, so this is the cheap way to attend a thread - use it instead of calling naumu_read_thread on a timer.\n\nReturns `{ messages, latest, latestId, timedOut }`. `messages` is oldest-first and each one carries `senderKind`: "self" (you), "user" (a human), "agent" (a bot or @Naumu), "system" (a system notice). Reply only to "user" messages unless your task says otherwise; ignore "agent" and "system" ones.\n\nTo keep attending, loop: call again with `after` = the `latest` you just received AND `afterId` = the `latestId`. Passing both is what stops two messages written in the same millisecond from being lost. Never reuse the old cursor after receiving messages - you will get the same ones back. If `timedOut` is true and `messages` is empty, nothing happened: call again with the same cursor.\n\nIf a returned message has `status: "processing"`, the reply is still being written - it is a placeholder that gets UPDATED in place, so waiting again will never show you the final text. Re-read that message with naumu_read_thread instead (pass `after` = its timestamp minus 1, or page back to it) until its status is `complete`.\n\nGet your first `after`/`afterId` from the newest message in naumu_read_thread. Before composing a reply call naumu_typing, then post it with naumu_post_message.',
+      inputSchema: z23.object({
+        threadId: z23.string().describe("The thread ID to wait on. You must be a participant."),
+        after: z23.number().describe(
+          "Unix timestamp in milliseconds. Only messages newer than this count. Use the `latest` value from the previous call, or the newest message timestamp from naumu_read_thread."
+        ),
+        afterId: z23.string().optional().describe(
+          "Message id that goes with `after` - the `latestId` from the previous call. Only meaningful alongside `after`. With it, messages sharing the `after` millisecond are compared by id instead of being skipped, so nothing written in the same millisecond is lost."
+        ),
+        timeoutSec: z23.number().int().min(1).max(25).default(20).describe("Seconds to block before returning empty, 1 to 25, default 20."),
+        excludeSelf: z23.boolean().default(true).describe(
+          'Ignore your own messages (senderKind "self") when deciding whether something new arrived. Default true - keep it on so your own reply does not end the next wait immediately.'
+        )
+      })
+    },
+    async ({ threadId, after, afterId, timeoutSec, excludeSelf }) => {
+      try {
+        const params = new URLSearchParams();
+        params.set("after", String(after));
+        if (afterId !== void 0) params.set("afterId", afterId);
+        if (timeoutSec !== void 0) params.set("timeoutSec", String(timeoutSec));
+        if (excludeSelf !== void 0) params.set("excludeSelf", String(excludeSelf));
+        const path = `/api/threads/${threadId}/messages/wait?${params.toString()}`;
+        const data = await client2.get(path);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // ../mcp-core/src/tools/whoami.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 function registerWhoami(server2, client2) {
   server2.registerTool(
     "naumu_whoami",
@@ -1254,7 +1367,7 @@ function registerWhoami(server2, client2) {
       title: "Who Am I",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Return who the calling key is, so you can bootstrap before the first real operation. A bot identity key returns its Identity row (id, graphId, name, instructions, allowedTools) plus its curated MCP tool manifest. A user API key returns `kind: "user"` with userId, name, and email - a person spans many graphs, so resolve a specific graph via naumu_list_graphs. The live tool list is already available from tools/list, so it is not repeated here. No arguments. Always available regardless of the permission grid.',
-      inputSchema: z22.object({})
+      inputSchema: z24.object({})
     },
     async () => {
       try {
@@ -1274,7 +1387,7 @@ function registerWhoami(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-threads.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 function sanitizeThreadParticipants(thread) {
   if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
     return thread;
@@ -1289,11 +1402,11 @@ function registerListThreads(server2, client2) {
       title: "List Threads",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "List threads sorted by last activity (newest first), for self-discovery before deciding which to engage. With a user API key, pass `graphId` to list threads you can see in that space (resolve it via naumu_list_graphs). Pass `nodeId` alongside `graphId` to list only the conversations tied to that node (attached, or that created/modified it). With a bot identity key, omit `graphId` to list threads in your own graph \u2014 each row carries an `isParticipant` flag (TRUE means you were explicitly invited and your replies fan out via webhook). Page back with `cursor` set to the oldest `lastActivityAt` from the previous page.",
-      inputSchema: z23.object({
-        graphId: z23.string().optional().describe("Graph (space) ID. Required for user API keys; omit for bot identity keys (defaults to your own graph)."),
-        nodeId: z23.string().optional().describe("Scope the listing to conversations tied to this node. Requires `graphId`."),
-        cursor: z23.number().int().optional().describe("Unix timestamp ms \u2014 returns threads with `lastActivityAt` strictly older than this. Omit for the newest page."),
-        limit: z23.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
+      inputSchema: z25.object({
+        graphId: z25.string().optional().describe("Graph (space) ID. Required for user API keys; omit for bot identity keys (defaults to your own graph)."),
+        nodeId: z25.string().optional().describe("Scope the listing to conversations tied to this node. Requires `graphId`."),
+        cursor: z25.number().int().optional().describe("Unix timestamp ms \u2014 returns threads with `lastActivityAt` strictly older than this. Omit for the newest page."),
+        limit: z25.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ graphId, nodeId, cursor, limit }) => {
@@ -1344,7 +1457,7 @@ function registerListThreads(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-topics.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 function toFilingDestination(topic) {
   if (!topic || typeof topic !== "object") return null;
   const t = topic;
@@ -1365,8 +1478,8 @@ function registerListTopics(server2, client2) {
       title: "List Topics",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "List a space's real topics \u2014 the filing destinations you can hand to the `topicIds` param of naumu_delegate or naumu_ask when creating a thread. Filing a new thread into one or more topics makes it visible to those topics' members from birth (instead of the default private thread). Each row carries { id, name, visibilityMode, memberCount, openToWeb }; use the id values in `topicIds`. Topics have no separate description field. The virtual #misc bucket is not a real topic and is omitted; archived topics are omitted because they can't be tagged. Resolve `graphId` via naumu_list_graphs first.",
-      inputSchema: z24.object({
-        graphId: z24.string().describe("The space (graph) id to list topics for.")
+      inputSchema: z26.object({
+        graphId: z26.string().describe("The space (graph) id to list topics for.")
       })
     },
     async ({ graphId }) => {
@@ -1389,7 +1502,7 @@ function registerListTopics(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-topic.ts
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 var TOPIC_NAME_PATTERN = /^[a-z0-9-]+$/;
 var TOPIC_NAME_MAX_LENGTH = 50;
 var RESERVED_TOPIC_NAMES = [
@@ -1423,18 +1536,18 @@ function registerCreateTopic(server2, client2) {
       title: "Create Topic",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: 'Create a new topic (filing destination) in a space; use when the topic a thread or note should be filed into does not exist yet. Check `naumu_list_topics` first so you reuse an existing topic instead of creating a near-duplicate. Returns the created topic `{id, name, color, visibilityMode, archived, openToWeb, webParticipation, createdAt, createdBy, memberIds, isMember}` - pass the returned `id` to the `topicIds` param of naumu_delegate, naumu_ask or naumu_create_note to file work into it. Name rules (validated before the call): lowercase letters, numbers and "-" only (channel-slug style, e.g. "core-team"), at most 50 characters, and never one of the reserved names all, everyone, naumu, here, misc, hidden, space, shared-with-you. Names are unique per space, case-insensitively. Requires admin rights on the space: editors and bot identities always get a 403, so do not attempt this on behalf of a bot. `visibilityMode` defaults to "open"; the caller is always added as a member, and `openToWeb` cannot be combined with a "closed" topic. Resolve `graphId` via naumu_list_graphs first.',
-      inputSchema: z25.object({
-        graphId: z25.string().describe("The space (graph) id to create the topic in."),
-        name: z25.string().min(1).describe(
+      inputSchema: z27.object({
+        graphId: z27.string().describe("The space (graph) id to create the topic in."),
+        name: z27.string().min(1).describe(
           'Topic name in channel-slug form: lowercase letters, numbers and "-" only, max 50 chars, not a reserved name. Unique per space (case-insensitive).'
         ),
-        color: z25.string().optional().describe("Optional named color token for the topic badge. Omit unless the user asked for a specific color."),
-        visibilityMode: z25.enum(["default", "open", "closed"]).optional().describe(
+        color: z27.string().optional().describe("Optional named color token for the topic badge. Omit unless the user asked for a specific color."),
+        visibilityMode: z27.enum(["default", "open", "closed"]).optional().describe(
           'Who can see and join the topic. "open" (the default) lets any space member join, "default" is the space default, "closed" is invite-only.'
         ),
-        openToWeb: z25.boolean().optional().describe('Expose the topic publicly on the web. Invalid together with visibilityMode "closed".'),
-        webParticipation: z25.enum(["participate", "view-only"]).optional().describe('What public web visitors may do when openToWeb is true. Defaults to "view-only".'),
-        memberIds: z25.array(z25.string()).optional().describe(
+        openToWeb: z27.boolean().optional().describe('Expose the topic publicly on the web. Invalid together with visibilityMode "closed".'),
+        webParticipation: z27.enum(["participate", "view-only"]).optional().describe('What public web visitors may do when openToWeb is true. Defaults to "view-only".'),
+        memberIds: z27.array(z27.string()).optional().describe(
           "User ids to add as topic members (get them from naumu_list_members). Ids that are not current space members are silently dropped. The caller is always added regardless."
         )
       })
@@ -1487,7 +1600,7 @@ function registerCreateTopic(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-thread.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 function sanitizeThreadParticipants2(thread) {
   if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
     return thread;
@@ -1502,8 +1615,8 @@ function registerGetThread(server2, client2) {
       title: "Get Thread",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Fetch a single thread, including the human participant roster (`participantDetails` \u2014 userId, name, image) and bot roster (`identityParticipants` \u2014 id, name, isSystem). Use this when `naumu_list_threads` surfaced a candidate and you want to know exactly who is in it before posting. Pair with `naumu_read_thread` for message history.",
-      inputSchema: z26.object({
-        threadId: z26.string().describe("The thread ID to fetch.")
+      inputSchema: z28.object({
+        threadId: z28.string().describe("The thread ID to fetch.")
       })
     },
     async ({ threadId }) => {
@@ -1525,7 +1638,7 @@ function registerGetThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-thread.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 function registerCreateThread(server2, client2) {
   server2.registerTool(
     "naumu_create_thread",
@@ -1540,23 +1653,23 @@ function registerCreateThread(server2, client2) {
         openWorldHint: false
       },
       description: "Start a new conversation in a space. You are auto-attached as a participant, and the thread's formal creator is your primary owner (the user who registered you), so it shows in their sidebar. Optional `participants` adds humans (by userId) and other bots (by identityId) at creation. Optional `initialMessage` opens the conversation as your first message. Optional `topicIds` files the new thread into one or more topics (see naumu_list_topics for ids): it becomes visible to those topics' members from birth instead of staying a private thread between you and your owner. Filing is creation-only and only ever widens - it never removes the thread from a topic later. Tagging people loops them in without invoking @Naumu; only an explicit @Naumu mention, or naumu_ask, brings the agent in. Returns the created thread (including its id) so you can follow up with naumu_post_message.",
-      inputSchema: z27.object({
-        title: z27.string().min(1).max(200).optional().describe('Thread title shown in the sidebar. If omitted, Naumu generates a default like "Conversation YYYY-MM-DD".'),
-        participants: z27.array(
-          z27.discriminatedUnion("type", [
-            z27.object({
-              type: z27.literal("user"),
-              userId: z27.string().min(1).describe("User UUID \u2014 get these from `naumu_get_thread`/`naumu_read_thread` participant rosters or webhook payloads.")
+      inputSchema: z29.object({
+        title: z29.string().min(1).max(200).optional().describe('Thread title shown in the sidebar. If omitted, Naumu generates a default like "Conversation YYYY-MM-DD".'),
+        participants: z29.array(
+          z29.discriminatedUnion("type", [
+            z29.object({
+              type: z29.literal("user"),
+              userId: z29.string().min(1).describe("User UUID \u2014 get these from `naumu_get_thread`/`naumu_read_thread` participant rosters or webhook payloads.")
             }),
-            z27.object({
-              type: z27.literal("identity"),
-              identityId: z27.string().min(1).describe("Identity id (`identity-\u2026` or `id-\u2026`). Other bots in the same graph can be co-attached to multi-bot threads.")
+            z29.object({
+              type: z29.literal("identity"),
+              identityId: z29.string().min(1).describe("Identity id (`identity-\u2026` or `id-\u2026`). Other bots in the same graph can be co-attached to multi-bot threads.")
             })
           ])
         ).max(32).optional().describe("Up to 32 humans and/or other bots to attach at creation. Your primary owner is added automatically \u2014 you do NOT need to list them here."),
-        initialMessage: z27.string().min(1).max(32e3).optional().describe("Markdown body for the first message. Authored by you (the bot), so it appears in the thread under your name."),
-        visibility: z27.enum(["restricted", "internal", "open"]).optional().describe("`restricted` (invite-only, default) hides from non-participants. `internal` is visible to space members. `open` is visible to anyone who can see the space."),
-        topicIds: z27.array(z27.string()).max(8).optional().describe(
+        initialMessage: z29.string().min(1).max(32e3).optional().describe("Markdown body for the first message. Authored by you (the bot), so it appears in the thread under your name."),
+        visibility: z29.enum(["restricted", "internal", "open"]).optional().describe("`restricted` (invite-only, default) hides from non-participants. `internal` is visible to space members. `open` is visible to anyone who can see the space."),
+        topicIds: z29.array(z29.string()).max(8).optional().describe(
           "Topic ids (from naumu_list_topics) to file the NEW thread into, making it visible to those topics' members from birth. Creation-only and only ever widens - it never removes the thread from a topic later. Omit to keep the default private thread between you and your owner."
         )
       })
@@ -1585,7 +1698,7 @@ function registerCreateThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/request-attachment-upload.ts
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 function registerRequestAttachmentUpload(server2, client2) {
   server2.registerTool(
     "naumu_request_attachment_upload",
@@ -1593,15 +1706,15 @@ function registerRequestAttachmentUpload(server2, client2) {
       title: "Request Attachment Upload",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Request a presigned S3 upload URL to attach a file - pass exactly one of `threadId`, `noteId`, or `canvasId` for where the upload will land, then PUT the bytes directly to the returned URL. Same flow Naumu users use for file uploads. User API keys and OAuth sessions must also pass `graphId` (a user spans many spaces; resolve it via `naumu_list_graphs`); bot keys resolve it automatically.\n\nThree destinations, three follow-up calls:\n\u2022 Thread: presign with `threadId` \u2192 PUT the bytes \u2192 call `naumu_post_message` with the returned `attachmentId` in `attachmentIds`.\n\u2022 Note: presign with `noteId` \u2192 PUT the bytes \u2192 call `naumu_note_append` (or any note write tool) with `![alt](attachment://<attachmentId>)` in the markdown. That single call binds the upload, embeds it inline as the note's canonical media node, and files it into the space's Files & Media library - the same syntax works for images, video, audio, and other files, dispatched by the upload's MIME type.\n\u2022 Canvas: presign with `canvasId` \u2192 PUT the bytes \u2192 call `naumu_persist_canvas_attachment` to extend the upload past its default 1-hour TTL. Placing the persisted attachment onto the canvas itself still happens in the app UI.\n\nTo attach media to a graph node, upload into a thread that originated or modified that node - files surface on the node via its threads; there is no separate node-attachment flow.\n\nPer-MIME size caps apply: 10MB for types the agent reads whole (image, text, PDF, office docs), otherwise the space plan's umbrella cap (50MB free, 500MB team, 1GB max). Audio takes the plan cap, NOT the 10MB agent-read budget - it is transcribed on upload and only the transcript reaches an agent, so a multi-hour recording is a legitimate attachment. Over-cap requests are refused with HTTP 413 before any URL is minted, and the size is re-checked at bind time against the object that actually landed - so an oversized upload is refused there too, not silently accepted.\n\nReturns `{ attachmentId, uploadUrl, method, requiredHeaders, expiresAt }`. Use these EXACTLY:\n\u2022 `method` is \"PUT\".\n\u2022 Send every header in `requiredHeaders`. It carries BOTH `Content-Type` and `Content-Length`, and both are load-bearing: `Content-Length` is signed INTO the URL, so the body must be exactly that many bytes or S3 answers 403. PUT the whole file as one fixed-length body - do not stream it, do not use chunked transfer encoding, and do not send a different byte count than the `fileSize` you declared here.\n\u2022 Do NOT add an Authorization header - the URL itself is the auth.\n\u2022 Do NOT log `uploadUrl` - it is a bearer capability for the duration of the TTL.\n\u2022 `expiresAt` is a Unix-ms timestamp; the pending attachment vanishes at that moment whether or not you uploaded. Bind it (post the message, embed the note reference, or persist the canvas attachment) before then or the upload orphans.\n\nServer-side checks at bind time enforce that the attachment was uploaded by you, in this graph, for this thread/note/canvas - you cannot reuse an upload across destinations.",
-      inputSchema: z28.object({
-        graphId: z28.string().optional().describe("Graph (space) UUID the destination lives in. REQUIRED for user API keys and OAuth sessions - a user spans many spaces, so nothing can infer it; resolve it once via `naumu_list_graphs` and reuse it. Bot keys may omit it: a bot is pinned to one graph and the tool resolves it automatically."),
-        threadId: z28.string().optional().describe("Destination thread - presign for a thread when the upload will be attached to a chat message via `naumu_post_message`'s `attachmentIds`. You must be a participant. Exactly one of `threadId`, `noteId`, or `canvasId` is required. The pending attachment is keyed to this thread - you cannot reuse it for a different one."),
-        noteId: z28.string().optional().describe("Destination note (Thought) - presign for a note when the upload will be embedded via `![alt](attachment://<attachmentId>)` in a note write tool call. Exactly one of `threadId`, `noteId`, or `canvasId` is required. The pending attachment is keyed to this note - you cannot reuse it for a different one."),
-        canvasId: z28.string().optional().describe("Destination canvas - presign for a canvas when the upload will be placed on a canvas; follow up with `naumu_persist_canvas_attachment` to extend its TTL. Exactly one of `threadId`, `noteId`, or `canvasId` is required. The pending attachment is keyed to this canvas - you cannot reuse it for a different one."),
-        fileName: z28.string().min(1).describe("Original filename (with extension). Used as the display name and for the S3 object suffix. Special characters are sanitized server-side."),
-        fileType: z28.string().min(1).describe("MIME type, e.g. `application/pdf`, `image/png`, `text/markdown`, `audio/mpeg`, `video/mp4`. The S3 PUT will enforce this Content-Type."),
-        fileSize: z28.number().int().positive().describe("File size in bytes, exact. Validated against per-MIME caps before the URL is issued - exceeding the cap returns a 413 (not a 400; 400 means a different rejection). This number is also signed into the upload URL as `Content-Length`, so it is a commitment, not an estimate: PUT exactly this many bytes. Audio is validated against the plan umbrella cap (50MB free / 500MB team / 1GB max), not the 10MB agent-read budget."),
-        audioDurationSec: z28.number().positive().optional().describe("For audio attachments, duration in seconds. Send it whenever you know it: audio carries an 8-hour ceiling on top of the size cap, and nothing measures the file server-side, so that ceiling is checked ONLY against a length you report. Omitting it skips the check rather than failing it - the size cap is what still binds you. Omit it rather than guessing: a wrong value is worse than none, and a deliberate under-report is a policy violation, not a workaround.")
+      inputSchema: z30.object({
+        graphId: z30.string().optional().describe("Graph (space) UUID the destination lives in. REQUIRED for user API keys and OAuth sessions - a user spans many spaces, so nothing can infer it; resolve it once via `naumu_list_graphs` and reuse it. Bot keys may omit it: a bot is pinned to one graph and the tool resolves it automatically."),
+        threadId: z30.string().optional().describe("Destination thread - presign for a thread when the upload will be attached to a chat message via `naumu_post_message`'s `attachmentIds`. You must be a participant. Exactly one of `threadId`, `noteId`, or `canvasId` is required. The pending attachment is keyed to this thread - you cannot reuse it for a different one."),
+        noteId: z30.string().optional().describe("Destination note (Thought) - presign for a note when the upload will be embedded via `![alt](attachment://<attachmentId>)` in a note write tool call. Exactly one of `threadId`, `noteId`, or `canvasId` is required. The pending attachment is keyed to this note - you cannot reuse it for a different one."),
+        canvasId: z30.string().optional().describe("Destination canvas - presign for a canvas when the upload will be placed on a canvas; follow up with `naumu_persist_canvas_attachment` to extend its TTL. Exactly one of `threadId`, `noteId`, or `canvasId` is required. The pending attachment is keyed to this canvas - you cannot reuse it for a different one."),
+        fileName: z30.string().min(1).describe("Original filename (with extension). Used as the display name and for the S3 object suffix. Special characters are sanitized server-side."),
+        fileType: z30.string().min(1).describe("MIME type, e.g. `application/pdf`, `image/png`, `text/markdown`, `audio/mpeg`, `video/mp4`. The S3 PUT will enforce this Content-Type."),
+        fileSize: z30.number().int().positive().describe("File size in bytes, exact. Validated against per-MIME caps before the URL is issued - exceeding the cap returns a 413 (not a 400; 400 means a different rejection). This number is also signed into the upload URL as `Content-Length`, so it is a commitment, not an estimate: PUT exactly this many bytes. Audio is validated against the plan umbrella cap (50MB free / 500MB team / 1GB max), not the 10MB agent-read budget."),
+        audioDurationSec: z30.number().positive().optional().describe("For audio attachments, duration in seconds. Send it whenever you know it: audio carries an 8-hour ceiling on top of the size cap, and nothing measures the file server-side, so that ceiling is checked ONLY against a length you report. Omitting it skips the check rather than failing it - the size cap is what still binds you. Omit it rather than guessing: a wrong value is worse than none, and a deliberate under-report is a policy violation, not a workaround.")
       }).refine(
         (data) => [data.threadId, data.noteId, data.canvasId].filter((v) => v !== void 0).length === 1,
         { message: "Exactly one of threadId, noteId, or canvasId is required - pick the single destination this upload is for." }
@@ -1649,7 +1762,7 @@ function registerRequestAttachmentUpload(server2, client2) {
 }
 
 // ../mcp-core/src/tools/persist-canvas-attachment.ts
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 function registerPersistCanvasAttachment(server2, client2) {
   server2.registerTool(
     "naumu_persist_canvas_attachment",
@@ -1657,8 +1770,8 @@ function registerPersistCanvasAttachment(server2, client2) {
       title: "Persist Canvas Attachment",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: "Extend a canvas-bound pending attachment's TTL from its default 1 hour to 30 days; call right after `naumu_request_attachment_upload` (with `canvasId` set) and the S3 PUT, so the upload survives long enough to be used. This only persists the upload - actually placing it onto the canvas still happens in the app UI, there is no MCP canvas-editing tool yet. Safe to call more than once for the same attachmentId.",
-      inputSchema: z29.object({
-        attachmentId: z29.string().min(1).describe("The `attachmentId` returned by `naumu_request_attachment_upload` for this canvas.")
+      inputSchema: z31.object({
+        attachmentId: z31.string().min(1).describe("The `attachmentId` returned by `naumu_request_attachment_upload` for this canvas.")
       })
     },
     async ({ attachmentId }) => {
@@ -1679,7 +1792,7 @@ function registerPersistCanvasAttachment(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-attachment.ts
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 var DOWNLOAD_URL_TTL_SECONDS = 900;
 var MAX_INLINE_PREVIEW_BYTES = 4 * 1024 * 1024;
 function normalizeAttachmentId(input) {
@@ -1700,8 +1813,8 @@ function registerGetAttachment(server2, client2) {
       title: "Get Attachment",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Read a chat attachment. Pass the `attachmentId` from a message's `attachments[].id` in naumu_read_thread (its `url` field works too - the id is extracted from it), and this resolves it into a short-lived download URL for the actual bytes.\n\nReturns a JSON text block with `{ attachmentId, downloadUrl, expiresInSeconds, note }`. Use `downloadUrl` EXACTLY as given:\n\u2022 GET it with no Authorization header - the URL itself is the auth, and adding one makes S3 answer 403.\n\u2022 It expires about 15 minutes after this call. Fetch it now; re-call this tool for a fresh URL rather than holding one.\n\u2022 Do not log it, quote it back to the user, or store it - it is a bearer capability for its whole lifetime.\n\nWhen the attachment is an image (or a video or PDF that has a generated poster), a downsized preview is also returned inline as an image block, so a visual attachment can often be understood without fetching anything. The preview is a thumbnail, not the original - fetch `downloadUrl` when you need full resolution or the exact file.\n\nAccess is checked the same way it is for a person: you only resolve attachments in threads you can already read.",
-      inputSchema: z30.object({
-        attachmentId: z30.string().min(1).describe("Attachment id, from `attachments[].id` on a message returned by naumu_read_thread. A full or relative download URL is also accepted - the id is extracted from its last path segment.")
+      inputSchema: z32.object({
+        attachmentId: z32.string().min(1).describe("Attachment id, from `attachments[].id` on a message returned by naumu_read_thread. A full or relative download URL is also accepted - the id is extracted from its last path segment.")
       })
     },
     async ({ attachmentId }) => {
@@ -1751,7 +1864,7 @@ function registerGetAttachment(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-reaction.ts
-import { z as z31 } from "zod";
+import { z as z33 } from "zod";
 function registerAddReaction(server2, client2) {
   server2.registerTool(
     "naumu_add_reaction",
@@ -1759,10 +1872,10 @@ function registerAddReaction(server2, client2) {
       title: "Add Reaction",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: 'Add an emoji reaction to a message in a thread you are participating in; use for lightweight acknowledgement instead of posting a message. Idempotent - calling twice with the same emoji is a no-op (use `naumu_remove_reaction` to undo). Returns `{ ok, messageId, emoji, alreadyExisted, reactionCount, reactions }` so you can confirm the state without re-reading the thread; `alreadyExisted: true` means the reaction was already on the message and the call was a no-op.\n\nWhen to react vs. when to post a message:\n\u2022 React (no message) for lightweight acknowledgement (\u{1F440}, \u2705, \u{1F44D}), appreciation (\u2764\uFE0F, \u{1F64C}), laughter (\u{1F602}), or "I saw this".\n\u2022 Post a message for direct questions, clarification, important corrections, or final results - situations where words are required.\n\u2022 For long tasks: react \u{1F440} first to acknowledge, optionally post a short "On it - I\'ll report back" if the work will take >20s, do the work, then post the final result.\n\u2022 Ignore casual human banter, side-conversations someone else already answered, or anything where you would only say "ok"/"nice"/"lol".\n\nUse at most one reaction per message unless explicitly useful. Reactions are social backpressure relief, not a sparkle-confetti channel.',
-      inputSchema: z31.object({
-        threadId: z31.string().describe("Thread containing the message. You must be a participant."),
-        messageId: z31.string().describe("The message to react to."),
-        emoji: z31.string().min(1).describe('Emoji character (e.g. "\u{1F440}", "\u2705", "\u2764\uFE0F"). Custom-emoji shortcodes are NOT supported here - pass a real Unicode emoji.')
+      inputSchema: z33.object({
+        threadId: z33.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z33.string().describe("The message to react to."),
+        emoji: z33.string().min(1).describe('Emoji character (e.g. "\u{1F440}", "\u2705", "\u2764\uFE0F"). Custom-emoji shortcodes are NOT supported here - pass a real Unicode emoji.')
       })
     },
     async ({ threadId, messageId, emoji }) => {
@@ -1786,7 +1899,7 @@ function registerAddReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-reaction.ts
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 function registerRemoveReaction(server2, client2) {
   server2.registerTool(
     "naumu_remove_reaction",
@@ -1794,10 +1907,10 @@ function registerRemoveReaction(server2, client2) {
       title: "Remove Reaction",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: "Remove your own emoji reaction from a message; use to walk back an acknowledgement you previously added. Idempotent - calling on a reaction you never added is a no-op. Pair with `naumu_add_reaction` (e.g. you reacted \u{1F440} to start a task and want to clear it after a final result message lands). Returns `{ ok, messageId, emoji, alreadyExisted, reactionCount, reactions }` - `alreadyExisted: false` means there was nothing to remove and the call was a no-op.",
-      inputSchema: z32.object({
-        threadId: z32.string().describe("Thread containing the message. You must be a participant."),
-        messageId: z32.string().describe("The message to remove your reaction from."),
-        emoji: z32.string().min(1).describe("Emoji character to remove (must match what you originally reacted with).")
+      inputSchema: z34.object({
+        threadId: z34.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z34.string().describe("The message to remove your reaction from."),
+        emoji: z34.string().min(1).describe("Emoji character to remove (must match what you originally reacted with).")
       })
     },
     async ({ threadId, messageId, emoji }) => {
@@ -1821,7 +1934,7 @@ function registerRemoveReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/naumu-typing.ts
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 function registerNaumuTyping(server2, client2) {
   server2.registerTool(
     "naumu_typing",
@@ -1832,9 +1945,9 @@ function registerNaumuTyping(server2, client2) {
       // repeating the same state is a no-op renew, so idempotent.
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: 'Show or hide your "is typing\u2026" pill in a thread; use to signal that you are composing a reply. Call with `state: "start"` the moment you decide to compose a reply (before any LLM call), and the server holds the pill alive - re-broadcasting on a short interval - until you stop, post a message, or the lease cap (~5 min) fires. You do NOT need to refresh on a timer; that\'s the lease\'s job.\n\nThe pill clears automatically when:\n\u2022 you call this tool with `state: "stop"`\n\u2022 you call `naumu_post_message` for the same thread (cleared on commit)\n\u2022 the lease cap expires\n\nUse `start` whenever you start work, even if you might end up not replying - call `stop` if you decide NOT to post. Calling `start` while a lease is already active renews it (resets the cap), so a long-running run can call `start` again as a heartbeat without breaking the indicator. You must be a participant of the thread.',
-      inputSchema: z33.object({
-        threadId: z33.string().describe("The thread ID to set typing in. You must be a participant."),
-        state: z33.enum(["start", "stop"]).describe('"start" acquires/renews the lease; "stop" ends it and clears the pill immediately.')
+      inputSchema: z35.object({
+        threadId: z35.string().describe("The thread ID to set typing in. You must be a participant."),
+        state: z35.enum(["start", "stop"]).describe('"start" acquires/renews the lease; "stop" ends it and clears the pill immediately.')
       })
     },
     async ({ threadId, state }) => {
@@ -1855,7 +1968,7 @@ function registerNaumuTyping(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-read.ts
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
 function registerNoteRead(server2, client2) {
   server2.registerTool(
     "naumu_note_read",
@@ -1863,8 +1976,8 @@ function registerNoteRead(server2, client2) {
       title: "Read Note",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Read the current contents of a note as markdown, with its title and `connections` (the graph nodes the note is tied to); use before editing so you know what you're working with. `naumu_note_find_replace` and the section-based tools (`naumu_note_insert`, `naumu_note_replace_section`, `naumu_note_delete_section`) anchor on text/headings present in the live doc.",
-      inputSchema: z34.object({
-        noteId: z34.string().describe("The note (Thought) ID")
+      inputSchema: z36.object({
+        noteId: z36.string().describe("The note (Thought) ID")
       })
     },
     async ({ noteId }) => {
@@ -1877,7 +1990,7 @@ function registerNoteRead(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-append.ts
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 function registerNoteAppend(server2, client2) {
   server2.registerTool(
     "naumu_note_append",
@@ -1885,9 +1998,9 @@ function registerNoteAppend(server2, client2) {
       title: "Append to Note",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Append markdown blocks to the end of a note; use for additive note writing that never touches existing content. Other participants see your colored cursor while the write lands. Markdown supports headings (1-3), bold/italic/code, lists, blockquotes, code blocks, links, and tables. To embed media, write `![alt](attachment://<attachmentId>)` as a sole-line image - the id must come from `naumu_request_attachment_upload` presigned with this same `noteId`. The one syntax covers images, video, audio, and other files, dispatched by the upload's MIME type into the note's canonical media node; an unresolvable or wrong-note id fails the whole write with a 400 naming the bad id. An id already embedded in the note can be repeated safely without re-uploading.",
-      inputSchema: z35.object({
-        noteId: z35.string().describe("The note (Thought) ID to append to"),
-        markdown: z35.string().min(1).describe("Markdown content to append at the end of the note")
+      inputSchema: z37.object({
+        noteId: z37.string().describe("The note (Thought) ID to append to"),
+        markdown: z37.string().min(1).describe("Markdown content to append at the end of the note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -1900,7 +2013,7 @@ function registerNoteAppend(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-insert.ts
-import { z as z36 } from "zod";
+import { z as z38 } from "zod";
 function registerNoteInsert(server2, client2) {
   server2.registerTool(
     "naumu_note_insert",
@@ -1908,10 +2021,10 @@ function registerNoteInsert(server2, client2) {
       title: "Insert After Heading",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Insert markdown content into a note immediately after a named section; use to add content under a specific heading without rewriting it. The section ends at the next heading of equal-or-higher level (or end of doc). 404 if no heading matches `headingText` exactly - call `naumu_note_read` first to see the live structure. To embed media, write `![alt](attachment://<attachmentId>)` as a sole-line image - the id must come from `naumu_request_attachment_upload` presigned with this same `noteId`. The one syntax covers images, video, audio, and other files, dispatched by the upload's MIME type; an unresolvable or wrong-note id fails the whole write with a 400 naming the bad id.",
-      inputSchema: z36.object({
-        noteId: z36.string().describe("The note (Thought) ID"),
-        headingText: z36.string().min(1).describe("Exact text of the heading whose section the new content follows"),
-        markdown: z36.string().min(1).describe("Markdown content to insert at the end of that section")
+      inputSchema: z38.object({
+        noteId: z38.string().describe("The note (Thought) ID"),
+        headingText: z38.string().min(1).describe("Exact text of the heading whose section the new content follows"),
+        markdown: z38.string().min(1).describe("Markdown content to insert at the end of that section")
       })
     },
     async ({ noteId, headingText, markdown }) => {
@@ -1927,7 +2040,7 @@ function registerNoteInsert(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace-section.ts
-import { z as z37 } from "zod";
+import { z as z39 } from "zod";
 function registerNoteReplaceSection(server2, client2) {
   server2.registerTool(
     "naumu_note_replace_section",
@@ -1935,11 +2048,11 @@ function registerNoteReplaceSection(server2, client2) {
       title: "Replace Section",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Replace the body under a named heading with new markdown; use to rewrite one section of a note while leaving the rest intact. By default the heading row itself is preserved (set `keepHeading: false` to drop it too). 404 if no heading matches. To embed media, write `![alt](attachment://<attachmentId>)` as a sole-line image - the id must come from `naumu_request_attachment_upload` presigned with this same `noteId`. The one syntax covers images, video, audio, and other files, dispatched by the upload's MIME type; an unresolvable or wrong-note id fails the whole write with a 400 naming the bad id. An id already embedded elsewhere in the note can be repeated safely without re-uploading.",
-      inputSchema: z37.object({
-        noteId: z37.string().describe("The note (Thought) ID"),
-        headingText: z37.string().min(1).describe("Exact text of the heading anchoring the section"),
-        markdown: z37.string().describe("Replacement markdown for the section body"),
-        keepHeading: z37.boolean().optional().describe("Whether to keep the heading row itself. Default true.")
+      inputSchema: z39.object({
+        noteId: z39.string().describe("The note (Thought) ID"),
+        headingText: z39.string().min(1).describe("Exact text of the heading anchoring the section"),
+        markdown: z39.string().describe("Replacement markdown for the section body"),
+        keepHeading: z39.boolean().optional().describe("Whether to keep the heading row itself. Default true.")
       })
     },
     async ({ noteId, headingText, markdown, keepHeading }) => {
@@ -1956,7 +2069,7 @@ function registerNoteReplaceSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-delete-section.ts
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 function registerNoteDeleteSection(server2, client2) {
   server2.registerTool(
     "naumu_note_delete_section",
@@ -1964,9 +2077,9 @@ function registerNoteDeleteSection(server2, client2) {
       title: "Delete Section",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "\u26A0 DESTRUCTIVE: remove a heading row plus its body (down to the next heading of equal-or-higher level); ONLY use when the user explicitly asks to drop a section. Anything inside that section is gone - there is no per-call undo. If you're unsure which heading they meant, call `naumu_note_read` first to see the current structure. Returns 404 if `headingText` does not exactly match any live heading.",
-      inputSchema: z38.object({
-        noteId: z38.string().describe("The note (Thought) ID"),
-        headingText: z38.string().min(1).describe("Exact text of the heading whose section will be deleted")
+      inputSchema: z40.object({
+        noteId: z40.string().describe("The note (Thought) ID"),
+        headingText: z40.string().min(1).describe("Exact text of the heading whose section will be deleted")
       })
     },
     async ({ noteId, headingText }) => {
@@ -1981,7 +2094,7 @@ function registerNoteDeleteSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace.ts
-import { z as z39 } from "zod";
+import { z as z41 } from "zod";
 function registerNoteReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_replace",
@@ -1989,9 +2102,9 @@ function registerNoteReplace(server2, client2) {
       title: "Replace Note",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "\u26A0 DESTRUCTIVE: replace the entire note content with new markdown; ONLY use when the user explicitly asks to rewrite/replace the whole note. Any concurrent human edits made during the call are silently overwritten. For additive work prefer `naumu_note_append`. For section-level edits use `naumu_note_replace_section`. For inline tweaks use `naumu_note_find_replace`. Read with `naumu_note_read` first if you weren't the last writer. To embed media, write `![alt](attachment://<attachmentId>)` as a sole-line image - the id must come from `naumu_request_attachment_upload` presigned with this same `noteId`. The one syntax covers images, video, audio, and other files, dispatched by the upload's MIME type; an unresolvable or wrong-note id fails the whole write with a 400 naming the bad id. Ids already embedded in the note (read them back via `naumu_note_read`) can be repeated safely without re-uploading.",
-      inputSchema: z39.object({
-        noteId: z39.string().describe("The note (Thought) ID"),
-        markdown: z39.string().describe("New markdown content for the entire note")
+      inputSchema: z41.object({
+        noteId: z41.string().describe("The note (Thought) ID"),
+        markdown: z41.string().describe("New markdown content for the entire note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -2004,7 +2117,7 @@ function registerNoteReplace(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-find-replace.ts
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 function registerNoteFindReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_find_replace",
@@ -2012,11 +2125,11 @@ function registerNoteFindReplace(server2, client2) {
       title: "Find/Replace in Note",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Literal find/replace within a note's text content; use for mid-paragraph tweaks the section-based tools can't target. Marks (bold, italic, code, etc.) are preserved on the surrounding text. \u26A0 The match is literal-substring across every text leaf in the doc; an overly generic `find` (e.g. \" a \") can rewrite the doc unrecognizably. Pick a phrase distinctive enough to land where you mean. By default replaces every occurrence; set `all: false` for first-only. Returns `{ replacements }` so you can sanity-check the count. `replace` can embed media by containing `![alt](attachment://<attachmentId>)` as a sole-line image - the id must come from `naumu_request_attachment_upload` presigned with this same `noteId`; an unresolvable or wrong-note id fails the whole write with a 400 naming the bad id.",
-      inputSchema: z40.object({
-        noteId: z40.string().describe("The note (Thought) ID"),
-        find: z40.string().min(1).describe("Substring to search for. Literal - no regex."),
-        replace: z40.string().describe("Replacement string. May be empty to delete the match."),
-        all: z40.boolean().optional().describe("Replace all occurrences (default true). Pass false to replace only the first.")
+      inputSchema: z42.object({
+        noteId: z42.string().describe("The note (Thought) ID"),
+        find: z42.string().min(1).describe("Substring to search for. Literal - no regex."),
+        replace: z42.string().describe("Replacement string. May be empty to delete the match."),
+        all: z42.boolean().optional().describe("Replace all occurrences (default true). Pass false to replace only the first.")
       })
     },
     async ({ noteId, find, replace, all }) => {
@@ -2032,8 +2145,43 @@ function registerNoteFindReplace(server2, client2) {
   );
 }
 
+// ../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 z41 } from "zod";
+import { z as z44 } from "zod";
 function registerCreateNote(server2, client2) {
   server2.registerTool(
     "naumu_create_note",
@@ -2041,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: z41.object({
-        graphId: z41.string().describe("The graph ID to create the note in"),
-        title: z41.string().optional().describe("Optional title for the note"),
-        markdown: z41.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: z41.boolean().optional().describe("Share the note with everyone in the space. Omit (or false) to keep it private to its participants."),
-        topicIds: z41.array(z41.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 }) => {
@@ -2059,7 +2207,7 @@ function registerCreateNote(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-schema-violations.ts
-import { z as z42 } from "zod";
+import { z as z45 } from "zod";
 var DEFAULT_EXAMPLE_LIMIT = 5;
 var rowsForKind = (violations, kind) => {
   const rows = [];
@@ -2085,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: z42.object({
-        graphId: z42.string().describe("The graph ID"),
-        kind: z42.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: z42.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)."
         )
       })
@@ -2142,7 +2290,7 @@ function registerListSchemaViolations(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-dense-nodes.ts
-import { z as z43 } from "zod";
+import { z as z46 } from "zod";
 function registerListDenseNodes(server2, client2) {
   server2.registerTool(
     "naumu_list_dense_nodes",
@@ -2150,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: z43.object({
-        graphId: z43.string().describe("The graph ID"),
-        minConnections: z43.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: z43.array(z43.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 }) => {
@@ -2171,7 +2319,7 @@ function registerListDenseNodes(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-node-connections.ts
-import { z as z44 } from "zod";
+import { z as z47 } from "zod";
 function registerListNodeConnections(server2, client2) {
   server2.registerTool(
     "naumu_list_node_connections",
@@ -2179,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: z44.object({
-        graphId: z44.string().describe("The graph ID"),
-        nodeId: z44.string().describe("The node ID to inspect"),
-        edgeType: z44.string().optional().describe('Restrict to a specific relation label (e.g. "ASSOCIATED_WITH"). Case-insensitive; non-alphanum chars are normalized.'),
-        direction: z44.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 }) => {
@@ -2201,7 +2349,7 @@ function registerListNodeConnections(server2, client2) {
 }
 
 // ../mcp-core/src/tools/reparent.ts
-import { z as z45 } from "zod";
+import { z as z48 } from "zod";
 function registerReparent(server2, client2) {
   server2.registerTool(
     "naumu_reparent",
@@ -2209,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: z45.object({
-        graphId: z45.string().describe("The graph ID"),
-        nodeId: z45.string().describe("The child node to reparent"),
-        newParentId: z45.string().describe("The new parent node id"),
-        newRelation: z45.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 }) => {
@@ -2229,7 +2377,7 @@ function registerReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/batch-reparent.ts
-import { z as z46 } from "zod";
+import { z as z49 } from "zod";
 function registerBatchReparent(server2, client2) {
   server2.registerTool(
     "naumu_batch_reparent",
@@ -2237,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: z46.object({
-        graphId: z46.string().describe("The graph ID"),
-        newParentId: z46.string().describe("Parent node id every nodeId in the batch will be parented to"),
-        newRelation: z46.string().describe("Parent edge relation label (must be valid per schema for child.type \u2192 parent.type)"),
-        nodeIds: z46.array(z46.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 }) => {
@@ -2258,7 +2406,7 @@ function registerBatchReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-search.ts
-import { z as z47 } from "zod";
+import { z as z50 } from "zod";
 
 // ../mcp-core/src/public-origin.ts
 function publicOrigin() {
@@ -2312,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: z47.object({
-        query: z47.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."
         )
       })
@@ -2347,7 +2495,7 @@ function registerChatgptSearch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-fetch.ts
-import { z as z48 } from "zod";
+import { z as z51 } from "zod";
 var NON_ATTRIBUTE_PROPS = /* @__PURE__ */ new Set([
   "id",
   "label",
@@ -2441,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: z48.object({
-        id: z48.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 }) => {
@@ -2485,7 +2633,7 @@ function registerChatgptFetch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/admission-status.ts
-import { z as z49 } from "zod";
+import { z as z52 } from "zod";
 function registerAdmissionStatus(server2, client2) {
   server2.registerTool(
     "naumu_admission_status",
@@ -2493,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: z49.object({
-        graphId: z49.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 }) => {
@@ -2524,7 +2672,7 @@ function registerAdmissionStatus(server2, client2) {
 }
 
 // ../mcp-core/src/tools/whitelist-members.ts
-import { z as z50 } from "zod";
+import { z as z53 } from "zod";
 function registerWhitelistMembers(server2, client2) {
   server2.registerTool(
     "naumu_whitelist_members",
@@ -2537,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: z50.object({
-        graphId: z50.string().describe("The space (graph) ID to whitelist emails for. You must be a member of this space."),
-        emails: z50.array(z50.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: z50.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 }) => {
@@ -2564,7 +2712,7 @@ function registerWhitelistMembers(server2, client2) {
 }
 
 // ../mcp-core/src/tools/resolve-admission.ts
-import { z as z51 } from "zod";
+import { z as z54 } from "zod";
 function registerResolveAdmission(server2, client2) {
   server2.registerTool(
     "naumu_resolve_admission",
@@ -2577,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: z51.object({
-        graphId: z51.string().describe("The space (graph) ID referenced by the repo .naumu file that the user wants to join."),
-        gitEmailHint: z51.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 }) => {
@@ -2603,7 +2751,7 @@ function registerResolveAdmission(server2, client2) {
 }
 
 // ../mcp-core/src/tools/resolve-join-request.ts
-import { z as z52 } from "zod";
+import { z as z55 } from "zod";
 function registerResolveJoinRequest(server2, client2) {
   server2.registerTool(
     "naumu_resolve_join_request",
@@ -2616,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: z52.object({
-        graphId: z52.string().describe("The space (graph) ID the request is for. You must be a member of this space."),
-        requestId: z52.string().describe("The pending join request ID, taken from naumu_admission_status."),
-        action: z52.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 }) => {
@@ -2688,7 +2836,9 @@ var TOOL_REGISTRARS = {
   naumu_delegate: registerDelegate,
   // naumu_traverse omitted on purpose — backend stub returns 503 (see import note).
   naumu_post_message: registerPostMessage,
+  naumu_add_participants: registerAddParticipants,
   naumu_read_thread: registerReadThread,
+  naumu_wait_for_activity: registerWaitForActivity,
   naumu_whoami: registerWhoami,
   naumu_list_threads: registerListThreads,
   naumu_list_topics: registerListTopics,
@@ -2714,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.12.1",
+	"version": "0.14.0",
 	"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.12.1",
+	"version": "0.14.0",
 	"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.12.1",
+			"version": "0.14.0",
 			"runtimeHint": "npx",
 			"transport": { "type": "stdio" },
 			"environmentVariables": [