@naumu/mcp 0.14.1 → 0.14.2

package/dist/index.js

@@ -41,7 +41,7 @@ function parseRetryAfterSeconds(retryAfter) {
 }
 
 // ../mcp-core/src/version.ts
-var NAUMU_MCP_VERSION = "0.14.1";
+var NAUMU_MCP_VERSION = "0.14.2";
 
 // ../mcp-core/src/client.ts
 var HEADER_VALUE_MAX_LENGTH = 100;
@@ -564,6 +564,13 @@ function registerAddConnection(server2, client2) {
 
 // ../mcp-core/src/tools/add-attribute.ts
 import { z as z8 } from "zod";
+
+// ../mcp-core/src/tools/find-by-name.ts
+function findByName(items, name, key) {
+  return items.find((item) => key(item) === name) ?? items.find((item) => key(item).toLowerCase() === name.toLowerCase());
+}
+
+// ../mcp-core/src/tools/add-attribute.ts
 function registerAddAttribute(server2, client2) {
   server2.registerTool(
     "naumu_add_attribute",
@@ -596,7 +603,7 @@ function registerAddAttribute(server2, client2) {
         };
       }
       node.attributes = node.attributes ?? [];
-      const existing = node.attributes.find((a) => a.name === name);
+      const existing = findByName(node.attributes, name, (a) => a.name);
       let action;
       if (!existing) {
         node.attributes.push({ name, type, values, ...description ? { description } : {} });
@@ -605,8 +612,14 @@ function registerAddAttribute(server2, client2) {
         const existingLabels = new Set((existing.values ?? []).map((v) => v.label));
         const added = values.filter((v) => !existingLabels.has(v.label));
         existing.values = [...existing.values ?? [], ...added];
-        if (description && !existing.description) existing.description = description;
-        action = added.length > 0 ? `Extended attribute "${name}" with ${added.length} new value(s); kept ${existingLabels.size} existing.` : `Attribute "${name}" already had all proposed values; no change.`;
+        if (description) existing.description = description;
+        const addedSet = new Set(added);
+        for (const incoming of values) {
+          if (incoming.description === void 0 || addedSet.has(incoming)) continue;
+          const stored = (existing.values ?? []).find((v) => v.label === incoming.label);
+          if (stored) stored.description = incoming.description;
+        }
+        action = added.length > 0 ? `Extended attribute "${existing.name}" with ${added.length} new value(s); kept ${existingLabels.size} existing.` : `Attribute "${existing.name}" already had all proposed values; no change.`;
       }
       await client2.post(`/api/graphs/${graphId}/schema`, { definition: schema });
       return {
@@ -616,8 +629,98 @@ function registerAddAttribute(server2, client2) {
   );
 }
 
-// ../mcp-core/src/tools/search.ts
+// ../mcp-core/src/tools/update-schema-description.ts
 import { z as z9 } from "zod";
+function errorResult(error) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error }, null, 2) }]
+  };
+}
+function registerUpdateSchemaDescription(server2, client2) {
+  server2.registerTool(
+    "naumu_update_schema_description",
+    {
+      title: "Update Schema Description",
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+      description: 'Rewrite the description of ONE existing schema target - the space-wide schema description, a node type, an attribute on that type, or a single value of that attribute. A description is the contrastive decision rule an agent reads when choosing between siblings: say what this target IS and, more importantly, when to pick it over the ones next to it (e.g. "Done - shipped to prod; use In review while the PR is open but not merged"). Generic restatements of the name are worthless; the contrast is the whole point. Call naumu_get_schema first to see the current descriptions and the exact sibling names, then rewrite the one that is ambiguous. Targeting: pass `value` (with its `attribute`) to update a value, `attribute` alone to update an attribute, `nodeType` alone to update the node type itself, and omit `nodeType` entirely to update the space-wide schema description - the guidance that holds across every type (e.g. what a parent connection means in this space). This replaces the existing description outright - it does not append. To create new types/attributes/values, use naumu_add_node_type / naumu_add_attribute.',
+      inputSchema: z9.object({
+        graphId: z9.string(),
+        nodeType: z9.string().optional().describe("Existing node type whose description (or whose attribute/value description) is being rewritten. Omit to rewrite the space-wide schema description instead."),
+        attribute: z9.string().optional().describe("Attribute name on that type. Omit to target the node type itself. Required when `value` is set."),
+        value: z9.string().optional().describe("Label of one value of `attribute`. When set, the description is written on that value instead of the attribute."),
+        description: z9.string().trim().min(1).max(300).describe("The new description (1-300 chars). One or two sentences, contrastive against sibling types/attributes/values so an agent can decide between them.")
+      })
+    },
+    async ({ graphId, nodeType, attribute, value, description }) => {
+      if (value !== void 0 && attribute === void 0) {
+        return errorResult("`value` requires `attribute` - pass the attribute the value belongs to.");
+      }
+      if (nodeType === void 0 && attribute !== void 0) {
+        return errorResult("`attribute` requires `nodeType` - pass the type the attribute is declared on.");
+      }
+      const current = await client2.get(`/api/graphs/${graphId}/schema`);
+      const schema = current.definition ? JSON.parse(current.definition) : { nodes: [] };
+      const nodes = schema.nodes ?? [];
+      if (nodeType === void 0) {
+        schema.description = description;
+        await client2.post(`/api/graphs/${graphId}/schema`, { definition: schema });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ message: "Description updated.", updated: { schema: true, description } }, null, 2)
+            }
+          ]
+        };
+      }
+      const node = findByName(nodes, nodeType, (n) => n.type);
+      if (!node) {
+        return errorResult(
+          `Node type "${nodeType}" not found. Available types: ${nodes.map((n) => n.type).join(", ") || "(none)"}.`
+        );
+      }
+      if (node.readonly) {
+        return errorResult(
+          `READ_ONLY: "${node.type}" mirrors ${node.source ?? "an external source"} and its schema cannot be edited in Naumu - descriptions on it (and on its attributes and values) are owned by the sync engine and would be discarded. Do not retry; describe one of your own types instead.`
+        );
+      }
+      let updated;
+      if (attribute === void 0) {
+        node.description = description;
+        updated = { type: node.type, description };
+      } else {
+        const attributes = node.attributes ?? [];
+        const attr = findByName(attributes, attribute, (a) => a.name);
+        if (!attr) {
+          return errorResult(
+            `Attribute "${attribute}" not found on node type "${node.type}". Available attributes: ${attributes.map((a) => a.name).join(", ") || "(none)"}.`
+          );
+        }
+        if (value === void 0) {
+          attr.description = description;
+          updated = { type: node.type, attribute: attr.name, description };
+        } else {
+          const values = attr.values ?? [];
+          const target = findByName(values, value, (v) => v.label);
+          if (!target) {
+            return errorResult(
+              `Value "${value}" not found on attribute "${attr.name}" of node type "${node.type}". Available values: ${values.map((v) => v.label).join(", ") || "(none)"}.`
+            );
+          }
+          target.description = description;
+          updated = { type: node.type, attribute: attr.name, value: target.label, description };
+        }
+      }
+      await client2.post(`/api/graphs/${graphId}/schema`, { definition: schema });
+      return {
+        content: [{ type: "text", text: JSON.stringify({ message: "Description updated.", updated }, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/search.ts
+import { z as z10 } from "zod";
 function registerSearch(server2, client2) {
   server2.registerTool(
     "naumu_search",
@@ -625,13 +728,13 @@ function registerSearch(server2, client2) {
       title: "Search Graph",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Hybrid search over graph nodes; use for meaning-based lookup when you don\'t know the exact label. Combines text matching, which looks for the whole query as one contiguous substring (good for UUIDs, proper nouns, specific labels), with semantic similarity (good for paraphrase and meaning), then fuses both rankings with Reciprocal Rank Fusion. Returns the top matches with a `matchedVia` tag - `both` is the highest-confidence signal, then `semantic`, then `text`. Use `naumu_filter` for structured queries by type and attributes (e.g. "all in-progress Tasks").',
-      inputSchema: z9.object({
-        graphId: z9.string().describe("The graph ID"),
-        query: z9.string().describe(
+      inputSchema: z10.object({
+        graphId: z10.string().describe("The graph ID"),
+        query: z10.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."
         ),
-        limit: z9.number().optional().default(20).describe("Max results to return (default 20, max 200). Adaptive cutoff may return fewer when the top match is weak."),
-        nodeTypes: z9.array(z9.string()).optional().describe('Filter to specific node types (e.g. ["Type A", "Type B"])')
+        limit: z10.number().optional().default(20).describe("Max results to return (default 20, max 200). Adaptive cutoff may return fewer when the top match is weak."),
+        nodeTypes: z10.array(z10.string()).optional().describe('Filter to specific node types (e.g. ["Type A", "Type B"])')
       })
     },
     async ({ graphId, query, limit, nodeTypes }) => {
@@ -648,7 +751,7 @@ function registerSearch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/filter.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function registerFilter(server2, client2) {
   server2.registerTool(
     "naumu_filter",
@@ -656,17 +759,17 @@ function registerFilter(server2, client2) {
       title: "Filter Graph Nodes",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Filter nodes by type and attributes with deterministic, complete results; use for structured queries like "all in-progress Tasks" or "Bugs not yet resolved." Unlike search tools, this returns every matching node (up to the limit) - no semantic ranking, no missed results. Results are sorted by sortKey or recency.',
-      inputSchema: z10.object({
-        graphId: z10.string().describe("The graph ID"),
-        nodeTypes: z10.array(z10.string()).optional().describe('Filter to specific node types (e.g. ["Type A", "Type B"])'),
-        includeAttributes: z10.record(z10.string(), z10.array(z10.string())).optional().describe(
+      inputSchema: z11.object({
+        graphId: z11.string().describe("The graph ID"),
+        nodeTypes: z11.array(z11.string()).optional().describe('Filter to specific node types (e.g. ["Type A", "Type B"])'),
+        includeAttributes: z11.record(z11.string(), z11.array(z11.string())).optional().describe(
           'Only include nodes where attribute matches one of the values. Example: {"Status": ["Todo", "In Progress"]}'
         ),
-        excludeAttributes: z10.record(z10.string(), z10.array(z10.string())).optional().describe(
+        excludeAttributes: z11.record(z11.string(), z11.array(z11.string())).optional().describe(
           'Exclude nodes where attribute matches any of the values. Example: {"Status": ["Done", "Wont do"]}'
         ),
-        sortBy: z10.enum(["sortKey", "updatedAt", "label"]).optional().default("sortKey").describe('Sort order: "sortKey" (default), "updatedAt" (most recent first), or "label" (alphabetical)'),
-        limit: z10.number().optional().default(50).describe("Max results to return (default 50, max 200)")
+        sortBy: z11.enum(["sortKey", "updatedAt", "label"]).optional().default("sortKey").describe('Sort order: "sortKey" (default), "updatedAt" (most recent first), or "label" (alphabetical)'),
+        limit: z11.number().optional().default(50).describe("Max results to return (default 50, max 200)")
       })
     },
     async ({ graphId, nodeTypes, includeAttributes, excludeAttributes, sortBy, limit }) => {
@@ -691,7 +794,7 @@ function registerFilter(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-node.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function registerGetNode(server2, client2) {
   server2.registerTool(
     "naumu_get_node",
@@ -699,9 +802,9 @@ function registerGetNode(server2, client2) {
       title: "Get Node",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Get a single node with all its properties, connections (incoming and outgoing edges with neighbor labels), and tied context: attached notes, conversations (threads), scheduled tasks, and the generated summary when one exists.",
-      inputSchema: z11.object({
-        graphId: z11.string().describe("The graph ID"),
-        nodeId: z11.string().describe("The node ID")
+      inputSchema: z12.object({
+        graphId: z12.string().describe("The graph ID"),
+        nodeId: z12.string().describe("The node ID")
       })
     },
     async ({ graphId, nodeId }) => {
@@ -714,10 +817,10 @@ function registerGetNode(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-node.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // ../mcp-core/src/tools/update-node.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function isValidIsoDate(s) {
   if (typeof s !== "string") return false;
@@ -774,13 +877,13 @@ function registerUpdateNode(server2, client2) {
       title: "Update Node",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: 'Overwrite properties of an existing node; use for simple attribute changes like setting a status, priority, or due date. Only the provided fields will be changed. For content or structural changes, consider `naumu_delegate` instead - it understands the full graph context and can propagate updates to related nodes. Attribute keys AND values must match the schema for the node type; use naumu_get_schema to check valid attribute names, types, and values before updating. Date attributes accept either null (to clear), an ISO date string "YYYY-MM-DD" (single day), or { start: "YYYY-MM-DD", end?: "YYYY-MM-DD" } (inclusive range). Example: { "due_date": { "start": "2026-05-21", "end": "2026-05-23" } } or { "due_date": "2026-05-21" } or { "due_date": null }. Select attributes accept the value label as a string.',
-      inputSchema: z12.object({
-        graphId: z12.string().describe("The graph ID"),
-        nodeId: z12.string().describe("The node ID to update"),
-        label: z12.string().optional().describe("New display name"),
-        type: z12.string().optional().describe("New node type"),
-        content: z12.string().optional().describe("New content / description"),
-        attributes: z12.record(z12.string(), z12.unknown()).optional().describe('Schema-defined attributes to set. Examples: {"Status": "In Progress"}, {"due_date": {"start": "2026-05-21", "end": "2026-05-23"}}, {"due_date": "2026-05-21"}, {"due_date": null}.')
+      inputSchema: z13.object({
+        graphId: z13.string().describe("The graph ID"),
+        nodeId: z13.string().describe("The node ID to update"),
+        label: z13.string().optional().describe("New display name"),
+        type: z13.string().optional().describe("New node type"),
+        content: z13.string().optional().describe("New content / description"),
+        attributes: z13.record(z13.string(), z13.unknown()).optional().describe('Schema-defined attributes to set. Examples: {"Status": "In Progress"}, {"due_date": {"start": "2026-05-21", "end": "2026-05-23"}}, {"due_date": "2026-05-21"}, {"due_date": null}.')
       })
     },
     async ({ graphId, nodeId, label, type, content, attributes }) => {
@@ -892,11 +995,11 @@ function normalizeNodeAttributes(schema, nodeType, attributes) {
   }
   return errors.length > 0 ? { ok: false, errors } : { ok: true, attributes: normalized };
 }
-var NodeInput = z13.object({
-  label: z13.string().describe("Display name of the node"),
-  type: z13.string().describe("Node type from the graph schema"),
-  content: z13.string().min(1).describe("Rich text content / description. REQUIRED - every node must explain what it is."),
-  attributes: z13.record(z13.string(), z13.unknown()).optional().describe(
+var NodeInput = z14.object({
+  label: z14.string().describe("Display name of the node"),
+  type: z14.string().describe("Node type from the graph schema"),
+  content: z14.string().min(1).describe("Rich text content / description. REQUIRED - every node must explain what it is."),
+  attributes: z14.record(z14.string(), z14.unknown()).optional().describe(
     `Schema-defined attributes. Keys are matched case-insensitively against the node type's schema attributes and stored in canonical form; unknown attributes or invalid select values reject the whole batch. Date attributes accept "YYYY-MM-DD" or { start, end? }.`
   )
 });
@@ -907,9 +1010,9 @@ function registerAddNode(server2, client2) {
       title: "Add Nodes (bulk)",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: 'Create 1-25 nodes in the knowledge graph in a single call; use when you have a vetted, dedup-checked batch ready to insert. Keep batches small and atomic (5-25 nodes) so failures stay contained. Each node MUST include a non-empty `content` describing what it is. Returns one entry per input node with `{id, label, type, status: "created"}` - there is NO server-side dedup, every input becomes a node. Dedup is the caller\'s responsibility: BEFORE calling this tool, run `naumu_search` on each candidate label and treat a result as the same entity when its `matchedVia` is "semantic" or "both" AND its type matches AND the labels plausibly name the same thing - then reuse/update that node instead of creating one. (The `score` field is a rank-fusion value, not a similarity - do not compare it against a threshold.) Warning: nodes are isolated until you connect them with `naumu_add_edge`. Prefer `naumu_delegate` for general knowledge intake - it discovers and creates connections for you.',
-      inputSchema: z13.object({
-        graphId: z13.string().describe("The graph ID"),
-        nodes: z13.array(NodeInput).min(1).max(25).describe("Batch of 1\u201325 nodes to create. Keep batches small for atomicity.")
+      inputSchema: z14.object({
+        graphId: z14.string().describe("The graph ID"),
+        nodes: z14.array(NodeInput).min(1).max(25).describe("Batch of 1\u201325 nodes to create. Keep batches small for atomicity.")
       })
     },
     async ({ graphId, nodes }) => {
@@ -954,12 +1057,12 @@ Use naumu_get_schema to check valid attribute names, types, and values.`
 }
 
 // ../mcp-core/src/tools/add-edge.ts
-import { z as z14 } from "zod";
-var EdgeInput = z14.object({
-  source: z14.string().describe("Source node ID"),
-  target: z14.string().describe("Target node ID"),
-  label: z14.string().describe("Relationship type (e.g. RELATES_TO, SOLVES, TRACKS)"),
-  isParent: z14.boolean().optional().describe("Whether this is a parent relationship")
+import { z as z15 } from "zod";
+var EdgeInput = z15.object({
+  source: z15.string().describe("Source node ID"),
+  target: z15.string().describe("Target node ID"),
+  label: z15.string().describe("Relationship type (e.g. RELATES_TO, SOLVES, TRACKS)"),
+  isParent: z15.boolean().optional().describe("Whether this is a parent relationship")
 });
 function registerAddEdge(server2, client2) {
   server2.registerTool(
@@ -968,9 +1071,9 @@ function registerAddEdge(server2, client2) {
       title: "Add Edges (bulk)",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Create 1-25 relationships (edges) between existing nodes in a single call; use after a bulk node insert to wire nodes together. Keep batches small and atomic (5-25 edges) so failures stay contained. Typical workflow: create nodes with `naumu_add_node`, then wire them up with batched `naumu_add_edge` calls. Direction matters and must match the schema: each edge's `(source.type, label, target.type)` tuple should appear in the schema's `connections` or `parent` for the source type. When the backend runs with `STRICT_EDGE_VALIDATION=true`, invalid tuples are rejected immediately with `error: invalid_edge` (the response includes `details.allowed_targets_for_relation` and a `hint` for routing the call); otherwise the edge persists and surfaces later as an `invalid_connection_target` / `parent_mismatch` violation. Either way, check `naumu_get_schema` and flip or drop offending edges before calling. Prefer `naumu_delegate` when you want the agent to discover the right connections itself.",
-      inputSchema: z14.object({
-        graphId: z14.string().describe("The graph ID"),
-        edges: z14.array(EdgeInput).min(1).max(25).describe("Batch of 1\u201325 edges to create. Keep batches small for atomicity.")
+      inputSchema: z15.object({
+        graphId: z15.string().describe("The graph ID"),
+        edges: z15.array(EdgeInput).min(1).max(25).describe("Batch of 1\u201325 edges to create. Keep batches small for atomicity.")
       })
     },
     async ({ graphId, edges }) => {
@@ -989,7 +1092,7 @@ function registerAddEdge(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-node.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function registerRemoveNode(server2, client2) {
   server2.registerTool(
     "naumu_remove_node",
@@ -997,9 +1100,9 @@ function registerRemoveNode(server2, client2) {
       title: "Remove Node",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Delete a node and all its connections from the knowledge graph; use only when you need precise, surgical deletion. This is destructive. Prefer `naumu_delegate` for removing knowledge - it understands the impact on the broader graph and can handle cascading changes.",
-      inputSchema: z15.object({
-        graphId: z15.string().describe("The graph ID"),
-        nodeId: z15.string().describe("The node ID to delete")
+      inputSchema: z16.object({
+        graphId: z16.string().describe("The graph ID"),
+        nodeId: z16.string().describe("The node ID to delete")
       })
     },
     async ({ graphId, nodeId }) => {
@@ -1012,7 +1115,7 @@ function registerRemoveNode(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-edge.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function registerRemoveEdge(server2, client2) {
   server2.registerTool(
     "naumu_remove_edge",
@@ -1020,11 +1123,11 @@ function registerRemoveEdge(server2, client2) {
       title: "Remove Edge",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Delete a single edge identified by `(source, target, label)` tuple; use to correct a wrong-target edge mistake (a recovery tool, not a routine one). Does NOT delete the endpoint nodes - only the edge between them. System edges (HAS_NODE, HAS_THREAD, OWNS, etc.) are rejected with `error: system_edge_not_removable`. Parent edges (`isParent: true`) are removable but the response includes a warning that the child may now be orphaned - call `naumu_reparent` first if you want connectivity preserved. Response: `{deleted: 0 | 1, warnings: string[]}`. Prefer `naumu_delegate` when the structural intent is broader than removing one specific edge - it can reason about the surrounding graph.",
-      inputSchema: z16.object({
-        graphId: z16.string().describe("The graph ID"),
-        source: z16.string().describe("Source node id of the edge to delete"),
-        target: z16.string().describe("Target node id of the edge to delete"),
-        label: z16.string().describe('Relation label of the edge to delete (e.g. "AUTHORED"). Case-insensitive; non-alphanum chars are normalized.')
+      inputSchema: z17.object({
+        graphId: z17.string().describe("The graph ID"),
+        source: z17.string().describe("Source node id of the edge to delete"),
+        target: z17.string().describe("Target node id of the edge to delete"),
+        label: z17.string().describe('Relation label of the edge to delete (e.g. "AUTHORED"). Case-insensitive; non-alphanum chars are normalized.')
       })
     },
     async ({ graphId, source, target, label }) => {
@@ -1041,11 +1144,11 @@ function registerRemoveEdge(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-edges-bulk.ts
-import { z as z17 } from "zod";
-var EdgeRef = z17.object({
-  source: z17.string().describe("Source node ID"),
-  target: z17.string().describe("Target node ID"),
-  label: z17.string().describe("Relation label of the edge to delete")
+import { z as z18 } from "zod";
+var EdgeRef = z18.object({
+  source: z18.string().describe("Source node ID"),
+  target: z18.string().describe("Target node ID"),
+  label: z18.string().describe("Relation label of the edge to delete")
 });
 function registerRemoveEdgesBulk(server2, client2) {
   server2.registerTool(
@@ -1054,9 +1157,9 @@ function registerRemoveEdgesBulk(server2, client2) {
       title: "Remove Edges (bulk)",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Delete 1-100 edges in a single atomic call (all-or-none); use to fix multiple wrong-target edge mistakes in one shot. Does NOT delete endpoint nodes. System edges (HAS_NODE, HAS_THREAD, OWNS, etc.) are rejected - if any edge in the batch targets a system relation, the WHOLE batch is rejected with `error: system_edge_not_removable`. Parent edges (`isParent: true`) are removable but each parent removal contributes a warning to the response (`{deleted, warnings: string[]}`) - call `naumu_reparent` first if you want connectivity preserved. Prefer `naumu_delegate` for broader structural cleanup that needs graph-wide reasoning.",
-      inputSchema: z17.object({
-        graphId: z17.string().describe("The graph ID"),
-        edges: z17.array(EdgeRef).min(1).max(100).describe("1-100 edges to delete. Atomic per call - all succeed or none do.")
+      inputSchema: z18.object({
+        graphId: z18.string().describe("The graph ID"),
+        edges: z18.array(EdgeRef).min(1).max(100).describe("1-100 edges to delete. Atomic per call - all succeed or none do.")
       })
     },
     async ({ graphId, edges }) => {
@@ -1069,7 +1172,7 @@ function registerRemoveEdgesBulk(server2, client2) {
 }
 
 // ../mcp-core/src/tools/ask.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 function registerAsk(server2, client2) {
   server2.registerTool(
     "naumu_ask",
@@ -1085,10 +1188,10 @@ function registerAsk(server2, client2) {
         openWorldHint: true
       },
       description: 'Ask @Naumu a question about a space and get back a synthesised, node-grounded answer with the exact source node ids it used and a confidence hint. This is THE tool for any question about a space - what is in it, what is new or recently changed, how something works, or a summary of any topic. @Naumu has full read access and has already inspected the graph for you, so its answer is authoritative: present it and its cited sources directly. Do NOT independently re-read the graph (naumu_get_schema, naumu_filter, naumu_get_node, fetch) to verify or flesh out the answer - that repeats work @Naumu already did and is far slower. Reach for a granular read ONLY to pull a specific node the answer pointed to but did not fully include. Returns { answer, sources, confidence, threadId, status }; the answer is saved as a visible conversation in the space, which is expected and useful, so do not avoid the tool to prevent creating a thread. On a very long synthesis it may return status "processing" with a threadId - in that case wait a few seconds and call naumu_read_thread with that threadId for the final answer, and still do not fall back to manual digging. To hand @Naumu work to carry out (add knowledge, make changes, record status) without waiting, use naumu_delegate instead.',
-      inputSchema: z18.object({
-        graphId: z18.string().describe("The space (graph) id to ask about."),
-        question: z18.string().max(4e3).describe("The question for @Naumu. Up to 4000 characters."),
-        topicIds: z18.array(z18.string()).max(8).optional().describe(
+      inputSchema: z19.object({
+        graphId: z19.string().describe("The space (graph) id to ask about."),
+        question: z19.string().max(4e3).describe("The question for @Naumu. Up to 4000 characters."),
+        topicIds: z19.array(z19.string()).max(8).optional().describe(
           "Topic ids (from naumu_list_topics) to file the resulting conversation into, making it visible to those topics' members from birth. Omit to keep the default behavior (the ask lands in the virtual #misc bucket)."
         )
       })
@@ -1114,7 +1217,7 @@ function registerAsk(server2, client2) {
 }
 
 // ../mcp-core/src/tools/delegate.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 function registerDelegate(server2, client2) {
   server2.registerTool(
     "naumu_delegate",
@@ -1130,11 +1233,11 @@ function registerDelegate(server2, client2) {
         openWorldHint: true
       },
       description: 'Hand @Naumu a task to carry out asynchronously: add knowledge, make graph-aware changes, or record a status update (e.g. "mark task X done", "log this deployment"). Returns immediately with a threadId; @Naumu works in the background and may take seconds to minutes. For status reports you can fire and forget. To read what @Naumu did, poll naumu_read_thread with the returned threadId. When you instead need an answer synchronously, use naumu_ask. File the new thread into topics by passing `topicIds` (see naumu_list_topics): omitting them keeps the default private thread, providing them makes it visible to those topics\' members from birth. This always invokes @Naumu, even in threads where auto-response is paused, so the task text must never contain a literal "@Naumu" mention (plain text never renders or triggers a mention).',
-      inputSchema: z19.object({
-        graphId: z19.string().describe("The space (graph) id to act in."),
-        task: z19.string().describe("What you want @Naumu to do, add, or record."),
-        threadId: z19.string().optional().describe("Continue an existing conversation; omit to start a new one."),
-        topicIds: z19.array(z19.string()).max(8).optional().describe(
+      inputSchema: z20.object({
+        graphId: z20.string().describe("The space (graph) id to act in."),
+        task: z20.string().describe("What you want @Naumu to do, add, or record."),
+        threadId: z20.string().optional().describe("Continue an existing conversation; omit to start a new one."),
+        topicIds: z20.array(z20.string()).max(8).optional().describe(
           "Topic ids (from naumu_list_topics) to file a NEW thread into, making it visible to those topics' members. Only used at creation; never adds topics to an existing thread, so it is ignored when threadId is provided. Omit to keep the default private thread."
         )
       })
@@ -1178,7 +1281,7 @@ function registerDelegate(server2, client2) {
 }
 
 // ../mcp-core/src/tools/post-message.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 function registerPostMessage(server2, client2) {
   server2.registerTool(
     "naumu_post_message",
@@ -1193,12 +1296,12 @@ function registerPostMessage(server2, client2) {
         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). 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.'),
-        contentFormat: z20.enum(["tiptap", "markdown"]).optional().describe('Format of `content`. Defaults to "markdown" (rendered subset plus `@[Name](id)` / `#[label](topic-id)` mention pills). Use "tiptap" for full rich content, e.g. a doc containing `{ type: "mention", attrs: { id: userIdOrEmailOrIdentityId, label: displayName } }`.'),
-        attachmentIds: z20.array(z20.string().min(1)).max(25).optional().describe("Attachment IDs from prior `naumu_request_attachment_upload` calls. Each must be a successfully-uploaded pending attachment in this graph (1-hour TTL). Up to 25 per message."),
-        invokeAgent: z20.boolean().optional().describe("Set true to summon @Naumu on this message unconditionally (mention-equivalent), even in threads where auto-response is paused. Required whenever the post must be committed to the graph (work-log entries, status updates). @Naumu processes in the background; poll naumu_read_thread. Defaults to false: plain append, no agent turn.")
+      inputSchema: z21.object({
+        threadId: z21.string().describe("The thread ID to post into. You must be a participant in this thread."),
+        content: z21.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.'),
+        contentFormat: z21.enum(["tiptap", "markdown"]).optional().describe('Format of `content`. Defaults to "markdown" (rendered subset plus `@[Name](id)` / `#[label](topic-id)` mention pills). Use "tiptap" for full rich content, e.g. a doc containing `{ type: "mention", attrs: { id: userIdOrEmailOrIdentityId, label: displayName } }`.'),
+        attachmentIds: z21.array(z21.string().min(1)).max(25).optional().describe("Attachment IDs from prior `naumu_request_attachment_upload` calls. Each must be a successfully-uploaded pending attachment in this graph (1-hour TTL). Up to 25 per message."),
+        invokeAgent: z21.boolean().optional().describe("Set true to summon @Naumu on this message unconditionally (mention-equivalent), even in threads where auto-response is paused. Required whenever the post must be committed to the graph (work-log entries, status updates). @Naumu processes in the background; poll naumu_read_thread. Defaults to false: plain append, no agent turn.")
       })
     },
     async ({ threadId, content, contentFormat, attachmentIds, invokeAgent }) => {
@@ -1230,7 +1333,7 @@ function registerPostMessage(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-participants.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 function registerAddParticipants(server2, client2) {
   server2.registerTool(
     "naumu_add_participants",
@@ -1238,10 +1341,10 @@ function registerAddParticipants(server2, client2) {
       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.")
+      inputSchema: z22.object({
+        threadId: z22.string().describe("The thread ID to add participants to. You must be able to manage this thread."),
+        userIds: z22.array(z22.string()).min(1).max(25).describe("User ids (UUIDs) of space members to add, from naumu_list_members or naumu_get_thread."),
+        role: z22.enum(["editor", "viewer"]).optional().describe("Thread role for the added participants. Defaults to editor (can post); viewer is read-only.")
       })
     },
     async ({ threadId, userIds, role }) => {
@@ -1270,7 +1373,7 @@ function registerAddParticipants(server2, client2) {
 }
 
 // ../mcp-core/src/tools/read-thread.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 function registerReadThread(server2, client2) {
   server2.registerTool(
     "naumu_read_thread",
@@ -1278,12 +1381,12 @@ function registerReadThread(server2, client2) {
       title: "Read Thread",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Read messages from a Naumu thread. Returns paginated history ordered newest-first, or oldest-first when you pass `after`; each message carries a `status` (`processing` while @Naumu is still composing, `complete` when done). Use this to pick up an answer after naumu_ask returns status "processing", or to read what naumu_delegate produced. Use `before` (timestamp ms) to page further back, or `after` (timestamp ms) to catch up on what arrived since you last looked. To wait for the next message instead of re-reading on a timer, use naumu_wait_for_activity. Default page size 50, max 200. 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.")
+      inputSchema: z23.object({
+        threadId: z23.string().describe("The thread ID to read from."),
+        before: z23.number().optional().describe("Unix timestamp in milliseconds. Returns messages strictly older than this. Omit for the newest page."),
+        after: z23.number().optional().describe("Unix timestamp in milliseconds. Returns only messages newer than this, oldest-first. Mutually exclusive with `before`."),
+        afterId: z23.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: z23.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ threadId, before, after, afterId, limit }) => {
@@ -1311,7 +1414,7 @@ function registerReadThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/wait-for-activity.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 function registerWaitForActivity(server2, client2) {
   server2.registerTool(
     "naumu_wait_for_activity",
@@ -1321,16 +1424,16 @@ function registerWaitForActivity(server2, client2) {
       // 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(
+      inputSchema: z24.object({
+        threadId: z24.string().describe("The thread ID to wait on. You must be a participant."),
+        after: z24.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(
+        afterId: z24.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(
+        timeoutSec: z24.number().int().min(1).max(25).default(20).describe("Seconds to block before returning empty, 1 to 25, default 20."),
+        excludeSelf: z24.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.'
         )
       })
@@ -1359,7 +1462,7 @@ function registerWaitForActivity(server2, client2) {
 }
 
 // ../mcp-core/src/tools/whoami.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 function registerWhoami(server2, client2) {
   server2.registerTool(
     "naumu_whoami",
@@ -1367,7 +1470,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: z24.object({})
+      inputSchema: z25.object({})
     },
     async () => {
       try {
@@ -1387,7 +1490,7 @@ function registerWhoami(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-threads.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 function sanitizeThreadParticipants(thread) {
   if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
     return thread;
@@ -1402,11 +1505,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: 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.")
+      inputSchema: z26.object({
+        graphId: z26.string().optional().describe("Graph (space) ID. Required for user API keys; omit for bot identity keys (defaults to your own graph)."),
+        nodeId: z26.string().optional().describe("Scope the listing to conversations tied to this node. Requires `graphId`."),
+        cursor: z26.number().int().optional().describe("Unix timestamp ms \u2014 returns threads with `lastActivityAt` strictly older than this. Omit for the newest page."),
+        limit: z26.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ graphId, nodeId, cursor, limit }) => {
@@ -1457,7 +1560,7 @@ function registerListThreads(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-topics.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 function toFilingDestination(topic) {
   if (!topic || typeof topic !== "object") return null;
   const t = topic;
@@ -1478,8 +1581,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: z26.object({
-        graphId: z26.string().describe("The space (graph) id to list topics for.")
+      inputSchema: z27.object({
+        graphId: z27.string().describe("The space (graph) id to list topics for.")
       })
     },
     async ({ graphId }) => {
@@ -1502,7 +1605,7 @@ function registerListTopics(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-topic.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var TOPIC_NAME_PATTERN = /^[a-z0-9-]+$/;
 var TOPIC_NAME_MAX_LENGTH = 50;
 var RESERVED_TOPIC_NAMES = [
@@ -1536,18 +1639,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: z27.object({
-        graphId: z27.string().describe("The space (graph) id to create the topic in."),
-        name: z27.string().min(1).describe(
+      inputSchema: z28.object({
+        graphId: z28.string().describe("The space (graph) id to create the topic in."),
+        name: z28.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: 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(
+        color: z28.string().optional().describe("Optional named color token for the topic badge. Omit unless the user asked for a specific color."),
+        visibilityMode: z28.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: 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(
+        openToWeb: z28.boolean().optional().describe('Expose the topic publicly on the web. Invalid together with visibilityMode "closed".'),
+        webParticipation: z28.enum(["participate", "view-only"]).optional().describe('What public web visitors may do when openToWeb is true. Defaults to "view-only".'),
+        memberIds: z28.array(z28.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."
         )
       })
@@ -1600,7 +1703,7 @@ function registerCreateTopic(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-thread.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 function sanitizeThreadParticipants2(thread) {
   if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
     return thread;
@@ -1615,8 +1718,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: z28.object({
-        threadId: z28.string().describe("The thread ID to fetch.")
+      inputSchema: z29.object({
+        threadId: z29.string().describe("The thread ID to fetch.")
       })
     },
     async ({ threadId }) => {
@@ -1638,7 +1741,7 @@ function registerGetThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-thread.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 function registerCreateThread(server2, client2) {
   server2.registerTool(
     "naumu_create_thread",
@@ -1653,23 +1756,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: 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.")
+      inputSchema: z30.object({
+        title: z30.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: z30.array(
+          z30.discriminatedUnion("type", [
+            z30.object({
+              type: z30.literal("user"),
+              userId: z30.string().min(1).describe("User UUID \u2014 get these from `naumu_get_thread`/`naumu_read_thread` participant rosters or webhook payloads.")
             }),
-            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.")
+            z30.object({
+              type: z30.literal("identity"),
+              identityId: z30.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: 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(
+        initialMessage: z30.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: z30.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: z30.array(z30.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."
         )
       })
@@ -1698,7 +1801,7 @@ function registerCreateThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/request-attachment-upload.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 function registerRequestAttachmentUpload(server2, client2) {
   server2.registerTool(
     "naumu_request_attachment_upload",
@@ -1706,15 +1809,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: 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.")
+      inputSchema: z31.object({
+        graphId: z31.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: z31.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: z31.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: z31.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: z31.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: z31.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: z31.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: z31.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." }
@@ -1762,7 +1865,7 @@ function registerRequestAttachmentUpload(server2, client2) {
 }
 
 // ../mcp-core/src/tools/persist-canvas-attachment.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 function registerPersistCanvasAttachment(server2, client2) {
   server2.registerTool(
     "naumu_persist_canvas_attachment",
@@ -1770,8 +1873,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: z31.object({
-        attachmentId: z31.string().min(1).describe("The `attachmentId` returned by `naumu_request_attachment_upload` for this canvas.")
+      inputSchema: z32.object({
+        attachmentId: z32.string().min(1).describe("The `attachmentId` returned by `naumu_request_attachment_upload` for this canvas.")
       })
     },
     async ({ attachmentId }) => {
@@ -1792,7 +1895,7 @@ function registerPersistCanvasAttachment(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-attachment.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var DOWNLOAD_URL_TTL_SECONDS = 900;
 var MAX_INLINE_PREVIEW_BYTES = 4 * 1024 * 1024;
 function normalizeAttachmentId(input) {
@@ -1813,8 +1916,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: 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.")
+      inputSchema: z33.object({
+        attachmentId: z33.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 }) => {
@@ -1864,7 +1967,7 @@ function registerGetAttachment(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-reaction.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 function registerAddReaction(server2, client2) {
   server2.registerTool(
     "naumu_add_reaction",
@@ -1872,10 +1975,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: 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.')
+      inputSchema: z34.object({
+        threadId: z34.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z34.string().describe("The message to react to."),
+        emoji: z34.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 }) => {
@@ -1899,7 +2002,7 @@ function registerAddReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-reaction.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 function registerRemoveReaction(server2, client2) {
   server2.registerTool(
     "naumu_remove_reaction",
@@ -1907,10 +2010,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: 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).")
+      inputSchema: z35.object({
+        threadId: z35.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z35.string().describe("The message to remove your reaction from."),
+        emoji: z35.string().min(1).describe("Emoji character to remove (must match what you originally reacted with).")
       })
     },
     async ({ threadId, messageId, emoji }) => {
@@ -1934,7 +2037,7 @@ function registerRemoveReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/naumu-typing.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 function registerNaumuTyping(server2, client2) {
   server2.registerTool(
     "naumu_typing",
@@ -1945,9 +2048,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: 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.')
+      inputSchema: z36.object({
+        threadId: z36.string().describe("The thread ID to set typing in. You must be a participant."),
+        state: z36.enum(["start", "stop"]).describe('"start" acquires/renews the lease; "stop" ends it and clears the pill immediately.')
       })
     },
     async ({ threadId, state }) => {
@@ -1968,7 +2071,7 @@ function registerNaumuTyping(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-read.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 function registerNoteRead(server2, client2) {
   server2.registerTool(
     "naumu_note_read",
@@ -1976,8 +2079,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: z36.object({
-        noteId: z36.string().describe("The note (Thought) ID")
+      inputSchema: z37.object({
+        noteId: z37.string().describe("The note (Thought) ID")
       })
     },
     async ({ noteId }) => {
@@ -1990,7 +2093,7 @@ function registerNoteRead(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-append.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 function registerNoteAppend(server2, client2) {
   server2.registerTool(
     "naumu_note_append",
@@ -1998,9 +2101,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: 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")
+      inputSchema: z38.object({
+        noteId: z38.string().describe("The note (Thought) ID to append to"),
+        markdown: z38.string().min(1).describe("Markdown content to append at the end of the note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -2013,7 +2116,7 @@ function registerNoteAppend(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-insert.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 function registerNoteInsert(server2, client2) {
   server2.registerTool(
     "naumu_note_insert",
@@ -2021,10 +2124,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: 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")
+      inputSchema: z39.object({
+        noteId: z39.string().describe("The note (Thought) ID"),
+        headingText: z39.string().min(1).describe("Exact text of the heading whose section the new content follows"),
+        markdown: z39.string().min(1).describe("Markdown content to insert at the end of that section")
       })
     },
     async ({ noteId, headingText, markdown }) => {
@@ -2040,7 +2143,7 @@ function registerNoteInsert(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace-section.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function registerNoteReplaceSection(server2, client2) {
   server2.registerTool(
     "naumu_note_replace_section",
@@ -2048,11 +2151,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: 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.")
+      inputSchema: z40.object({
+        noteId: z40.string().describe("The note (Thought) ID"),
+        headingText: z40.string().min(1).describe("Exact text of the heading anchoring the section"),
+        markdown: z40.string().describe("Replacement markdown for the section body"),
+        keepHeading: z40.boolean().optional().describe("Whether to keep the heading row itself. Default true.")
       })
     },
     async ({ noteId, headingText, markdown, keepHeading }) => {
@@ -2069,7 +2172,7 @@ function registerNoteReplaceSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-delete-section.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 function registerNoteDeleteSection(server2, client2) {
   server2.registerTool(
     "naumu_note_delete_section",
@@ -2077,9 +2180,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: 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")
+      inputSchema: z41.object({
+        noteId: z41.string().describe("The note (Thought) ID"),
+        headingText: z41.string().min(1).describe("Exact text of the heading whose section will be deleted")
       })
     },
     async ({ noteId, headingText }) => {
@@ -2094,7 +2197,7 @@ function registerNoteDeleteSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 function registerNoteReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_replace",
@@ -2102,9 +2205,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: z41.object({
-        noteId: z41.string().describe("The note (Thought) ID"),
-        markdown: z41.string().describe("New markdown content for the entire note")
+      inputSchema: z42.object({
+        noteId: z42.string().describe("The note (Thought) ID"),
+        markdown: z42.string().describe("New markdown content for the entire note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -2117,7 +2220,7 @@ function registerNoteReplace(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-find-replace.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 function registerNoteFindReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_find_replace",
@@ -2125,11 +2228,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: 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.")
+      inputSchema: z43.object({
+        noteId: z43.string().describe("The note (Thought) ID"),
+        find: z43.string().min(1).describe("Substring to search for. Literal - no regex."),
+        replace: z43.string().describe("Replacement string. May be empty to delete the match."),
+        all: z43.boolean().optional().describe("Replace all occurrences (default true). Pass false to replace only the first.")
       })
     },
     async ({ noteId, find, replace, all }) => {
@@ -2146,18 +2249,18 @@ function registerNoteFindReplace(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-batch.ts
-import { z as z43 } from "zod";
+import { z as z44 } 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(
+var opSchema = z44.object({
+  op: z44.enum(["append", "insertAfter", "replaceSection", "deleteSection", "replace", "findReplace"]).describe("Which edit to perform."),
+  markdown: z44.string().optional().describe("Markdown payload. Required for append, insertAfter, replaceSection, replace."),
+  heading: z44.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).")
+  keepHeading: z44.boolean().optional().describe("replaceSection only: keep the heading row and replace just its body (default true)."),
+  find: z44.string().optional().describe("findReplace only: literal substring to search for."),
+  replace: z44.string().optional().describe("findReplace only: replacement string. May be empty to delete the match."),
+  all: z44.boolean().optional().describe("findReplace only: replace every occurrence (default true).")
 }).describe("One edit in the batch.");
 function registerNoteBatch(server2, client2) {
   server2.registerTool(
@@ -2166,9 +2269,9 @@ function registerNoteBatch(server2, client2) {
       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}.`)
+      inputSchema: z44.object({
+        noteId: z44.string().describe("The note (Thought) ID to edit"),
+        ops: z44.array(opSchema).min(1).max(MAX_BATCH_OPS).describe(`Edits to apply, in order. Max ${MAX_BATCH_OPS}.`)
       })
     },
     async ({ noteId, ops }) => {
@@ -2181,7 +2284,7 @@ function registerNoteBatch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-note.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 function registerCreateNote(server2, client2) {
   server2.registerTool(
     "naumu_create_note",
@@ -2189,12 +2292,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: 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.")
+      inputSchema: z45.object({
+        graphId: z45.string().describe("The graph ID to create the note in"),
+        title: z45.string().optional().describe("Optional title for the note"),
+        markdown: z45.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: z45.boolean().optional().describe("Share the note with everyone in the space. Omit (or false) to keep it private to its participants."),
+        topicIds: z45.array(z45.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 }) => {
@@ -2207,7 +2310,7 @@ function registerCreateNote(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-schema-violations.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 var DEFAULT_EXAMPLE_LIMIT = 5;
 var rowsForKind = (violations, kind) => {
   const rows = [];
@@ -2233,12 +2336,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: z45.object({
-        graphId: z45.string().describe("The graph ID"),
-        kind: z45.string().optional().describe(
+      inputSchema: z46.object({
+        graphId: z46.string().describe("The graph ID"),
+        kind: z46.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: z45.number().int().min(1).optional().describe(
+        limit: z46.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)."
         )
       })
@@ -2290,7 +2393,7 @@ function registerListSchemaViolations(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-dense-nodes.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 function registerListDenseNodes(server2, client2) {
   server2.registerTool(
     "naumu_list_dense_nodes",
@@ -2298,10 +2401,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: 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.")
+      inputSchema: z47.object({
+        graphId: z47.string().describe("The graph ID"),
+        minConnections: z47.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: z47.array(z47.string()).optional().describe("Optional list of node types to restrict the scan to.")
       })
     },
     async ({ graphId, minConnections, nodeTypes }) => {
@@ -2319,7 +2422,7 @@ function registerListDenseNodes(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-node-connections.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 function registerListNodeConnections(server2, client2) {
   server2.registerTool(
     "naumu_list_node_connections",
@@ -2327,11 +2430,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: 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).')
+      inputSchema: z48.object({
+        graphId: z48.string().describe("The graph ID"),
+        nodeId: z48.string().describe("The node ID to inspect"),
+        edgeType: z48.string().optional().describe('Restrict to a specific relation label (e.g. "ASSOCIATED_WITH"). Case-insensitive; non-alphanum chars are normalized.'),
+        direction: z48.enum(["in", "out", "both"]).optional().describe('Edge direction filter - "in" (incoming), "out" (outgoing), "both" (default).')
       })
     },
     async ({ graphId, nodeId, edgeType, direction }) => {
@@ -2349,7 +2452,7 @@ function registerListNodeConnections(server2, client2) {
 }
 
 // ../mcp-core/src/tools/reparent.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 function registerReparent(server2, client2) {
   server2.registerTool(
     "naumu_reparent",
@@ -2357,11 +2460,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: 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).')
+      inputSchema: z49.object({
+        graphId: z49.string().describe("The graph ID"),
+        nodeId: z49.string().describe("The child node to reparent"),
+        newParentId: z49.string().describe("The new parent node id"),
+        newRelation: z49.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 }) => {
@@ -2377,7 +2480,7 @@ function registerReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/batch-reparent.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 function registerBatchReparent(server2, client2) {
   server2.registerTool(
     "naumu_batch_reparent",
@@ -2385,11 +2488,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: 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`")
+      inputSchema: z50.object({
+        graphId: z50.string().describe("The graph ID"),
+        newParentId: z50.string().describe("Parent node id every nodeId in the batch will be parented to"),
+        newRelation: z50.string().describe("Parent edge relation label (must be valid per schema for child.type \u2192 parent.type)"),
+        nodeIds: z50.array(z50.string()).min(1).max(25).describe("1\u201325 child node ids to reparent under `newParentId`")
       })
     },
     async ({ graphId, newParentId, newRelation, nodeIds }) => {
@@ -2406,7 +2509,7 @@ function registerBatchReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-search.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 
 // ../mcp-core/src/public-origin.ts
 function publicOrigin() {
@@ -2460,8 +2563,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: z50.object({
-        query: z50.string().describe(
+      inputSchema: z51.object({
+        query: z51.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."
         )
       })
@@ -2495,7 +2598,7 @@ function registerChatgptSearch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-fetch.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 var NON_ATTRIBUTE_PROPS = /* @__PURE__ */ new Set([
   "id",
   "label",
@@ -2589,8 +2692,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: z51.object({
-        id: z51.string().describe("A resource id from a previous `search` result, in the form `<graphId>:<nodeId>`.")
+      inputSchema: z52.object({
+        id: z52.string().describe("A resource id from a previous `search` result, in the form `<graphId>:<nodeId>`.")
       })
     },
     async ({ id }) => {
@@ -2633,7 +2736,7 @@ function registerChatgptFetch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/admission-status.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 function registerAdmissionStatus(server2, client2) {
   server2.registerTool(
     "naumu_admission_status",
@@ -2641,8 +2744,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: z52.object({
-        graphId: z52.string().describe("The space (graph) ID to inspect admission for. You must be a member of this space.")
+      inputSchema: z53.object({
+        graphId: z53.string().describe("The space (graph) ID to inspect admission for. You must be a member of this space.")
       })
     },
     async ({ graphId }) => {
@@ -2672,7 +2775,7 @@ function registerAdmissionStatus(server2, client2) {
 }
 
 // ../mcp-core/src/tools/whitelist-members.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 function registerWhitelistMembers(server2, client2) {
   server2.registerTool(
     "naumu_whitelist_members",
@@ -2685,10 +2788,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: 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.")
+      inputSchema: z54.object({
+        graphId: z54.string().describe("The space (graph) ID to whitelist emails for. You must be a member of this space."),
+        emails: z54.array(z54.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: z54.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 }) => {
@@ -2712,7 +2815,7 @@ function registerWhitelistMembers(server2, client2) {
 }
 
 // ../mcp-core/src/tools/resolve-admission.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 function registerResolveAdmission(server2, client2) {
   server2.registerTool(
     "naumu_resolve_admission",
@@ -2725,9 +2828,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: 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.")
+      inputSchema: z55.object({
+        graphId: z55.string().describe("The space (graph) ID referenced by the repo .naumu file that the user wants to join."),
+        gitEmailHint: z55.string().optional().describe("The email from `git config user.email`, used to match whitelist entries and auto-join domains.")
       })
     },
     async ({ graphId, gitEmailHint }) => {
@@ -2751,7 +2854,7 @@ function registerResolveAdmission(server2, client2) {
 }
 
 // ../mcp-core/src/tools/resolve-join-request.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 function registerResolveJoinRequest(server2, client2) {
   server2.registerTool(
     "naumu_resolve_join_request",
@@ -2764,10 +2867,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: 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.")
+      inputSchema: z56.object({
+        graphId: z56.string().describe("The space (graph) ID the request is for. You must be a member of this space."),
+        requestId: z56.string().describe("The pending join request ID, taken from naumu_admission_status."),
+        action: z56.enum(["approve", "deny"]).describe("approve adds the requester as a member; deny rejects the request.")
       })
     },
     async ({ graphId, requestId, action }) => {
@@ -2823,6 +2926,7 @@ var TOOL_REGISTRARS = {
   naumu_add_node_type: registerAddNodeType,
   naumu_add_connection: registerAddConnection,
   naumu_add_attribute: registerAddAttribute,
+  naumu_update_schema_description: registerUpdateSchemaDescription,
   naumu_search: registerSearch,
   naumu_filter: registerFilter,
   naumu_get_node: registerGetNode,