@naumu/mcp 0.6.4 → 0.7.0

package/dist/index.js

@@ -118,7 +118,7 @@ var NaumuClient = class {
 // ../mcp-core/src/instructions.ts
 var NAUMU_INSTRUCTIONS = `The Naumu MCP server gives structured access to Naumu knowledge graphs (also called spaces). Prefer these tools over WebFetch whenever the user mentions a naumu.ai URL \u2014 Naumu pages are client-rendered React, so WebFetch returns an empty shell with no data.
 
-Getting information about a space: 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.
+Getting information about a space: use naumu_ask. It puts your question to the @Naumu agent (which has full read access and inspects the graph for you) and returns a synthesised, node-grounded answer with the exact source node ids and a confidence hint, in a single call. It is the authoritative answer for what is in a space, what is new or recently changed, how something works, or any summary - present it and its sources directly. Do NOT then re-read the graph yourself with naumu_get_schema, naumu_filter, naumu_get_node or fetch to verify or sanity-check the answer: that repeats work naumu_ask already did and is dramatically slower (it can turn a 40-second answer into minutes). Trust the answer and its cited sources. Reach for a granular read only to fetch one specific node the answer pointed to, or for a need naumu_ask genuinely cannot serve (naumu_search to locate nodes by meaning, naumu_list_threads + naumu_read_thread for conversation history). Recording the question and answer as a visible conversation in the space is expected and useful, so do not avoid naumu_ask to prevent creating a thread. To hand @Naumu work to carry out in the background (add knowledge, make changes, record a status update), use naumu_delegate.
 
 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.
 
@@ -127,20 +127,9 @@ Call naumu_list_graphs and find the graph whose 'slug' field matches the URL seg
 
 URL \u2192 tool mapping (the value after /spaces/ is the slug \u2014 resolve it first):
 - 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_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:
-1. naumu_list_graphs \u2014 find the graph whose slug matches the URL. Note its 'id' (the UUID) as graphId.
-2. naumu_get_view {graphId, viewId} \u2014 read the returned 'summary' and 'filters' to understand what the view returns. This is cheap.
-3. naumu_list_view_nodes {graphId, viewId} \u2014 page through results.
-   - fields:"summary" (default) for {id, label, type} per node \u2014 best for browsing.
-   - fields:"id" for {id} only \u2014 best when you just need to count or iterate.
-   - fields:"full" for the complete node payload \u2014 only when you need every attribute.
-   - The response always includes totalCount, so you don't need to page through everything to get a count.
-4. naumu_get_node {graphId, nodeId} for per-node detail when needed.
+- Other panel URLs (notes, canvases, views, 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.
 
 Localhost URLs (http://localhost:3000/spaces/{slug}/...) follow the same shape \u2014 resolve the slug the same way. The MCP backend host is configured separately; the URL the user pastes is just for parsing structure.`;
 
@@ -151,7 +140,7 @@ function registerListGraphs(server2, client2) {
     "naumu_list_graphs",
     {
       title: "List Graphs",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "List all knowledge graphs (spaces) the authenticated user has access to. Returns graph IDs, names, and roles.",
       inputSchema: z.object({})
     },
@@ -219,8 +208,7 @@ function formatSchema(schema) {
             if (v.description) value.description = v.description;
             return value;
           });
-          const attr = { name: a.name, values };
-          if (a.type) attr.type = a.type;
+          const attr = { name: a.name, type: a.type ?? "select", values };
           if (a.description) attr.description = a.description;
           return attr;
         });
@@ -234,7 +222,7 @@ function registerGetSchema(server2, client2) {
     "naumu_get_schema",
     {
       title: "Get Graph Schema",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, 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")
@@ -268,16 +256,16 @@ 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 - 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 - 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")'),
-  type: z4.enum(["select", "multiselect", "string", "number", "date"]).optional().describe("Attribute type. Defaults to select if omitted."),
+  type: z4.enum(["select", "multiselect", "string", "number", "date"]).describe('Attribute type (required). select/multiselect define a closed set of categories with values; string/number/date hold free-form per-node data with values []. Calendar dates use "date", not select values.'),
   values: z4.array(AttributeValueSchema).describe("Allowed enum values for select/multiselect; pass [] for string/number/date."),
   description: z4.string().optional().describe("Short note explaining what this attribute captures and how it differs from similarly-named attributes elsewhere in the schema. Strongly encouraged.")
 });
 var NodeTypeSchema = z4.object({
-  type: z4.string().describe("Type name in PascalCase (e.g. Company, Person, Feature, Document)"),
+  type: z4.string().describe("Type name in PascalCase (e.g. TypeA, TypeB)"),
   connections: z4.object({
     parent: ConnectionSchema.optional().describe("Optional parent relation (this type nests under another via this connection)."),
     required: z4.array(ConnectionSchema).default([]).describe("Required outgoing connections to other types."),
@@ -288,7 +276,7 @@ var NodeTypeSchema = z4.object({
     '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 - 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. "Type A - distinct from Type B, which is broader"). 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."),
@@ -300,7 +288,7 @@ function registerUpdateSchema(server2, client2) {
     {
       title: "Update Graph Schema",
       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.",
+      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, relation names UPPER_SNAKE_CASE. 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
@@ -327,13 +315,13 @@ var ConnectionSchema2 = z5.object({
 var AttributeValueSchema2 = z5.object({
   label: z5.string(),
   color: z5.string().optional(),
-  description: z5.string().optional().describe('Short note distinguishing this value from sibling values (e.g. for status="closed-won", "Deal signed and revenue committed"). Encouraged when the label alone is ambiguous.')
+  description: z5.string().optional().describe('Short note distinguishing this value from sibling values (e.g. for status="closed-won", "signed and revenue committed"). Encouraged when the label alone is ambiguous.')
 });
 var AttributeSchema2 = z5.object({
   name: z5.string(),
-  type: z5.enum(["select", "multiselect", "string", "number", "date"]).optional(),
+  type: z5.enum(["select", "multiselect", "string", "number", "date"]).describe('Attribute type (required). select/multiselect define a closed set of categories with values; string/number/date hold free-form per-node data with values []. Calendar dates use "date", not select values.'),
   values: z5.array(AttributeValueSchema2).default([]),
-  description: z5.string().optional().describe('Short note explaining what this attribute captures and how it differs from similarly-named attributes on other types (e.g. "stage on Feature" vs "stage on Deal"). Strongly encouraged.')
+  description: z5.string().optional().describe('Short note explaining what this attribute captures and how it differs from similarly-named attributes on other types (e.g. "stage on Type A" vs "stage on Type B"). Strongly encouraged.')
 });
 function registerAddNodeType(server2, client2) {
   server2.registerTool(
@@ -341,7 +329,7 @@ function registerAddNodeType(server2, client2) {
     {
       title: "Add Node Type to Schema",
       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.',
+      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. Relation names UPPER_SNAKE_CASE. (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. "Type A \u2014 distinct from Type B, which is broader"). 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"),
@@ -395,7 +383,7 @@ function registerAddConnection(server2, client2) {
     {
       title: "Add Connection to Node Type",
       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.',
+      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. Type A under Type A) 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."),
@@ -445,12 +433,12 @@ function registerAddAttribute(server2, client2) {
     {
       title: "Add Attribute to Node Type",
       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.',
+      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). 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."),
         name: z7.string().describe('Attribute key (e.g. "stage", "status").'),
-        type: z7.enum(["select", "multiselect", "string", "number", "date"]).default("select"),
+        type: z7.enum(["select", "multiselect", "string", "number", "date"]).describe('Attribute type (required). select/multiselect define a closed set of categories - provide their values. string/number/date hold free-form per-node data - pass values: []. A specific calendar date is per-node data, so use type "date" and write the date on the node, rather than adding the date as a select value.'),
         values: z7.array(
           z7.object({
             label: z7.string(),
@@ -498,7 +486,7 @@ function registerSearch(server2, client2) {
     "naumu_search",
     {
       title: "Search Graph",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Hybrid search over graph nodes; use for meaning-based lookup when you don\'t know the exact label. Combines 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"),
@@ -506,7 +494,7 @@ function registerSearch(server2, client2) {
           'Search query text. Mix synonyms and exact tokens freely (e.g. "auth login SSO 2fa Twitter handle").'
         ),
         limit: z8.number().optional().default(20).describe("Max results to return (default 20, max 200). Adaptive cutoff may return fewer when the top match is weak."),
-        nodeTypes: z8.array(z8.string()).optional().describe('Filter to specific node types (e.g. ["Feature", "Pain"])')
+        nodeTypes: z8.array(z8.string()).optional().describe('Filter to specific node types (e.g. ["Type A", "Type B"])')
       })
     },
     async ({ graphId, query, limit, nodeTypes }) => {
@@ -529,11 +517,11 @@ function registerFilter(server2, client2) {
     "naumu_filter",
     {
       title: "Filter Graph Nodes",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Filter nodes by type and attributes with deterministic, complete results; use for structured queries like "all in-progress Tasks" or "Bugs not yet resolved." Unlike search tools, this returns every matching node (up to the limit) - no semantic ranking, no missed results. Results are sorted by sortKey or recency.',
       inputSchema: 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"])'),
+        nodeTypes: z9.array(z9.string()).optional().describe('Filter to specific node types (e.g. ["Type A", "Type B"])'),
         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"]}'
         ),
@@ -572,7 +560,7 @@ function registerGetNode(server2, client2) {
     "naumu_get_node",
     {
       title: "Get Node",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, 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"),
@@ -592,7 +580,7 @@ function registerGetNode(server2, client2) {
 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)"),
+  type: z11.string().describe("Node type from the graph schema"),
   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")
 });
@@ -883,7 +871,7 @@ function registerAsk(server2, client2) {
         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.',
+      description: 'Ask @Naumu a question about a space and get back a synthesised, node-grounded answer with the exact source node ids it used and a confidence hint. This is THE tool for any question about a space - what is in it, what is new or recently changed, how something works, or a summary of any topic. @Naumu has full read access and has already inspected the graph for you, so its answer is authoritative: present it and its cited sources directly. Do NOT independently re-read the graph (naumu_get_schema, naumu_filter, naumu_get_node, fetch) to verify or flesh out the answer - that repeats work @Naumu already did and is far slower. Reach for a granular read ONLY to pull a specific node the answer pointed to but did not fully include. Returns { answer, sources, confidence, threadId, status }; the answer is saved as a visible conversation in the space, which is expected and useful, so do not avoid the tool to prevent creating a thread. On a very long synthesis it may return status "processing" with a threadId - in that case wait a few seconds and call naumu_read_thread with that threadId for the final answer, and still do not fall back to manual digging. To hand @Naumu work to carry out (add knowledge, make changes, record status) without waiting, use naumu_delegate instead.',
       inputSchema: z17.object({
         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.")
@@ -963,184 +951,8 @@ function registerDelegate(server2, client2) {
   );
 }
 
-// ../mcp-core/src/tools/get-view.ts
-import { z as z19 } from "zod";
-function registerGetView(server2, client2) {
-  server2.registerTool(
-    "naumu_get_view",
-    {
-      title: "Get 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 }) => {
-      const data = await client2.get(`/api/graphs/${graphId}/views/${viewId}`);
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
-// ../mcp-core/src/tools/list-view-nodes.ts
-import { z as z20 } from "zod";
-function registerListViewNodes(server2, client2) {
-  server2.registerTool(
-    "naumu_list_view_nodes",
-    {
-      title: "List View Nodes",
-      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 }) => {
-      const params = new URLSearchParams();
-      if (cursor) params.set("cursor", cursor);
-      if (limit !== void 0) params.set("limit", String(limit));
-      if (fields) params.set("fields", fields);
-      const qs = params.toString();
-      const path = `/api/graphs/${graphId}/views/${viewId}/nodes${qs ? `?${qs}` : ""}`;
-      const data = await client2.get(path);
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
-// ../mcp-core/src/tools/list-canvases.ts
-import { z as z21 } from "zod";
-function registerListCanvases(server2, client2) {
-  server2.registerTool(
-    "naumu_list_canvases",
-    {
-      title: "List Canvases",
-      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: z21.object({
-        graphId: z21.string().describe("The graph ID to list canvases for")
-      })
-    },
-    async ({ graphId }) => {
-      const data = await client2.get(`/api/canvases?graphId=${encodeURIComponent(graphId)}`);
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
-// ../mcp-core/src/tools/get-canvas-elements.ts
-import { z as z22 } from "zod";
-function registerGetCanvasElements(server2, client2) {
-  server2.registerTool(
-    "naumu_get_canvas_elements",
-    {
-      title: "Get Canvas Elements",
-      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 }) => {
-      const data = await client2.get(`/api/canvases/${encodeURIComponent(canvasId)}/elements`);
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
-// ../mcp-core/src/tools/get-canvas-image.ts
-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, 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."
-        )
-      })
-    },
-    async ({ canvasId, scale, theme, mode }) => {
-      if (mode === "url") {
-        return await fetchAsUrl(client2, canvasId, scale, theme);
-      }
-      const params = new URLSearchParams({
-        scale: String(scale),
-        theme
-      });
-      const { buffer, contentType } = await client2.getBinary(
-        `/api/canvases/${encodeURIComponent(canvasId)}/image?${params.toString()}`
-      );
-      if (buffer.byteLength > MAX_INLINE_BYTES) {
-        return await fetchAsUrl(client2, canvasId, scale, theme, {
-          reason: `Canvas PNG is ${formatBytes(buffer.byteLength)}, exceeds inline limit ${formatBytes(MAX_INLINE_BYTES)} \u2014 returning signed URL instead.`
-        });
-      }
-      const base64 = bufferToBase64(buffer);
-      return {
-        content: [
-          {
-            type: "image",
-            data: base64,
-            mimeType: contentType.startsWith("image/") ? contentType : "image/png"
-          }
-        ]
-      };
-    }
-  );
-}
-async function fetchAsUrl(client2, canvasId, scale, theme, extra) {
-  const params = new URLSearchParams({
-    as: "url",
-    scale: String(scale),
-    theme
-  });
-  const data = await client2.get(
-    `/api/canvases/${encodeURIComponent(canvasId)}/image?${params.toString()}`
-  );
-  const payload = extra ? { ...data, note: extra.reason } : data;
-  return {
-    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
-  };
-}
-function bufferToBase64(buffer) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(buffer).toString("base64");
-  }
-  let binary = "";
-  for (let i = 0; i < buffer.byteLength; i++) {
-    binary += String.fromCharCode(buffer[i]);
-  }
-  return btoa(binary);
-}
-function formatBytes(bytes) {
-  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-  return `${(bytes / 1024).toFixed(1)}KB`;
-}
-
 // ../mcp-core/src/tools/post-message.ts
-import { z as z24 } from "zod";
+import { z as z19 } from "zod";
 function registerPostMessage(server2, client2) {
   server2.registerTool(
     "naumu_post_message",
@@ -1155,11 +967,11 @@ function registerPostMessage(server2, client2) {
         openWorldHint: false
       },
       description: 'Post a message in a Naumu thread you participate in. Use it to reply to humans (or other bots) in a thread that pinged you. 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.")
+      inputSchema: z19.object({
+        threadId: z19.string().describe("The thread ID to post into. You must be a participant in this thread."),
+        content: z19.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: z19.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: z19.array(z19.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 }) => {
@@ -1185,18 +997,18 @@ function registerPostMessage(server2, client2) {
 }
 
 // ../mcp-core/src/tools/read-thread.ts
-import { z as z25 } from "zod";
+import { z as z20 } from "zod";
 function registerReadThread(server2, client2) {
   server2.registerTool(
     "naumu_read_thread",
     {
       title: "Read Thread",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Read messages from a Naumu thread. Returns paginated history ordered newest-first; each message carries a `status` (`processing` while @Naumu is still composing, `complete` when done). Use this to pick up an answer after naumu_ask returns status "processing", or to read what naumu_delegate produced. Use `before` (timestamp ms) to page further back. Default page size 50, max 200.',
-      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.")
+      inputSchema: z20.object({
+        threadId: z20.string().describe("The thread ID to read from."),
+        before: z20.number().optional().describe("Unix timestamp in milliseconds. Returns messages strictly older than this. Omit for the newest page."),
+        limit: z20.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ threadId, before, limit }) => {
@@ -1222,15 +1034,15 @@ function registerReadThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/whoami.ts
-import { z as z26 } from "zod";
+import { z as z21 } from "zod";
 function registerWhoami(server2, client2, allToolNames) {
   server2.registerTool(
     "naumu_whoami",
     {
       title: "Who Am I",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, 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({})
+      inputSchema: z21.object({})
     },
     async () => {
       try {
@@ -1253,7 +1065,7 @@ function registerWhoami(server2, client2, allToolNames) {
 }
 
 // ../mcp-core/src/tools/list-threads.ts
-import { z as z27 } from "zod";
+import { z as z22 } from "zod";
 function sanitizeThreadParticipants(thread) {
   if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
     return thread;
@@ -1266,12 +1078,12 @@ function registerListThreads(server2, client2) {
     "naumu_list_threads",
     {
       title: "List Threads",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "List threads sorted by last activity (newest first), for self-discovery before deciding which to engage. With a user API key, pass `graphId` to list threads you can see in that space (resolve it via naumu_list_graphs). 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: 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.")
+      inputSchema: z22.object({
+        graphId: z22.string().optional().describe("Graph (space) ID. Required for user API keys; omit for bot identity keys (defaults to your own graph)."),
+        cursor: z22.number().int().optional().describe("Unix timestamp ms \u2014 returns threads with `lastActivityAt` strictly older than this. Omit for the newest page."),
+        limit: z22.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ graphId, cursor, limit }) => {
@@ -1307,7 +1119,7 @@ function registerListThreads(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-thread.ts
-import { z as z28 } from "zod";
+import { z as z23 } from "zod";
 function sanitizeThreadParticipants2(thread) {
   if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
     return thread;
@@ -1320,10 +1132,10 @@ function registerGetThread(server2, client2) {
     "naumu_get_thread",
     {
       title: "Get Thread",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Fetch a single thread, including the human participant roster (`participantDetails` \u2014 userId, name, image) and bot roster (`identityParticipants` \u2014 id, name, isSystem). Use this when `naumu_list_threads` surfaced a candidate and you want to know exactly who is in it before posting. Pair with `naumu_read_thread` for message history.",
-      inputSchema: z28.object({
-        threadId: z28.string().describe("The thread ID to fetch.")
+      inputSchema: z23.object({
+        threadId: z23.string().describe("The thread ID to fetch.")
       })
     },
     async ({ threadId }) => {
@@ -1345,7 +1157,7 @@ function registerGetThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-thread.ts
-import { z as z29 } from "zod";
+import { z as z24 } from "zod";
 function registerCreateThread(server2, client2) {
   server2.registerTool(
     "naumu_create_thread",
@@ -1360,22 +1172,22 @@ function registerCreateThread(server2, client2) {
         openWorldHint: false
       },
       description: "Start a new conversation in a space. You are auto-attached as a participant, and the thread's formal creator is your primary owner (the user who registered you), so it shows in their sidebar. Optional `participants` adds humans (by userId) and other bots (by identityId) at creation. Optional `initialMessage` opens the conversation as your first message. Tagging people loops them in without invoking @Naumu; only an explicit @Naumu mention, or naumu_ask, brings the agent in. Returns the created thread (including its id) so you can follow up with naumu_post_message.",
-      inputSchema: z29.object({
-        title: z29.string().min(1).max(200).optional().describe('Thread title shown in the sidebar. If omitted, Naumu generates a default like "Conversation YYYY-MM-DD".'),
-        participants: z29.array(
-          z29.discriminatedUnion("type", [
-            z29.object({
-              type: z29.literal("user"),
-              userId: z29.string().min(1).describe("User UUID \u2014 get these from `naumu_get_thread`/`naumu_read_thread` participant rosters or webhook payloads.")
+      inputSchema: z24.object({
+        title: z24.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: z24.array(
+          z24.discriminatedUnion("type", [
+            z24.object({
+              type: z24.literal("user"),
+              userId: z24.string().min(1).describe("User UUID \u2014 get these from `naumu_get_thread`/`naumu_read_thread` participant rosters or webhook payloads.")
             }),
-            z29.object({
-              type: z29.literal("identity"),
-              identityId: z29.string().min(1).describe("Identity id (`identity-\u2026` or `id-\u2026`). Other bots in the same graph can be co-attached to multi-bot threads.")
+            z24.object({
+              type: z24.literal("identity"),
+              identityId: z24.string().min(1).describe("Identity id (`identity-\u2026` or `id-\u2026`). Other bots in the same graph can be co-attached to multi-bot threads.")
             })
           ])
         ).max(32).optional().describe("Up to 32 humans and/or other bots to attach at creation. Your primary owner is added automatically \u2014 you do NOT need to list them here."),
-        initialMessage: z29.string().min(1).max(32e3).optional().describe("Markdown body for the first message. Authored by you (the bot), so it appears in the thread under your name."),
-        visibility: z29.enum(["restricted", "internal", "open"]).optional().describe("`restricted` (invite-only, default) hides from non-participants. `internal` is visible to space members. `open` is visible to anyone who can see the space.")
+        initialMessage: z24.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: z24.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 }) => {
@@ -1401,7 +1213,7 @@ function registerCreateThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/request-attachment-upload.ts
-import { z as z30 } from "zod";
+import { z as z25 } from "zod";
 function registerRequestAttachmentUpload(server2, client2) {
   server2.registerTool(
     "naumu_request_attachment_upload",
@@ -1409,12 +1221,12 @@ function registerRequestAttachmentUpload(server2, client2) {
       title: "Request Attachment Upload",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: 'Request a presigned S3 upload URL to attach a file 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).")
+      inputSchema: z25.object({
+        threadId: z25.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: z25.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: z25.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: z25.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: z25.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 }) => {
@@ -1444,7 +1256,7 @@ function registerRequestAttachmentUpload(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-reaction.ts
-import { z as z31 } from "zod";
+import { z as z26 } from "zod";
 function registerAddReaction(server2, client2) {
   server2.registerTool(
     "naumu_add_reaction",
@@ -1452,10 +1264,10 @@ function registerAddReaction(server2, client2) {
       title: "Add Reaction",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: 'Add an emoji reaction to a message in a thread you are participating in; use for lightweight acknowledgement instead of posting a message. Idempotent - calling twice with the same emoji is a no-op (use `naumu_remove_reaction` to undo). Returns `{ ok, messageId, emoji, alreadyExisted, reactionCount, reactions }` so you can confirm the state without re-reading the thread; `alreadyExisted: true` means the reaction was already on the message and the call was a no-op.\n\nWhen to react vs. when to post a message:\n\u2022 React (no message) for lightweight acknowledgement (\u{1F440}, \u2705, \u{1F44D}), appreciation (\u2764\uFE0F, \u{1F64C}), laughter (\u{1F602}), or "I saw this".\n\u2022 Post a message for direct questions, clarification, important corrections, or final results - situations where words are required.\n\u2022 For long tasks: react \u{1F440} first to acknowledge, optionally post a short "On it - I\'ll report back" if the work will take >20s, do the work, then post the final result.\n\u2022 Ignore casual human banter, side-conversations someone else already answered, or anything where you would only say "ok"/"nice"/"lol".\n\nUse at most one reaction per message unless explicitly useful. Reactions are social backpressure relief, not a sparkle-confetti channel.',
-      inputSchema: z31.object({
-        threadId: z31.string().describe("Thread containing the message. You must be a participant."),
-        messageId: z31.string().describe("The message to react to."),
-        emoji: z31.string().min(1).describe('Emoji character (e.g. "\u{1F440}", "\u2705", "\u2764\uFE0F"). Custom-emoji shortcodes are NOT supported here - pass a real Unicode emoji.')
+      inputSchema: z26.object({
+        threadId: z26.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z26.string().describe("The message to react to."),
+        emoji: z26.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 }) => {
@@ -1479,7 +1291,7 @@ function registerAddReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-reaction.ts
-import { z as z32 } from "zod";
+import { z as z27 } from "zod";
 function registerRemoveReaction(server2, client2) {
   server2.registerTool(
     "naumu_remove_reaction",
@@ -1487,10 +1299,10 @@ function registerRemoveReaction(server2, client2) {
       title: "Remove Reaction",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: "Remove your own emoji reaction from a message; use to walk back an acknowledgement you previously added. Idempotent - calling on a reaction you never added is a no-op. Pair with `naumu_add_reaction` (e.g. you reacted \u{1F440} to start a task and want to clear it after a final result message lands). Returns `{ ok, messageId, emoji, alreadyExisted, reactionCount, reactions }` - `alreadyExisted: false` means there was nothing to remove and the call was a no-op.",
-      inputSchema: z32.object({
-        threadId: z32.string().describe("Thread containing the message. You must be a participant."),
-        messageId: z32.string().describe("The message to remove your reaction from."),
-        emoji: z32.string().min(1).describe("Emoji character to remove (must match what you originally reacted with).")
+      inputSchema: z27.object({
+        threadId: z27.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z27.string().describe("The message to remove your reaction from."),
+        emoji: z27.string().min(1).describe("Emoji character to remove (must match what you originally reacted with).")
       })
     },
     async ({ threadId, messageId, emoji }) => {
@@ -1514,7 +1326,7 @@ function registerRemoveReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/naumu-typing.ts
-import { z as z33 } from "zod";
+import { z as z28 } from "zod";
 function registerNaumuTyping(server2, client2) {
   server2.registerTool(
     "naumu_typing",
@@ -1525,9 +1337,9 @@ function registerNaumuTyping(server2, client2) {
       // repeating the same state is a no-op renew, so idempotent.
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: 'Show or hide your "is typing\u2026" pill in a thread; use to signal that you are composing a reply. Call with `state: "start"` the moment you decide to compose a reply (before any LLM call), and the server holds the pill alive - re-broadcasting on a short interval - until you stop, post a message, or the lease cap (~5 min) fires. You do NOT need to refresh on a timer; that\'s the lease\'s job.\n\nThe pill clears automatically when:\n\u2022 you call this tool with `state: "stop"`\n\u2022 you call `naumu_post_message` for the same thread (cleared on commit)\n\u2022 the lease cap expires\n\nUse `start` whenever you start work, even if you might end up not replying - call `stop` if you decide NOT to post. Calling `start` while a lease is already active renews it (resets the cap), so a long-running run can call `start` again as a heartbeat without breaking the indicator. You must be a participant of the thread.',
-      inputSchema: z33.object({
-        threadId: z33.string().describe("The thread ID to set typing in. You must be a participant."),
-        state: z33.enum(["start", "stop"]).describe('"start" acquires/renews the lease; "stop" ends it and clears the pill immediately.')
+      inputSchema: z28.object({
+        threadId: z28.string().describe("The thread ID to set typing in. You must be a participant."),
+        state: z28.enum(["start", "stop"]).describe('"start" acquires/renews the lease; "stop" ends it and clears the pill immediately.')
       })
     },
     async ({ threadId, state }) => {
@@ -1548,16 +1360,16 @@ function registerNaumuTyping(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-read.ts
-import { z as z34 } from "zod";
+import { z as z29 } from "zod";
 function registerNoteRead(server2, client2) {
   server2.registerTool(
     "naumu_note_read",
     {
       title: "Read Note",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, 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")
+      inputSchema: z29.object({
+        noteId: z29.string().describe("The note (Thought) ID")
       })
     },
     async ({ noteId }) => {
@@ -1570,7 +1382,7 @@ function registerNoteRead(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-append.ts
-import { z as z35 } from "zod";
+import { z as z30 } from "zod";
 function registerNoteAppend(server2, client2) {
   server2.registerTool(
     "naumu_note_append",
@@ -1578,9 +1390,9 @@ function registerNoteAppend(server2, client2) {
       title: "Append to Note",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Append markdown blocks to the end of a note; use for additive note writing that never touches existing content. Other participants see your colored cursor while the write lands. Markdown supports headings (1-3), bold/italic/code, lists, blockquotes, code blocks, links, and tables.",
-      inputSchema: z35.object({
-        noteId: z35.string().describe("The note (Thought) ID to append to"),
-        markdown: z35.string().min(1).describe("Markdown content to append at the end of the note")
+      inputSchema: z30.object({
+        noteId: z30.string().describe("The note (Thought) ID to append to"),
+        markdown: z30.string().min(1).describe("Markdown content to append at the end of the note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -1593,7 +1405,7 @@ function registerNoteAppend(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-insert.ts
-import { z as z36 } from "zod";
+import { z as z31 } from "zod";
 function registerNoteInsert(server2, client2) {
   server2.registerTool(
     "naumu_note_insert",
@@ -1601,10 +1413,10 @@ function registerNoteInsert(server2, client2) {
       title: "Insert After Heading",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Insert markdown content into a note immediately after a named section; use to add content under a specific heading without rewriting it. The section ends at the next heading of equal-or-higher level (or end of doc). 404 if no heading matches `headingText` exactly - call `naumu_note_read` first to see the live structure.",
-      inputSchema: z36.object({
-        noteId: z36.string().describe("The note (Thought) ID"),
-        headingText: z36.string().min(1).describe("Exact text of the heading whose section the new content follows"),
-        markdown: z36.string().min(1).describe("Markdown content to insert at the end of that section")
+      inputSchema: z31.object({
+        noteId: z31.string().describe("The note (Thought) ID"),
+        headingText: z31.string().min(1).describe("Exact text of the heading whose section the new content follows"),
+        markdown: z31.string().min(1).describe("Markdown content to insert at the end of that section")
       })
     },
     async ({ noteId, headingText, markdown }) => {
@@ -1620,7 +1432,7 @@ function registerNoteInsert(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace-section.ts
-import { z as z37 } from "zod";
+import { z as z32 } from "zod";
 function registerNoteReplaceSection(server2, client2) {
   server2.registerTool(
     "naumu_note_replace_section",
@@ -1628,11 +1440,11 @@ function registerNoteReplaceSection(server2, client2) {
       title: "Replace Section",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Replace the body under a named heading with new markdown; use to rewrite one section of a note while leaving the rest intact. By default the heading row itself is preserved (set `keepHeading: false` to drop it too). 404 if no heading matches.",
-      inputSchema: z37.object({
-        noteId: z37.string().describe("The note (Thought) ID"),
-        headingText: z37.string().min(1).describe("Exact text of the heading anchoring the section"),
-        markdown: z37.string().describe("Replacement markdown for the section body"),
-        keepHeading: z37.boolean().optional().describe("Whether to keep the heading row itself. Default true.")
+      inputSchema: z32.object({
+        noteId: z32.string().describe("The note (Thought) ID"),
+        headingText: z32.string().min(1).describe("Exact text of the heading anchoring the section"),
+        markdown: z32.string().describe("Replacement markdown for the section body"),
+        keepHeading: z32.boolean().optional().describe("Whether to keep the heading row itself. Default true.")
       })
     },
     async ({ noteId, headingText, markdown, keepHeading }) => {
@@ -1649,7 +1461,7 @@ function registerNoteReplaceSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-delete-section.ts
-import { z as z38 } from "zod";
+import { z as z33 } from "zod";
 function registerNoteDeleteSection(server2, client2) {
   server2.registerTool(
     "naumu_note_delete_section",
@@ -1657,9 +1469,9 @@ function registerNoteDeleteSection(server2, client2) {
       title: "Delete Section",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "\u26A0 DESTRUCTIVE: remove a heading row plus its body (down to the next heading of equal-or-higher level); ONLY use when the user explicitly asks to drop a section. Anything inside that section is gone - there is no per-call undo. If you're unsure which heading they meant, call `naumu_note_read` first to see the current structure. Returns 404 if `headingText` does not exactly match any live heading.",
-      inputSchema: z38.object({
-        noteId: z38.string().describe("The note (Thought) ID"),
-        headingText: z38.string().min(1).describe("Exact text of the heading whose section will be deleted")
+      inputSchema: z33.object({
+        noteId: z33.string().describe("The note (Thought) ID"),
+        headingText: z33.string().min(1).describe("Exact text of the heading whose section will be deleted")
       })
     },
     async ({ noteId, headingText }) => {
@@ -1674,7 +1486,7 @@ function registerNoteDeleteSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace.ts
-import { z as z39 } from "zod";
+import { z as z34 } from "zod";
 function registerNoteReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_replace",
@@ -1682,9 +1494,9 @@ function registerNoteReplace(server2, client2) {
       title: "Replace Note",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "\u26A0 DESTRUCTIVE: replace the entire note content with new markdown; ONLY use when the user explicitly asks to rewrite/replace the whole note. Any concurrent human edits made during the call are silently overwritten. For additive work prefer `naumu_note_append`. For section-level edits use `naumu_note_replace_section`. For inline tweaks use `naumu_note_find_replace`. Read with `naumu_note_read` first if you weren't the last writer.",
-      inputSchema: z39.object({
-        noteId: z39.string().describe("The note (Thought) ID"),
-        markdown: z39.string().describe("New markdown content for the entire note")
+      inputSchema: z34.object({
+        noteId: z34.string().describe("The note (Thought) ID"),
+        markdown: z34.string().describe("New markdown content for the entire note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -1697,7 +1509,7 @@ function registerNoteReplace(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-find-replace.ts
-import { z as z40 } from "zod";
+import { z as z35 } from "zod";
 function registerNoteFindReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_find_replace",
@@ -1705,11 +1517,11 @@ function registerNoteFindReplace(server2, client2) {
       title: "Find/Replace in Note",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Literal find/replace within a note's text content; use for mid-paragraph tweaks the section-based tools can't target. Marks (bold, italic, code, etc.) are preserved on the surrounding text. \u26A0 The match is literal-substring across every text leaf in the doc; an overly generic `find` (e.g. \" a \") can rewrite the doc unrecognizably. Pick a phrase distinctive enough to land where you mean. By default replaces every occurrence; set `all: false` for first-only. Returns `{ replacements }` so you can sanity-check the count.",
-      inputSchema: z40.object({
-        noteId: z40.string().describe("The note (Thought) ID"),
-        find: z40.string().min(1).describe("Substring to search for. Literal - no regex."),
-        replace: z40.string().describe("Replacement string. May be empty to delete the match."),
-        all: z40.boolean().optional().describe("Replace all occurrences (default true). Pass false to replace only the first.")
+      inputSchema: z35.object({
+        noteId: z35.string().describe("The note (Thought) ID"),
+        find: z35.string().min(1).describe("Substring to search for. Literal - no regex."),
+        replace: z35.string().describe("Replacement string. May be empty to delete the match."),
+        all: z35.boolean().optional().describe("Replace all occurrences (default true). Pass false to replace only the first.")
       })
     },
     async ({ noteId, find, replace, all }) => {
@@ -1725,107 +1537,8 @@ function registerNoteFindReplace(server2, client2) {
   );
 }
 
-// ../mcp-core/src/tools/canvas-add-element.ts
-import { z as z41 } from "zod";
-var ELEMENT_TYPES = [
-  "rectangle",
-  "ellipse",
-  "diamond",
-  "text",
-  "line",
-  "arrow",
-  "freehand",
-  "image",
-  "bookmark-card",
-  "entity-embed"
-];
-function registerCanvasAddElement(server2, client2) {
-  server2.registerTool(
-    "naumu_canvas_add_element",
-    {
-      title: "Add Canvas Element",
-      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 }) => {
-      const data = await client2.post(`/api/canvases/${canvasId}/elements`, { element });
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
-// ../mcp-core/src/tools/canvas-update-element.ts
-import { z as z42 } from "zod";
-function registerCanvasUpdateElement(server2, client2) {
-  server2.registerTool(
-    "naumu_canvas_update_element",
-    {
-      title: "Update Canvas Element",
-      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 }) => {
-      const data = await client2.patch(
-        `/api/canvases/${canvasId}/elements/${elementId}`,
-        { changes }
-      );
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
-// ../mcp-core/src/tools/canvas-remove-element.ts
-import { z as z43 } from "zod";
-function registerCanvasRemoveElement(server2, client2) {
-  server2.registerTool(
-    "naumu_canvas_remove_element",
-    {
-      title: "Remove Canvas Element",
-      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 }) => {
-      const data = await client2.del(`/api/canvases/${canvasId}/elements/${elementId}`);
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
 // ../mcp-core/src/tools/create-note.ts
-import { z as z44 } from "zod";
+import { z as z36 } from "zod";
 function registerCreateNote(server2, client2) {
   server2.registerTool(
     "naumu_create_note",
@@ -1833,9 +1546,9 @@ function registerCreateNote(server2, client2) {
       title: "Create 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")
+      inputSchema: z36.object({
+        graphId: z36.string().describe("The graph ID to create the note in"),
+        title: z36.string().optional().describe("Optional title for the note")
       })
     },
     async ({ graphId, title }) => {
@@ -1847,31 +1560,8 @@ function registerCreateNote(server2, client2) {
   );
 }
 
-// ../mcp-core/src/tools/create-canvas.ts
-import { z as z45 } from "zod";
-function registerCreateCanvas(server2, client2) {
-  server2.registerTool(
-    "naumu_create_canvas",
-    {
-      title: "Create 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 }) => {
-      const data = await client2.post("/api/canvases", { graphId, title });
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
 // ../mcp-core/src/tools/list-schema-violations.ts
-import { z as z46 } from "zod";
+import { z as z37 } from "zod";
 var DEFAULT_EXAMPLE_LIMIT = 5;
 var rowsForKind = (violations, kind) => {
   const rows = [];
@@ -1895,14 +1585,14 @@ function registerListSchemaViolations(server2, client2) {
     "naumu_list_schema_violations",
     {
       title: "List Schema Violations",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Audit a graph against its schema. By default returns a compact summary: total counts plus, for each violation kind, its count and up to 5 example nodes (id/label/type/message) \u2014 small enough not to flood the client. Violation kinds: parent_missing (schema expects a parent edge that does not exist), parent_multiple (more than one parent edge where one is expected), parent_mismatch (parent edge has wrong target type or relation label), parent_not_backbone (an edge uses a backbone/parent relation but is not stored as a backbone edge, so the subtree stays off the hierarchy), unknown_relation (edge uses a relation not in the schema), invalid_connection_target (edge connects to a type the schema does not allow for this source), unknown_type (node carries a type no longer in the schema), disconnected (node heads a group with no backbone path to the main tree). To see every node for one kind, pass `kind` to filter; `limit` caps how many rows are returned (examples in the default summary, or full rows when `kind` is set). Use for audits, import-verification, and CI-style checks after batch writes.",
-      inputSchema: z46.object({
-        graphId: z46.string().describe("The graph ID"),
-        kind: z46.string().optional().describe(
+      inputSchema: z37.object({
+        graphId: z37.string().describe("The graph ID"),
+        kind: z37.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(
+        limit: z37.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)."
         )
       })
@@ -1954,18 +1644,18 @@ function registerListSchemaViolations(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-dense-nodes.ts
-import { z as z47 } from "zod";
+import { z as z38 } from "zod";
 function registerListDenseNodes(server2, client2) {
   server2.registerTool(
     "naumu_list_dense_nodes",
     {
       title: "List Dense Nodes",
-      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.")
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+      description: 'Return nodes whose child count (children via parent edges; mesh cross-links don\'t count) is \u2265 minConnections, grouped by type; use for /restructure hub detection. Each row includes `same_typed_child_count` - the number of children of the SAME type as the node (the Naumu hub-pattern signal) and `connection_count` - its total children. Sort the response by `same_typed_child_count` descending and route any node with \u226510 same-typed children through a mini-hub split. Pass `nodeTypes` (comma-separated) to restrict to a subset (e.g. ["Type A","Type B"]). Cheap to call - runs a single Cypher aggregation.',
+      inputSchema: z38.object({
+        graphId: z38.string().describe("The graph ID"),
+        minConnections: z38.number().int().min(1).describe("Minimum number of children (parent edges; mesh cross-links excluded). Typical: 10 for hub detection, 11 to count only hubs that exceed the round-4 \u226410 threshold."),
+        nodeTypes: z38.array(z38.string()).optional().describe("Optional list of node types to restrict the scan to.")
       })
     },
     async ({ graphId, minConnections, nodeTypes }) => {
@@ -1983,19 +1673,19 @@ function registerListDenseNodes(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-node-connections.ts
-import { z as z48 } from "zod";
+import { z as z39 } from "zod";
 function registerListNodeConnections(server2, client2) {
   server2.registerTool(
     "naumu_list_node_connections",
     {
       title: "List Node Connections",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: 'Return a single node\'s edges (non-system) with the connected node on the other side; use during /restructure to confirm mini-hub candidates and verify reparenting outcomes. Filter with `edgeType` (relation label) and `direction` ("in" | "out" | "both", default both). Response: `{ node: {id,label,type}, edges: [{relation, direction, isParent, other: {id,label,type}}] }`.',
-      inputSchema: 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).')
+      inputSchema: z39.object({
+        graphId: z39.string().describe("The graph ID"),
+        nodeId: z39.string().describe("The node ID to inspect"),
+        edgeType: z39.string().optional().describe('Restrict to a specific relation label (e.g. "ASSOCIATED_WITH"). Case-insensitive; non-alphanum chars are normalized.'),
+        direction: z39.enum(["in", "out", "both"]).optional().describe('Edge direction filter - "in" (incoming), "out" (outgoing), "both" (default).')
       })
     },
     async ({ graphId, nodeId, edgeType, direction }) => {
@@ -2013,7 +1703,7 @@ function registerListNodeConnections(server2, client2) {
 }
 
 // ../mcp-core/src/tools/reparent.ts
-import { z as z49 } from "zod";
+import { z as z40 } from "zod";
 function registerReparent(server2, client2) {
   server2.registerTool(
     "naumu_reparent",
@@ -2021,11 +1711,11 @@ function registerReparent(server2, client2) {
       title: "Reparent Node",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: 'Atomically swap a node\'s parent edge; use to move a child under a different parent (e.g. during /restructure to reparent children under newly-created mini-hubs). Deletes any existing `isParent: true` edges on the node and creates a new one to `newParentId` with relation `newRelation`. Preserves the node\'s id, content, attributes, and embedding - does NOT trigger embedding regeneration because only the parent edge changes. Idempotent: if the node already has the requested parent edge, response is `status: "skipped"`. Response shape: `{nodeId, oldParentId, newParentId, newRelation, status: "moved" | "skipped"}`.',
-      inputSchema: 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).')
+      inputSchema: z40.object({
+        graphId: z40.string().describe("The graph ID"),
+        nodeId: z40.string().describe("The child node to reparent"),
+        newParentId: z40.string().describe("The new parent node id"),
+        newRelation: z40.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 }) => {
@@ -2041,7 +1731,7 @@ function registerReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/batch-reparent.ts
-import { z as z50 } from "zod";
+import { z as z41 } from "zod";
 function registerBatchReparent(server2, client2) {
   server2.registerTool(
     "naumu_batch_reparent",
@@ -2049,11 +1739,11 @@ function registerBatchReparent(server2, client2) {
       title: "Batch Reparent Nodes",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: 'Reparent 1-25 nodes onto a shared `newParentId` with the same `newRelation`; use to move a same-typed cluster under a freshly-created mini-hub in /restructure. Same semantics as `naumu_reparent` per-node: atomic swap of the isParent edge, preserves id/content/attributes/embedding, no re-embedding. Idempotent per node (already-parented nodes return `status: "skipped"`). Per-node response array: `[{nodeId, oldParentId, newParentId, status: "moved" | "skipped" | "error", error?}]`.',
-      inputSchema: 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`")
+      inputSchema: z41.object({
+        graphId: z41.string().describe("The graph ID"),
+        newParentId: z41.string().describe("Parent node id every nodeId in the batch will be parented to"),
+        newRelation: z41.string().describe("Parent edge relation label (must be valid per schema for child.type \u2192 parent.type)"),
+        nodeIds: z41.array(z41.string()).min(1).max(25).describe("1\u201325 child node ids to reparent under `newParentId`")
       })
     },
     async ({ graphId, newParentId, newRelation, nodeIds }) => {
@@ -2070,7 +1760,7 @@ function registerBatchReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-search.ts
-import { z as z51 } from "zod";
+import { z as z42 } from "zod";
 
 // ../mcp-core/src/public-origin.ts
 function publicOrigin() {
@@ -2122,10 +1812,10 @@ function registerChatgptSearch(server2, client2) {
     "search",
     {
       title: "Search",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Search across all of the knowledge graphs (spaces) you can access and return the most relevant nodes. Returns `{ results: [{ id, title, url }] }`. Pass each result `id` to the `fetch` tool to read the full node. (This is the cross-space entry point for ChatGPT/Deep Research; within a single space, `naumu_search` exposes more controls.)",
-      inputSchema: z51.object({
-        query: z51.string().describe('Search query text. Mix synonyms and exact tokens freely (e.g. "auth login SSO 2fa").')
+      inputSchema: z42.object({
+        query: z42.string().describe('Search query text. Mix synonyms and exact tokens freely (e.g. "auth login SSO 2fa").')
       })
     },
     async ({ query }) => {
@@ -2157,7 +1847,7 @@ function registerChatgptSearch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-fetch.ts
-import { z as z52 } from "zod";
+import { z as z43 } from "zod";
 var NON_ATTRIBUTE_PROPS = /* @__PURE__ */ new Set([
   "id",
   "label",
@@ -2220,10 +1910,10 @@ function registerChatgptFetch(server2, client2) {
     "fetch",
     {
       title: "Fetch",
-      annotations: { readOnlyHint: true, openWorldHint: false },
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       description: "Fetch the full contents of a node returned by the `search` tool. Pass the result `id` verbatim (format `<graphId>:<nodeId>`). Returns `{ id, title, text, url }` where `text` is the node content plus its type, attributes, and connections.",
-      inputSchema: z52.object({
-        id: z52.string().describe("A resource id from a previous `search` result, in the form `<graphId>:<nodeId>`.")
+      inputSchema: z43.object({
+        id: z43.string().describe("A resource id from a previous `search` result, in the form `<graphId>:<nodeId>`.")
       })
     },
     async ({ id }) => {
@@ -2277,8 +1967,6 @@ var TOOL_REGISTRARS = {
   naumu_search: registerSearch,
   naumu_filter: registerFilter,
   naumu_get_node: registerGetNode,
-  naumu_get_view: registerGetView,
-  naumu_list_view_nodes: registerListViewNodes,
   naumu_add_node: registerAddNode,
   naumu_update_node: registerUpdateNode,
   naumu_add_edge: registerAddEdge,
@@ -2288,9 +1976,6 @@ var TOOL_REGISTRARS = {
   naumu_ask: registerAsk,
   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_whoami: registerWhoami,
@@ -2308,11 +1993,7 @@ var TOOL_REGISTRARS = {
   naumu_note_delete_section: registerNoteDeleteSection,
   naumu_note_replace: registerNoteReplace,
   naumu_note_find_replace: registerNoteFindReplace,
-  naumu_canvas_add_element: registerCanvasAddElement,
-  naumu_canvas_update_element: registerCanvasUpdateElement,
-  naumu_canvas_remove_element: registerCanvasRemoveElement,
   naumu_create_note: registerCreateNote,
-  naumu_create_canvas: registerCreateCanvas,
   naumu_list_schema_violations: registerListSchemaViolations,
   naumu_list_dense_nodes: registerListDenseNodes,
   naumu_list_node_connections: registerListNodeConnections,

package/package.json

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