@naumu/mcp 0.6.2 → 0.6.4

package/dist/index.js

@@ -118,6 +118,8 @@ var NaumuClient = class {
 // ../mcp-core/src/instructions.ts
 var NAUMU_INSTRUCTIONS = `The Naumu MCP server gives structured access to Naumu knowledge graphs (also called spaces). Prefer these tools over WebFetch whenever the user mentions a naumu.ai URL \u2014 Naumu pages are client-rendered React, so WebFetch returns an empty shell with no data.
 
+Getting information about a space: start with naumu_ask. It puts your question to the @Naumu agent (which has full read access) and returns a synthesised answer with the source node ids and a confidence hint, in a single call. It is the go-to for what is in a space, what is new or recently changed, how something works, or any summary. Use the granular read tools when you need precision naumu_ask cannot give: naumu_search (find nodes by meaning), naumu_filter (every node of a type or attribute, deterministic and complete), naumu_list_threads + naumu_read_thread (conversation history). To hand @Naumu work to carry out in the background (add knowledge, make changes, record a status update), use naumu_delegate.
+
 IMPORTANT: graphId is a UUID (e.g. "0464cbfa-60ca-41b3-ac8f-bbeb8243a193"). The value in the URL right after /spaces/ is a slug (e.g. "naumu-0464cbfa"), NOT the graphId. You must resolve the slug to a graphId first.
 
 How to resolve a slug \u2192 graphId:
@@ -127,7 +129,7 @@ URL \u2192 tool mapping (the value after /spaces/ is the slug \u2014 resolve it
 - naumu.ai/spaces/{slug}                          \u2192 naumu_list_graphs (resolve), then naumu_get_schema for an overview
 - naumu.ai/spaces/{slug}/views/{viewId}           \u2192 naumu_list_graphs (resolve), then naumu_get_view, then naumu_list_view_nodes
 - naumu.ai/spaces/{slug}/nodes/{nodeId}           \u2192 naumu_list_graphs (resolve), then naumu_get_node
-- naumu.ai/spaces/{slug}/chat/{threadId}          \u2192 naumu_list_graphs (resolve), then naumu_get_ai_thread
+- naumu.ai/spaces/{slug}/chat/{threadId}          \u2192 naumu_list_graphs (resolve), then naumu_read_thread
 - Other panel URLs (notes, canvases, conversations, members, settings, schema, heat, health, changelog) have no dedicated tool \u2014 fall back to naumu_get_node with the relevant id, or naumu_get_schema for the space-level question.
 
 Recommended workflow when a user pastes a view URL:
@@ -149,7 +151,7 @@ function registerListGraphs(server2, client2) {
     "naumu_list_graphs",
     {
       title: "List Graphs",
-      annotations: { readOnlyHint: true },
+      annotations: { readOnlyHint: true, openWorldHint: false },
       description: "List all knowledge graphs (spaces) the authenticated user has access to. Returns graph IDs, names, and roles.",
       inputSchema: z.object({})
     },
@@ -169,8 +171,8 @@ function registerCreateGraph(server2, client2) {
     "naumu_create_graph",
     {
       title: "Create Graph",
-      annotations: { destructiveHint: true },
-      description: "Create a new knowledge graph (space) owned by the authenticated user. Returns `{id, name, slug, role, memberRole, createdAt, onboardingThreadId}` \u2014 use the returned `id` as `graphId` for subsequent tool calls. The space starts empty (no schema, no nodes); follow up with `naumu_update_schema` to register types before any `naumu_add_node` calls.",
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+      description: "Create a new, empty knowledge graph (space) owned by the authenticated user; use when you need a fresh space to populate. Returns `{id, name, slug, role, memberRole, createdAt, onboardingThreadId}` - use the returned `id` as `graphId` for subsequent tool calls. The space starts empty (no schema, no nodes); follow up with `naumu_update_schema` to register types before any `naumu_add_node` calls.",
       inputSchema: z2.object({
         name: z2.string().min(1).describe("Display name for the new space. A URL slug is generated from this name.")
       })
@@ -186,36 +188,42 @@ function registerCreateGraph(server2, client2) {
 
 // ../mcp-core/src/tools/get-schema.ts
 import { z as z3 } from "zod";
+function formatConnection(c) {
+  const out = { relation: c.relation };
+  if (c.polymorphic) {
+    out.polymorphic = true;
+  } else if (c.target_node) {
+    out.target_node = c.target_node;
+  }
+  return out;
+}
 function formatSchema(schema) {
   return {
     description: schema.description ?? null,
     types: schema.nodes.map((node) => {
       const result = { type: node.type };
       if (node.description) result.description = node.description;
+      const connections = {
+        required: (node.connections.required ?? []).map(formatConnection),
+        suggested: (node.connections.suggested ?? []).map(formatConnection)
+      };
       if (node.connections.parent) {
-        result.parent = `${node.connections.parent.relation} \u2192 ${node.connections.parent.target_node}`;
+        connections.parent = formatConnection(node.connections.parent);
       }
-      const connections = [
-        ...node.connections.required.map((c) => `${c.relation} \u2192 ${c.target_node} (required)`),
-        ...node.connections.suggested.map((c) => `${c.relation} \u2192 ${c.target_node}`)
-      ];
-      if (connections.length > 0) result.connections = connections;
+      result.connections = connections;
       if (node.attributes && node.attributes.length > 0) {
-        result.attributes = Object.fromEntries(
-          node.attributes.map((a) => {
-            const values = (a.values ?? []).map(
-              (v) => v.description ? { label: v.label, description: v.description } : v.label
-            );
-            const attrDetail = { values };
-            if (a.description) attrDetail.description = a.description;
-            const hasDesc = !!a.description;
-            const hasValueDescs = values.some((v) => typeof v !== "string");
-            if (!hasDesc && !hasValueDescs) {
-              return [a.name, (a.values ?? []).map((v) => v.label)];
-            }
-            return [a.name, attrDetail];
-          })
-        );
+        result.attributes = node.attributes.map((a) => {
+          const values = (a.values ?? []).map((v) => {
+            const value = { label: v.label };
+            if (v.color) value.color = v.color;
+            if (v.description) value.description = v.description;
+            return value;
+          });
+          const attr = { name: a.name, values };
+          if (a.type) attr.type = a.type;
+          if (a.description) attr.description = a.description;
+          return attr;
+        });
       }
       return result;
     })
@@ -226,8 +234,8 @@ function registerGetSchema(server2, client2) {
     "naumu_get_schema",
     {
       title: "Get Graph Schema",
-      annotations: { readOnlyHint: true },
-      description: "Get the schema definition for a knowledge graph. Returns node types, their allowed attributes (with valid values), allowed relationships, and any descriptions authored on types/attributes/values. Call this before classifying a new node into a type, before picking an attribute value, or before extending the schema \u2014 descriptions are short, contrastive notes from the schema author explaining what each type/attribute/value is for and how it differs from similar-sounding ones.",
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Get the schema definition for a knowledge graph; call this before classifying a new node into a type, before picking an attribute value, or before extending the schema. Returns a ROUND-TRIPPABLE structural schema: each `types[]` entry has the SAME shape `naumu_update_schema` ingests (type, description, structured `connections: { parent?, required, suggested }` with parent NESTED - not a string, and structured attributes), so you can copy a type straight back into naumu_update_schema without losing data (notably the parent relation). Descriptions are short, contrastive notes from the schema author explaining what each type/attribute/value is for and how it differs from similar-sounding ones.",
       inputSchema: z3.object({
         graphId: z3.string().describe("The graph ID")
       })
@@ -260,7 +268,7 @@ var ConnectionSchema = z4.object({
 var AttributeValueSchema = z4.object({
   label: z4.string().describe("Display label for this enum value"),
   color: z4.string().optional().describe('Optional hex color (e.g. "#ff5722")'),
-  description: z4.string().optional().describe('Short note distinguishing this value from sibling values (e.g. "closed-won \u2014 deal signed and revenue committed"). Encouraged when the label alone is ambiguous.')
+  description: z4.string().optional().describe('Short note distinguishing this value from sibling values (e.g. "closed-won - deal signed and revenue committed"). Encouraged when the label alone is ambiguous.')
 });
 var AttributeSchema = z4.object({
   name: z4.string().describe('Attribute key (e.g. "stage", "status", "category")'),
@@ -277,10 +285,10 @@ var NodeTypeSchema = z4.object({
   }),
   attributes: z4.array(AttributeSchema).optional().describe("Type-level attributes for instances of this type."),
   defaultVisibility: z4.enum(["restricted", "internal", "open"]).optional().describe(
-    'Default visibility for NEW nodes of this type when no explicit visibility is passed on creation. Does NOT retroactively change visibility on existing nodes. "open" = visible to anyone with the space link (including non-members), "internal" = visible to all space members, "restricted" = only members explicitly granted access. Omit to leave the type unset \u2014 it then falls back to the space-level defaultVisibility.'
+    'Default visibility for NEW nodes of this type when no explicit visibility is passed on creation. Does NOT retroactively change visibility on existing nodes. "open" = visible to anyone with the space link (including non-members), "internal" = visible to all space members, "restricted" = only members explicitly granted access. Omit to leave the type unset - it then falls back to the space-level defaultVisibility.'
   ),
   color: z4.string().optional().describe("Optional hex color for instances of this type."),
-  description: z4.string().optional().describe('Short one-sentence description of what this type represents AND how it differs from semantically similar types (e.g. "External entity delivering services on contract \u2014 distinct from Organization which is any legal entity"). Strongly encouraged on every type. Future agents rely on this when classifying a new node into one of several similar-sounding types.')
+  description: z4.string().optional().describe('Short one-sentence description of what this type represents AND how it differs from semantically similar types (e.g. "External entity delivering services on contract - distinct from Organization which is any legal entity"). Strongly encouraged on every type. Future agents rely on this when classifying a new node into one of several similar-sounding types.')
 });
 var SchemaDefinitionSchema = z4.object({
   description: z4.string().optional().describe("Schema-level description / domain summary."),
@@ -291,8 +299,8 @@ function registerUpdateSchema(server2, client2) {
     "naumu_update_schema",
     {
       title: "Update Graph Schema",
-      annotations: { destructiveHint: true },
-      description: "Replace the graph schema with a new full definition. STRUCTURAL RULES (load-bearing): (1) HIERARCHICAL with a single root \u2014 exactly ONE type has no parent; every other type MUST declare a parent. (2) Each parent / required / suggested connection is XOR: ONE concrete target_node OR polymorphic=true \u2014 never both, never a list of multiple targets. (3) DEFAULT TO CONCRETE target_node. Polymorphic is the ESCAPE HATCH \u2014 reserve for genuinely cross-cutting concepts like Comment or Tag (entities that validly attach to many distinct types). If you find yourself making most parents polymorphic, you are avoiding the design work \u2014 pick concrete relationships instead. If you can't pick a concrete parent, you may be missing a type \u2014 add the missing type first. (4) Same-type nesting is implicit: a node can be placed under another of its same type using the existing parent relation \u2014 never add a self-relation just to enable nesting. (5) Always provide `description` on every node type, attribute, and select value \u2014 one short, contrastive sentence (what it IS and what it is NOT vs sibling types/attrs/values). This is the single strongest disambiguation signal for future agents classifying nodes. Use to bootstrap an empty graph (cold-start) or fully replace mid-build (call naumu_get_schema first, send the FULL new schema \u2014 anything you omit is removed). Conventions: type names PascalCase (Company, Person, Feature), relation names UPPER_SNAKE_CASE (WORKS_AT, BELONGS_TO). Bias toward general types \u2014 refine via attributes or nested children, not type proliferation.",
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      description: "Replace the graph schema with a new full definition; use to bootstrap an empty graph (cold-start) or fully replace mid-build. STRUCTURAL RULES (load-bearing): (1) HIERARCHICAL with a single root - exactly ONE type has no parent; every other type MUST declare a parent. (2) Each parent / required / suggested connection is XOR: ONE concrete target_node OR polymorphic=true - never both, never a list of multiple targets. (3) DEFAULT TO CONCRETE target_node. Polymorphic is the ESCAPE HATCH - reserve for genuinely cross-cutting concepts like Comment or Tag (entities that validly attach to many distinct types). If you find yourself making most parents polymorphic, you are avoiding the design work - pick concrete relationships instead. If you can't pick a concrete parent, you may be missing a type - add the missing type first. (4) Same-type nesting is implicit: a node can be placed under another of its same type using the existing parent relation - never add a self-relation just to enable nesting. (5) Always provide `description` on every node type, attribute, and select value - one short, contrastive sentence (what it IS and what it is NOT vs sibling types/attrs/values). This is the single strongest disambiguation signal for future agents classifying nodes. When replacing mid-build, call naumu_get_schema first (it returns a round-trippable structural schema you can copy back) and send the FULL new schema; anything you omit is removed. PARENT PRESERVATION: omitting a type's `connections.parent` PRESERVES its existing parent (so a round-trip never silently orphans a type). To intentionally remove a parent and make a type a root, send `parent: null` explicitly. (A parent whose target type you delete is dropped automatically.) Conventions: type names PascalCase (Company, Person, Feature), relation names UPPER_SNAKE_CASE (WORKS_AT, BELONGS_TO). Bias toward general types - refine via attributes or nested children, not type proliferation.",
       inputSchema: z4.object({
         graphId: z4.string().describe("The graph ID"),
         schema: SchemaDefinitionSchema
@@ -332,15 +340,15 @@ function registerAddNodeType(server2, client2) {
     "naumu_add_node_type",
     {
       title: "Add Node Type to Schema",
-      annotations: { destructiveHint: true },
-      description: 'Add one new node type to the schema. Cheaper than naumu_update_schema. STRUCTURAL RULES: (1) Schemas are hierarchical with a single root. If schema is empty, the first type IS the root \u2014 omit `parent`. Every subsequent type MUST set `parent`. (2) DEFAULT TO CONCRETE \u2014 pass {relation, target_node: <existing type>}. Polymorphic is the ESCAPE HATCH \u2014 use {relation, polymorphic: true} ONLY for genuinely cross-cutting concepts like Comment or Tag (types that validly attach to many distinct parents). If you can\'t pick a concrete parent, you may be missing a type \u2014 add the missing type first instead of falling back to polymorphic. (3) Required/suggested connections also each take ONE concrete target_node OR polymorphic \u2014 never a list. Default concrete there too. (4) Type name PascalCase (Company, Person, Feature). Relation names UPPER_SNAKE_CASE (BELONGS_TO, WORKS_AT). (5) ALWAYS provide `description` \u2014 one short sentence that says what this type is AND what it is NOT relative to semantically close types (e.g. "External entity that delivers services on contract; distinct from Organization which is any legal entity"). This is the single strongest signal future agents have when classifying a node into one of several similar-sounding types. Returns an error if the type already exists \u2014 use naumu_add_attribute / naumu_add_connection to extend it.',
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      description: 'Add one new node type to the schema; use to extend an existing schema without resending the whole thing (cheaper than naumu_update_schema). STRUCTURAL RULES: (1) Schemas are hierarchical with a single root. If schema is empty, the first type IS the root - omit `parent`. Every subsequent type MUST set `parent`. (2) DEFAULT TO CONCRETE - pass {relation, target_node: <existing type>}. Polymorphic is the ESCAPE HATCH - use {relation, polymorphic: true} ONLY for genuinely cross-cutting concepts like Comment or Tag (types that validly attach to many distinct parents). If you can\'t pick a concrete parent, you may be missing a type - add the missing type first instead of falling back to polymorphic. (3) Required/suggested connections also each take ONE concrete target_node OR polymorphic - never a list. Default concrete there too. (4) Type name PascalCase (Company, Person, Feature). Relation names UPPER_SNAKE_CASE (BELONGS_TO, WORKS_AT). (5) ALWAYS provide `description` - one short sentence that says what this type is AND what it is NOT relative to semantically close types (e.g. "External entity that delivers services on contract; distinct from Organization which is any legal entity"). This is the single strongest signal future agents have when classifying a node into one of several similar-sounding types. Returns an error if the type already exists - use naumu_add_attribute / naumu_add_connection to extend it.',
       inputSchema: z5.object({
         graphId: z5.string(),
         type: z5.string().describe("PascalCase type name"),
         description: z5.string().optional().describe(
-          "Short one-sentence description of what this type represents and how it differs from sibling types. Contrastive (say what it IS and what it is NOT) is most useful. Strongly encouraged on every new type \u2014 agents reading the schema later rely on this to classify nodes."
+          "Short one-sentence description of what this type represents and how it differs from sibling types. Contrastive (say what it IS and what it is NOT) is most useful. Strongly encouraged on every new type - agents reading the schema later rely on this to classify nodes."
         ),
-        parent: ConnectionSchema2.optional().describe("Optional parent connection \u2014 sets this type as a child of another type."),
+        parent: ConnectionSchema2.optional().describe("Optional parent connection - sets this type as a child of another type."),
         required: z5.array(ConnectionSchema2).optional(),
         suggested: z5.array(ConnectionSchema2).optional(),
         attributes: z5.array(AttributeSchema2).optional(),
@@ -386,8 +394,8 @@ function registerAddConnection(server2, client2) {
     "naumu_add_connection",
     {
       title: "Add Connection to Node Type",
-      annotations: { destructiveHint: true },
-      description: 'Add one connection from an existing node type to another. `kind`: "parent" (sets/replaces \u2014 every non-root type needs exactly one parent; only ONE type in the whole schema has no parent), "required" (must exist on instances), "suggested" (optional). Each connection is XOR: ONE concrete target_node OR polymorphic=true \u2014 never both. DEFAULT TO CONCRETE target_node. Polymorphic is the ESCAPE HATCH \u2014 reserve for genuinely cross-cutting relations (e.g. a Tag-style relation that validly applies to many distinct types). If you can\'t pick a concrete target, you may be missing a type \u2014 add it first instead of falling back to polymorphic. Same-type nesting (e.g. Topic under Topic) does NOT need a new connection \u2014 use the existing parent relation. Relation name UPPER_SNAKE_CASE.',
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      description: 'Add one connection from an existing node type to another; use to extend a type\'s relations without resending the whole schema. `kind`: "parent" (sets/replaces - every non-root type needs exactly one parent; only ONE type in the whole schema has no parent), "required" (must exist on instances), "suggested" (optional). Each connection is XOR: ONE concrete target_node OR polymorphic=true - never both. DEFAULT TO CONCRETE target_node. Polymorphic is the ESCAPE HATCH - reserve for genuinely cross-cutting relations (e.g. a Tag-style relation that validly applies to many distinct types). If you can\'t pick a concrete target, you may be missing a type - add it first instead of falling back to polymorphic. Same-type nesting (e.g. Topic under Topic) does NOT need a new connection - use the existing parent relation. Relation name UPPER_SNAKE_CASE.',
       inputSchema: z6.object({
         graphId: z6.string(),
         source_type: z6.string().describe("Existing node type to add the connection to."),
@@ -436,8 +444,8 @@ function registerAddAttribute(server2, client2) {
     "naumu_add_attribute",
     {
       title: "Add Attribute to Node Type",
-      annotations: { destructiveHint: true },
-      description: 'Add or extend an attribute on an existing node type. If the attribute name doesn\'t exist, it is created. If it exists and is a select/multiselect, new values are merged in (existing values kept). Use type "select"/"multiselect" with values; "string"/"number"/"date" for free-form fields (pass values: [] \u2014 string/number/date have no enum values). Example date attribute: { name: "due_date", type: "date", values: [], description: "Target completion date (single day or range)" }. Date values on nodes are written via naumu_update_node as either an ISO date string "YYYY-MM-DD" (single day) or an object { start, end? } with ISO date strings (inclusive range). Strongly encouraged to provide `description` on the attribute and on each value \u2014 short, contrastive notes (e.g. attribute "stage \u2014 sales funnel position; distinct from status which captures health/blockers", value "closed-won \u2014 deal signed and revenue committed"). Descriptions are the single strongest signal future agents use when picking which attribute/value to set.',
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      description: 'Add or extend an attribute on an existing node type; use to add a field or merge new enum values into an existing one. If the attribute name doesn\'t exist, it is created. If it exists and is a select/multiselect, new values are merged in (existing values kept). Use type "select"/"multiselect" with values; "string"/"number"/"date" for free-form fields (pass values: [] - string/number/date have no enum values). Example date attribute: { name: "due_date", type: "date", values: [], description: "Target completion date (single day or range)" }. Date values on nodes are written via naumu_update_node as either an ISO date string "YYYY-MM-DD" (single day) or an object { start, end? } with ISO date strings (inclusive range). Strongly encouraged to provide `description` on the attribute and on each value - short, contrastive notes (e.g. attribute "stage - sales funnel position; distinct from status which captures health/blockers", value "closed-won - deal signed and revenue committed"). Descriptions are the single strongest signal future agents use when picking which attribute/value to set.',
       inputSchema: z7.object({
         graphId: z7.string(),
         node_type: z7.string().describe("Existing node type to add the attribute to."),
@@ -447,7 +455,7 @@ function registerAddAttribute(server2, client2) {
           z7.object({
             label: z7.string(),
             color: z7.string().optional(),
-            description: z7.string().optional().describe('Short note distinguishing this value from sibling values (e.g. "closed-won \u2014 deal signed and revenue committed"). Encouraged when the label alone is ambiguous.')
+            description: z7.string().optional().describe('Short note distinguishing this value from sibling values (e.g. "closed-won - deal signed and revenue committed"). Encouraged when the label alone is ambiguous.')
           })
         ).default([]),
         description: z7.string().optional().describe('Short note explaining what this attribute captures and how it differs from similarly-named attributes elsewhere in the schema (e.g. "Sales funnel position; differs from `status` which captures health/blockers"). Strongly encouraged.')
@@ -490,8 +498,8 @@ function registerSearch(server2, client2) {
     "naumu_search",
     {
       title: "Search Graph",
-      annotations: { readOnlyHint: true },
-      description: 'Hybrid search over graph nodes. Combines exact-token text matching (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 \u2014 `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"). Tip: include both synonyms ("authentication login SSO") and exact tokens you remember in the same query \u2014 the fusion handles both.',
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: 'Hybrid search over graph nodes; use for meaning-based lookup when you don\'t know the exact label. Combines exact-token text matching (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"). Tip: include both synonyms ("authentication login SSO") and exact tokens you remember in the same query - the fusion handles both.',
       inputSchema: z8.object({
         graphId: z8.string().describe("The graph ID"),
         query: z8.string().describe(
@@ -521,15 +529,15 @@ function registerFilter(server2, client2) {
     "naumu_filter",
     {
       title: "Filter Graph Nodes",
-      annotations: { readOnlyHint: true },
-      description: 'Filter nodes by type and attributes with deterministic, complete results. Use this 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) \u2014 no semantic ranking, no missed results. Results are sorted by sortKey or recency.',
+      annotations: { readOnlyHint: true, 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: z9.object({
         graphId: z9.string().describe("The graph ID"),
         nodeTypes: z9.array(z9.string()).optional().describe('Filter to specific node types (e.g. ["Task", "Bug"])'),
-        includeAttributes: z9.record(z9.array(z9.string())).optional().describe(
+        includeAttributes: z9.record(z9.string(), z9.array(z9.string())).optional().describe(
           'Only include nodes where attribute matches one of the values. Example: {"Status": ["Todo", "In Progress"]}'
         ),
-        excludeAttributes: z9.record(z9.array(z9.string())).optional().describe(
+        excludeAttributes: z9.record(z9.string(), z9.array(z9.string())).optional().describe(
           'Exclude nodes where attribute matches any of the values. Example: {"Status": ["Done", "Wont do"]}'
         ),
         sortBy: z9.enum(["sortKey", "updatedAt", "label"]).optional().default("sortKey").describe('Sort order: "sortKey" (default), "updatedAt" (most recent first), or "label" (alphabetical)'),
@@ -564,7 +572,7 @@ function registerGetNode(server2, client2) {
     "naumu_get_node",
     {
       title: "Get Node",
-      annotations: { readOnlyHint: true },
+      annotations: { readOnlyHint: true, openWorldHint: false },
       description: "Get a single node with all its properties and connections (incoming and outgoing edges).",
       inputSchema: z10.object({
         graphId: z10.string().describe("The graph ID"),
@@ -585,7 +593,7 @@ import { z as z11 } from "zod";
 var NodeInput = z11.object({
   label: z11.string().describe("Display name of the node"),
   type: z11.string().describe("Node type from the graph schema (e.g. Feature, Pain, Metric)"),
-  content: z11.string().min(1).describe("Rich text content / description. REQUIRED \u2014 every node must explain what it is."),
+  content: z11.string().min(1).describe("Rich text content / description. REQUIRED - every node must explain what it is."),
   attributes: z11.record(z11.string(), z11.unknown()).optional().describe("Additional key-value attributes")
 });
 function registerAddNode(server2, client2) {
@@ -593,8 +601,8 @@ function registerAddNode(server2, client2) {
     "naumu_add_node",
     {
       title: "Add Nodes (bulk)",
-      annotations: { destructiveHint: true },
-      description: 'Create 1\u201325 nodes in the knowledge graph in a single call. Keep batches small and atomic (5\u201325 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"}` \u2014 there is NO server-side dedup, every input becomes a node. Dedup is the caller\'s responsibility: BEFORE calling this tool, run `naumu_semantic_search` on each candidate label and skip/route to update if a result has high similarity (\u22650.78) and matching type. Warning: nodes are isolated until you connect them with `naumu_add_edge`. **Prefer `naumu_ask`** for general knowledge intake \u2014 it discovers and creates connections for you. Use this when you have a vetted, dedup-checked batch ready to insert.',
+      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 skip/route to update if a result has high similarity (\u22650.78) and matching type. 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: z11.object({
         graphId: z11.string().describe("The graph ID"),
         nodes: z11.array(NodeInput).min(1).max(25).describe("Batch of 1\u201325 nodes to create. Keep batches small for atomicity.")
@@ -670,8 +678,8 @@ function registerUpdateNode(server2, client2) {
     "naumu_update_node",
     {
       title: "Update Node",
-      annotations: { destructiveHint: true },
-      description: 'Update properties of an existing node. Only the provided fields will be changed. Good for simple attribute changes like setting a status, priority, or due date. For content or structural changes, consider `naumu_ask` instead \u2014 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.',
+      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"),
@@ -757,8 +765,8 @@ function registerAddEdge(server2, client2) {
     "naumu_add_edge",
     {
       title: "Add Edges (bulk)",
-      annotations: { destructiveHint: true },
-      description: "Create 1\u201325 relationships (edges) between existing nodes in a single call. Keep batches small and atomic (5\u201325 edges) so failures stay contained. Typical workflow after a bulk import: 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 / drop offending edges before calling. **Prefer `naumu_ask`** when you want the agent to discover the right connections itself.",
+      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: z13.object({
         graphId: z13.string().describe("The graph ID"),
         edges: z13.array(EdgeInput).min(1).max(25).describe("Batch of 1\u201325 edges to create. Keep batches small for atomicity.")
@@ -786,8 +794,8 @@ function registerRemoveNode(server2, client2) {
     "naumu_remove_node",
     {
       title: "Remove Node",
-      annotations: { destructiveHint: true },
-      description: "Low-level tool: delete a node and all its connections from the knowledge graph. This is a destructive operation. **Prefer `naumu_ask`** for removing knowledge \u2014 it understands the impact on the broader graph and can handle cascading changes. Use this only when you need precise, surgical deletion.",
+      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: z14.object({
         graphId: z14.string().describe("The graph ID"),
         nodeId: z14.string().describe("The node ID to delete")
@@ -809,8 +817,8 @@ function registerRemoveEdge(server2, client2) {
     "naumu_remove_edge",
     {
       title: "Remove Edge",
-      annotations: { destructiveHint: true },
-      description: "Delete a single edge identified by `(source, target, label)` tuple. Does NOT delete the endpoint nodes \u2014 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 \u2014 call `naumu_reparent` first if you want connectivity preserved. Response: `{deleted: 0 | 1, warnings: string[]}`. Use for correcting wrong-target edge mistakes; this is a recovery tool, not a routine one. **Prefer `naumu_ask`** when the structural intent is broader than removing one specific edge \u2014 `naumu_ask` can reason about the surrounding graph.",
+      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: z15.object({
         graphId: z15.string().describe("The graph ID"),
         source: z15.string().describe("Source node id of the edge to delete"),
@@ -843,11 +851,11 @@ function registerRemoveEdgesBulk(server2, client2) {
     "naumu_remove_edges_bulk",
     {
       title: "Remove Edges (bulk)",
-      annotations: { destructiveHint: true },
-      description: "Delete 1\u2013100 edges in a single atomic call \u2014 all-or-none, same semantics as `naumu_add_node`. Does NOT delete endpoint nodes. **System edges** (HAS_NODE, HAS_THREAD, OWNS, etc.) are rejected \u2014 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[]}`) \u2014 call `naumu_reparent` first if you want connectivity preserved. Use to fix multiple wrong-target edge mistakes in one shot. **Prefer `naumu_ask`** for broader structural cleanup that needs graph-wide reasoning.",
+      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: z16.object({
         graphId: z16.string().describe("The graph ID"),
-        edges: z16.array(EdgeRef).min(1).max(100).describe("1\u2013100 edges to delete. Atomic per call \u2014 all succeed or none do.")
+        edges: z16.array(EdgeRef).min(1).max(100).describe("1-100 edges to delete. Atomic per call - all succeed or none do.")
       })
     },
     async ({ graphId, edges }) => {
@@ -865,95 +873,108 @@ function registerAsk(server2, client2) {
   server2.registerTool(
     "naumu_ask",
     {
-      title: "Ask AI",
-      annotations: { destructiveHint: true },
-      description: 'Send a message to the Naumu AI agent. Use for adding knowledge, making changes, asking questions, or reporting status updates. Always returns immediately with a threadId \u2014 the AI processes the request in the background. Depending on complexity, the agent may take anywhere from a few seconds to a few minutes to finish.\n\n**For reports and status updates** (e.g. "mark task X as done", "record a deployment"): fire and forget \u2014 no need to check the response.\n\n**For questions that need an answer**: after calling this tool, poll with `naumu_get_ai_thread` using the returned threadId until the AI response is ready.',
+      title: "Ask Naumu",
+      // Writes a visible conversation (question + reply) and runs the @Naumu
+      // agent. Additive, not destructive. Open-world: the answer is
+      // synthesised by an LLM with full read access to the space.
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      description: 'Ask @Naumu a question about a space and get a synthesised answer back, with the node ids it drew from and a confidence hint. This is the primary, go-to tool for getting information 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 assembles the answer for you, so prefer it for any space question and fall back to the granular reads only when you need precision it cannot give (naumu_search to find nodes by meaning, naumu_filter for every node of a type/attribute, naumu_list_threads + naumu_read_thread for conversation history). The question and answer are saved as a visible conversation in the space. Returns { answer, sources, confidence, threadId, status }; on a long synthesis it returns status "processing" with a threadId you read later via naumu_read_thread. To hand @Naumu work to carry out (add knowledge, make changes, record status) without waiting, use naumu_delegate instead.',
       inputSchema: z17.object({
-        graphId: z17.string().describe("The graph ID to query against"),
-        question: z17.string().describe("Your message to the Naumu AI agent"),
-        threadId: z17.string().optional().describe("Thread ID for follow-up messages (omit for new conversation)")
+        graphId: z17.string().describe("The space (graph) id to ask about."),
+        question: z17.string().max(4e3).describe("The question for @Naumu. Up to 4000 characters.")
       })
     },
-    async ({ graphId, question, threadId }) => {
-      if (!threadId) {
-        const thread = await client2.post("/api/threads", { graphId });
-        threadId = thread.id;
+    async ({ graphId, question }) => {
+      try {
+        const data = await client2.post(`/api/graphs/${graphId}/ask`, { question });
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
       }
-      await client2.post(`/api/threads/${threadId}/messages`, {
-        content: question,
-        async: true
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ threadId, status: "processing" }, null, 2)
-          }
-        ]
-      };
     }
   );
 }
 
-// ../mcp-core/src/tools/get-ai-thread.ts
+// ../mcp-core/src/tools/delegate.ts
 import { z as z18 } from "zod";
-function registerGetAiThread(server2, client2) {
+function registerDelegate(server2, client2) {
   server2.registerTool(
-    "naumu_get_ai_thread",
+    "naumu_delegate",
     {
-      title: "Get AI Thread",
-      annotations: { readOnlyHint: true },
-      description: 'Retrieve messages from an AI conversation thread. Use to read the AI response after a `naumu_ask` call.\n\nThe last AI message has a `status` field: `"processing"` means the AI is still working, `"complete"` means the response is ready. If still processing, wait a few seconds and try again.',
+      title: "Delegate to Naumu",
+      // Posts a message that the @Naumu agent acts on in the background.
+      // Additive, not destructive at this layer. Open-world: hands work to an
+      // LLM agent that may read and write the graph.
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        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.',
       inputSchema: z18.object({
-        threadId: z18.string().describe("The thread ID returned by naumu_ask")
+        graphId: z18.string().describe("The space (graph) id to act in."),
+        task: z18.string().describe("What you want @Naumu to do, add, or record."),
+        threadId: z18.string().optional().describe("Continue an existing conversation; omit to start a new one.")
       })
     },
-    async ({ threadId }) => {
-      const data = await client2.get(`/api/threads/${threadId}/messages`);
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
-// ../mcp-core/src/tools/traverse.ts
-import { z as z19 } from "zod";
-function registerTraverse(server2, client2) {
-  server2.registerTool(
-    "naumu_traverse",
-    {
-      title: "Traverse Knowledge Graph",
-      annotations: { readOnlyHint: true },
-      description: 'Query the graph structurally using natural language. A sub-LLM generates and executes Cypher queries. Use for structural questions like "tasks without a parent", "features with most tasks", "orphan nodes", "everything within 2 hops of X", or temporal filters like "nodes updated this week". For meaning-based search, use `naumu_search` instead.',
-      inputSchema: z19.object({
-        graphId: z19.string().describe("The graph ID"),
-        query: z19.string().describe(
-          `Natural language description of the structural pattern to find (e.g. "tasks without a parent", "features that don't resolve any pain")`
-        )
-      })
-    },
-    async ({ graphId, query }) => {
-      const data = await client2.post(`/api/graphs/${graphId}/traverse`, { query });
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
+    async ({ graphId, task, threadId }) => {
+      try {
+        let resolvedThreadId = threadId;
+        if (!resolvedThreadId) {
+          const thread = await client2.post("/api/threads", { graphId });
+          resolvedThreadId = thread.id;
+        }
+        await client2.post(`/api/threads/${resolvedThreadId}/messages`, {
+          content: task,
+          async: true
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { threadId: resolvedThreadId, status: "processing" },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
     }
   );
 }
 
 // ../mcp-core/src/tools/get-view.ts
-import { z as z20 } from "zod";
+import { z as z19 } from "zod";
 function registerGetView(server2, client2) {
   server2.registerTool(
     "naumu_get_view",
     {
       title: "Get View",
-      annotations: { readOnlyHint: true },
-      description: "Fetch a saved Naumu view's configuration plus a one-line natural-language summary of its filters. Call this BEFORE naumu_list_view_nodes whenever you encounter a view URL \u2014 the summary tells you what data the view returns so you can decide whether to page through it. Returns: id, name, description, summary, filters, and table column config.",
-      inputSchema: z20.object({
-        graphId: z20.string().describe("The graph (space) ID. From naumu.ai URLs this is the value after /spaces/."),
-        viewId: z20.string().describe('The view ID (typically prefixed with "view_").')
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Fetch a saved Naumu view's configuration plus a one-line natural-language summary of its filters; call this BEFORE naumu_list_view_nodes whenever you encounter a view URL. The summary tells you what data the view returns so you can decide whether to page through it. Returns: id, name, description, summary, filters, and table column config.",
+      inputSchema: z19.object({
+        graphId: z19.string().describe("The graph (space) ID. From naumu.ai URLs this is the value after /spaces/."),
+        viewId: z19.string().describe('The view ID (typically prefixed with "view_").')
       })
     },
     async ({ graphId, viewId }) => {
@@ -966,20 +987,20 @@ function registerGetView(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-view-nodes.ts
-import { z as z21 } from "zod";
+import { z as z20 } from "zod";
 function registerListViewNodes(server2, client2) {
   server2.registerTool(
     "naumu_list_view_nodes",
     {
       title: "List View Nodes",
-      annotations: { readOnlyHint: true },
-      description: 'List nodes that match a saved view. Cursor-paginated. Pair with naumu_get_view first to read the view\'s filters and decide what payload size you need.\n\nResponse shape: { nodes, totalCount, nextCursor, hasMore }. Use totalCount to know how many results exist without paging through them. Use hasMore (boolean) to decide whether to fetch the next page; pass nextCursor back as `cursor` to do so.\n\nfields parameter:\n- "summary" (default): {id, label, type} \u2014 best for browsing.\n- "id": {id} only \u2014 use when you need to count or iterate cheaply.\n- "full": full node payload with all attributes \u2014 use when you need every property.\n\nDefault page size 25, max 100.',
-      inputSchema: z21.object({
-        graphId: z21.string().describe("The graph (space) ID."),
-        viewId: z21.string().describe("The view ID."),
-        cursor: z21.string().optional().describe("Opaque cursor from a previous response's nextCursor. Omit for the first page."),
-        limit: z21.number().int().min(1).max(100).optional().describe("Page size, default 25, max 100."),
-        fields: z21.enum(["id", "summary", "full"]).optional().describe('How much detail per node. Default "summary".')
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: 'List nodes that match a saved view; pair with naumu_get_view first to read the view\'s filters and decide what payload size you need. Cursor-paginated.\n\nResponse shape: { nodes, totalCount, nextCursor, hasMore }. Use totalCount to know how many results exist without paging through them. Use hasMore (boolean) to decide whether to fetch the next page; pass nextCursor back as `cursor` to do so.\n\nfields parameter:\n- "summary" (default): {id, label, type} - best for browsing.\n- "id": {id} only - use when you need to count or iterate cheaply.\n- "full": full node payload with all attributes - use when you need every property.\n\nDefault page size 25, max 100.',
+      inputSchema: z20.object({
+        graphId: z20.string().describe("The graph (space) ID."),
+        viewId: z20.string().describe("The view ID."),
+        cursor: z20.string().optional().describe("Opaque cursor from a previous response's nextCursor. Omit for the first page."),
+        limit: z20.number().int().min(1).max(100).optional().describe("Page size, default 25, max 100."),
+        fields: z20.enum(["id", "summary", "full"]).optional().describe('How much detail per node. Default "summary".')
       })
     },
     async ({ graphId, viewId, cursor, limit, fields }) => {
@@ -998,16 +1019,16 @@ function registerListViewNodes(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-canvases.ts
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 function registerListCanvases(server2, client2) {
   server2.registerTool(
     "naumu_list_canvases",
     {
       title: "List Canvases",
-      annotations: { readOnlyHint: true },
+      annotations: { readOnlyHint: true, openWorldHint: false },
       description: "List freeform drawing canvases in a graph. Each canvas is an Excalidraw-style sketch surface that may contain shapes, text, freehand strokes, images, bookmark cards, and embedded references to graph nodes.",
-      inputSchema: z22.object({
-        graphId: z22.string().describe("The graph ID to list canvases for")
+      inputSchema: z21.object({
+        graphId: z21.string().describe("The graph ID to list canvases for")
       })
     },
     async ({ graphId }) => {
@@ -1020,16 +1041,16 @@ function registerListCanvases(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-canvas-elements.ts
-import { z as z23 } from "zod";
+import { z as z22 } from "zod";
 function registerGetCanvasElements(server2, client2) {
   server2.registerTool(
     "naumu_get_canvas_elements",
     {
       title: "Get Canvas Elements",
-      annotations: { readOnlyHint: true },
-      description: "Read the structured JSON contents of a canvas \u2014 every shape, text, line, freehand stroke, image, bookmark card, and entity-embed with their positions, colors, and text. Use this when you need to reason about what a user has drawn without needing to see the visual output.",
-      inputSchema: z23.object({
-        canvasId: z23.string().describe("The canvas ID")
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Read the structured JSON contents of a canvas - every shape, text, line, freehand stroke, image, bookmark card, and entity-embed with their positions, colors, and text. Use this when you need to reason about what a user has drawn without needing to see the visual output.",
+      inputSchema: z22.object({
+        canvasId: z22.string().describe("The canvas ID")
       })
     },
     async ({ canvasId }) => {
@@ -1042,21 +1063,21 @@ function registerGetCanvasElements(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-canvas-image.ts
-import { z as z24 } from "zod";
+import { z as z23 } from "zod";
 var MAX_INLINE_BYTES = 4 * 1024 * 1024;
 function registerGetCanvasImage(server2, client2) {
   server2.registerTool(
     "naumu_get_canvas_image",
     {
       title: "Get Canvas Image",
-      annotations: { readOnlyHint: true },
-      description: 'Render a canvas to a PNG image so you can visually inspect what was drawn \u2014 freehand strokes, spatial layout, sketches. Returns the image inline by default so any MCP host can see it directly. Use `mode: "url"` if you specifically need a signed URL (e.g. very large canvases, or to share the link).',
-      inputSchema: z24.object({
-        canvasId: z24.string().describe("The canvas ID"),
-        scale: z24.union([z24.literal(1), z24.literal(2)]).default(2).describe("Pixel density (1 or 2). Default is 2 for retina-quality output."),
-        theme: z24.enum(["light", "dark"]).default("light").describe("Background theme to render with."),
-        mode: z24.enum(["inline", "url"]).default("inline").describe(
-          "`inline` (default) embeds the PNG directly so vision-capable hosts see it. `url` returns a signed S3 URL that expires in 1 hour \u2014 useful for large canvases or sharing."
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: 'Render a canvas to a PNG image so you can visually inspect what was drawn - freehand strokes, spatial layout, sketches. Returns the image inline by default so any MCP host can see it directly. Use `mode: "url"` if you specifically need a signed URL (e.g. very large canvases, or to share the link).',
+      inputSchema: z23.object({
+        canvasId: z23.string().describe("The canvas ID"),
+        scale: z23.union([z23.literal(1), z23.literal(2)]).default(2).describe("Pixel density (1 or 2). Default is 2 for retina-quality output."),
+        theme: z23.enum(["light", "dark"]).default("light").describe("Background theme to render with."),
+        mode: z23.enum(["inline", "url"]).default("inline").describe(
+          "`inline` (default) embeds the PNG directly so vision-capable hosts see it. `url` returns a signed S3 URL that expires in 1 hour - useful for large canvases or sharing."
         )
       })
     },
@@ -1119,19 +1140,26 @@ function formatBytes(bytes) {
 }
 
 // ../mcp-core/src/tools/post-message.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 function registerPostMessage(server2, client2) {
   server2.registerTool(
     "naumu_post_message",
     {
       title: "Post Message",
-      annotations: { destructiveHint: true },
-      description: 'Post a message in a Naumu thread you are participating in. Use this to reply to humans (or other bots) in a thread that pinged you. Plain text is accepted by default; for rendered @mentions, pass a Tiptap JSON document with mention nodes (`{ type: "mention", attrs: { id, label } }`) and set contentFormat to "tiptap". To attach files (reports, images, audio, video) call `naumu_request_attachment_upload` first for each file, PUT the bytes to the returned `uploadUrl`, then pass the resulting `attachmentId`s here as `attachmentIds`. The message must have either `content` or `attachmentIds` (or both). Returns the created message JSON.',
-      inputSchema: z25.object({
-        threadId: z25.string().describe("The thread ID to post into. You must be a participant in this thread."),
-        content: z25.string().optional().describe('Message body. Plain text by default; pass a Tiptap JSON document only if contentFormat is set to "tiptap". Optional when `attachmentIds` is provided.'),
-        contentFormat: z25.enum(["tiptap", "text"]).optional().describe('Format of `content`. Defaults to "text". Use "tiptap" for rendered mentions/embeds, e.g. a doc containing `{ type: "mention", attrs: { id: userIdOrIdentityId, label: displayName } }`.'),
-        attachmentIds: z25.array(z25.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.")
+      // Additive: appends a message to a thread. Not destructive, not
+      // idempotent, graph-local.
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      description: 'Post a message in a Naumu thread you participate in. Use it to reply to humans (or other bots) in a thread that pinged you. Plain text is accepted by default; for rendered @mentions pass a Tiptap JSON document with mention nodes (`{ type: "mention", attrs: { id, label } }`) and set contentFormat to "tiptap". @mentioning people loops them in without invoking @Naumu. 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. To get a synthesised answer from @Naumu, use naumu_ask.',
+      inputSchema: z24.object({
+        threadId: z24.string().describe("The thread ID to post into. You must be a participant in this thread."),
+        content: z24.string().optional().describe('Message body. Plain text by default; pass a Tiptap JSON document only if contentFormat is set to "tiptap". Optional when `attachmentIds` is provided.'),
+        contentFormat: z24.enum(["tiptap", "text"]).optional().describe('Format of `content`. Defaults to "text". Use "tiptap" for rendered mentions/embeds, e.g. a doc containing `{ type: "mention", attrs: { id: userIdOrIdentityId, label: displayName } }`.'),
+        attachmentIds: z24.array(z24.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.")
       })
     },
     async ({ threadId, content, contentFormat, attachmentIds }) => {
@@ -1157,18 +1185,18 @@ function registerPostMessage(server2, client2) {
 }
 
 // ../mcp-core/src/tools/read-thread.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 function registerReadThread(server2, client2) {
   server2.registerTool(
     "naumu_read_thread",
     {
       title: "Read Thread",
-      annotations: { readOnlyHint: true },
-      description: "Read messages from a Naumu thread. Returns paginated history ordered newest-first. Use `before` (timestamp ms) to page back further into older history. Default page size 50, max 200.",
-      inputSchema: z26.object({
-        threadId: z26.string().describe("The thread ID to read from."),
-        before: z26.number().optional().describe("Unix timestamp in milliseconds. Returns messages 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.")
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: 'Read messages from a Naumu thread. Returns paginated history ordered newest-first; each message carries a `status` (`processing` while @Naumu is still composing, `complete` when done). Use this to pick up an answer after naumu_ask returns status "processing", or to read what naumu_delegate produced. Use `before` (timestamp ms) to page further back. Default page size 50, max 200.',
+      inputSchema: z25.object({
+        threadId: z25.string().describe("The thread ID to read from."),
+        before: z25.number().optional().describe("Unix timestamp in milliseconds. Returns messages strictly older than this. Omit for the newest page."),
+        limit: z25.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ threadId, before, limit }) => {
@@ -1193,65 +1221,16 @@ function registerReadThread(server2, client2) {
   );
 }
 
-// ../mcp-core/src/tools/ask-naumu.ts
-import { z as z27 } from "zod";
-function registerAskNaumu(server2, client2) {
-  server2.registerTool(
-    "naumu_ask_naumu",
-    {
-      title: "Ask Naumu",
-      // NOT read-only: the backend creates a durable sidechannel thread +
-      // message, may seed a system Identity, and spawns a SpaceAgent task
-      // (and consumes a 5/hour budget). Additive, not destructive.
-      annotations: { destructiveHint: false },
-      description: "Ask the system @Naumu Identity (the canonical graph-writer/curator) a question about your graph. Use for questions where direct graph reads would be inefficient \u2014 Naumu has full read access and synthesizes answers. Limited to 5 calls per hour per Identity. Returns { answer, sources, confidence, durationMs }.",
-      inputSchema: z27.object({
-        graphId: z27.string().describe("The graph ID to ask about."),
-        question: z27.string().max(4e3).describe("The question to ask Naumu. Max 4000 characters.")
-      })
-    },
-    async ({ graphId, question }) => {
-      try {
-        const identityId = process.env.NAUMU_IDENTITY_ID;
-        if (!identityId) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: NAUMU_IDENTITY_ID env var is required for ask_naumu \u2014 re-run the pairing setup."
-              }
-            ],
-            isError: true
-          };
-        }
-        const data = await client2.post(`/api/identities/${identityId}/ask`, {
-          graphId,
-          question
-        });
-        return {
-          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-        };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `Error: ${message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-
 // ../mcp-core/src/tools/whoami.ts
-import { z as z28 } from "zod";
+import { z as z26 } from "zod";
 function registerWhoami(server2, client2, allToolNames) {
   server2.registerTool(
     "naumu_whoami",
     {
       title: "Who Am I",
-      annotations: { readOnlyHint: true },
-      description: 'Return who the calling key is plus the live MCP tool manifest, so you can bootstrap before the first real operation. A bot identity key returns its Identity row (id, graphId, name, instructions, allowedTools). A user API key returns `kind: "user"` with userId, name, and email \u2014 a person spans many graphs, so resolve a specific graph via naumu_list_graphs. No arguments. Always available regardless of the permission grid.',
-      inputSchema: z28.object({})
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: 'Return who the calling key is plus the live MCP tool manifest, so you can bootstrap before the first real operation. A bot identity key returns its Identity row (id, graphId, name, instructions, allowedTools). 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. No arguments. Always available regardless of the permission grid.',
+      inputSchema: z26.object({})
     },
     async () => {
       try {
@@ -1274,18 +1253,25 @@ function registerWhoami(server2, client2, allToolNames) {
 }
 
 // ../mcp-core/src/tools/list-threads.ts
-import { z as z29 } from "zod";
+import { z as z27 } from "zod";
+function sanitizeThreadParticipants(thread) {
+  if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
+    return thread;
+  }
+  const { participantEmails: _participantEmails, ...rest } = thread;
+  return rest;
+}
 function registerListThreads(server2, client2) {
   server2.registerTool(
     "naumu_list_threads",
     {
       title: "List Threads",
-      annotations: { readOnlyHint: true },
+      annotations: { readOnlyHint: true, 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). 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: z29.object({
-        graphId: z29.string().optional().describe("Graph (space) ID. Required for user API keys; omit for bot identity keys (defaults to your own graph)."),
-        cursor: z29.number().int().optional().describe("Unix timestamp ms \u2014 returns threads with `lastActivityAt` strictly older than this. Omit for the newest page."),
-        limit: z29.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
+      inputSchema: z27.object({
+        graphId: z27.string().optional().describe("Graph (space) ID. Required for user API keys; omit for bot identity keys (defaults to your own graph)."),
+        cursor: z27.number().int().optional().describe("Unix timestamp ms \u2014 returns threads with `lastActivityAt` strictly older than this. Omit for the newest page."),
+        limit: z27.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ graphId, cursor, limit }) => {
@@ -1302,8 +1288,12 @@ function registerListThreads(server2, client2) {
           path = `/api/identities/me/threads${qs ? `?${qs}` : ""}`;
         }
         const data = await client2.get(path);
+        const clean = data && typeof data === "object" && Array.isArray(data.threads) ? {
+          ...data,
+          threads: data.threads.map(sanitizeThreadParticipants)
+        } : data;
         return {
-          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify(clean, null, 2) }]
         };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -1317,23 +1307,31 @@ function registerListThreads(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-thread.ts
-import { z as z30 } from "zod";
+import { z as z28 } from "zod";
+function sanitizeThreadParticipants2(thread) {
+  if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
+    return thread;
+  }
+  const { participantEmails: _participantEmails, ...rest } = thread;
+  return rest;
+}
 function registerGetThread(server2, client2) {
   server2.registerTool(
     "naumu_get_thread",
     {
       title: "Get Thread",
-      annotations: { readOnlyHint: true },
+      annotations: { readOnlyHint: true, 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: z30.object({
-        threadId: z30.string().describe("The thread ID to fetch.")
+      inputSchema: z28.object({
+        threadId: z28.string().describe("The thread ID to fetch.")
       })
     },
     async ({ threadId }) => {
       try {
         const data = await client2.get(`/api/threads/${threadId}`);
+        const clean = sanitizeThreadParticipants2(data);
         return {
-          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify(clean, null, 2) }]
         };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -1347,30 +1345,37 @@ function registerGetThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-thread.ts
-import { z as z31 } from "zod";
+import { z as z29 } from "zod";
 function registerCreateThread(server2, client2) {
   server2.registerTool(
     "naumu_create_thread",
     {
       title: "Create Thread",
-      annotations: { destructiveHint: true },
-      description: 'Start a new conversation in your graph. You are auto-attached as a permanent participant; the thread\'s formal creator is your primary owner (the user who registered you), so the thread shows up in their sidebar. Optional `participants` adds humans (by userId) and other bots (by identityId) at creation time. Optional `initialMessage` is posted as your first message \u2014 use it to open the conversation. Returns the created thread (including its id) so you can immediately call `naumu_post_message` for follow-ups. Useful for scheduled briefings ("Brief me about X every morning at 9am" \u2014 schedule on your side, then call this to deliver into Naumu).',
-      inputSchema: z31.object({
-        title: z31.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: z31.array(
-          z31.discriminatedUnion("type", [
-            z31.object({
-              type: z31.literal("user"),
-              userId: z31.string().min(1).describe("User UUID \u2014 get these from `naumu_get_thread`/`naumu_read_thread` participant rosters or webhook payloads.")
+      // Additive: creates a thread (and optional first message). Not
+      // destructive, not idempotent, graph-local.
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        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. 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.")
             }),
-            z31.object({
-              type: z31.literal("identity"),
-              identityId: z31.string().min(1).describe("Identity id (`identity-\u2026` or `id-\u2026`). Other bots in the same graph can be co-attached to multi-bot threads.")
+            z29.object({
+              type: z29.literal("identity"),
+              identityId: z29.string().min(1).describe("Identity id (`identity-\u2026` or `id-\u2026`). Other bots in the same graph can be co-attached to multi-bot threads.")
             })
           ])
         ).max(32).optional().describe("Up to 32 humans and/or other bots to attach at creation. Your primary owner is added automatically \u2014 you do NOT need to list them here."),
-        initialMessage: z31.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: z31.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.")
+        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.")
       })
     },
     async ({ title, participants, initialMessage, visibility }) => {
@@ -1396,20 +1401,20 @@ function registerCreateThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/request-attachment-upload.ts
-import { z as z32 } from "zod";
+import { z as z30 } from "zod";
 function registerRequestAttachmentUpload(server2, client2) {
   server2.registerTool(
     "naumu_request_attachment_upload",
     {
       title: "Request Attachment Upload",
-      annotations: { destructiveHint: true },
-      description: 'Request a presigned S3 upload URL to attach a file to a message. Same flow Naumu users use for file uploads: get a signed URL, PUT the bytes to it directly, then call `naumu_post_message` with the returned `attachmentId` in `attachmentIds`. Use this when you want to deliver generated content as a file (a markdown report, a PDF, an image, an audio recording, a video). Per-MIME size caps apply (typically 50MB umbrella, 10MB for agent-readable types).\n\nReturns `{ attachmentId, uploadUrl, method, requiredHeaders, expiresAt }`. Use these EXACTLY:\n\u2022 `method` is "PUT".\n\u2022 Send every header in `requiredHeaders` (Content-Type matters for S3 signature validation).\n\u2022 Do NOT add an Authorization header \u2014 the URL itself is the auth.\n\u2022 Do NOT log `uploadUrl` \u2014 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. Call `naumu_post_message` with the attachmentId before then or the upload orphans.\n\nServer-side checks at post time enforce that the attachment was uploaded by you, in this graph, for this thread \u2014 you cannot reuse an upload across threads.',
-      inputSchema: z32.object({
-        threadId: z32.string().describe("Thread the attachment will land in. You must be a participant. The pending attachment is keyed to this thread \u2014 you cannot reuse it for a different one."),
-        fileName: z32.string().min(1).describe("Original filename (with extension). Used as the display name in the message and for the S3 object suffix. Special characters are sanitized server-side."),
-        fileType: z32.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: z32.number().int().positive().describe("File size in bytes. Validated against per-MIME caps before the URL is issued \u2014 exceeding the cap returns a 400."),
-        audioDurationSec: z32.number().positive().optional().describe("For audio attachments, duration in seconds. Validated against the audio recording cap (currently 8 hours).")
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+      description: 'Request a presigned S3 upload URL to attach a file to a message; use when you want to deliver generated content as a file (a markdown report, a PDF, an image, an audio recording, a video). Same flow Naumu users use for file uploads: get a signed URL, PUT the bytes to it directly, then call `naumu_post_message` with the returned `attachmentId` in `attachmentIds`. Per-MIME size caps apply (typically 50MB umbrella, 10MB for agent-readable types).\n\nReturns `{ attachmentId, uploadUrl, method, requiredHeaders, expiresAt }`. Use these EXACTLY:\n\u2022 `method` is "PUT".\n\u2022 Send every header in `requiredHeaders` (Content-Type matters for S3 signature validation).\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. Call `naumu_post_message` with the attachmentId before then or the upload orphans.\n\nServer-side checks at post time enforce that the attachment was uploaded by you, in this graph, for this thread - you cannot reuse an upload across threads.',
+      inputSchema: z30.object({
+        threadId: z30.string().describe("Thread the attachment will land in. You must be a participant. The pending attachment is keyed to this thread - you cannot reuse it for a different one."),
+        fileName: z30.string().min(1).describe("Original filename (with extension). Used as the display name in the message 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. Validated against per-MIME caps before the URL is issued - exceeding the cap returns a 400."),
+        audioDurationSec: z30.number().positive().optional().describe("For audio attachments, duration in seconds. Validated against the audio recording cap (currently 8 hours).")
       })
     },
     async ({ threadId, fileName, fileType, fileSize, audioDurationSec }) => {
@@ -1439,18 +1444,18 @@ function registerRequestAttachmentUpload(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-reaction.ts
-import { z as z33 } from "zod";
+import { z as z31 } from "zod";
 function registerAddReaction(server2, client2) {
   server2.registerTool(
     "naumu_add_reaction",
     {
       title: "Add Reaction",
-      annotations: { destructiveHint: true },
-      description: 'Add an emoji reaction to a message in a thread you are participating in. Idempotent \u2014 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 \u2014 situations where words are required.\n\u2022 For long tasks: react \u{1F440} first to acknowledge, optionally post a short "On it \u2014 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 \u2014 pass a real Unicode emoji.')
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+      description: 'Add an emoji reaction to a message in a thread you are participating in; use for lightweight acknowledgement instead of posting a message. Idempotent - calling twice with the same emoji is a no-op (use `naumu_remove_reaction` to undo). Returns `{ ok, messageId, emoji, alreadyExisted, reactionCount, reactions }` so you can confirm the state without re-reading the thread; `alreadyExisted: true` means the reaction was already on the message and the call was a no-op.\n\nWhen to react vs. when to post a message:\n\u2022 React (no message) for lightweight acknowledgement (\u{1F440}, \u2705, \u{1F44D}), appreciation (\u2764\uFE0F, \u{1F64C}), laughter (\u{1F602}), or "I saw this".\n\u2022 Post a message for direct questions, clarification, important corrections, or final results - situations where words are required.\n\u2022 For long tasks: react \u{1F440} first to acknowledge, optionally post a short "On it - I\'ll report back" if the work will take >20s, do the work, then post the final result.\n\u2022 Ignore casual human banter, side-conversations someone else already answered, or anything where you would only say "ok"/"nice"/"lol".\n\nUse at most one reaction per message unless explicitly useful. Reactions are social backpressure relief, not a sparkle-confetti channel.',
+      inputSchema: z31.object({
+        threadId: z31.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z31.string().describe("The message to react to."),
+        emoji: z31.string().min(1).describe('Emoji character (e.g. "\u{1F440}", "\u2705", "\u2764\uFE0F"). Custom-emoji shortcodes are NOT supported here - pass a real Unicode emoji.')
       })
     },
     async ({ threadId, messageId, emoji }) => {
@@ -1474,18 +1479,18 @@ function registerAddReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-reaction.ts
-import { z as z34 } from "zod";
+import { z as z32 } from "zod";
 function registerRemoveReaction(server2, client2) {
   server2.registerTool(
     "naumu_remove_reaction",
     {
       title: "Remove Reaction",
-      annotations: { destructiveHint: true },
-      description: "Remove your own emoji reaction from a message. Idempotent \u2014 calling on a reaction you never added is a no-op. Pair with `naumu_add_reaction` when you need to walk back an acknowledgement (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 }` \u2014 `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).")
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+      description: "Remove your own emoji reaction from a message; use to walk back an acknowledgement you previously added. Idempotent - calling on a reaction you never added is a no-op. Pair with `naumu_add_reaction` (e.g. you reacted \u{1F440} to start a task and want to clear it after a final result message lands). Returns `{ ok, messageId, emoji, alreadyExisted, reactionCount, reactions }` - `alreadyExisted: false` means there was nothing to remove and the call was a no-op.",
+      inputSchema: z32.object({
+        threadId: z32.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z32.string().describe("The message to remove your reaction from."),
+        emoji: z32.string().min(1).describe("Emoji character to remove (must match what you originally reacted with).")
       })
     },
     async ({ threadId, messageId, emoji }) => {
@@ -1509,19 +1514,20 @@ function registerRemoveReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/naumu-typing.ts
-import { z as z35 } from "zod";
+import { z as z33 } from "zod";
 function registerNaumuTyping(server2, client2) {
   server2.registerTool(
     "naumu_typing",
     {
       title: "Set Typing Indicator",
       // Purely ephemeral: drives an in-memory WS typing lease (no durable
-      // state, self-expires, trivially reversible via "stop"). Not destructive.
-      annotations: { destructiveHint: false },
-      description: 'Show or hide your "is typing\u2026" pill in a thread. Call with `state: "start"` the moment you decide to compose a reply (before any LLM call), and the server holds the pill alive \u2014 re-broadcasting on a short interval \u2014 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 \u2014 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.')
+      // state, self-expires, trivially reversible via "stop"). Not destructive;
+      // repeating the same state is a no-op renew, so idempotent.
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+      description: 'Show or hide your "is typing\u2026" pill in a thread; use to signal that you are composing a reply. Call with `state: "start"` the moment you decide to compose a reply (before any LLM call), and the server holds the pill alive - re-broadcasting on a short interval - until you stop, post a message, or the lease cap (~5 min) fires. You do NOT need to refresh on a timer; that\'s the lease\'s job.\n\nThe pill clears automatically when:\n\u2022 you call this tool with `state: "stop"`\n\u2022 you call `naumu_post_message` for the same thread (cleared on commit)\n\u2022 the lease cap expires\n\nUse `start` whenever you start work, even if you might end up not replying - call `stop` if you decide NOT to post. Calling `start` while a lease is already active renews it (resets the cap), so a long-running run can call `start` again as a heartbeat without breaking the indicator. You must be a participant of the thread.',
+      inputSchema: z33.object({
+        threadId: z33.string().describe("The thread ID to set typing in. You must be a participant."),
+        state: z33.enum(["start", "stop"]).describe('"start" acquires/renews the lease; "stop" ends it and clears the pill immediately.')
       })
     },
     async ({ threadId, state }) => {
@@ -1542,16 +1548,16 @@ function registerNaumuTyping(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-read.ts
-import { z as z36 } from "zod";
+import { z as z34 } from "zod";
 function registerNoteRead(server2, client2) {
   server2.registerTool(
     "naumu_note_read",
     {
       title: "Read Note",
-      annotations: { readOnlyHint: true },
-      description: "Read the current contents of a note as markdown. Use before editing so you know what you're working with \u2014 `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")
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: "Read the current contents of a note as markdown; use before editing so you know what you're working with. `naumu_note_find_replace` and the section-based tools (`naumu_note_insert`, `naumu_note_replace_section`, `naumu_note_delete_section`) anchor on text/headings present in the live doc.",
+      inputSchema: z34.object({
+        noteId: z34.string().describe("The note (Thought) ID")
       })
     },
     async ({ noteId }) => {
@@ -1564,17 +1570,17 @@ function registerNoteRead(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-append.ts
-import { z as z37 } from "zod";
+import { z as z35 } from "zod";
 function registerNoteAppend(server2, client2) {
   server2.registerTool(
     "naumu_note_append",
     {
       title: "Append to Note",
-      annotations: { destructiveHint: true },
-      description: "Append markdown blocks to the end of a note. Other participants see your colored cursor while the write lands. Markdown supports headings (1\u20133), bold/italic/code, lists, blockquotes, code blocks, links, and tables.",
-      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")
+      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.",
+      inputSchema: z35.object({
+        noteId: z35.string().describe("The note (Thought) ID to append to"),
+        markdown: z35.string().min(1).describe("Markdown content to append at the end of the note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -1587,18 +1593,18 @@ function registerNoteAppend(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-insert.ts
-import { z as z38 } from "zod";
+import { z as z36 } from "zod";
 function registerNoteInsert(server2, client2) {
   server2.registerTool(
     "naumu_note_insert",
     {
       title: "Insert After Heading",
-      annotations: { destructiveHint: true },
-      description: "Insert markdown content into a note immediately after a named section. The section ends at the next heading of equal-or-higher level (or end of doc). 404 if no heading matches `headingText` exactly \u2014 call `naumu_note_read` first to see the live structure.",
-      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")
+      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.",
+      inputSchema: z36.object({
+        noteId: z36.string().describe("The note (Thought) ID"),
+        headingText: z36.string().min(1).describe("Exact text of the heading whose section the new content follows"),
+        markdown: z36.string().min(1).describe("Markdown content to insert at the end of that section")
       })
     },
     async ({ noteId, headingText, markdown }) => {
@@ -1614,19 +1620,19 @@ function registerNoteInsert(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace-section.ts
-import { z as z39 } from "zod";
+import { z as z37 } from "zod";
 function registerNoteReplaceSection(server2, client2) {
   server2.registerTool(
     "naumu_note_replace_section",
     {
       title: "Replace Section",
-      annotations: { destructiveHint: true },
-      description: "Replace the body under a named heading with new markdown. By default the heading row itself is preserved (set `keepHeading: false` to drop it too). 404 if no heading matches.",
-      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.")
+      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.",
+      inputSchema: z37.object({
+        noteId: z37.string().describe("The note (Thought) ID"),
+        headingText: z37.string().min(1).describe("Exact text of the heading anchoring the section"),
+        markdown: z37.string().describe("Replacement markdown for the section body"),
+        keepHeading: z37.boolean().optional().describe("Whether to keep the heading row itself. Default true.")
       })
     },
     async ({ noteId, headingText, markdown, keepHeading }) => {
@@ -1643,17 +1649,17 @@ function registerNoteReplaceSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-delete-section.ts
-import { z as z40 } from "zod";
+import { z as z38 } from "zod";
 function registerNoteDeleteSection(server2, client2) {
   server2.registerTool(
     "naumu_note_delete_section",
     {
       title: "Delete Section",
-      annotations: { destructiveHint: true },
-      description: "\u26A0 DESTRUCTIVE: removes a heading row plus its body (down to the next heading of equal-or-higher level). Anything inside that section is gone \u2014 there is no per-call undo. ONLY use when the user explicitly asks to drop a section. 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")
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      description: "\u26A0 DESTRUCTIVE: remove a heading row plus its body (down to the next heading of equal-or-higher level); ONLY use when the user explicitly asks to drop a section. Anything inside that section is gone - there is no per-call undo. If you're unsure which heading they meant, call `naumu_note_read` first to see the current structure. Returns 404 if `headingText` does not exactly match any live heading.",
+      inputSchema: z38.object({
+        noteId: z38.string().describe("The note (Thought) ID"),
+        headingText: z38.string().min(1).describe("Exact text of the heading whose section will be deleted")
       })
     },
     async ({ noteId, headingText }) => {
@@ -1668,17 +1674,17 @@ function registerNoteDeleteSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace.ts
-import { z as z41 } from "zod";
+import { z as z39 } from "zod";
 function registerNoteReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_replace",
     {
       title: "Replace Note",
-      annotations: { destructiveHint: true },
-      description: "\u26A0 DESTRUCTIVE: replaces the entire note content with new markdown. Any concurrent human edits made during the call are silently overwritten. ONLY use when the user explicitly asks to rewrite/replace the whole note. 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.",
-      inputSchema: z41.object({
-        noteId: z41.string().describe("The note (Thought) ID"),
-        markdown: z41.string().describe("New markdown content for the entire 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.",
+      inputSchema: z39.object({
+        noteId: z39.string().describe("The note (Thought) ID"),
+        markdown: z39.string().describe("New markdown content for the entire note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -1691,19 +1697,19 @@ function registerNoteReplace(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-find-replace.ts
-import { z as z42 } from "zod";
+import { z as z40 } from "zod";
 function registerNoteFindReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_find_replace",
     {
       title: "Find/Replace in Note",
-      annotations: { destructiveHint: true },
-      description: "Literal find/replace within a note's text content. Marks (bold, italic, code, etc.) are preserved on the surrounding text. Use this for mid-paragraph tweaks \u2014 the section-based tools can't target inline substrings. \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.",
-      inputSchema: z42.object({
-        noteId: z42.string().describe("The note (Thought) ID"),
-        find: z42.string().min(1).describe("Substring to search for. Literal \u2014 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.")
+      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.",
+      inputSchema: z40.object({
+        noteId: z40.string().describe("The note (Thought) ID"),
+        find: z40.string().min(1).describe("Substring to search for. Literal - no regex."),
+        replace: z40.string().describe("Replacement string. May be empty to delete the match."),
+        all: z40.boolean().optional().describe("Replace all occurrences (default true). Pass false to replace only the first.")
       })
     },
     async ({ noteId, find, replace, all }) => {
@@ -1720,7 +1726,7 @@ function registerNoteFindReplace(server2, client2) {
 }
 
 // ../mcp-core/src/tools/canvas-add-element.ts
-import { z as z43 } from "zod";
+import { z as z41 } from "zod";
 var ELEMENT_TYPES = [
   "rectangle",
   "ellipse",
@@ -1738,25 +1744,25 @@ function registerCanvasAddElement(server2, client2) {
     "naumu_canvas_add_element",
     {
       title: "Add Canvas Element",
-      annotations: { destructiveHint: true },
-      description: "Add a new element to a canvas. Other participants see your colored cursor at the element's center while it lands. The server fills in `id`, `version`, `fractionalIndex`, and `seed` automatically \u2014 pass only `type`, position (`x`, `y`), and size (`width`, `height`); other fields are optional and have sensible defaults (stroke #1e1e1e, no fill, opacity 1, etc.). For text elements, set `label` and `fontSize`. Coordinates are canvas-space (the same units the live editor uses).",
-      inputSchema: z43.object({
-        canvasId: z43.string().describe("The canvas ID"),
-        element: z43.object({
-          type: z43.enum(ELEMENT_TYPES).describe("Element shape"),
-          x: z43.number().describe("Top-left x coordinate in canvas space"),
-          y: z43.number().describe("Top-left y coordinate in canvas space"),
-          width: z43.number().describe("Width in canvas units"),
-          height: z43.number().describe("Height in canvas units"),
-          strokeColor: z43.string().optional().describe("Stroke color (hex). Default #1e1e1e."),
-          fillColor: z43.string().optional().describe('Fill color (hex) or "transparent". Default transparent.'),
-          strokeWidth: z43.number().optional().describe("Stroke width. Default 2."),
-          opacity: z43.number().min(0).max(1).optional().describe("0..1, default 1"),
-          roughness: z43.number().min(0).max(2).optional().describe("Hand-drawn roughness 0..2. Default 1."),
-          label: z43.string().optional().describe("Optional label/text content"),
-          labelFontSize: z43.number().optional().describe("Label font size"),
-          angle: z43.number().optional().describe("Rotation in radians. Default 0.")
-        }).passthrough().describe("Element fields. Pass only what you set \u2014 defaults fill the rest.")
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+      description: "Add a new element to a canvas; use to draw a shape, text, or embed onto a drawing surface. Other participants see your colored cursor at the element's center while it lands. The server fills in `id`, `version`, `fractionalIndex`, and `seed` automatically - pass only `type`, position (`x`, `y`), and size (`width`, `height`); other fields are optional and have sensible defaults (stroke #1e1e1e, no fill, opacity 1, etc.). For text elements, set `label` and `fontSize`. Coordinates are canvas-space (the same units the live editor uses).",
+      inputSchema: z41.object({
+        canvasId: z41.string().describe("The canvas ID"),
+        element: z41.object({
+          type: z41.enum(ELEMENT_TYPES).describe("Element shape"),
+          x: z41.number().describe("Top-left x coordinate in canvas space"),
+          y: z41.number().describe("Top-left y coordinate in canvas space"),
+          width: z41.number().describe("Width in canvas units"),
+          height: z41.number().describe("Height in canvas units"),
+          strokeColor: z41.string().optional().describe("Stroke color (hex). Default #1e1e1e."),
+          fillColor: z41.string().optional().describe('Fill color (hex) or "transparent". Default transparent.'),
+          strokeWidth: z41.number().optional().describe("Stroke width. Default 2."),
+          opacity: z41.number().min(0).max(1).optional().describe("0..1, default 1"),
+          roughness: z41.number().min(0).max(2).optional().describe("Hand-drawn roughness 0..2. Default 1."),
+          label: z41.string().optional().describe("Optional label/text content"),
+          labelFontSize: z41.number().optional().describe("Label font size"),
+          angle: z41.number().optional().describe("Rotation in radians. Default 0.")
+        }).passthrough().describe("Element fields. Pass only what you set - defaults fill the rest.")
       })
     },
     async ({ canvasId, element }) => {
@@ -1769,18 +1775,18 @@ function registerCanvasAddElement(server2, client2) {
 }
 
 // ../mcp-core/src/tools/canvas-update-element.ts
-import { z as z44 } from "zod";
+import { z as z42 } from "zod";
 function registerCanvasUpdateElement(server2, client2) {
   server2.registerTool(
     "naumu_canvas_update_element",
     {
       title: "Update Canvas Element",
-      annotations: { destructiveHint: true },
-      description: "Patch an existing canvas element. Only the fields you pass in `changes` are updated \u2014 `id`, `version`, `createdBy`, and `isDeleted` are server-managed and ignored if present. Useful for moving (`x`, `y`), resizing (`width`, `height`), recoloring (`strokeColor`, `fillColor`), or relabeling (`label`).",
-      inputSchema: z44.object({
-        canvasId: z44.string().describe("The canvas ID"),
-        elementId: z44.string().describe("The element ID returned by `naumu_canvas_add_element` or `naumu_get_canvas_elements`"),
-        changes: z44.record(z44.string(), z44.unknown()).describe("Partial element fields to merge in. Server bumps `version` automatically.")
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      description: "Patch an existing canvas element; use to move, resize, recolor, or relabel a shape already on the canvas. Only the fields you pass in `changes` are updated - `id`, `version`, `createdBy`, and `isDeleted` are server-managed and ignored if present. Useful for moving (`x`, `y`), resizing (`width`, `height`), recoloring (`strokeColor`, `fillColor`), or relabeling (`label`).",
+      inputSchema: z42.object({
+        canvasId: z42.string().describe("The canvas ID"),
+        elementId: z42.string().describe("The element ID returned by `naumu_canvas_add_element` or `naumu_get_canvas_elements`"),
+        changes: z42.record(z42.string(), z42.unknown()).describe("Partial element fields to merge in. Server bumps `version` automatically.")
       })
     },
     async ({ canvasId, elementId, changes }) => {
@@ -1796,17 +1802,17 @@ function registerCanvasUpdateElement(server2, client2) {
 }
 
 // ../mcp-core/src/tools/canvas-remove-element.ts
-import { z as z45 } from "zod";
+import { z as z43 } from "zod";
 function registerCanvasRemoveElement(server2, client2) {
   server2.registerTool(
     "naumu_canvas_remove_element",
     {
       title: "Remove Canvas Element",
-      annotations: { destructiveHint: true },
-      description: "Soft-delete a canvas element. The element is tombstoned (isDeleted=true) so concurrent edits don't resurrect it. 404 if the element id is not present on this canvas.",
-      inputSchema: z45.object({
-        canvasId: z45.string().describe("The canvas ID"),
-        elementId: z45.string().describe("The element ID to delete")
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+      description: "Soft-delete a canvas element; use to remove a shape from a canvas. The element is tombstoned (isDeleted=true) so concurrent edits don't resurrect it. 404 if the element id is not present on this canvas.",
+      inputSchema: z43.object({
+        canvasId: z43.string().describe("The canvas ID"),
+        elementId: z43.string().describe("The element ID to delete")
       })
     },
     async ({ canvasId, elementId }) => {
@@ -1819,17 +1825,17 @@ function registerCanvasRemoveElement(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-note.ts
-import { z as z46 } from "zod";
+import { z as z44 } from "zod";
 function registerCreateNote(server2, client2) {
   server2.registerTool(
     "naumu_create_note",
     {
       title: "Create Note",
-      annotations: { destructiveHint: true },
-      description: "Create a new empty note in a graph. Returns the new note row including its `id` \u2014 pass that id to `naumu_note_append` / `naumu_note_replace` to fill in the content. Bots can only create notes in their own graph.",
-      inputSchema: z46.object({
-        graphId: z46.string().describe("The graph ID to create the note in"),
-        title: z46.string().optional().describe("Optional title for the note")
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+      description: "Create a new empty note in a graph; use when you need a fresh note to write into. Returns the new note row including its `id` - pass that id to `naumu_note_append` / `naumu_note_replace` to fill in the content. Bots can only create notes in their own graph.",
+      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")
       })
     },
     async ({ graphId, title }) => {
@@ -1842,17 +1848,17 @@ function registerCreateNote(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-canvas.ts
-import { z as z47 } from "zod";
+import { z as z45 } from "zod";
 function registerCreateCanvas(server2, client2) {
   server2.registerTool(
     "naumu_create_canvas",
     {
       title: "Create Canvas",
-      annotations: { destructiveHint: true },
-      description: "Create a new empty canvas in a graph. Returns the new canvas row including its `id` \u2014 pass that id to `naumu_canvas_add_element` to start drawing. Bots can only create canvases in their own graph.",
-      inputSchema: z47.object({
-        graphId: z47.string().describe("The graph ID to create the canvas in"),
-        title: z47.string().optional().describe("Optional title for the canvas")
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+      description: "Create a new empty canvas in a graph; use when you need a fresh drawing surface. Returns the new canvas row including its `id` - pass that id to `naumu_canvas_add_element` to start drawing. Bots can only create canvases in their own graph.",
+      inputSchema: z45.object({
+        graphId: z45.string().describe("The graph ID to create the canvas in"),
+        title: z45.string().optional().describe("Optional title for the canvas")
       })
     },
     async ({ graphId, title }) => {
@@ -1865,42 +1871,101 @@ function registerCreateCanvas(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-schema-violations.ts
-import { z as z48 } from "zod";
+import { z as z46 } from "zod";
+var DEFAULT_EXAMPLE_LIMIT = 5;
+var rowsForKind = (violations, kind) => {
+  const rows = [];
+  for (const v of violations) {
+    for (const issue of v.issues) {
+      if (issue.kind !== kind) continue;
+      rows.push({ nodeId: v.nodeId, label: v.label, type: v.type, message: issue.message });
+    }
+  }
+  return rows;
+};
+var allKinds = (violations) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of violations) {
+    for (const issue of v.issues) seen.add(issue.kind);
+  }
+  return [...seen];
+};
 function registerListSchemaViolations(server2, client2) {
   server2.registerTool(
     "naumu_list_schema_violations",
     {
       title: "List Schema Violations",
-      annotations: { readOnlyHint: true },
-      description: "List every schema-validation issue in a graph. Returns each node with issues and a summary by violation kind: parent_missing (schema expects a parent edge that does not exist), parent_multiple (more than one parent edge on a node that should have one), parent_mismatch (parent edge has wrong target type or relation label), unknown_relation (edge uses a relation label not defined in the schema), invalid_connection_target (edge connects to a type the schema does not allow for this source). Use for audits, import-verification, and CI-style checks after batch writes.",
-      inputSchema: z48.object({
-        graphId: z48.string().describe("The graph ID")
+      annotations: { readOnlyHint: true, 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: 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: 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)."
+        )
       })
     },
-    async ({ graphId }) => {
+    async ({ graphId, kind, limit }) => {
       const data = await client2.get(
         `/api/graphs/${graphId}/schema/validation`
       );
+      const { violations, summary } = data;
+      if (kind) {
+        const rows = rowsForKind(violations, kind);
+        const capped = limit !== void 0 ? rows.slice(0, limit) : rows;
+        const payload2 = {
+          graphId,
+          kind,
+          nodeCount: summary.nodeCount,
+          totalForKind: rows.length,
+          returned: capped.length,
+          truncated: capped.length < rows.length,
+          rows: capped
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }]
+        };
+      }
+      const exampleLimit = limit ?? DEFAULT_EXAMPLE_LIMIT;
+      const byKind = allKinds(violations).map((k) => {
+        const rows = rowsForKind(violations, k);
+        return {
+          kind: k,
+          count: summary.byKind[k] ?? rows.length,
+          examples: rows.slice(0, exampleLimit)
+        };
+      }).sort((a, b) => b.count - a.count);
+      const payload = {
+        graphId,
+        nodeCount: summary.nodeCount,
+        nodesWithIssues: summary.nodesWithIssues,
+        totalIssues: summary.totalIssues,
+        exampleLimit,
+        byKind,
+        hint: summary.totalIssues === 0 ? "No violations \u2014 the graph conforms to its schema." : "Pass `kind` to list every node for one violation kind (use `limit` to cap rows)."
+      };
       return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
       };
     }
   );
 }
 
 // ../mcp-core/src/tools/list-dense-nodes.ts
-import { z as z49 } from "zod";
+import { z as z47 } from "zod";
 function registerListDenseNodes(server2, client2) {
   server2.registerTool(
     "naumu_list_dense_nodes",
     {
       title: "List Dense Nodes",
-      annotations: { readOnlyHint: true },
-      description: 'Return nodes whose total edge count (in+out, non-system) is \u2265 minConnections, grouped by type. Built for /restructure hub detection: each row includes `same_typed_child_count` \u2014 the number of children of the SAME type as the node (the Naumu hub-pattern signal). 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. ["Feature","Company"]). Cheap to call \u2014 runs a single Cypher aggregation.',
-      inputSchema: z49.object({
-        graphId: z49.string().describe("The graph ID"),
-        minConnections: z49.number().int().min(1).describe("Minimum total edge count (in + out, excluding system relations). Typical: 10 for hub detection, 11 to count only hubs that exceed the round-4 \u226410 threshold."),
-        nodeTypes: z49.array(z49.string()).optional().describe("Optional list of node types to restrict the scan to.")
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      description: 'Return nodes whose total edge count (in+out, non-system) 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). 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. ["Feature","Company"]). Cheap to call - runs a single Cypher aggregation.',
+      inputSchema: z47.object({
+        graphId: z47.string().describe("The graph ID"),
+        minConnections: z47.number().int().min(1).describe("Minimum total edge count (in + out, excluding system relations). 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 }) => {
@@ -1918,19 +1983,19 @@ function registerListDenseNodes(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-node-connections.ts
-import { z as z50 } from "zod";
+import { z as z48 } from "zod";
 function registerListNodeConnections(server2, client2) {
   server2.registerTool(
     "naumu_list_node_connections",
     {
       title: "List Node Connections",
-      annotations: { readOnlyHint: true },
-      description: 'Return a single node\'s edges (non-system) with the connected node on the other side. Used 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: z50.object({
-        graphId: z50.string().describe("The graph ID"),
-        nodeId: z50.string().describe("The node ID to inspect"),
-        edgeType: z50.string().optional().describe('Restrict to a specific relation label (e.g. "ASSOCIATED_WITH"). Case-insensitive; non-alphanum chars are normalized.'),
-        direction: z50.enum(["in", "out", "both"]).optional().describe('Edge direction filter \u2014 "in" (incoming), "out" (outgoing), "both" (default).')
+      annotations: { readOnlyHint: true, 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: 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 }) => {
@@ -1948,19 +2013,19 @@ function registerListNodeConnections(server2, client2) {
 }
 
 // ../mcp-core/src/tools/reparent.ts
-import { z as z51 } from "zod";
+import { z as z49 } from "zod";
 function registerReparent(server2, client2) {
   server2.registerTool(
     "naumu_reparent",
     {
       title: "Reparent Node",
-      annotations: { destructiveHint: true },
-      description: 'Atomically swap a node\'s parent edge. 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** \u2014 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"}`. Use during /restructure to reparent children under newly-created mini-hubs.',
-      inputSchema: z51.object({
-        graphId: z51.string().describe("The graph ID"),
-        nodeId: z51.string().describe("The child node to reparent"),
-        newParentId: z51.string().describe("The new parent node id"),
-        newRelation: z51.string().describe('The new parent edge relation label (e.g. "PART_OF"). Must be valid per the schema for (child.type, relation, parent.type).')
+      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: 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 }) => {
@@ -1976,19 +2041,19 @@ function registerReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/batch-reparent.ts
-import { z as z52 } from "zod";
+import { z as z50 } from "zod";
 function registerBatchReparent(server2, client2) {
   server2.registerTool(
     "naumu_batch_reparent",
     {
       title: "Batch Reparent Nodes",
-      annotations: { destructiveHint: true },
-      description: 'Reparent 1\u201325 nodes onto a shared `newParentId` with the same `newRelation`. 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?}]`. Used to move a same-typed cluster under a freshly-created mini-hub in /restructure.',
-      inputSchema: z52.object({
-        graphId: z52.string().describe("The graph ID"),
-        newParentId: z52.string().describe("Parent node id every nodeId in the batch will be parented to"),
-        newRelation: z52.string().describe("Parent edge relation label (must be valid per schema for child.type \u2192 parent.type)"),
-        nodeIds: z52.array(z52.string()).min(1).max(25).describe("1\u201325 child node ids to reparent under `newParentId`")
+      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: 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 }) => {
@@ -2005,7 +2070,7 @@ function registerBatchReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-search.ts
-import { z as z53 } from "zod";
+import { z as z51 } from "zod";
 
 // ../mcp-core/src/public-origin.ts
 function publicOrigin() {
@@ -2057,10 +2122,10 @@ function registerChatgptSearch(server2, client2) {
     "search",
     {
       title: "Search",
-      annotations: { readOnlyHint: true },
+      annotations: { readOnlyHint: true, 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: z53.object({
-        query: z53.string().describe('Search query text. Mix synonyms and exact tokens freely (e.g. "auth login SSO 2fa").')
+      inputSchema: z51.object({
+        query: z51.string().describe('Search query text. Mix synonyms and exact tokens freely (e.g. "auth login SSO 2fa").')
       })
     },
     async ({ query }) => {
@@ -2092,7 +2157,7 @@ function registerChatgptSearch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-fetch.ts
-import { z as z54 } from "zod";
+import { z as z52 } from "zod";
 var NON_ATTRIBUTE_PROPS = /* @__PURE__ */ new Set([
   "id",
   "label",
@@ -2155,10 +2220,10 @@ function registerChatgptFetch(server2, client2) {
     "fetch",
     {
       title: "Fetch",
-      annotations: { readOnlyHint: true },
+      annotations: { readOnlyHint: true, 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: z54.object({
-        id: z54.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 }) => {
@@ -2221,14 +2286,13 @@ var TOOL_REGISTRARS = {
   naumu_remove_edge: registerRemoveEdge,
   naumu_remove_edges_bulk: registerRemoveEdgesBulk,
   naumu_ask: registerAsk,
-  naumu_get_ai_thread: registerGetAiThread,
-  naumu_traverse: registerTraverse,
+  naumu_delegate: registerDelegate,
+  // naumu_traverse omitted on purpose — backend stub returns 503 (see import note).
   naumu_list_canvases: registerListCanvases,
   naumu_get_canvas_elements: registerGetCanvasElements,
   naumu_get_canvas_image: registerGetCanvasImage,
   naumu_post_message: registerPostMessage,
   naumu_read_thread: registerReadThread,
-  naumu_ask_naumu: registerAskNaumu,
   naumu_whoami: registerWhoami,
   naumu_list_threads: registerListThreads,
   naumu_get_thread: registerGetThread,