@naumu/mcp 0.6.4 → 0.7.1

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({})
     },
@@ -164,8 +153,44 @@ function registerListGraphs(server2, client2) {
   );
 }
 
-// ../mcp-core/src/tools/create-graph.ts
+// ../mcp-core/src/tools/list-members.ts
 import { z as z2 } from "zod";
+function registerListMembers(server2, client2) {
+  server2.registerTool(
+    "naumu_list_members",
+    {
+      title: "List Members",
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+      description: "List the members of a Naumu space (graph): each member's userId, name, email, and role. Use it to discover teammates and to get the id you pass when @mentioning a human via naumu_post_message (their userId or email both work).",
+      inputSchema: z2.object({
+        graphId: z2.string().describe("The space (graph) ID to list members of. You must be a member of this space.")
+      })
+    },
+    async ({ graphId }) => {
+      try {
+        const data = await client2.get(`/api/graphs/${graphId}/members`);
+        const members = Array.isArray(data) ? data.map((m) => ({
+          userId: m.userId,
+          name: m.name,
+          email: m.email,
+          role: m.role
+        })) : data;
+        return {
+          content: [{ type: "text", text: JSON.stringify(members, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/create-graph.ts
+import { z as z3 } from "zod";
 function registerCreateGraph(server2, client2) {
   server2.registerTool(
     "naumu_create_graph",
@@ -173,8 +198,8 @@ function registerCreateGraph(server2, client2) {
       title: "Create Graph",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Create a new, empty knowledge graph (space) owned by the authenticated user; use when you need a fresh space to populate. Returns `{id, name, slug, role, memberRole, createdAt, onboardingThreadId}` - use the returned `id` as `graphId` for subsequent tool calls. The space starts empty (no schema, no nodes); follow up with `naumu_update_schema` to register types before any `naumu_add_node` calls.",
-      inputSchema: z2.object({
-        name: z2.string().min(1).describe("Display name for the new space. A URL slug is generated from this name.")
+      inputSchema: z3.object({
+        name: z3.string().min(1).describe("Display name for the new space. A URL slug is generated from this name.")
       })
     },
     async ({ name }) => {
@@ -187,7 +212,7 @@ function registerCreateGraph(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-schema.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function formatConnection(c) {
   const out = { relation: c.relation };
   if (c.polymorphic) {
@@ -219,8 +244,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,10 +258,10 @@ 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")
+      inputSchema: z4.object({
+        graphId: z4.string().describe("The graph ID")
       })
     },
     async ({ graphId }) => {
@@ -259,40 +283,40 @@ function registerGetSchema(server2, client2) {
 }
 
 // ../mcp-core/src/tools/update-schema.ts
-import { z as z4 } from "zod";
-var ConnectionSchema = z4.object({
-  relation: z4.string().describe("UPPER_SNAKE_CASE relation name (e.g. WORKS_AT, BUILT_BY, BELONGS_TO)"),
-  target_node: z4.string().optional().describe("Target type name. Omit when polymorphic=true."),
-  polymorphic: z4.boolean().optional().describe("Set true when this relation can target multiple types.")
+import { z as z5 } from "zod";
+var ConnectionSchema = z5.object({
+  relation: z5.string().describe("UPPER_SNAKE_CASE relation name (e.g. WORKS_AT, BUILT_BY, BELONGS_TO)"),
+  target_node: z5.string().optional().describe("Target type name. Omit when polymorphic=true."),
+  polymorphic: z5.boolean().optional().describe("Set true when this relation can target multiple types.")
 });
-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.')
+var AttributeValueSchema = z5.object({
+  label: z5.string().describe("Display label for this enum value"),
+  color: z5.string().optional().describe('Optional hex color (e.g. "#ff5722")'),
+  description: z5.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."),
-  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 AttributeSchema = z5.object({
+  name: z5.string().describe('Attribute key (e.g. "stage", "status", "category")'),
+  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(AttributeValueSchema).describe("Allowed enum values for select/multiselect; pass [] for string/number/date."),
+  description: z5.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)"),
-  connections: z4.object({
+var NodeTypeSchema = z5.object({
+  type: z5.string().describe("Type name in PascalCase (e.g. TypeA, TypeB)"),
+  connections: z5.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."),
-    suggested: z4.array(ConnectionSchema).default([]).describe("Suggested-but-optional outgoing connections.")
+    required: z5.array(ConnectionSchema).default([]).describe("Required outgoing connections to other types."),
+    suggested: z5.array(ConnectionSchema).default([]).describe("Suggested-but-optional outgoing connections.")
   }),
-  attributes: z4.array(AttributeSchema).optional().describe("Type-level attributes for instances of this type."),
-  defaultVisibility: z4.enum(["restricted", "internal", "open"]).optional().describe(
+  attributes: z5.array(AttributeSchema).optional().describe("Type-level attributes for instances of this type."),
+  defaultVisibility: z5.enum(["restricted", "internal", "open"]).optional().describe(
     'Default visibility for NEW nodes of this type when no explicit visibility is passed on creation. Does NOT retroactively change visibility on existing nodes. "open" = visible to anyone with the space link (including non-members), "internal" = visible to all space members, "restricted" = only members explicitly granted access. Omit to leave the type unset - 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.')
+  color: z5.string().optional().describe("Optional hex color for instances of this type."),
+  description: z5.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."),
-  nodes: z4.array(NodeTypeSchema).describe("All node types in the schema.")
+var SchemaDefinitionSchema = z5.object({
+  description: z5.string().optional().describe("Schema-level description / domain summary."),
+  nodes: z5.array(NodeTypeSchema).describe("All node types in the schema.")
 });
 function registerUpdateSchema(server2, client2) {
   server2.registerTool(
@@ -300,9 +324,9 @@ 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.",
-      inputSchema: z4.object({
-        graphId: z4.string().describe("The graph ID"),
+      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: z5.object({
+        graphId: z5.string().describe("The graph ID"),
         schema: SchemaDefinitionSchema
       })
     },
@@ -318,22 +342,22 @@ function registerUpdateSchema(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-node-type.ts
-import { z as z5 } from "zod";
-var ConnectionSchema2 = z5.object({
-  relation: z5.string().describe("UPPER_SNAKE_CASE relation name (WORKS_AT, BELONGS_TO)."),
-  target_node: z5.string().optional().describe("Target type name. Omit when polymorphic=true."),
-  polymorphic: z5.boolean().optional().describe("True when this relation can target many types.")
+import { z as z6 } from "zod";
+var ConnectionSchema2 = z6.object({
+  relation: z6.string().describe("UPPER_SNAKE_CASE relation name (WORKS_AT, BELONGS_TO)."),
+  target_node: z6.string().optional().describe("Target type name. Omit when polymorphic=true."),
+  polymorphic: z6.boolean().optional().describe("True when this relation can target many types.")
 });
-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.')
+var AttributeValueSchema2 = z6.object({
+  label: z6.string(),
+  color: z6.string().optional(),
+  description: z6.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(),
-  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.')
+var AttributeSchema2 = z6.object({
+  name: z6.string(),
+  type: z6.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: z6.array(AttributeValueSchema2).default([]),
+  description: z6.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,19 +365,19 @@ 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.',
-      inputSchema: z5.object({
-        graphId: z5.string(),
-        type: z5.string().describe("PascalCase type name"),
-        description: z5.string().optional().describe(
+      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: z6.object({
+        graphId: z6.string(),
+        type: z6.string().describe("PascalCase type name"),
+        description: z6.string().optional().describe(
           "Short one-sentence description of what this type represents and how it differs from sibling types. Contrastive (say what it IS and what it is NOT) is most useful. Strongly encouraged on every new type - agents reading the schema later rely on this to classify nodes."
         ),
         parent: ConnectionSchema2.optional().describe("Optional parent connection - sets this type as a child of another type."),
-        required: z5.array(ConnectionSchema2).optional(),
-        suggested: z5.array(ConnectionSchema2).optional(),
-        attributes: z5.array(AttributeSchema2).optional(),
-        color: z5.string().optional(),
-        defaultVisibility: z5.enum(["restricted", "internal", "open"]).optional().describe(
+        required: z6.array(ConnectionSchema2).optional(),
+        suggested: z6.array(ConnectionSchema2).optional(),
+        attributes: z6.array(AttributeSchema2).optional(),
+        color: z6.string().optional(),
+        defaultVisibility: z6.enum(["restricted", "internal", "open"]).optional().describe(
           'Default visibility for NEW nodes of this type when no explicit visibility is passed on creation. Does NOT retroactively change existing nodes. "open" = visible to anyone with the space link, "internal" = visible to all space members, "restricted" = only members explicitly granted access. Omit to fall back to the space-level defaultVisibility.'
         )
       })
@@ -388,21 +412,21 @@ function registerAddNodeType(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-connection.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function registerAddConnection(server2, client2) {
   server2.registerTool(
     "naumu_add_connection",
     {
       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.',
-      inputSchema: z6.object({
-        graphId: z6.string(),
-        source_type: z6.string().describe("Existing node type to add the connection to."),
-        relation: z6.string().describe("UPPER_SNAKE_CASE relation name."),
-        target_node: z6.string().optional().describe("Target type. Omit when polymorphic=true."),
-        polymorphic: z6.boolean().optional(),
-        kind: z6.enum(["required", "suggested", "parent"]).default("suggested")
+      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: z7.object({
+        graphId: z7.string(),
+        source_type: z7.string().describe("Existing node type to add the connection to."),
+        relation: z7.string().describe("UPPER_SNAKE_CASE relation name."),
+        target_node: z7.string().optional().describe("Target type. Omit when polymorphic=true."),
+        polymorphic: z7.boolean().optional(),
+        kind: z7.enum(["required", "suggested", "parent"]).default("suggested")
       })
     },
     async ({ graphId, source_type, relation, target_node, polymorphic, kind }) => {
@@ -438,27 +462,27 @@ function registerAddConnection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-attribute.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function registerAddAttribute(server2, client2) {
   server2.registerTool(
     "naumu_add_attribute",
     {
       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.',
-      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"),
-        values: z7.array(
-          z7.object({
-            label: z7.string(),
-            color: z7.string().optional(),
-            description: z7.string().optional().describe('Short note distinguishing this value from sibling values (e.g. "closed-won - deal signed and revenue committed"). Encouraged when the label alone is ambiguous.')
+      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: z8.object({
+        graphId: z8.string(),
+        node_type: z8.string().describe("Existing node type to add the attribute to."),
+        name: z8.string().describe('Attribute key (e.g. "stage", "status").'),
+        type: z8.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: z8.array(
+          z8.object({
+            label: z8.string(),
+            color: z8.string().optional(),
+            description: z8.string().optional().describe('Short note distinguishing this value from sibling values (e.g. "closed-won - deal signed and revenue committed"). Encouraged when the label alone is ambiguous.')
           })
         ).default([]),
-        description: z7.string().optional().describe('Short note explaining what this attribute captures and how it differs from similarly-named attributes elsewhere in the schema (e.g. "Sales funnel position; differs from `status` which captures health/blockers"). Strongly encouraged.')
+        description: z8.string().optional().describe('Short note explaining what this attribute captures and how it differs from similarly-named attributes elsewhere in the schema (e.g. "Sales funnel position; differs from `status` which captures health/blockers"). Strongly encouraged.')
       })
     },
     async ({ graphId, node_type, name, type, values, description }) => {
@@ -492,21 +516,21 @@ function registerAddAttribute(server2, client2) {
 }
 
 // ../mcp-core/src/tools/search.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function registerSearch(server2, client2) {
   server2.registerTool(
     "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"),
-        query: z8.string().describe(
+      inputSchema: z9.object({
+        graphId: z9.string().describe("The graph ID"),
+        query: z9.string().describe(
           '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"])')
+        limit: z9.number().optional().default(20).describe("Max results to return (default 20, max 200). Adaptive cutoff may return fewer when the top match is weak."),
+        nodeTypes: z9.array(z9.string()).optional().describe('Filter to specific node types (e.g. ["Type A", "Type B"])')
       })
     },
     async ({ graphId, query, limit, nodeTypes }) => {
@@ -523,25 +547,25 @@ function registerSearch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/filter.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function registerFilter(server2, client2) {
   server2.registerTool(
     "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"])'),
-        includeAttributes: z9.record(z9.string(), z9.array(z9.string())).optional().describe(
+      inputSchema: z10.object({
+        graphId: z10.string().describe("The graph ID"),
+        nodeTypes: z10.array(z10.string()).optional().describe('Filter to specific node types (e.g. ["Type A", "Type B"])'),
+        includeAttributes: z10.record(z10.string(), z10.array(z10.string())).optional().describe(
           'Only include nodes where attribute matches one of the values. Example: {"Status": ["Todo", "In Progress"]}'
         ),
-        excludeAttributes: z9.record(z9.string(), z9.array(z9.string())).optional().describe(
+        excludeAttributes: z10.record(z10.string(), z10.array(z10.string())).optional().describe(
           'Exclude nodes where attribute matches any of the values. Example: {"Status": ["Done", "Wont do"]}'
         ),
-        sortBy: z9.enum(["sortKey", "updatedAt", "label"]).optional().default("sortKey").describe('Sort order: "sortKey" (default), "updatedAt" (most recent first), or "label" (alphabetical)'),
-        limit: z9.number().optional().default(50).describe("Max results to return (default 50, max 200)")
+        sortBy: z10.enum(["sortKey", "updatedAt", "label"]).optional().default("sortKey").describe('Sort order: "sortKey" (default), "updatedAt" (most recent first), or "label" (alphabetical)'),
+        limit: z10.number().optional().default(50).describe("Max results to return (default 50, max 200)")
       })
     },
     async ({ graphId, nodeTypes, includeAttributes, excludeAttributes, sortBy, limit }) => {
@@ -566,17 +590,17 @@ function registerFilter(server2, client2) {
 }
 
 // ../mcp-core/src/tools/get-node.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function registerGetNode(server2, client2) {
   server2.registerTool(
     "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"),
-        nodeId: z10.string().describe("The node ID")
+      inputSchema: z11.object({
+        graphId: z11.string().describe("The graph ID"),
+        nodeId: z11.string().describe("The node ID")
       })
     },
     async ({ graphId, nodeId }) => {
@@ -589,38 +613,7 @@ function registerGetNode(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-node.ts
-import { z as z11 } from "zod";
-var NodeInput = z11.object({
-  label: z11.string().describe("Display name of the node"),
-  type: z11.string().describe("Node type from the graph schema (e.g. Feature, Pain, Metric)"),
-  content: z11.string().min(1).describe("Rich text content / description. REQUIRED - every node must explain what it is."),
-  attributes: z11.record(z11.string(), z11.unknown()).optional().describe("Additional key-value attributes")
-});
-function registerAddNode(server2, client2) {
-  server2.registerTool(
-    "naumu_add_node",
-    {
-      title: "Add Nodes (bulk)",
-      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-      description: 'Create 1-25 nodes in the knowledge graph in a single call; use when you have a vetted, dedup-checked batch ready to insert. Keep batches small and atomic (5-25 nodes) so failures stay contained. Each node MUST include a non-empty `content` describing what it is. Returns one entry per input node with `{id, label, type, status: "created"}` - there is NO server-side dedup, every input becomes a node. Dedup is the caller\'s responsibility: BEFORE calling this tool, run `naumu_search` on each candidate label and skip/route to update if a result has high similarity (\u22650.78) and matching type. Warning: nodes are isolated until you connect them with `naumu_add_edge`. Prefer `naumu_delegate` for general knowledge intake - it discovers and creates connections for you.',
-      inputSchema: z11.object({
-        graphId: z11.string().describe("The graph ID"),
-        nodes: z11.array(NodeInput).min(1).max(25).describe("Batch of 1\u201325 nodes to create. Keep batches small for atomicity.")
-      })
-    },
-    async ({ graphId, nodes }) => {
-      const payload = nodes.map(({ label, type, content, attributes }) => {
-        const node = { label, type, content };
-        if (attributes) Object.assign(node, attributes);
-        return node;
-      });
-      const data = await client2.post(`/api/graphs/${graphId}/nodes`, { nodes: payload });
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
+import { z as z13 } from "zod";
 
 // ../mcp-core/src/tools/update-node.ts
 import { z as z12 } from "zod";
@@ -752,13 +745,120 @@ Use naumu_get_schema to check valid attributes and values for this node type.`
   );
 }
 
+// ../mcp-core/src/tools/add-node.ts
+var RESERVED_KEYS = /* @__PURE__ */ new Set(["id", "label", "type", "content"]);
+function normalizeNodeAttributes(schema, nodeType, attributes) {
+  const attrMap = /* @__PURE__ */ new Map();
+  const nodeDef = schema.nodes.find((n) => n.type === nodeType);
+  for (const attr of nodeDef?.attributes ?? []) {
+    attrMap.set(attr.name.toLowerCase(), attr);
+  }
+  const normalized = {};
+  const errors = [];
+  for (const [key, val] of Object.entries(attributes)) {
+    const lower = key.toLowerCase();
+    if (RESERVED_KEYS.has(lower)) {
+      errors.push(`Attribute "${key}" conflicts with a reserved node field.`);
+      continue;
+    }
+    const schemaDef = attrMap.get(lower);
+    if (!schemaDef) {
+      const validNames = [...attrMap.values()].map((a) => a.name);
+      errors.push(
+        `Unknown attribute "${key}" for type "${nodeType}". Valid attributes: ${validNames.length > 0 ? validNames.join(", ") : "none"}.`
+      );
+      continue;
+    }
+    if (schemaDef.type === "date") {
+      const result = validateDateAttribute(schemaDef.name, val);
+      if (!result.ok) {
+        errors.push(result.error);
+        continue;
+      }
+      if (result.value === null) continue;
+      const range = typeof result.value === "string" ? { start: result.value } : result.value;
+      normalized[lower] = JSON.stringify(range);
+      continue;
+    }
+    const validValues = schemaDef.values.map((v) => v.label);
+    if (typeof val === "string" && validValues.length > 0 && !validValues.includes(val)) {
+      errors.push(
+        `Invalid value "${val}" for attribute "${schemaDef.name}" on type "${nodeType}". Valid values: ${validValues.join(", ")}.`
+      );
+      continue;
+    }
+    normalized[lower] = val;
+  }
+  return errors.length > 0 ? { ok: false, errors } : { ok: true, attributes: normalized };
+}
+var NodeInput = z13.object({
+  label: z13.string().describe("Display name of the node"),
+  type: z13.string().describe("Node type from the graph schema"),
+  content: z13.string().min(1).describe("Rich text content / description. REQUIRED - every node must explain what it is."),
+  attributes: z13.record(z13.string(), z13.unknown()).optional().describe(
+    `Schema-defined attributes. Keys are matched case-insensitively against the node type's schema attributes and stored in canonical form; unknown attributes or invalid select values reject the whole batch. Date attributes accept "YYYY-MM-DD" or { start, end? }.`
+  )
+});
+function registerAddNode(server2, client2) {
+  server2.registerTool(
+    "naumu_add_node",
+    {
+      title: "Add Nodes (bulk)",
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+      description: 'Create 1-25 nodes in the knowledge graph in a single call; use when you have a vetted, dedup-checked batch ready to insert. Keep batches small and atomic (5-25 nodes) so failures stay contained. Each node MUST include a non-empty `content` describing what it is. Returns one entry per input node with `{id, label, type, status: "created"}` - there is NO server-side dedup, every input becomes a node. Dedup is the caller\'s responsibility: BEFORE calling this tool, run `naumu_search` on each candidate label and skip/route to update if a result has high similarity (\u22650.78) and matching type. Warning: nodes are isolated until you connect them with `naumu_add_edge`. Prefer `naumu_delegate` for general knowledge intake - it discovers and creates connections for you.',
+      inputSchema: z13.object({
+        graphId: z13.string().describe("The graph ID"),
+        nodes: z13.array(NodeInput).min(1).max(25).describe("Batch of 1\u201325 nodes to create. Keep batches small for atomicity.")
+      })
+    },
+    async ({ graphId, nodes }) => {
+      let schema = null;
+      if (nodes.some((n) => n.attributes && Object.keys(n.attributes).length > 0)) {
+        const schemaRes = await client2.get(`/api/graphs/${graphId}/schema`);
+        schema = JSON.parse(schemaRes.definition);
+      }
+      const errors = [];
+      const payload = nodes.map(({ label, type, content, attributes }, i) => {
+        const node = { label, type, content };
+        if (schema && attributes && Object.keys(attributes).length > 0) {
+          const result = normalizeNodeAttributes(schema, type, attributes);
+          if (result.ok) {
+            Object.assign(node, result.attributes);
+          } else {
+            errors.push(...result.errors.map((e) => `nodes[${i}] ("${label}"): ${e}`));
+          }
+        }
+        return node;
+      });
+      if (errors.length > 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Attribute validation failed \u2014 no nodes were created:
+${errors.join("\n")}
+
+Use naumu_get_schema to check valid attribute names, types, and values.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const data = await client2.post(`/api/graphs/${graphId}/nodes`, { nodes: payload });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
 // ../mcp-core/src/tools/add-edge.ts
-import { z as z13 } from "zod";
-var EdgeInput = z13.object({
-  source: z13.string().describe("Source node ID"),
-  target: z13.string().describe("Target node ID"),
-  label: z13.string().describe("Relationship type (e.g. RELATES_TO, SOLVES, TRACKS)"),
-  isParent: z13.boolean().optional().describe("Whether this is a parent relationship")
+import { z as z14 } from "zod";
+var EdgeInput = z14.object({
+  source: z14.string().describe("Source node ID"),
+  target: z14.string().describe("Target node ID"),
+  label: z14.string().describe("Relationship type (e.g. RELATES_TO, SOLVES, TRACKS)"),
+  isParent: z14.boolean().optional().describe("Whether this is a parent relationship")
 });
 function registerAddEdge(server2, client2) {
   server2.registerTool(
@@ -767,9 +867,9 @@ function registerAddEdge(server2, client2) {
       title: "Add Edges (bulk)",
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
       description: "Create 1-25 relationships (edges) between existing nodes in a single call; use after a bulk node insert to wire nodes together. Keep batches small and atomic (5-25 edges) so failures stay contained. Typical workflow: create nodes with `naumu_add_node`, then wire them up with batched `naumu_add_edge` calls. Direction matters and must match the schema: each edge's `(source.type, label, target.type)` tuple should appear in the schema's `connections` or `parent` for the source type. When the backend runs with `STRICT_EDGE_VALIDATION=true`, invalid tuples are rejected immediately with `error: invalid_edge` (the response includes `details.allowed_targets_for_relation` and a `hint` for routing the call); otherwise the edge persists and surfaces later as an `invalid_connection_target` / `parent_mismatch` violation. Either way, check `naumu_get_schema` and flip or drop offending edges before calling. Prefer `naumu_delegate` when you want the agent to discover the right connections itself.",
-      inputSchema: z13.object({
-        graphId: z13.string().describe("The graph ID"),
-        edges: z13.array(EdgeInput).min(1).max(25).describe("Batch of 1\u201325 edges to create. Keep batches small for atomicity.")
+      inputSchema: z14.object({
+        graphId: z14.string().describe("The graph ID"),
+        edges: z14.array(EdgeInput).min(1).max(25).describe("Batch of 1\u201325 edges to create. Keep batches small for atomicity.")
       })
     },
     async ({ graphId, edges }) => {
@@ -788,7 +888,7 @@ function registerAddEdge(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-node.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function registerRemoveNode(server2, client2) {
   server2.registerTool(
     "naumu_remove_node",
@@ -796,9 +896,9 @@ function registerRemoveNode(server2, client2) {
       title: "Remove Node",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Delete a node and all its connections from the knowledge graph; use only when you need precise, surgical deletion. This is destructive. Prefer `naumu_delegate` for removing knowledge - it understands the impact on the broader graph and can handle cascading changes.",
-      inputSchema: z14.object({
-        graphId: z14.string().describe("The graph ID"),
-        nodeId: z14.string().describe("The node ID to delete")
+      inputSchema: z15.object({
+        graphId: z15.string().describe("The graph ID"),
+        nodeId: z15.string().describe("The node ID to delete")
       })
     },
     async ({ graphId, nodeId }) => {
@@ -811,7 +911,7 @@ function registerRemoveNode(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-edge.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function registerRemoveEdge(server2, client2) {
   server2.registerTool(
     "naumu_remove_edge",
@@ -819,11 +919,11 @@ function registerRemoveEdge(server2, client2) {
       title: "Remove Edge",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Delete a single edge identified by `(source, target, label)` tuple; use to correct a wrong-target edge mistake (a recovery tool, not a routine one). Does NOT delete the endpoint nodes - only the edge between them. System edges (HAS_NODE, HAS_THREAD, OWNS, etc.) are rejected with `error: system_edge_not_removable`. Parent edges (`isParent: true`) are removable but the response includes a warning that the child may now be orphaned - call `naumu_reparent` first if you want connectivity preserved. Response: `{deleted: 0 | 1, warnings: string[]}`. Prefer `naumu_delegate` when the structural intent is broader than removing one specific edge - it can reason about the surrounding graph.",
-      inputSchema: z15.object({
-        graphId: z15.string().describe("The graph ID"),
-        source: z15.string().describe("Source node id of the edge to delete"),
-        target: z15.string().describe("Target node id of the edge to delete"),
-        label: z15.string().describe('Relation label of the edge to delete (e.g. "AUTHORED"). Case-insensitive; non-alphanum chars are normalized.')
+      inputSchema: z16.object({
+        graphId: z16.string().describe("The graph ID"),
+        source: z16.string().describe("Source node id of the edge to delete"),
+        target: z16.string().describe("Target node id of the edge to delete"),
+        label: z16.string().describe('Relation label of the edge to delete (e.g. "AUTHORED"). Case-insensitive; non-alphanum chars are normalized.')
       })
     },
     async ({ graphId, source, target, label }) => {
@@ -840,11 +940,11 @@ function registerRemoveEdge(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-edges-bulk.ts
-import { z as z16 } from "zod";
-var EdgeRef = z16.object({
-  source: z16.string().describe("Source node ID"),
-  target: z16.string().describe("Target node ID"),
-  label: z16.string().describe("Relation label of the edge to delete")
+import { z as z17 } from "zod";
+var EdgeRef = z17.object({
+  source: z17.string().describe("Source node ID"),
+  target: z17.string().describe("Target node ID"),
+  label: z17.string().describe("Relation label of the edge to delete")
 });
 function registerRemoveEdgesBulk(server2, client2) {
   server2.registerTool(
@@ -853,9 +953,9 @@ function registerRemoveEdgesBulk(server2, client2) {
       title: "Remove Edges (bulk)",
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
       description: "Delete 1-100 edges in a single atomic call (all-or-none); use to fix multiple wrong-target edge mistakes in one shot. Does NOT delete endpoint nodes. System edges (HAS_NODE, HAS_THREAD, OWNS, etc.) are rejected - if any edge in the batch targets a system relation, the WHOLE batch is rejected with `error: system_edge_not_removable`. Parent edges (`isParent: true`) are removable but each parent removal contributes a warning to the response (`{deleted, warnings: string[]}`) - call `naumu_reparent` first if you want connectivity preserved. Prefer `naumu_delegate` for broader structural cleanup that needs graph-wide reasoning.",
-      inputSchema: z16.object({
-        graphId: z16.string().describe("The graph ID"),
-        edges: z16.array(EdgeRef).min(1).max(100).describe("1-100 edges to delete. Atomic per call - all succeed or none do.")
+      inputSchema: z17.object({
+        graphId: z17.string().describe("The graph ID"),
+        edges: z17.array(EdgeRef).min(1).max(100).describe("1-100 edges to delete. Atomic per call - all succeed or none do.")
       })
     },
     async ({ graphId, edges }) => {
@@ -868,7 +968,7 @@ function registerRemoveEdgesBulk(server2, client2) {
 }
 
 // ../mcp-core/src/tools/ask.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function registerAsk(server2, client2) {
   server2.registerTool(
     "naumu_ask",
@@ -883,15 +983,21 @@ 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.',
-      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.")
+      description: 'Ask @Naumu a question about a space and get back a synthesised, node-grounded answer with the exact source node ids it used and a confidence hint. This is THE tool for any question about a space - what is in it, what is new or recently changed, how something works, or a summary of any topic. @Naumu has full read access and has already inspected the graph for you, so its answer is authoritative: present it and its cited sources directly. Do NOT independently re-read the graph (naumu_get_schema, naumu_filter, naumu_get_node, fetch) to verify or flesh out the answer - that repeats work @Naumu already did and is far slower. Reach for a granular read ONLY to pull a specific node the answer pointed to but did not fully include. Returns { answer, sources, confidence, threadId, status }; the answer is saved as a visible conversation in the space, which is expected and useful, so do not avoid the tool to prevent creating a thread. On a very long synthesis it may return status "processing" with a threadId - in that case wait a few seconds and call naumu_read_thread with that threadId for the final answer, and still do not fall back to manual digging. To hand @Naumu work to carry out (add knowledge, make changes, record status) without waiting, use naumu_delegate instead.',
+      inputSchema: z18.object({
+        graphId: z18.string().describe("The space (graph) id to ask about."),
+        question: z18.string().max(4e3).describe("The question for @Naumu. Up to 4000 characters."),
+        topicIds: z18.array(z18.string()).max(8).optional().describe(
+          "Topic ids (from naumu_list_topics) to file the resulting conversation into, making it visible to those topics' members from birth. Omit to keep the default behavior (the ask lands in the virtual #misc bucket)."
+        )
       })
     },
-    async ({ graphId, question }) => {
+    async ({ graphId, question, topicIds }) => {
       try {
-        const data = await client2.post(`/api/graphs/${graphId}/ask`, { question });
+        const data = await client2.post(`/api/graphs/${graphId}/ask`, {
+          question,
+          ...topicIds && topicIds.length > 0 ? { topicIds } : {}
+        });
         return {
           content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
         };
@@ -907,7 +1013,7 @@ function registerAsk(server2, client2) {
 }
 
 // ../mcp-core/src/tools/delegate.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 function registerDelegate(server2, client2) {
   server2.registerTool(
     "naumu_delegate",
@@ -922,23 +1028,30 @@ function registerDelegate(server2, client2) {
         idempotentHint: false,
         openWorldHint: true
       },
-      description: 'Hand @Naumu a task to carry out asynchronously: add knowledge, make graph-aware changes, or record a status update (e.g. "mark task X done", "log this deployment"). Returns immediately with a threadId; @Naumu works in the background and may take seconds to minutes. For status reports you can fire and forget. To read what @Naumu did, poll naumu_read_thread with the returned threadId. When you instead need an answer synchronously, use naumu_ask.',
-      inputSchema: z18.object({
-        graphId: z18.string().describe("The space (graph) id to act in."),
-        task: z18.string().describe("What you want @Naumu to do, add, or record."),
-        threadId: z18.string().optional().describe("Continue an existing conversation; omit to start a new one.")
+      description: 'Hand @Naumu a task to carry out asynchronously: add knowledge, make graph-aware changes, or record a status update (e.g. "mark task X done", "log this deployment"). Returns immediately with a threadId; @Naumu works in the background and may take seconds to minutes. For status reports you can fire and forget. To read what @Naumu did, poll naumu_read_thread with the returned threadId. When you instead need an answer synchronously, use naumu_ask. File the new thread into topics by passing `topicIds` (see naumu_list_topics): omitting them keeps the default private thread, providing them makes it visible to those topics\' members from birth. This always invokes @Naumu, even in threads where auto-response is paused, so the task text must never contain a literal "@Naumu" mention (plain text never renders or triggers a mention).',
+      inputSchema: z19.object({
+        graphId: z19.string().describe("The space (graph) id to act in."),
+        task: z19.string().describe("What you want @Naumu to do, add, or record."),
+        threadId: z19.string().optional().describe("Continue an existing conversation; omit to start a new one."),
+        topicIds: z19.array(z19.string()).max(8).optional().describe(
+          "Topic ids (from naumu_list_topics) to file a NEW thread into, making it visible to those topics' members. Only used at creation; never adds topics to an existing thread, so it is ignored when threadId is provided. Omit to keep the default private thread."
+        )
       })
     },
-    async ({ graphId, task, threadId }) => {
+    async ({ graphId, task, threadId, topicIds }) => {
       try {
         let resolvedThreadId = threadId;
         if (!resolvedThreadId) {
-          const thread = await client2.post("/api/threads", { graphId });
+          const thread = await client2.post("/api/threads", {
+            graphId,
+            ...topicIds && topicIds.length > 0 ? { topicIds } : {}
+          });
           resolvedThreadId = thread.id;
         }
         await client2.post(`/api/threads/${resolvedThreadId}/messages`, {
           content: task,
-          async: true
+          async: true,
+          invokeAgent: true
         });
         return {
           content: [
@@ -963,184 +1076,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 z20 } from "zod";
 function registerPostMessage(server2, client2) {
   server2.registerTool(
     "naumu_post_message",
@@ -1154,12 +1091,12 @@ function registerPostMessage(server2, client2) {
         idempotentHint: false,
         openWorldHint: false
       },
-      description: 'Post a message in a Naumu thread you participate in. Use it to reply to humans (or other bots) in a thread that pinged you. 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.")
+      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 (mention notifications, prompts) without invoking @Naumu. For a human, the mention `id` is their User id (from naumu_list_members or naumu_get_thread participantDetails) or their email - both work; for a bot/agent, use its identity id. 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: z20.object({
+        threadId: z20.string().describe("The thread ID to post into. You must be a participant in this thread."),
+        content: z20.string().optional().describe('Message body. Plain text by default; pass a Tiptap JSON document only if contentFormat is set to "tiptap". Optional when `attachmentIds` is provided.'),
+        contentFormat: z20.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: userIdOrEmailOrIdentityId, label: displayName } }` (a human mention id is their User id or email; a bot mention id is its identity id).'),
+        attachmentIds: z20.array(z20.string().min(1)).max(25).optional().describe("Attachment IDs from prior `naumu_request_attachment_upload` calls. Each must be a successfully-uploaded pending attachment in this graph (1-hour TTL). Up to 25 per message.")
       })
     },
     async ({ threadId, content, contentFormat, attachmentIds }) => {
@@ -1185,18 +1122,18 @@ function registerPostMessage(server2, client2) {
 }
 
 // ../mcp-core/src/tools/read-thread.ts
-import { z as z25 } from "zod";
+import { z as z21 } 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: z21.object({
+        threadId: z21.string().describe("The thread ID to read from."),
+        before: z21.number().optional().describe("Unix timestamp in milliseconds. Returns messages strictly older than this. Omit for the newest page."),
+        limit: z21.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ threadId, before, limit }) => {
@@ -1222,15 +1159,15 @@ function registerReadThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/whoami.ts
-import { z as z26 } from "zod";
+import { z as z22 } 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: z22.object({})
     },
     async () => {
       try {
@@ -1253,7 +1190,7 @@ function registerWhoami(server2, client2, allToolNames) {
 }
 
 // ../mcp-core/src/tools/list-threads.ts
-import { z as z27 } from "zod";
+import { z as z23 } from "zod";
 function sanitizeThreadParticipants(thread) {
   if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
     return thread;
@@ -1266,12 +1203,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: z23.object({
+        graphId: z23.string().optional().describe("Graph (space) ID. Required for user API keys; omit for bot identity keys (defaults to your own graph)."),
+        cursor: z23.number().int().optional().describe("Unix timestamp ms \u2014 returns threads with `lastActivityAt` strictly older than this. Omit for the newest page."),
+        limit: z23.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
       })
     },
     async ({ graphId, cursor, limit }) => {
@@ -1306,8 +1243,53 @@ function registerListThreads(server2, client2) {
   );
 }
 
+// ../mcp-core/src/tools/list-topics.ts
+import { z as z24 } from "zod";
+function toFilingDestination(topic) {
+  if (!topic || typeof topic !== "object") return null;
+  const t = topic;
+  if (typeof t.id !== "string" || typeof t.name !== "string") return null;
+  return {
+    id: t.id,
+    name: t.name,
+    ...typeof t.visibilityMode === "string" ? { visibilityMode: t.visibilityMode } : {},
+    ...typeof t.memberCount === "number" ? { memberCount: t.memberCount } : {},
+    ...typeof t.openToWeb === "boolean" ? { openToWeb: t.openToWeb } : {},
+    ...typeof t.isMember === "boolean" ? { isMember: t.isMember } : {}
+  };
+}
+function registerListTopics(server2, client2) {
+  server2.registerTool(
+    "naumu_list_topics",
+    {
+      title: "List Topics",
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+      description: "List a space's real topics \u2014 the filing destinations you can hand to the `topicIds` param of naumu_delegate or naumu_ask when creating a thread. Filing a new thread into one or more topics makes it visible to those topics' members from birth (instead of the default private thread). Each row carries { id, name, visibilityMode, memberCount, openToWeb }; use the id values in `topicIds`. Topics have no separate description field. The virtual #misc bucket is not a real topic and is omitted; archived topics are omitted because they can't be tagged. Resolve `graphId` via naumu_list_graphs first.",
+      inputSchema: z24.object({
+        graphId: z24.string().describe("The space (graph) id to list topics for.")
+      })
+    },
+    async ({ graphId }) => {
+      try {
+        const data = await client2.get(`/api/graphs/${graphId}/topics`);
+        const rows = Array.isArray(data) ? data : [];
+        const topics = rows.filter((t) => !(t && typeof t === "object" && t.archived === true)).map(toFilingDestination).filter((t) => t !== null);
+        return {
+          content: [{ type: "text", text: JSON.stringify(topics, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // ../mcp-core/src/tools/get-thread.ts
-import { z as z28 } from "zod";
+import { z as z25 } from "zod";
 function sanitizeThreadParticipants2(thread) {
   if (!thread || typeof thread !== "object" || !("participantEmails" in thread)) {
     return thread;
@@ -1320,10 +1302,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: z25.object({
+        threadId: z25.string().describe("The thread ID to fetch.")
       })
     },
     async ({ threadId }) => {
@@ -1345,7 +1327,7 @@ function registerGetThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/create-thread.ts
-import { z as z29 } from "zod";
+import { z as z26 } from "zod";
 function registerCreateThread(server2, client2) {
   server2.registerTool(
     "naumu_create_thread",
@@ -1359,32 +1341,36 @@ function registerCreateThread(server2, client2) {
         idempotentHint: false,
         openWorldHint: false
       },
-      description: "Start a new conversation in a space. You are auto-attached as a participant, and the thread's formal creator is your primary owner (the user who registered you), so it shows in their sidebar. Optional `participants` adds humans (by userId) and other bots (by identityId) at creation. Optional `initialMessage` opens the conversation as your first message. Tagging people loops them in without invoking @Naumu; only an explicit @Naumu mention, or naumu_ask, brings the agent in. Returns the created thread (including its id) so you can follow up with naumu_post_message.",
-      inputSchema: z29.object({
-        title: z29.string().min(1).max(200).optional().describe('Thread title shown in the sidebar. If omitted, Naumu generates a default like "Conversation YYYY-MM-DD".'),
-        participants: z29.array(
-          z29.discriminatedUnion("type", [
-            z29.object({
-              type: z29.literal("user"),
-              userId: z29.string().min(1).describe("User UUID \u2014 get these from `naumu_get_thread`/`naumu_read_thread` participant rosters or webhook payloads.")
+      description: "Start a new conversation in a space. You are auto-attached as a participant, and the thread's formal creator is your primary owner (the user who registered you), so it shows in their sidebar. Optional `participants` adds humans (by userId) and other bots (by identityId) at creation. Optional `initialMessage` opens the conversation as your first message. Optional `topicIds` files the new thread into one or more topics (see naumu_list_topics for ids): it becomes visible to those topics' members from birth instead of staying a private thread between you and your owner. Filing is creation-only and only ever widens - it never removes the thread from a topic later. Tagging people loops them in without invoking @Naumu; only an explicit @Naumu mention, or naumu_ask, brings the agent in. Returns the created thread (including its id) so you can follow up with naumu_post_message.",
+      inputSchema: z26.object({
+        title: z26.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: z26.array(
+          z26.discriminatedUnion("type", [
+            z26.object({
+              type: z26.literal("user"),
+              userId: z26.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.")
+            z26.object({
+              type: z26.literal("identity"),
+              identityId: z26.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: z26.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: z26.enum(["restricted", "internal", "open"]).optional().describe("`restricted` (invite-only, default) hides from non-participants. `internal` is visible to space members. `open` is visible to anyone who can see the space."),
+        topicIds: z26.array(z26.string()).max(8).optional().describe(
+          "Topic ids (from naumu_list_topics) to file the NEW thread into, making it visible to those topics' members from birth. Creation-only and only ever widens - it never removes the thread from a topic later. Omit to keep the default private thread between you and your owner."
+        )
       })
     },
-    async ({ title, participants, initialMessage, visibility }) => {
+    async ({ title, participants, initialMessage, visibility, topicIds }) => {
       try {
         const body = {};
         if (title !== void 0) body.title = title;
         if (participants !== void 0) body.participants = participants;
         if (initialMessage !== void 0) body.initialMessage = initialMessage;
         if (visibility !== void 0) body.visibility = visibility;
+        if (topicIds !== void 0) body.topicIds = topicIds;
         const data = await client2.post("/api/identities/me/threads", body);
         return {
           content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
@@ -1401,7 +1387,7 @@ function registerCreateThread(server2, client2) {
 }
 
 // ../mcp-core/src/tools/request-attachment-upload.ts
-import { z as z30 } from "zod";
+import { z as z27 } from "zod";
 function registerRequestAttachmentUpload(server2, client2) {
   server2.registerTool(
     "naumu_request_attachment_upload",
@@ -1409,12 +1395,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: z27.object({
+        threadId: z27.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: z27.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: z27.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: z27.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: z27.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 +1430,7 @@ function registerRequestAttachmentUpload(server2, client2) {
 }
 
 // ../mcp-core/src/tools/add-reaction.ts
-import { z as z31 } from "zod";
+import { z as z28 } from "zod";
 function registerAddReaction(server2, client2) {
   server2.registerTool(
     "naumu_add_reaction",
@@ -1452,10 +1438,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: z28.object({
+        threadId: z28.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z28.string().describe("The message to react to."),
+        emoji: z28.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 +1465,7 @@ function registerAddReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/remove-reaction.ts
-import { z as z32 } from "zod";
+import { z as z29 } from "zod";
 function registerRemoveReaction(server2, client2) {
   server2.registerTool(
     "naumu_remove_reaction",
@@ -1487,10 +1473,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: z29.object({
+        threadId: z29.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z29.string().describe("The message to remove your reaction from."),
+        emoji: z29.string().min(1).describe("Emoji character to remove (must match what you originally reacted with).")
       })
     },
     async ({ threadId, messageId, emoji }) => {
@@ -1514,7 +1500,7 @@ function registerRemoveReaction(server2, client2) {
 }
 
 // ../mcp-core/src/tools/naumu-typing.ts
-import { z as z33 } from "zod";
+import { z as z30 } from "zod";
 function registerNaumuTyping(server2, client2) {
   server2.registerTool(
     "naumu_typing",
@@ -1525,9 +1511,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: z30.object({
+        threadId: z30.string().describe("The thread ID to set typing in. You must be a participant."),
+        state: z30.enum(["start", "stop"]).describe('"start" acquires/renews the lease; "stop" ends it and clears the pill immediately.')
       })
     },
     async ({ threadId, state }) => {
@@ -1548,16 +1534,16 @@ function registerNaumuTyping(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-read.ts
-import { z as z34 } from "zod";
+import { z as z31 } 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: z31.object({
+        noteId: z31.string().describe("The note (Thought) ID")
       })
     },
     async ({ noteId }) => {
@@ -1570,7 +1556,7 @@ function registerNoteRead(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-append.ts
-import { z as z35 } from "zod";
+import { z as z32 } from "zod";
 function registerNoteAppend(server2, client2) {
   server2.registerTool(
     "naumu_note_append",
@@ -1578,9 +1564,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: z32.object({
+        noteId: z32.string().describe("The note (Thought) ID to append to"),
+        markdown: z32.string().min(1).describe("Markdown content to append at the end of the note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -1593,7 +1579,7 @@ function registerNoteAppend(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-insert.ts
-import { z as z36 } from "zod";
+import { z as z33 } from "zod";
 function registerNoteInsert(server2, client2) {
   server2.registerTool(
     "naumu_note_insert",
@@ -1601,10 +1587,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: z33.object({
+        noteId: z33.string().describe("The note (Thought) ID"),
+        headingText: z33.string().min(1).describe("Exact text of the heading whose section the new content follows"),
+        markdown: z33.string().min(1).describe("Markdown content to insert at the end of that section")
       })
     },
     async ({ noteId, headingText, markdown }) => {
@@ -1620,7 +1606,7 @@ function registerNoteInsert(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace-section.ts
-import { z as z37 } from "zod";
+import { z as z34 } from "zod";
 function registerNoteReplaceSection(server2, client2) {
   server2.registerTool(
     "naumu_note_replace_section",
@@ -1628,11 +1614,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: z34.object({
+        noteId: z34.string().describe("The note (Thought) ID"),
+        headingText: z34.string().min(1).describe("Exact text of the heading anchoring the section"),
+        markdown: z34.string().describe("Replacement markdown for the section body"),
+        keepHeading: z34.boolean().optional().describe("Whether to keep the heading row itself. Default true.")
       })
     },
     async ({ noteId, headingText, markdown, keepHeading }) => {
@@ -1649,7 +1635,7 @@ function registerNoteReplaceSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-delete-section.ts
-import { z as z38 } from "zod";
+import { z as z35 } from "zod";
 function registerNoteDeleteSection(server2, client2) {
   server2.registerTool(
     "naumu_note_delete_section",
@@ -1657,9 +1643,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: z35.object({
+        noteId: z35.string().describe("The note (Thought) ID"),
+        headingText: z35.string().min(1).describe("Exact text of the heading whose section will be deleted")
       })
     },
     async ({ noteId, headingText }) => {
@@ -1674,7 +1660,7 @@ function registerNoteDeleteSection(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-replace.ts
-import { z as z39 } from "zod";
+import { z as z36 } from "zod";
 function registerNoteReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_replace",
@@ -1682,9 +1668,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: z36.object({
+        noteId: z36.string().describe("The note (Thought) ID"),
+        markdown: z36.string().describe("New markdown content for the entire note")
       })
     },
     async ({ noteId, markdown }) => {
@@ -1697,7 +1683,7 @@ function registerNoteReplace(server2, client2) {
 }
 
 // ../mcp-core/src/tools/note-find-replace.ts
-import { z as z40 } from "zod";
+import { z as z37 } from "zod";
 function registerNoteFindReplace(server2, client2) {
   server2.registerTool(
     "naumu_note_find_replace",
@@ -1705,11 +1691,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: z37.object({
+        noteId: z37.string().describe("The note (Thought) ID"),
+        find: z37.string().min(1).describe("Substring to search for. Literal - no regex."),
+        replace: z37.string().describe("Replacement string. May be empty to delete the match."),
+        all: z37.boolean().optional().describe("Replace all occurrences (default true). Pass false to replace only the first.")
       })
     },
     async ({ noteId, find, replace, all }) => {
@@ -1725,144 +1711,24 @@ 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 z38 } from "zod";
 function registerCreateNote(server2, client2) {
   server2.registerTool(
     "naumu_create_note",
     {
       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")
-      })
-    },
-    async ({ graphId, title }) => {
-      const data = await client2.post("/api/notes", { graphId, title });
-      return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-      };
-    }
-  );
-}
-
-// ../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")
+      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, and a bot-created note is private (participants only) unless `sharedWithSpace` is set true. Bots cannot file notes into topics \u2014 a bot passing `topicIds` is rejected (bots hold no topic membership); use `sharedWithSpace` instead.",
+      inputSchema: z38.object({
+        graphId: z38.string().describe("The graph ID to create the note in"),
+        title: z38.string().optional().describe("Optional title for the note"),
+        sharedWithSpace: z38.boolean().optional().describe("Share the note with everyone in the space. Omit (or false) to keep it private to its participants."),
+        topicIds: z38.array(z38.string()).max(8).optional().describe("File the note into these topics (get ids from naumu_list_topics), making it visible to those topics' members. Not available to bots.")
       })
     },
-    async ({ graphId, title }) => {
-      const data = await client2.post("/api/canvases", { graphId, title });
+    async ({ graphId, title, sharedWithSpace, topicIds }) => {
+      const data = await client2.post("/api/notes", { graphId, title, sharedWithSpace, topicIds });
       return {
         content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
       };
@@ -1871,7 +1737,7 @@ function registerCreateCanvas(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-schema-violations.ts
-import { z as z46 } from "zod";
+import { z as z39 } from "zod";
 var DEFAULT_EXAMPLE_LIMIT = 5;
 var rowsForKind = (violations, kind) => {
   const rows = [];
@@ -1895,14 +1761,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: z39.object({
+        graphId: z39.string().describe("The graph ID"),
+        kind: z39.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: z39.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 +1820,18 @@ function registerListSchemaViolations(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-dense-nodes.ts
-import { z as z47 } from "zod";
+import { z as z40 } 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: z40.object({
+        graphId: z40.string().describe("The graph ID"),
+        minConnections: z40.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: z40.array(z40.string()).optional().describe("Optional list of node types to restrict the scan to.")
       })
     },
     async ({ graphId, minConnections, nodeTypes }) => {
@@ -1983,19 +1849,19 @@ function registerListDenseNodes(server2, client2) {
 }
 
 // ../mcp-core/src/tools/list-node-connections.ts
-import { z as z48 } from "zod";
+import { z as z41 } 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: z41.object({
+        graphId: z41.string().describe("The graph ID"),
+        nodeId: z41.string().describe("The node ID to inspect"),
+        edgeType: z41.string().optional().describe('Restrict to a specific relation label (e.g. "ASSOCIATED_WITH"). Case-insensitive; non-alphanum chars are normalized.'),
+        direction: z41.enum(["in", "out", "both"]).optional().describe('Edge direction filter - "in" (incoming), "out" (outgoing), "both" (default).')
       })
     },
     async ({ graphId, nodeId, edgeType, direction }) => {
@@ -2013,7 +1879,7 @@ function registerListNodeConnections(server2, client2) {
 }
 
 // ../mcp-core/src/tools/reparent.ts
-import { z as z49 } from "zod";
+import { z as z42 } from "zod";
 function registerReparent(server2, client2) {
   server2.registerTool(
     "naumu_reparent",
@@ -2021,11 +1887,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: z42.object({
+        graphId: z42.string().describe("The graph ID"),
+        nodeId: z42.string().describe("The child node to reparent"),
+        newParentId: z42.string().describe("The new parent node id"),
+        newRelation: z42.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 +1907,7 @@ function registerReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/batch-reparent.ts
-import { z as z50 } from "zod";
+import { z as z43 } from "zod";
 function registerBatchReparent(server2, client2) {
   server2.registerTool(
     "naumu_batch_reparent",
@@ -2049,11 +1915,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: z43.object({
+        graphId: z43.string().describe("The graph ID"),
+        newParentId: z43.string().describe("Parent node id every nodeId in the batch will be parented to"),
+        newRelation: z43.string().describe("Parent edge relation label (must be valid per schema for child.type \u2192 parent.type)"),
+        nodeIds: z43.array(z43.string()).min(1).max(25).describe("1\u201325 child node ids to reparent under `newParentId`")
       })
     },
     async ({ graphId, newParentId, newRelation, nodeIds }) => {
@@ -2070,7 +1936,7 @@ function registerBatchReparent(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-search.ts
-import { z as z51 } from "zod";
+import { z as z44 } from "zod";
 
 // ../mcp-core/src/public-origin.ts
 function publicOrigin() {
@@ -2122,10 +1988,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: z44.object({
+        query: z44.string().describe('Search query text. Mix synonyms and exact tokens freely (e.g. "auth login SSO 2fa").')
       })
     },
     async ({ query }) => {
@@ -2157,7 +2023,7 @@ function registerChatgptSearch(server2, client2) {
 }
 
 // ../mcp-core/src/tools/chatgpt-fetch.ts
-import { z as z52 } from "zod";
+import { z as z45 } from "zod";
 var NON_ATTRIBUTE_PROPS = /* @__PURE__ */ new Set([
   "id",
   "label",
@@ -2220,10 +2086,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: z45.object({
+        id: z45.string().describe("A resource id from a previous `search` result, in the form `<graphId>:<nodeId>`.")
       })
     },
     async ({ id }) => {
@@ -2268,6 +2134,7 @@ function registerChatgptFetch(server2, client2) {
 // ../mcp-core/src/tools/index.ts
 var TOOL_REGISTRARS = {
   naumu_list_graphs: registerListGraphs,
+  naumu_list_members: registerListMembers,
   naumu_create_graph: registerCreateGraph,
   naumu_get_schema: registerGetSchema,
   naumu_update_schema: registerUpdateSchema,
@@ -2277,8 +2144,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,13 +2153,11 @@ 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,
   naumu_list_threads: registerListThreads,
+  naumu_list_topics: registerListTopics,
   naumu_get_thread: registerGetThread,
   naumu_create_thread: registerCreateThread,
   naumu_request_attachment_upload: registerRequestAttachmentUpload,
@@ -2308,11 +2171,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,
@@ -2325,9 +2184,13 @@ var TOOL_REGISTRARS = {
   search: registerChatgptSearch,
   fetch: registerChatgptFetch
 };
-var ALL_TOOL_NAMES = Object.keys(TOOL_REGISTRARS);
+var BOT_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set(["naumu_create_thread"]);
+var ALL_TOOL_NAMES = Object.keys(TOOL_REGISTRARS).filter(
+  (name) => !BOT_ONLY_TOOL_NAMES.has(name)
+);
 function registerAllTools(server2, client2) {
   for (const [name, registrar] of Object.entries(TOOL_REGISTRARS)) {
+    if (BOT_ONLY_TOOL_NAMES.has(name)) continue;
     if (name === "naumu_whoami") {
       registerWhoami(server2, client2, ALL_TOOL_NAMES);
     } else {