@naumu/mcp 0.6.0 → 0.6.2

package/dist/index.js

@@ -1,68 +1,2333 @@
 #!/usr/bin/env node
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { NaumuClient } from './client.js';
-import { registerAllTools, registerNamedTools } from './tools/index.js';
-const DEFAULT_API_URL = 'https://naumu.ai';
-const BOT_KEY_PREFIX = 'nmu_bot_';
-const apiUrl = (process.env.NAUMU_API_URL || DEFAULT_API_URL).replace(/\/api\/?$/, '');
-const apiKey = process.env.NAUMU_API_KEY;
-if (!apiKey) {
-    console.error('Missing required environment variable: NAUMU_API_KEY');
-    process.exit(1);
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../mcp-core/src/errors.ts
+var NaumuApiError = class extends Error {
+  constructor(status, message, upstreamMessage) {
+    super(message);
+    this.status = status;
+    this.upstreamMessage = upstreamMessage;
+    this.name = "NaumuApiError";
+  }
+  status;
+  upstreamMessage;
+};
+function safeErrorMessage(status, upstream) {
+  if (status === 400 || status === 422) return upstream;
+  if (status === 401) return "Unauthorized \u2014 check your API key.";
+  if (status === 403 || status === 404) {
+    return "Resource not found, or you do not have access to it.";
+  }
+  if (status === 409) return "Conflict with current state.";
+  if (status === 410) return "Resource is no longer available.";
+  if (status === 413) return "Payload too large.";
+  if (status === 429) return "Rate limit exceeded \u2014 slow down and retry.";
+  if (status >= 500) return "Server error \u2014 try again shortly.";
+  return `Request failed with status ${status}.`;
 }
-const 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 — Naumu pages are client-rendered React, so WebFetch returns an empty shell with no data.
+
+// ../mcp-core/src/client.ts
+var NaumuClient = class {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey2) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey2;
+  }
+  headers() {
+    return {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async handleResponse(res) {
+    if (!res.ok) {
+      const text = await res.text().catch(() => "Unknown error");
+      let upstream;
+      try {
+        const json = JSON.parse(text);
+        upstream = json.message || text;
+      } catch {
+        upstream = text;
+      }
+      console.error(
+        `[mcp] upstream ${res.status}: ${upstream.slice(0, 500)}`
+      );
+      throw new NaumuApiError(res.status, safeErrorMessage(res.status, upstream), upstream);
+    }
+    return res.json();
+  }
+  async get(path) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "GET",
+      headers: this.headers()
+    });
+    return this.handleResponse(res);
+  }
+  async getBinary(path) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.apiKey}` }
+    });
+    if (!res.ok) {
+      const upstream = await res.text().catch(() => "Unknown error");
+      console.error(
+        `[mcp] upstream binary ${res.status}: ${upstream.slice(0, 500)}`
+      );
+      throw new NaumuApiError(
+        res.status,
+        safeErrorMessage(res.status, upstream),
+        upstream
+      );
+    }
+    const arrayBuffer = await res.arrayBuffer();
+    return {
+      buffer: new Uint8Array(arrayBuffer),
+      contentType: res.headers.get("content-type") ?? "application/octet-stream"
+    };
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: this.headers(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return this.handleResponse(res);
+  }
+  async patch(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "PATCH",
+      headers: this.headers(),
+      body: JSON.stringify(body)
+    });
+    return this.handleResponse(res);
+  }
+  async del(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      headers: this.headers(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return this.handleResponse(res);
+  }
+};
+
+// ../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.
 
 IMPORTANT: graphId is a UUID (e.g. "0464cbfa-60ca-41b3-ac8f-bbeb8243a193"). The value in the URL right after /spaces/ is a slug (e.g. "naumu-0464cbfa"), NOT the graphId. You must resolve the slug to a graphId first.
 
-How to resolve a slug → graphId:
+How to resolve a slug \u2192 graphId:
 Call naumu_list_graphs and find the graph whose 'slug' field matches the URL segment. Use that graph's 'id' as graphId for every other tool. Cache it for the rest of the conversation; the user will likely paste more URLs for the same space.
 
-URL → tool mapping (the value after /spaces/ is the slug — resolve it first):
-- naumu.ai/spaces/{slug}                          → naumu_list_graphs (resolve), then naumu_get_schema for an overview
-- naumu.ai/spaces/{slug}/views/{viewId}           → naumu_list_graphs (resolve), then naumu_get_view, then naumu_list_view_nodes
-- naumu.ai/spaces/{slug}/nodes/{nodeId}           → naumu_list_graphs (resolve), then naumu_get_node
-- naumu.ai/spaces/{slug}/chat/{threadId}          → naumu_list_graphs (resolve), then naumu_get_ai_thread
-- Other panel URLs (notes, canvases, conversations, members, settings, schema, heat, health, changelog) have no dedicated tool — fall back to naumu_get_node with the relevant id, or naumu_get_schema for the space-level question.
+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_get_ai_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 — find the graph whose slug matches the URL. Note its 'id' (the UUID) as graphId.
-2. naumu_get_view {graphId, viewId} — read the returned 'summary' and 'filters' to understand what the view returns. This is cheap.
-3. naumu_list_view_nodes {graphId, viewId} — page through results.
-   - fields:"summary" (default) for {id, label, type} per node — best for browsing.
-   - fields:"id" for {id} only — best when you just need to count or iterate.
-   - fields:"full" for the complete node payload — only when you need every attribute.
+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.
 
-Localhost URLs (http://localhost:3000/spaces/{slug}/...) follow the same shape — resolve the slug the same way. The MCP backend host is configured separately via NAUMU_API_URL; the URL the user pastes is just for parsing structure.`;
-const client = new NaumuClient(apiUrl, apiKey);
-const server = new McpServer({
-    name: 'naumu',
-    version: '0.4.0',
-}, {
-    instructions: NAUMU_INSTRUCTIONS,
+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.`;
+
+// ../mcp-core/src/tools/list-graphs.ts
+import { z } from "zod";
+function registerListGraphs(server2, client2) {
+  server2.registerTool(
+    "naumu_list_graphs",
+    {
+      title: "List Graphs",
+      annotations: { readOnlyHint: true },
+      description: "List all knowledge graphs (spaces) the authenticated user has access to. Returns graph IDs, names, and roles.",
+      inputSchema: z.object({})
+    },
+    async () => {
+      const data = await client2.get("/api/graphs");
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/create-graph.ts
+import { z as z2 } from "zod";
+function registerCreateGraph(server2, client2) {
+  server2.registerTool(
+    "naumu_create_graph",
+    {
+      title: "Create Graph",
+      annotations: { destructiveHint: true },
+      description: "Create a new knowledge graph (space) owned by the authenticated user. Returns `{id, name, slug, role, memberRole, createdAt, onboardingThreadId}` \u2014 use the returned `id` as `graphId` for subsequent tool calls. The space starts empty (no schema, no nodes); follow up with `naumu_update_schema` to register types before any `naumu_add_node` calls.",
+      inputSchema: z2.object({
+        name: z2.string().min(1).describe("Display name for the new space. A URL slug is generated from this name.")
+      })
+    },
+    async ({ name }) => {
+      const data = await client2.post("/api/graphs", { name });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/get-schema.ts
+import { z as z3 } from "zod";
+function formatSchema(schema) {
+  return {
+    description: schema.description ?? null,
+    types: schema.nodes.map((node) => {
+      const result = { type: node.type };
+      if (node.description) result.description = node.description;
+      if (node.connections.parent) {
+        result.parent = `${node.connections.parent.relation} \u2192 ${node.connections.parent.target_node}`;
+      }
+      const connections = [
+        ...node.connections.required.map((c) => `${c.relation} \u2192 ${c.target_node} (required)`),
+        ...node.connections.suggested.map((c) => `${c.relation} \u2192 ${c.target_node}`)
+      ];
+      if (connections.length > 0) result.connections = connections;
+      if (node.attributes && node.attributes.length > 0) {
+        result.attributes = Object.fromEntries(
+          node.attributes.map((a) => {
+            const values = (a.values ?? []).map(
+              (v) => v.description ? { label: v.label, description: v.description } : v.label
+            );
+            const attrDetail = { values };
+            if (a.description) attrDetail.description = a.description;
+            const hasDesc = !!a.description;
+            const hasValueDescs = values.some((v) => typeof v !== "string");
+            if (!hasDesc && !hasValueDescs) {
+              return [a.name, (a.values ?? []).map((v) => v.label)];
+            }
+            return [a.name, attrDetail];
+          })
+        );
+      }
+      return result;
+    })
+  };
+}
+function registerGetSchema(server2, client2) {
+  server2.registerTool(
+    "naumu_get_schema",
+    {
+      title: "Get Graph Schema",
+      annotations: { readOnlyHint: true },
+      description: "Get the schema definition for a knowledge graph. Returns node types, their allowed attributes (with valid values), allowed relationships, and any descriptions authored on types/attributes/values. Call this before classifying a new node into a type, before picking an attribute value, or before extending the schema \u2014 descriptions are short, contrastive notes from the schema author explaining what each type/attribute/value is for and how it differs from similar-sounding ones.",
+      inputSchema: z3.object({
+        graphId: z3.string().describe("The graph ID")
+      })
+    },
+    async ({ graphId }) => {
+      const data = await client2.get(`/api/graphs/${graphId}/schema`);
+      const schema = JSON.parse(data.definition);
+      const formatted = formatSchema(schema);
+      let spaceDescription = null;
+      try {
+        const summary = await client2.get(`/api/graphs/${graphId}/summary`);
+        spaceDescription = summary.description ?? summary.summary ?? null;
+      } catch {
+      }
+      const out = { ...formatted, space_description: spaceDescription };
+      return {
+        content: [{ type: "text", text: JSON.stringify(out, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../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.")
 });
-// Bot keys (`nmu_bot_*`) get a filtered tool surface — the backend computes
-// the allowed set from the Identity's `allowedTools`. User keys keep the full
-// surface (no per-Identity scoping applies).
-const isBotKey = apiKey.startsWith(BOT_KEY_PREFIX);
-if (isBotKey) {
-    try {
-        const manifest = (await client.get('/api/identities/me/mcp-tool-manifest'));
-        registerNamedTools(server, client, manifest.mcpTools);
-        console.error(`[mcp] connected to ${apiUrl} as bot identity ${manifest.identityId} (${manifest.intelligenceKind}); ${manifest.mcpTools.length} tool(s) registered`);
+var AttributeValueSchema = z4.object({
+  label: z4.string().describe("Display label for this enum value"),
+  color: z4.string().optional().describe('Optional hex color (e.g. "#ff5722")'),
+  description: z4.string().optional().describe('Short note distinguishing this value from sibling values (e.g. "closed-won \u2014 deal signed and revenue committed"). Encouraged when the label alone is ambiguous.')
+});
+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 NodeTypeSchema = z4.object({
+  type: z4.string().describe("Type name in PascalCase (e.g. Company, Person, Feature, Document)"),
+  connections: z4.object({
+    parent: ConnectionSchema.optional().describe("Optional parent relation (this type nests under another via this connection)."),
+    required: z4.array(ConnectionSchema).default([]).describe("Required outgoing connections to other types."),
+    suggested: z4.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(
+    'Default visibility for NEW nodes of this type when no explicit visibility is passed on creation. Does NOT retroactively change visibility on existing nodes. "open" = visible to anyone with the space link (including non-members), "internal" = visible to all space members, "restricted" = only members explicitly granted access. Omit to leave the type unset \u2014 it then falls back to the space-level defaultVisibility.'
+  ),
+  color: z4.string().optional().describe("Optional hex color for instances of this type."),
+  description: z4.string().optional().describe('Short one-sentence description of what this type represents AND how it differs from semantically similar types (e.g. "External entity delivering services on contract \u2014 distinct from Organization which is any legal entity"). Strongly encouraged on every type. Future agents rely on this when classifying a new node into one of several similar-sounding types.')
+});
+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.")
+});
+function registerUpdateSchema(server2, client2) {
+  server2.registerTool(
+    "naumu_update_schema",
+    {
+      title: "Update Graph Schema",
+      annotations: { destructiveHint: true },
+      description: "Replace the graph schema with a new full definition. STRUCTURAL RULES (load-bearing): (1) HIERARCHICAL with a single root \u2014 exactly ONE type has no parent; every other type MUST declare a parent. (2) Each parent / required / suggested connection is XOR: ONE concrete target_node OR polymorphic=true \u2014 never both, never a list of multiple targets. (3) DEFAULT TO CONCRETE target_node. Polymorphic is the ESCAPE HATCH \u2014 reserve for genuinely cross-cutting concepts like Comment or Tag (entities that validly attach to many distinct types). If you find yourself making most parents polymorphic, you are avoiding the design work \u2014 pick concrete relationships instead. If you can't pick a concrete parent, you may be missing a type \u2014 add the missing type first. (4) Same-type nesting is implicit: a node can be placed under another of its same type using the existing parent relation \u2014 never add a self-relation just to enable nesting. (5) Always provide `description` on every node type, attribute, and select value \u2014 one short, contrastive sentence (what it IS and what it is NOT vs sibling types/attrs/values). This is the single strongest disambiguation signal for future agents classifying nodes. Use to bootstrap an empty graph (cold-start) or fully replace mid-build (call naumu_get_schema first, send the FULL new schema \u2014 anything you omit is removed). Conventions: type names PascalCase (Company, Person, Feature), relation names UPPER_SNAKE_CASE (WORKS_AT, BELONGS_TO). Bias toward general types \u2014 refine via attributes or nested children, not type proliferation.",
+      inputSchema: z4.object({
+        graphId: z4.string().describe("The graph ID"),
+        schema: SchemaDefinitionSchema
+      })
+    },
+    async ({ graphId, schema }) => {
+      const data = await client2.post(`/api/graphs/${graphId}/schema`, {
+        definition: schema
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../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.")
+});
+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 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.')
+});
+function registerAddNodeType(server2, client2) {
+  server2.registerTool(
+    "naumu_add_node_type",
+    {
+      title: "Add Node Type to Schema",
+      annotations: { destructiveHint: true },
+      description: 'Add one new node type to the schema. Cheaper than naumu_update_schema. STRUCTURAL RULES: (1) Schemas are hierarchical with a single root. If schema is empty, the first type IS the root \u2014 omit `parent`. Every subsequent type MUST set `parent`. (2) DEFAULT TO CONCRETE \u2014 pass {relation, target_node: <existing type>}. Polymorphic is the ESCAPE HATCH \u2014 use {relation, polymorphic: true} ONLY for genuinely cross-cutting concepts like Comment or Tag (types that validly attach to many distinct parents). If you can\'t pick a concrete parent, you may be missing a type \u2014 add the missing type first instead of falling back to polymorphic. (3) Required/suggested connections also each take ONE concrete target_node OR polymorphic \u2014 never a list. Default concrete there too. (4) Type name PascalCase (Company, Person, Feature). Relation names UPPER_SNAKE_CASE (BELONGS_TO, WORKS_AT). (5) ALWAYS provide `description` \u2014 one short sentence that says what this type is AND what it is NOT relative to semantically close types (e.g. "External entity that delivers services on contract; distinct from Organization which is any legal entity"). This is the single strongest signal future agents have when classifying a node into one of several similar-sounding types. Returns an error if the type already exists \u2014 use naumu_add_attribute / naumu_add_connection to extend it.',
+      inputSchema: z5.object({
+        graphId: z5.string(),
+        type: z5.string().describe("PascalCase type name"),
+        description: z5.string().optional().describe(
+          "Short one-sentence description of what this type represents and how it differs from sibling types. Contrastive (say what it IS and what it is NOT) is most useful. Strongly encouraged on every new type \u2014 agents reading the schema later rely on this to classify nodes."
+        ),
+        parent: ConnectionSchema2.optional().describe("Optional parent connection \u2014 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(
+          '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.'
+        )
+      })
+    },
+    async ({ graphId, type, description, parent, required, suggested, attributes, color, defaultVisibility }) => {
+      const current = await client2.get(`/api/graphs/${graphId}/schema`);
+      const schema = current.definition ? JSON.parse(current.definition) : { nodes: [] };
+      if (schema.nodes.some((n) => n.type === type)) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Node type "${type}" already exists. Use naumu_add_attribute / naumu_add_connection to extend it.` }, null, 2) }]
+        };
+      }
+      const newNode = {
+        type,
+        connections: {
+          required: required ?? [],
+          suggested: suggested ?? [],
+          ...parent ? { parent } : {}
+        },
+        ...attributes && attributes.length > 0 ? { attributes } : {},
+        ...color ? { color } : {},
+        ...description ? { description } : {},
+        ...defaultVisibility ? { defaultVisibility } : {}
+      };
+      schema.nodes.push(newNode);
+      await client2.post(`/api/graphs/${graphId}/schema`, { definition: schema });
+      return {
+        content: [{ type: "text", text: JSON.stringify({ message: `Added node type "${type}"`, total_types: schema.nodes.length }, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/add-connection.ts
+import { z as z6 } from "zod";
+function registerAddConnection(server2, client2) {
+  server2.registerTool(
+    "naumu_add_connection",
+    {
+      title: "Add Connection to Node Type",
+      annotations: { destructiveHint: true },
+      description: 'Add one connection from an existing node type to another. `kind`: "parent" (sets/replaces \u2014 every non-root type needs exactly one parent; only ONE type in the whole schema has no parent), "required" (must exist on instances), "suggested" (optional). Each connection is XOR: ONE concrete target_node OR polymorphic=true \u2014 never both. DEFAULT TO CONCRETE target_node. Polymorphic is the ESCAPE HATCH \u2014 reserve for genuinely cross-cutting relations (e.g. a Tag-style relation that validly applies to many distinct types). If you can\'t pick a concrete target, you may be missing a type \u2014 add it first instead of falling back to polymorphic. Same-type nesting (e.g. Topic under Topic) does NOT need a new connection \u2014 use the existing parent relation. Relation name UPPER_SNAKE_CASE.',
+      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")
+      })
+    },
+    async ({ graphId, source_type, relation, target_node, polymorphic, kind }) => {
+      const current = await client2.get(`/api/graphs/${graphId}/schema`);
+      const schema = current.definition ? JSON.parse(current.definition) : { nodes: [] };
+      const node = schema.nodes.find((n) => n.type === source_type);
+      if (!node) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Node type "${source_type}" not found. Add it first via naumu_add_node_type.` }, null, 2) }]
+        };
+      }
+      const conn = { relation, ...polymorphic ? { polymorphic: true } : {}, ...target_node ? { target_node } : {} };
+      if (!node.connections) node.connections = { required: [], suggested: [] };
+      if (kind === "parent") {
+        node.connections.parent = conn;
+      } else {
+        const list = node.connections[kind] ?? [];
+        const exists = list.some((c) => c.relation === relation && c.target_node === target_node && Boolean(c.polymorphic) === Boolean(polymorphic));
+        if (exists) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ message: `Connection already exists on "${source_type}", no change.` }, null, 2) }]
+          };
+        }
+        list.push(conn);
+        node.connections[kind] = list;
+      }
+      await client2.post(`/api/graphs/${graphId}/schema`, { definition: schema });
+      return {
+        content: [{ type: "text", text: JSON.stringify({ message: `Added ${kind} connection ${relation}${target_node ? ` \u2192 ${target_node}` : " (polymorphic)"} on "${source_type}".` }, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/add-attribute.ts
+import { z as z7 } from "zod";
+function registerAddAttribute(server2, client2) {
+  server2.registerTool(
+    "naumu_add_attribute",
+    {
+      title: "Add Attribute to Node Type",
+      annotations: { destructiveHint: true },
+      description: 'Add or extend an attribute on an existing node type. If the attribute name doesn\'t exist, it is created. If it exists and is a select/multiselect, new values are merged in (existing values kept). Use type "select"/"multiselect" with values; "string"/"number"/"date" for free-form fields (pass values: [] \u2014 string/number/date have no enum values). Example date attribute: { name: "due_date", type: "date", values: [], description: "Target completion date (single day or range)" }. Date values on nodes are written via naumu_update_node as either an ISO date string "YYYY-MM-DD" (single day) or an object { start, end? } with ISO date strings (inclusive range). Strongly encouraged to provide `description` on the attribute and on each value \u2014 short, contrastive notes (e.g. attribute "stage \u2014 sales funnel position; distinct from status which captures health/blockers", value "closed-won \u2014 deal signed and revenue committed"). Descriptions are the single strongest signal future agents use when picking which attribute/value to set.',
+      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 \u2014 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.')
+      })
+    },
+    async ({ graphId, node_type, name, type, values, description }) => {
+      const current = await client2.get(`/api/graphs/${graphId}/schema`);
+      const schema = current.definition ? JSON.parse(current.definition) : { nodes: [] };
+      const node = schema.nodes.find((n) => n.type === node_type);
+      if (!node) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Node type "${node_type}" not found. Add it first via naumu_add_node_type.` }, null, 2) }]
+        };
+      }
+      node.attributes = node.attributes ?? [];
+      const existing = node.attributes.find((a) => a.name === name);
+      let action;
+      if (!existing) {
+        node.attributes.push({ name, type, values, ...description ? { description } : {} });
+        action = `Created attribute "${name}" (${type}) with ${values.length} value(s).`;
+      } else {
+        const existingLabels = new Set((existing.values ?? []).map((v) => v.label));
+        const added = values.filter((v) => !existingLabels.has(v.label));
+        existing.values = [...existing.values ?? [], ...added];
+        if (description && !existing.description) existing.description = description;
+        action = added.length > 0 ? `Extended attribute "${name}" with ${added.length} new value(s); kept ${existingLabels.size} existing.` : `Attribute "${name}" already had all proposed values; no change.`;
+      }
+      await client2.post(`/api/graphs/${graphId}/schema`, { definition: schema });
+      return {
+        content: [{ type: "text", text: JSON.stringify({ message: action, node_type }, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/search.ts
+import { z as z8 } from "zod";
+function registerSearch(server2, client2) {
+  server2.registerTool(
+    "naumu_search",
+    {
+      title: "Search Graph",
+      annotations: { readOnlyHint: true },
+      description: 'Hybrid search over graph nodes. Combines exact-token text matching (good for UUIDs, proper nouns, specific labels) with semantic similarity (good for paraphrase and meaning), then fuses both rankings with Reciprocal Rank Fusion. Returns the top matches with a `matchedVia` tag \u2014 `both` is the highest-confidence signal, then `semantic`, then `text`. Use `naumu_filter` for structured queries by type and attributes (e.g. "all in-progress Tasks"). Tip: include both synonyms ("authentication login SSO") and exact tokens you remember in the same query \u2014 the fusion handles both.',
+      inputSchema: z8.object({
+        graphId: z8.string().describe("The graph ID"),
+        query: z8.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"])')
+      })
+    },
+    async ({ graphId, query, limit, nodeTypes }) => {
+      const params = new URLSearchParams();
+      params.set("q", query);
+      if (limit) params.set("limit", String(limit));
+      if (nodeTypes?.length) params.set("nodeTypes", nodeTypes.join(","));
+      const data = await client2.get(`/api/graphs/${graphId}/search/hybrid?${params.toString()}`);
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/filter.ts
+import { z as z9 } from "zod";
+function registerFilter(server2, client2) {
+  server2.registerTool(
+    "naumu_filter",
+    {
+      title: "Filter Graph Nodes",
+      annotations: { readOnlyHint: true },
+      description: 'Filter nodes by type and attributes with deterministic, complete results. Use this for structured queries like "all in-progress Tasks" or "Bugs not yet resolved." Unlike search tools, this returns every matching node (up to the limit) \u2014 no semantic ranking, no missed results. Results are sorted by sortKey or recency.',
+      inputSchema: z9.object({
+        graphId: z9.string().describe("The graph ID"),
+        nodeTypes: z9.array(z9.string()).optional().describe('Filter to specific node types (e.g. ["Task", "Bug"])'),
+        includeAttributes: z9.record(z9.array(z9.string())).optional().describe(
+          'Only include nodes where attribute matches one of the values. Example: {"Status": ["Todo", "In Progress"]}'
+        ),
+        excludeAttributes: z9.record(z9.array(z9.string())).optional().describe(
+          'Exclude nodes where attribute matches any of the values. Example: {"Status": ["Done", "Wont do"]}'
+        ),
+        sortBy: z9.enum(["sortKey", "updatedAt", "label"]).optional().default("sortKey").describe('Sort order: "sortKey" (default), "updatedAt" (most recent first), or "label" (alphabetical)'),
+        limit: z9.number().optional().default(50).describe("Max results to return (default 50, max 200)")
+      })
+    },
+    async ({ graphId, nodeTypes, includeAttributes, excludeAttributes, sortBy, limit }) => {
+      const params = new URLSearchParams();
+      if (nodeTypes?.length) params.set("nodeTypes", nodeTypes.join(","));
+      if (sortBy) params.set("sortBy", sortBy);
+      if (limit) params.set("limit", String(limit));
+      if (includeAttributes) {
+        const parts = Object.entries(includeAttributes).map(([k, v]) => `${k}:${v.join(",")}`);
+        params.set("includeAttributes", parts.join(";"));
+      }
+      if (excludeAttributes) {
+        const parts = Object.entries(excludeAttributes).map(([k, v]) => `${k}:${v.join(",")}`);
+        params.set("excludeAttributes", parts.join(";"));
+      }
+      const data = await client2.get(`/api/graphs/${graphId}/filter?${params.toString()}`);
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/get-node.ts
+import { z as z10 } from "zod";
+function registerGetNode(server2, client2) {
+  server2.registerTool(
+    "naumu_get_node",
+    {
+      title: "Get Node",
+      annotations: { readOnlyHint: true },
+      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")
+      })
+    },
+    async ({ graphId, nodeId }) => {
+      const data = await client2.get(`/api/graphs/${graphId}/nodes/${nodeId}`);
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../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 \u2014 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: { destructiveHint: true },
+      description: 'Create 1\u201325 nodes in the knowledge graph in a single call. Keep batches small and atomic (5\u201325 nodes) so failures stay contained. Each node MUST include a non-empty `content` describing what it is. Returns one entry per input node with `{id, label, type, status: "created"}` \u2014 there is NO server-side dedup, every input becomes a node. Dedup is the caller\'s responsibility: BEFORE calling this tool, run `naumu_semantic_search` on each candidate label and skip/route to update if a result has high similarity (\u22650.78) and matching type. Warning: nodes are isolated until you connect them with `naumu_add_edge`. **Prefer `naumu_ask`** for general knowledge intake \u2014 it discovers and creates connections for you. Use this when you have a vetted, dedup-checked batch ready to insert.',
+      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) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/update-node.ts
+import { z as z12 } from "zod";
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+function isValidIsoDate(s) {
+  if (typeof s !== "string") return false;
+  if (!ISO_DATE_REGEX.test(s)) return false;
+  const [yearStr, monthStr, dayStr] = s.split("-");
+  const year = Number(yearStr);
+  const month = Number(monthStr);
+  const day = Number(dayStr);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  if (Number.isNaN(date.getTime())) return false;
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function isValidDateRange(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  if (!isValidIsoDate(candidate.start)) return false;
+  if (candidate.end !== void 0) {
+    if (!isValidIsoDate(candidate.end)) return false;
+    if (candidate.end < candidate.start) return false;
+  }
+  return true;
+}
+function getAttributeMap(schema, nodeType) {
+  const map = /* @__PURE__ */ new Map();
+  const nodeDef = schema.nodes.find((n) => n.type === nodeType);
+  if (nodeDef?.attributes) {
+    for (const attr of nodeDef.attributes) {
+      map.set(attr.name.toLowerCase(), attr);
+    }
+  }
+  return map;
+}
+function validateDateAttribute(name, val) {
+  const rejectionMessage = `Date attribute "${name}" expects null, an ISO date string (YYYY-MM-DD), or { start, end? } with ISO dates.`;
+  if (val === null) return { ok: true, value: null };
+  if (typeof val === "string") {
+    if (isValidIsoDate(val)) return { ok: true, value: val };
+    return { ok: false, error: rejectionMessage };
+  }
+  if (typeof val === "object" && val !== null) {
+    if (isValidDateRange(val)) {
+      const range = val;
+      const normalized = range.end === void 0 || range.end === range.start ? { start: range.start } : { start: range.start, end: range.end };
+      return { ok: true, value: normalized };
+    }
+    return { ok: false, error: rejectionMessage };
+  }
+  return { ok: false, error: rejectionMessage };
+}
+function registerUpdateNode(server2, client2) {
+  server2.registerTool(
+    "naumu_update_node",
+    {
+      title: "Update Node",
+      annotations: { destructiveHint: true },
+      description: 'Update properties of an existing node. Only the provided fields will be changed. Good for simple attribute changes like setting a status, priority, or due date. For content or structural changes, consider `naumu_ask` instead \u2014 it understands the full graph context and can propagate updates to related nodes. Attribute keys AND values must match the schema for the node type. Use naumu_get_schema to check valid attribute names, types, and values before updating. Date attributes accept either null (to clear), an ISO date string "YYYY-MM-DD" (single day), or { start: "YYYY-MM-DD", end?: "YYYY-MM-DD" } (inclusive range). Example: { "due_date": { "start": "2026-05-21", "end": "2026-05-23" } } or { "due_date": "2026-05-21" } or { "due_date": null }. Select attributes accept the value label as a string.',
+      inputSchema: z12.object({
+        graphId: z12.string().describe("The graph ID"),
+        nodeId: z12.string().describe("The node ID to update"),
+        label: z12.string().optional().describe("New display name"),
+        type: z12.string().optional().describe("New node type"),
+        content: z12.string().optional().describe("New content / description"),
+        attributes: z12.record(z12.string(), z12.unknown()).optional().describe('Schema-defined attributes to set. Examples: {"Status": "In Progress"}, {"due_date": {"start": "2026-05-21", "end": "2026-05-23"}}, {"due_date": "2026-05-21"}, {"due_date": null}.')
+      })
+    },
+    async ({ graphId, nodeId, label, type, content, attributes }) => {
+      const body = {};
+      if (label !== void 0) body.label = label;
+      if (type !== void 0) body.type = type;
+      if (content !== void 0) body.content = content;
+      if (attributes && Object.keys(attributes).length > 0) {
+        const node = await client2.get(`/api/graphs/${graphId}/nodes/${nodeId}`);
+        const nodeType = type ?? node.type;
+        const schemaRes = await client2.get(`/api/graphs/${graphId}/schema`);
+        const schema = JSON.parse(schemaRes.definition);
+        const attrMap = getAttributeMap(schema, nodeType);
+        const errors = [];
+        for (const [key, val] of Object.entries(attributes)) {
+          const normalized = key.toLowerCase();
+          const schemaDef = attrMap.get(normalized);
+          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;
+            }
+            body[normalized] = result.value;
+            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;
+          }
+          body[normalized] = val;
+        }
+        if (errors.length > 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Attribute validation failed:
+${errors.join("\n")}
+
+Use naumu_get_schema to check valid attributes and values for this node type.`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      const data = await client2.patch(`/api/graphs/${graphId}/nodes/${nodeId}`, body);
+      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")
+});
+function registerAddEdge(server2, client2) {
+  server2.registerTool(
+    "naumu_add_edge",
+    {
+      title: "Add Edges (bulk)",
+      annotations: { destructiveHint: true },
+      description: "Create 1\u201325 relationships (edges) between existing nodes in a single call. Keep batches small and atomic (5\u201325 edges) so failures stay contained. Typical workflow after a bulk import: create nodes with `naumu_add_node`, then wire them up with batched `naumu_add_edge` calls. **Direction matters and must match the schema.** Each edge's `(source.type, label, target.type)` tuple should appear in the schema's `connections` or `parent` for the source type. When the backend runs with `STRICT_EDGE_VALIDATION=true`, invalid tuples are rejected immediately with `error: invalid_edge` (the response includes `details.allowed_targets_for_relation` and a `hint` for routing the call); otherwise the edge persists and surfaces later as an `invalid_connection_target` / `parent_mismatch` violation. Either way, check `naumu_get_schema` and flip / drop offending edges before calling. **Prefer `naumu_ask`** when you want the agent to discover the right connections itself.",
+      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.")
+      })
+    },
+    async ({ graphId, edges }) => {
+      const payload = edges.map((e) => ({
+        source: e.source,
+        target: e.target,
+        label: e.label,
+        isParent: e.isParent || false
+      }));
+      const data = await client2.post(`/api/graphs/${graphId}/edges`, { edges: payload });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/remove-node.ts
+import { z as z14 } from "zod";
+function registerRemoveNode(server2, client2) {
+  server2.registerTool(
+    "naumu_remove_node",
+    {
+      title: "Remove Node",
+      annotations: { destructiveHint: true },
+      description: "Low-level tool: delete a node and all its connections from the knowledge graph. This is a destructive operation. **Prefer `naumu_ask`** for removing knowledge \u2014 it understands the impact on the broader graph and can handle cascading changes. Use this only when you need precise, surgical deletion.",
+      inputSchema: z14.object({
+        graphId: z14.string().describe("The graph ID"),
+        nodeId: z14.string().describe("The node ID to delete")
+      })
+    },
+    async ({ graphId, nodeId }) => {
+      const data = await client2.del(`/api/graphs/${graphId}/nodes/${nodeId}`);
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/remove-edge.ts
+import { z as z15 } from "zod";
+function registerRemoveEdge(server2, client2) {
+  server2.registerTool(
+    "naumu_remove_edge",
+    {
+      title: "Remove Edge",
+      annotations: { destructiveHint: true },
+      description: "Delete a single edge identified by `(source, target, label)` tuple. Does NOT delete the endpoint nodes \u2014 only the edge between them. System edges (HAS_NODE, HAS_THREAD, OWNS, etc.) are rejected with `error: system_edge_not_removable`. Parent edges (`isParent: true`) are removable but the response includes a warning that the child may now be orphaned \u2014 call `naumu_reparent` first if you want connectivity preserved. Response: `{deleted: 0 | 1, warnings: string[]}`. Use for correcting wrong-target edge mistakes; this is a recovery tool, not a routine one. **Prefer `naumu_ask`** when the structural intent is broader than removing one specific edge \u2014 `naumu_ask` can reason about the surrounding graph.",
+      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.')
+      })
+    },
+    async ({ graphId, source, target, label }) => {
+      const data = await client2.del(`/api/graphs/${graphId}/edges`, {
+        source,
+        target,
+        label
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
     }
-    catch (err) {
+  );
+}
+
+// ../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")
+});
+function registerRemoveEdgesBulk(server2, client2) {
+  server2.registerTool(
+    "naumu_remove_edges_bulk",
+    {
+      title: "Remove Edges (bulk)",
+      annotations: { destructiveHint: true },
+      description: "Delete 1\u2013100 edges in a single atomic call \u2014 all-or-none, same semantics as `naumu_add_node`. Does NOT delete endpoint nodes. **System edges** (HAS_NODE, HAS_THREAD, OWNS, etc.) are rejected \u2014 if any edge in the batch targets a system relation, the WHOLE batch is rejected with `error: system_edge_not_removable`. **Parent edges** (`isParent: true`) are removable but each parent removal contributes a warning to the response (`{deleted, warnings: string[]}`) \u2014 call `naumu_reparent` first if you want connectivity preserved. Use to fix multiple wrong-target edge mistakes in one shot. **Prefer `naumu_ask`** for broader structural cleanup that needs graph-wide reasoning.",
+      inputSchema: z16.object({
+        graphId: z16.string().describe("The graph ID"),
+        edges: z16.array(EdgeRef).min(1).max(100).describe("1\u2013100 edges to delete. Atomic per call \u2014 all succeed or none do.")
+      })
+    },
+    async ({ graphId, edges }) => {
+      const data = await client2.del(`/api/graphs/${graphId}/edges/bulk`, { edges });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/ask.ts
+import { z as z17 } from "zod";
+function registerAsk(server2, client2) {
+  server2.registerTool(
+    "naumu_ask",
+    {
+      title: "Ask AI",
+      annotations: { destructiveHint: true },
+      description: 'Send a message to the Naumu AI agent. Use for adding knowledge, making changes, asking questions, or reporting status updates. Always returns immediately with a threadId \u2014 the AI processes the request in the background. Depending on complexity, the agent may take anywhere from a few seconds to a few minutes to finish.\n\n**For reports and status updates** (e.g. "mark task X as done", "record a deployment"): fire and forget \u2014 no need to check the response.\n\n**For questions that need an answer**: after calling this tool, poll with `naumu_get_ai_thread` using the returned threadId until the AI response is ready.',
+      inputSchema: z17.object({
+        graphId: z17.string().describe("The graph ID to query against"),
+        question: z17.string().describe("Your message to the Naumu AI agent"),
+        threadId: z17.string().optional().describe("Thread ID for follow-up messages (omit for new conversation)")
+      })
+    },
+    async ({ graphId, question, threadId }) => {
+      if (!threadId) {
+        const thread = await client2.post("/api/threads", { graphId });
+        threadId = thread.id;
+      }
+      await client2.post(`/api/threads/${threadId}/messages`, {
+        content: question,
+        async: true
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ threadId, status: "processing" }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/get-ai-thread.ts
+import { z as z18 } from "zod";
+function registerGetAiThread(server2, client2) {
+  server2.registerTool(
+    "naumu_get_ai_thread",
+    {
+      title: "Get AI Thread",
+      annotations: { readOnlyHint: true },
+      description: 'Retrieve messages from an AI conversation thread. Use to read the AI response after a `naumu_ask` call.\n\nThe last AI message has a `status` field: `"processing"` means the AI is still working, `"complete"` means the response is ready. If still processing, wait a few seconds and try again.',
+      inputSchema: z18.object({
+        threadId: z18.string().describe("The thread ID returned by naumu_ask")
+      })
+    },
+    async ({ threadId }) => {
+      const data = await client2.get(`/api/threads/${threadId}/messages`);
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/traverse.ts
+import { z as z19 } from "zod";
+function registerTraverse(server2, client2) {
+  server2.registerTool(
+    "naumu_traverse",
+    {
+      title: "Traverse Knowledge Graph",
+      annotations: { readOnlyHint: true },
+      description: 'Query the graph structurally using natural language. A sub-LLM generates and executes Cypher queries. Use for structural questions like "tasks without a parent", "features with most tasks", "orphan nodes", "everything within 2 hops of X", or temporal filters like "nodes updated this week". For meaning-based search, use `naumu_search` instead.',
+      inputSchema: z19.object({
+        graphId: z19.string().describe("The graph ID"),
+        query: z19.string().describe(
+          `Natural language description of the structural pattern to find (e.g. "tasks without a parent", "features that don't resolve any pain")`
+        )
+      })
+    },
+    async ({ graphId, query }) => {
+      const data = await client2.post(`/api/graphs/${graphId}/traverse`, { query });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/get-view.ts
+import { z as z20 } from "zod";
+function registerGetView(server2, client2) {
+  server2.registerTool(
+    "naumu_get_view",
+    {
+      title: "Get View",
+      annotations: { readOnlyHint: true },
+      description: "Fetch a saved Naumu view's configuration plus a one-line natural-language summary of its filters. Call this BEFORE naumu_list_view_nodes whenever you encounter a view URL \u2014 the summary tells you what data the view returns so you can decide whether to page through it. Returns: id, name, description, summary, filters, and table column config.",
+      inputSchema: z20.object({
+        graphId: z20.string().describe("The graph (space) ID. From naumu.ai URLs this is the value after /spaces/."),
+        viewId: z20.string().describe('The view ID (typically prefixed with "view_").')
+      })
+    },
+    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 z21 } from "zod";
+function registerListViewNodes(server2, client2) {
+  server2.registerTool(
+    "naumu_list_view_nodes",
+    {
+      title: "List View Nodes",
+      annotations: { readOnlyHint: true },
+      description: 'List nodes that match a saved view. Cursor-paginated. Pair with naumu_get_view first to read the view\'s filters and decide what payload size you need.\n\nResponse shape: { nodes, totalCount, nextCursor, hasMore }. Use totalCount to know how many results exist without paging through them. Use hasMore (boolean) to decide whether to fetch the next page; pass nextCursor back as `cursor` to do so.\n\nfields parameter:\n- "summary" (default): {id, label, type} \u2014 best for browsing.\n- "id": {id} only \u2014 use when you need to count or iterate cheaply.\n- "full": full node payload with all attributes \u2014 use when you need every property.\n\nDefault page size 25, max 100.',
+      inputSchema: z21.object({
+        graphId: z21.string().describe("The graph (space) ID."),
+        viewId: z21.string().describe("The view ID."),
+        cursor: z21.string().optional().describe("Opaque cursor from a previous response's nextCursor. Omit for the first page."),
+        limit: z21.number().int().min(1).max(100).optional().describe("Page size, default 25, max 100."),
+        fields: z21.enum(["id", "summary", "full"]).optional().describe('How much detail per node. Default "summary".')
+      })
+    },
+    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 z22 } from "zod";
+function registerListCanvases(server2, client2) {
+  server2.registerTool(
+    "naumu_list_canvases",
+    {
+      title: "List Canvases",
+      annotations: { readOnlyHint: true },
+      description: "List freeform drawing canvases in a graph. Each canvas is an Excalidraw-style sketch surface that may contain shapes, text, freehand strokes, images, bookmark cards, and embedded references to graph nodes.",
+      inputSchema: z22.object({
+        graphId: z22.string().describe("The graph ID to list canvases for")
+      })
+    },
+    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 z23 } from "zod";
+function registerGetCanvasElements(server2, client2) {
+  server2.registerTool(
+    "naumu_get_canvas_elements",
+    {
+      title: "Get Canvas Elements",
+      annotations: { readOnlyHint: true },
+      description: "Read the structured JSON contents of a canvas \u2014 every shape, text, line, freehand stroke, image, bookmark card, and entity-embed with their positions, colors, and text. Use this when you need to reason about what a user has drawn without needing to see the visual output.",
+      inputSchema: z23.object({
+        canvasId: z23.string().describe("The canvas ID")
+      })
+    },
+    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 z24 } from "zod";
+var MAX_INLINE_BYTES = 4 * 1024 * 1024;
+function registerGetCanvasImage(server2, client2) {
+  server2.registerTool(
+    "naumu_get_canvas_image",
+    {
+      title: "Get Canvas Image",
+      annotations: { readOnlyHint: true },
+      description: 'Render a canvas to a PNG image so you can visually inspect what was drawn \u2014 freehand strokes, spatial layout, sketches. Returns the image inline by default so any MCP host can see it directly. Use `mode: "url"` if you specifically need a signed URL (e.g. very large canvases, or to share the link).',
+      inputSchema: z24.object({
+        canvasId: z24.string().describe("The canvas ID"),
+        scale: z24.union([z24.literal(1), z24.literal(2)]).default(2).describe("Pixel density (1 or 2). Default is 2 for retina-quality output."),
+        theme: z24.enum(["light", "dark"]).default("light").describe("Background theme to render with."),
+        mode: z24.enum(["inline", "url"]).default("inline").describe(
+          "`inline` (default) embeds the PNG directly so vision-capable hosts see it. `url` returns a signed S3 URL that expires in 1 hour \u2014 useful for large canvases or sharing."
+        )
+      })
+    },
+    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 z25 } from "zod";
+function registerPostMessage(server2, client2) {
+  server2.registerTool(
+    "naumu_post_message",
+    {
+      title: "Post Message",
+      annotations: { destructiveHint: true },
+      description: 'Post a message in a Naumu thread you are participating in. Use this to reply to humans (or other bots) in a thread that pinged you. Plain text is accepted by default; for rendered @mentions, pass a Tiptap JSON document with mention nodes (`{ type: "mention", attrs: { id, label } }`) and set contentFormat to "tiptap". To attach files (reports, images, audio, video) call `naumu_request_attachment_upload` first for each file, PUT the bytes to the returned `uploadUrl`, then pass the resulting `attachmentId`s here as `attachmentIds`. The message must have either `content` or `attachmentIds` (or both). Returns the created message JSON.',
+      inputSchema: z25.object({
+        threadId: z25.string().describe("The thread ID to post into. You must be a participant in this thread."),
+        content: z25.string().optional().describe('Message body. Plain text by default; pass a Tiptap JSON document only if contentFormat is set to "tiptap". Optional when `attachmentIds` is provided.'),
+        contentFormat: z25.enum(["tiptap", "text"]).optional().describe('Format of `content`. Defaults to "text". Use "tiptap" for rendered mentions/embeds, e.g. a doc containing `{ type: "mention", attrs: { id: userIdOrIdentityId, label: displayName } }`.'),
+        attachmentIds: z25.array(z25.string().min(1)).max(25).optional().describe("Attachment IDs from prior `naumu_request_attachment_upload` calls. Each must be a successfully-uploaded pending attachment in this graph (1-hour TTL). Up to 25 per message.")
+      })
+    },
+    async ({ threadId, content, contentFormat, attachmentIds }) => {
+      try {
+        const body = {
+          contentFormat: contentFormat ?? "text"
+        };
+        if (content !== void 0) body.content = content;
+        if (attachmentIds && attachmentIds.length > 0) body.attachmentIds = attachmentIds;
+        const data = await client2.post(`/api/threads/${threadId}/messages`, body);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/read-thread.ts
+import { z as z26 } from "zod";
+function registerReadThread(server2, client2) {
+  server2.registerTool(
+    "naumu_read_thread",
+    {
+      title: "Read Thread",
+      annotations: { readOnlyHint: true },
+      description: "Read messages from a Naumu thread. Returns paginated history ordered newest-first. Use `before` (timestamp ms) to page back further into older history. Default page size 50, max 200.",
+      inputSchema: z26.object({
+        threadId: z26.string().describe("The thread ID to read from."),
+        before: z26.number().optional().describe("Unix timestamp in milliseconds. Returns messages strictly older than this. Omit for the newest page."),
+        limit: z26.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
+      })
+    },
+    async ({ threadId, before, limit }) => {
+      try {
+        const params = new URLSearchParams();
+        if (before !== void 0) params.set("before", String(before));
+        if (limit !== void 0) params.set("limit", String(limit));
+        const qs = params.toString();
+        const path = `/api/threads/${threadId}/messages${qs ? `?${qs}` : ""}`;
+        const data = await client2.get(path);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/ask-naumu.ts
+import { z as z27 } from "zod";
+function registerAskNaumu(server2, client2) {
+  server2.registerTool(
+    "naumu_ask_naumu",
+    {
+      title: "Ask Naumu",
+      // NOT read-only: the backend creates a durable sidechannel thread +
+      // message, may seed a system Identity, and spawns a SpaceAgent task
+      // (and consumes a 5/hour budget). Additive, not destructive.
+      annotations: { destructiveHint: false },
+      description: "Ask the system @Naumu Identity (the canonical graph-writer/curator) a question about your graph. Use for questions where direct graph reads would be inefficient \u2014 Naumu has full read access and synthesizes answers. Limited to 5 calls per hour per Identity. Returns { answer, sources, confidence, durationMs }.",
+      inputSchema: z27.object({
+        graphId: z27.string().describe("The graph ID to ask about."),
+        question: z27.string().max(4e3).describe("The question to ask Naumu. Max 4000 characters.")
+      })
+    },
+    async ({ graphId, question }) => {
+      try {
+        const identityId = process.env.NAUMU_IDENTITY_ID;
+        if (!identityId) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: NAUMU_IDENTITY_ID env var is required for ask_naumu \u2014 re-run the pairing setup."
+              }
+            ],
+            isError: true
+          };
+        }
+        const data = await client2.post(`/api/identities/${identityId}/ask`, {
+          graphId,
+          question
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.error(`[mcp] failed to fetch tool manifest: ${message}`);
-        process.exit(1);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
     }
+  );
 }
-else {
-    registerAllTools(server, client);
-    console.error(`[mcp] connected to ${apiUrl} as user key (${process.env.NAUMU_IDENTITY_ID ?? 'no identity id set'})`);
+
+// ../mcp-core/src/tools/whoami.ts
+import { z as z28 } from "zod";
+function registerWhoami(server2, client2, allToolNames) {
+  server2.registerTool(
+    "naumu_whoami",
+    {
+      title: "Who Am I",
+      annotations: { readOnlyHint: true },
+      description: 'Return who the calling key is plus the live MCP tool manifest, so you can bootstrap before the first real operation. A bot identity key returns its Identity row (id, graphId, name, instructions, allowedTools). A user API key returns `kind: "user"` with userId, name, and email \u2014 a person spans many graphs, so resolve a specific graph via naumu_list_graphs. No arguments. Always available regardless of the permission grid.',
+      inputSchema: z28.object({})
+    },
+    async () => {
+      try {
+        const data = await client2.get("/api/identities/me/whoami");
+        if (allToolNames && data && typeof data === "object" && data.kind === "user") {
+          data.mcpTools = allToolNames;
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/list-threads.ts
+import { z as z29 } from "zod";
+function registerListThreads(server2, client2) {
+  server2.registerTool(
+    "naumu_list_threads",
+    {
+      title: "List Threads",
+      annotations: { readOnlyHint: true },
+      description: "List threads sorted by last activity (newest first), for self-discovery before deciding which to engage. With a user API key, pass `graphId` to list threads you can see in that space (resolve it via naumu_list_graphs). With a bot identity key, omit `graphId` to list threads in your own graph \u2014 each row carries an `isParticipant` flag (TRUE means you were explicitly invited and your replies fan out via webhook). Page back with `cursor` set to the oldest `lastActivityAt` from the previous page.",
+      inputSchema: z29.object({
+        graphId: z29.string().optional().describe("Graph (space) ID. Required for user API keys; omit for bot identity keys (defaults to your own graph)."),
+        cursor: z29.number().int().optional().describe("Unix timestamp ms \u2014 returns threads with `lastActivityAt` strictly older than this. Omit for the newest page."),
+        limit: z29.number().int().min(1).max(200).optional().describe("Page size, default 50, max 200.")
+      })
+    },
+    async ({ graphId, cursor, limit }) => {
+      try {
+        const params = new URLSearchParams();
+        if (cursor !== void 0) params.set("cursor", String(cursor));
+        if (limit !== void 0) params.set("limit", String(limit));
+        let path;
+        if (graphId) {
+          params.set("graphId", graphId);
+          path = `/api/threads/paginated?${params.toString()}`;
+        } else {
+          const qs = params.toString();
+          path = `/api/identities/me/threads${qs ? `?${qs}` : ""}`;
+        }
+        const data = await client2.get(path);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/get-thread.ts
+import { z as z30 } from "zod";
+function registerGetThread(server2, client2) {
+  server2.registerTool(
+    "naumu_get_thread",
+    {
+      title: "Get Thread",
+      annotations: { readOnlyHint: true },
+      description: "Fetch a single thread, including the human participant roster (`participantDetails` \u2014 userId, name, image) and bot roster (`identityParticipants` \u2014 id, name, isSystem). Use this when `naumu_list_threads` surfaced a candidate and you want to know exactly who is in it before posting. Pair with `naumu_read_thread` for message history.",
+      inputSchema: z30.object({
+        threadId: z30.string().describe("The thread ID to fetch.")
+      })
+    },
+    async ({ threadId }) => {
+      try {
+        const data = await client2.get(`/api/threads/${threadId}`);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/create-thread.ts
+import { z as z31 } from "zod";
+function registerCreateThread(server2, client2) {
+  server2.registerTool(
+    "naumu_create_thread",
+    {
+      title: "Create Thread",
+      annotations: { destructiveHint: true },
+      description: 'Start a new conversation in your graph. You are auto-attached as a permanent participant; the thread\'s formal creator is your primary owner (the user who registered you), so the thread shows up in their sidebar. Optional `participants` adds humans (by userId) and other bots (by identityId) at creation time. Optional `initialMessage` is posted as your first message \u2014 use it to open the conversation. Returns the created thread (including its id) so you can immediately call `naumu_post_message` for follow-ups. Useful for scheduled briefings ("Brief me about X every morning at 9am" \u2014 schedule on your side, then call this to deliver into Naumu).',
+      inputSchema: z31.object({
+        title: z31.string().min(1).max(200).optional().describe('Thread title shown in the sidebar. If omitted, Naumu generates a default like "Conversation YYYY-MM-DD".'),
+        participants: z31.array(
+          z31.discriminatedUnion("type", [
+            z31.object({
+              type: z31.literal("user"),
+              userId: z31.string().min(1).describe("User UUID \u2014 get these from `naumu_get_thread`/`naumu_read_thread` participant rosters or webhook payloads.")
+            }),
+            z31.object({
+              type: z31.literal("identity"),
+              identityId: z31.string().min(1).describe("Identity id (`identity-\u2026` or `id-\u2026`). Other bots in the same graph can be co-attached to multi-bot threads.")
+            })
+          ])
+        ).max(32).optional().describe("Up to 32 humans and/or other bots to attach at creation. Your primary owner is added automatically \u2014 you do NOT need to list them here."),
+        initialMessage: z31.string().min(1).max(32e3).optional().describe("Markdown body for the first message. Authored by you (the bot), so it appears in the thread under your name."),
+        visibility: z31.enum(["restricted", "internal", "open"]).optional().describe("`restricted` (invite-only, default) hides from non-participants. `internal` is visible to space members. `open` is visible to anyone who can see the space.")
+      })
+    },
+    async ({ title, participants, initialMessage, visibility }) => {
+      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;
+        const data = await client2.post("/api/identities/me/threads", body);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/request-attachment-upload.ts
+import { z as z32 } from "zod";
+function registerRequestAttachmentUpload(server2, client2) {
+  server2.registerTool(
+    "naumu_request_attachment_upload",
+    {
+      title: "Request Attachment Upload",
+      annotations: { destructiveHint: true },
+      description: 'Request a presigned S3 upload URL to attach a file to a message. Same flow Naumu users use for file uploads: get a signed URL, PUT the bytes to it directly, then call `naumu_post_message` with the returned `attachmentId` in `attachmentIds`. Use this when you want to deliver generated content as a file (a markdown report, a PDF, an image, an audio recording, a video). Per-MIME size caps apply (typically 50MB umbrella, 10MB for agent-readable types).\n\nReturns `{ attachmentId, uploadUrl, method, requiredHeaders, expiresAt }`. Use these EXACTLY:\n\u2022 `method` is "PUT".\n\u2022 Send every header in `requiredHeaders` (Content-Type matters for S3 signature validation).\n\u2022 Do NOT add an Authorization header \u2014 the URL itself is the auth.\n\u2022 Do NOT log `uploadUrl` \u2014 it is a bearer capability for the duration of the TTL.\n\u2022 `expiresAt` is a Unix-ms timestamp; the pending attachment vanishes at that moment whether or not you uploaded. Call `naumu_post_message` with the attachmentId before then or the upload orphans.\n\nServer-side checks at post time enforce that the attachment was uploaded by you, in this graph, for this thread \u2014 you cannot reuse an upload across threads.',
+      inputSchema: z32.object({
+        threadId: z32.string().describe("Thread the attachment will land in. You must be a participant. The pending attachment is keyed to this thread \u2014 you cannot reuse it for a different one."),
+        fileName: z32.string().min(1).describe("Original filename (with extension). Used as the display name in the message and for the S3 object suffix. Special characters are sanitized server-side."),
+        fileType: z32.string().min(1).describe("MIME type, e.g. `application/pdf`, `image/png`, `text/markdown`, `audio/mpeg`, `video/mp4`. The S3 PUT will enforce this Content-Type."),
+        fileSize: z32.number().int().positive().describe("File size in bytes. Validated against per-MIME caps before the URL is issued \u2014 exceeding the cap returns a 400."),
+        audioDurationSec: z32.number().positive().optional().describe("For audio attachments, duration in seconds. Validated against the audio recording cap (currently 8 hours).")
+      })
+    },
+    async ({ threadId, fileName, fileType, fileSize, audioDurationSec }) => {
+      try {
+        const me = await client2.get("/api/identities/me/whoami");
+        const body = {
+          graphId: me.graphId,
+          threadId,
+          fileName,
+          fileType,
+          fileSize
+        };
+        if (audioDurationSec !== void 0) body.audioDurationSec = audioDurationSec;
+        const data = await client2.post("/api/attachments/presign", body);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/add-reaction.ts
+import { z as z33 } from "zod";
+function registerAddReaction(server2, client2) {
+  server2.registerTool(
+    "naumu_add_reaction",
+    {
+      title: "Add Reaction",
+      annotations: { destructiveHint: true },
+      description: 'Add an emoji reaction to a message in a thread you are participating in. Idempotent \u2014 calling twice with the same emoji is a no-op (use `naumu_remove_reaction` to undo). Returns `{ ok, messageId, emoji, alreadyExisted, reactionCount, reactions }` so you can confirm the state without re-reading the thread; `alreadyExisted: true` means the reaction was already on the message and the call was a no-op.\n\nWhen to react vs. when to post a message:\n\u2022 React (no message) for lightweight acknowledgement (\u{1F440}, \u2705, \u{1F44D}), appreciation (\u2764\uFE0F, \u{1F64C}), laughter (\u{1F602}), or "I saw this".\n\u2022 Post a message for direct questions, clarification, important corrections, or final results \u2014 situations where words are required.\n\u2022 For long tasks: react \u{1F440} first to acknowledge, optionally post a short "On it \u2014 I\'ll report back" if the work will take >20s, do the work, then post the final result.\n\u2022 Ignore casual human banter, side-conversations someone else already answered, or anything where you would only say "ok"/"nice"/"lol".\n\nUse at most one reaction per message unless explicitly useful. Reactions are social backpressure relief, not a sparkle-confetti channel.',
+      inputSchema: z33.object({
+        threadId: z33.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z33.string().describe("The message to react to."),
+        emoji: z33.string().min(1).describe('Emoji character (e.g. "\u{1F440}", "\u2705", "\u2764\uFE0F"). Custom-emoji shortcodes are NOT supported here \u2014 pass a real Unicode emoji.')
+      })
+    },
+    async ({ threadId, messageId, emoji }) => {
+      try {
+        const data = await client2.post(
+          `/api/threads/${threadId}/messages/${messageId}/reactions`,
+          { emoji, action: "add" }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/remove-reaction.ts
+import { z as z34 } from "zod";
+function registerRemoveReaction(server2, client2) {
+  server2.registerTool(
+    "naumu_remove_reaction",
+    {
+      title: "Remove Reaction",
+      annotations: { destructiveHint: true },
+      description: "Remove your own emoji reaction from a message. Idempotent \u2014 calling on a reaction you never added is a no-op. Pair with `naumu_add_reaction` when you need to walk back an acknowledgement (e.g. you reacted \u{1F440} to start a task and want to clear it after a final result message lands). Returns `{ ok, messageId, emoji, alreadyExisted, reactionCount, reactions }` \u2014 `alreadyExisted: false` means there was nothing to remove and the call was a no-op.",
+      inputSchema: z34.object({
+        threadId: z34.string().describe("Thread containing the message. You must be a participant."),
+        messageId: z34.string().describe("The message to remove your reaction from."),
+        emoji: z34.string().min(1).describe("Emoji character to remove (must match what you originally reacted with).")
+      })
+    },
+    async ({ threadId, messageId, emoji }) => {
+      try {
+        const data = await client2.post(
+          `/api/threads/${threadId}/messages/${messageId}/reactions`,
+          { emoji, action: "remove" }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/naumu-typing.ts
+import { z as z35 } from "zod";
+function registerNaumuTyping(server2, client2) {
+  server2.registerTool(
+    "naumu_typing",
+    {
+      title: "Set Typing Indicator",
+      // Purely ephemeral: drives an in-memory WS typing lease (no durable
+      // state, self-expires, trivially reversible via "stop"). Not destructive.
+      annotations: { destructiveHint: false },
+      description: 'Show or hide your "is typing\u2026" pill in a thread. Call with `state: "start"` the moment you decide to compose a reply (before any LLM call), and the server holds the pill alive \u2014 re-broadcasting on a short interval \u2014 until you stop, post a message, or the lease cap (~5 min) fires. You do NOT need to refresh on a timer; that\'s the lease\'s job.\n\nThe pill clears automatically when:\n\u2022 you call this tool with `state: "stop"`\n\u2022 you call `naumu_post_message` for the same thread (cleared on commit)\n\u2022 the lease cap expires\n\nUse `start` whenever you start work, even if you might end up not replying \u2014 call `stop` if you decide NOT to post. Calling `start` while a lease is already active renews it (resets the cap), so a long-running run can call `start` again as a heartbeat without breaking the indicator. You must be a participant of the thread.',
+      inputSchema: z35.object({
+        threadId: z35.string().describe("The thread ID to set typing in. You must be a participant."),
+        state: z35.enum(["start", "stop"]).describe('"start" acquires/renews the lease; "stop" ends it and clears the pill immediately.')
+      })
+    },
+    async ({ threadId, state }) => {
+      try {
+        const data = await client2.post(`/api/threads/${threadId}/typing`, { state });
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/note-read.ts
+import { z as z36 } from "zod";
+function registerNoteRead(server2, client2) {
+  server2.registerTool(
+    "naumu_note_read",
+    {
+      title: "Read Note",
+      annotations: { readOnlyHint: true },
+      description: "Read the current contents of a note as markdown. Use before editing so you know what you're working with \u2014 `naumu_note_find_replace` and the section-based tools (`naumu_note_insert`, `naumu_note_replace_section`, `naumu_note_delete_section`) anchor on text/headings present in the live doc.",
+      inputSchema: z36.object({
+        noteId: z36.string().describe("The note (Thought) ID")
+      })
+    },
+    async ({ noteId }) => {
+      const data = await client2.get(`/api/notes/${noteId}/markdown`);
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/note-append.ts
+import { z as z37 } from "zod";
+function registerNoteAppend(server2, client2) {
+  server2.registerTool(
+    "naumu_note_append",
+    {
+      title: "Append to Note",
+      annotations: { destructiveHint: true },
+      description: "Append markdown blocks to the end of a note. Other participants see your colored cursor while the write lands. Markdown supports headings (1\u20133), bold/italic/code, lists, blockquotes, code blocks, links, and tables.",
+      inputSchema: z37.object({
+        noteId: z37.string().describe("The note (Thought) ID to append to"),
+        markdown: z37.string().min(1).describe("Markdown content to append at the end of the note")
+      })
+    },
+    async ({ noteId, markdown }) => {
+      const data = await client2.post(`/api/notes/${noteId}/append`, { markdown });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/note-insert.ts
+import { z as z38 } from "zod";
+function registerNoteInsert(server2, client2) {
+  server2.registerTool(
+    "naumu_note_insert",
+    {
+      title: "Insert After Heading",
+      annotations: { destructiveHint: true },
+      description: "Insert markdown content into a note immediately after a named section. The section ends at the next heading of equal-or-higher level (or end of doc). 404 if no heading matches `headingText` exactly \u2014 call `naumu_note_read` first to see the live structure.",
+      inputSchema: z38.object({
+        noteId: z38.string().describe("The note (Thought) ID"),
+        headingText: z38.string().min(1).describe("Exact text of the heading whose section the new content follows"),
+        markdown: z38.string().min(1).describe("Markdown content to insert at the end of that section")
+      })
+    },
+    async ({ noteId, headingText, markdown }) => {
+      const data = await client2.post(`/api/notes/${noteId}/insert-after`, {
+        headingText,
+        markdown
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/note-replace-section.ts
+import { z as z39 } from "zod";
+function registerNoteReplaceSection(server2, client2) {
+  server2.registerTool(
+    "naumu_note_replace_section",
+    {
+      title: "Replace Section",
+      annotations: { destructiveHint: true },
+      description: "Replace the body under a named heading with new markdown. By default the heading row itself is preserved (set `keepHeading: false` to drop it too). 404 if no heading matches.",
+      inputSchema: z39.object({
+        noteId: z39.string().describe("The note (Thought) ID"),
+        headingText: z39.string().min(1).describe("Exact text of the heading anchoring the section"),
+        markdown: z39.string().describe("Replacement markdown for the section body"),
+        keepHeading: z39.boolean().optional().describe("Whether to keep the heading row itself. Default true.")
+      })
+    },
+    async ({ noteId, headingText, markdown, keepHeading }) => {
+      const data = await client2.post(`/api/notes/${noteId}/replace-section`, {
+        headingText,
+        markdown,
+        keepHeading
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/note-delete-section.ts
+import { z as z40 } from "zod";
+function registerNoteDeleteSection(server2, client2) {
+  server2.registerTool(
+    "naumu_note_delete_section",
+    {
+      title: "Delete Section",
+      annotations: { destructiveHint: true },
+      description: "\u26A0 DESTRUCTIVE: removes a heading row plus its body (down to the next heading of equal-or-higher level). Anything inside that section is gone \u2014 there is no per-call undo. ONLY use when the user explicitly asks to drop a section. If you're unsure which heading they meant, call `naumu_note_read` first to see the current structure. Returns 404 if `headingText` does not exactly match any live heading.",
+      inputSchema: z40.object({
+        noteId: z40.string().describe("The note (Thought) ID"),
+        headingText: z40.string().min(1).describe("Exact text of the heading whose section will be deleted")
+      })
+    },
+    async ({ noteId, headingText }) => {
+      const data = await client2.post(`/api/notes/${noteId}/delete-section`, {
+        headingText
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/note-replace.ts
+import { z as z41 } from "zod";
+function registerNoteReplace(server2, client2) {
+  server2.registerTool(
+    "naumu_note_replace",
+    {
+      title: "Replace Note",
+      annotations: { destructiveHint: true },
+      description: "\u26A0 DESTRUCTIVE: replaces the entire note content with new markdown. Any concurrent human edits made during the call are silently overwritten. ONLY use when the user explicitly asks to rewrite/replace the whole note. For additive work prefer `naumu_note_append`. For section-level edits use `naumu_note_replace_section`. For inline tweaks use `naumu_note_find_replace`. Read with `naumu_note_read` first if you weren't the last writer.",
+      inputSchema: z41.object({
+        noteId: z41.string().describe("The note (Thought) ID"),
+        markdown: z41.string().describe("New markdown content for the entire note")
+      })
+    },
+    async ({ noteId, markdown }) => {
+      const data = await client2.post(`/api/notes/${noteId}/replace`, { markdown });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/note-find-replace.ts
+import { z as z42 } from "zod";
+function registerNoteFindReplace(server2, client2) {
+  server2.registerTool(
+    "naumu_note_find_replace",
+    {
+      title: "Find/Replace in Note",
+      annotations: { destructiveHint: true },
+      description: "Literal find/replace within a note's text content. Marks (bold, italic, code, etc.) are preserved on the surrounding text. Use this for mid-paragraph tweaks \u2014 the section-based tools can't target inline substrings. \u26A0 The match is literal-substring across every text leaf in the doc; an overly generic `find` (e.g. \" a \") can rewrite the doc unrecognizably. Pick a phrase distinctive enough to land where you mean. By default replaces every occurrence; set `all: false` for first-only. Returns `{ replacements }` so you can sanity-check the count.",
+      inputSchema: z42.object({
+        noteId: z42.string().describe("The note (Thought) ID"),
+        find: z42.string().min(1).describe("Substring to search for. Literal \u2014 no regex."),
+        replace: z42.string().describe("Replacement string. May be empty to delete the match."),
+        all: z42.boolean().optional().describe("Replace all occurrences (default true). Pass false to replace only the first.")
+      })
+    },
+    async ({ noteId, find, replace, all }) => {
+      const data = await client2.post(`/api/notes/${noteId}/find-replace`, {
+        find,
+        replace,
+        all
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/canvas-add-element.ts
+import { z as z43 } 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: { destructiveHint: true },
+      description: "Add a new element to a canvas. Other participants see your colored cursor at the element's center while it lands. The server fills in `id`, `version`, `fractionalIndex`, and `seed` automatically \u2014 pass only `type`, position (`x`, `y`), and size (`width`, `height`); other fields are optional and have sensible defaults (stroke #1e1e1e, no fill, opacity 1, etc.). For text elements, set `label` and `fontSize`. Coordinates are canvas-space (the same units the live editor uses).",
+      inputSchema: z43.object({
+        canvasId: z43.string().describe("The canvas ID"),
+        element: z43.object({
+          type: z43.enum(ELEMENT_TYPES).describe("Element shape"),
+          x: z43.number().describe("Top-left x coordinate in canvas space"),
+          y: z43.number().describe("Top-left y coordinate in canvas space"),
+          width: z43.number().describe("Width in canvas units"),
+          height: z43.number().describe("Height in canvas units"),
+          strokeColor: z43.string().optional().describe("Stroke color (hex). Default #1e1e1e."),
+          fillColor: z43.string().optional().describe('Fill color (hex) or "transparent". Default transparent.'),
+          strokeWidth: z43.number().optional().describe("Stroke width. Default 2."),
+          opacity: z43.number().min(0).max(1).optional().describe("0..1, default 1"),
+          roughness: z43.number().min(0).max(2).optional().describe("Hand-drawn roughness 0..2. Default 1."),
+          label: z43.string().optional().describe("Optional label/text content"),
+          labelFontSize: z43.number().optional().describe("Label font size"),
+          angle: z43.number().optional().describe("Rotation in radians. Default 0.")
+        }).passthrough().describe("Element fields. Pass only what you set \u2014 defaults fill the rest.")
+      })
+    },
+    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 z44 } from "zod";
+function registerCanvasUpdateElement(server2, client2) {
+  server2.registerTool(
+    "naumu_canvas_update_element",
+    {
+      title: "Update Canvas Element",
+      annotations: { destructiveHint: true },
+      description: "Patch an existing canvas element. Only the fields you pass in `changes` are updated \u2014 `id`, `version`, `createdBy`, and `isDeleted` are server-managed and ignored if present. Useful for moving (`x`, `y`), resizing (`width`, `height`), recoloring (`strokeColor`, `fillColor`), or relabeling (`label`).",
+      inputSchema: z44.object({
+        canvasId: z44.string().describe("The canvas ID"),
+        elementId: z44.string().describe("The element ID returned by `naumu_canvas_add_element` or `naumu_get_canvas_elements`"),
+        changes: z44.record(z44.string(), z44.unknown()).describe("Partial element fields to merge in. Server bumps `version` automatically.")
+      })
+    },
+    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 z45 } from "zod";
+function registerCanvasRemoveElement(server2, client2) {
+  server2.registerTool(
+    "naumu_canvas_remove_element",
+    {
+      title: "Remove Canvas Element",
+      annotations: { destructiveHint: true },
+      description: "Soft-delete a canvas element. The element is tombstoned (isDeleted=true) so concurrent edits don't resurrect it. 404 if the element id is not present on this canvas.",
+      inputSchema: z45.object({
+        canvasId: z45.string().describe("The canvas ID"),
+        elementId: z45.string().describe("The element ID to delete")
+      })
+    },
+    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 z46 } from "zod";
+function registerCreateNote(server2, client2) {
+  server2.registerTool(
+    "naumu_create_note",
+    {
+      title: "Create Note",
+      annotations: { destructiveHint: true },
+      description: "Create a new empty note in a graph. Returns the new note row including its `id` \u2014 pass that id to `naumu_note_append` / `naumu_note_replace` to fill in the content. Bots can only create notes in their own graph.",
+      inputSchema: z46.object({
+        graphId: z46.string().describe("The graph ID to create the note in"),
+        title: z46.string().optional().describe("Optional title for the note")
+      })
+    },
+    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 z47 } from "zod";
+function registerCreateCanvas(server2, client2) {
+  server2.registerTool(
+    "naumu_create_canvas",
+    {
+      title: "Create Canvas",
+      annotations: { destructiveHint: true },
+      description: "Create a new empty canvas in a graph. Returns the new canvas row including its `id` \u2014 pass that id to `naumu_canvas_add_element` to start drawing. Bots can only create canvases in their own graph.",
+      inputSchema: z47.object({
+        graphId: z47.string().describe("The graph ID to create the canvas in"),
+        title: z47.string().optional().describe("Optional title for the canvas")
+      })
+    },
+    async ({ graphId, title }) => {
+      const data = await client2.post("/api/canvases", { graphId, title });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/list-schema-violations.ts
+import { z as z48 } from "zod";
+function registerListSchemaViolations(server2, client2) {
+  server2.registerTool(
+    "naumu_list_schema_violations",
+    {
+      title: "List Schema Violations",
+      annotations: { readOnlyHint: true },
+      description: "List every schema-validation issue in a graph. Returns each node with issues and a summary by violation kind: parent_missing (schema expects a parent edge that does not exist), parent_multiple (more than one parent edge on a node that should have one), parent_mismatch (parent edge has wrong target type or relation label), unknown_relation (edge uses a relation label not defined in the schema), invalid_connection_target (edge connects to a type the schema does not allow for this source). Use for audits, import-verification, and CI-style checks after batch writes.",
+      inputSchema: z48.object({
+        graphId: z48.string().describe("The graph ID")
+      })
+    },
+    async ({ graphId }) => {
+      const data = await client2.get(
+        `/api/graphs/${graphId}/schema/validation`
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/list-dense-nodes.ts
+import { z as z49 } from "zod";
+function registerListDenseNodes(server2, client2) {
+  server2.registerTool(
+    "naumu_list_dense_nodes",
+    {
+      title: "List Dense Nodes",
+      annotations: { readOnlyHint: true },
+      description: 'Return nodes whose total edge count (in+out, non-system) is \u2265 minConnections, grouped by type. Built for /restructure hub detection: each row includes `same_typed_child_count` \u2014 the number of children of the SAME type as the node (the Naumu hub-pattern signal). Sort the response by `same_typed_child_count` descending and route any node with \u226510 same-typed children through a mini-hub split. Pass `nodeTypes` (comma-separated) to restrict to a subset (e.g. ["Feature","Company"]). Cheap to call \u2014 runs a single Cypher aggregation.',
+      inputSchema: z49.object({
+        graphId: z49.string().describe("The graph ID"),
+        minConnections: z49.number().int().min(1).describe("Minimum total edge count (in + out, excluding system relations). Typical: 10 for hub detection, 11 to count only hubs that exceed the round-4 \u226410 threshold."),
+        nodeTypes: z49.array(z49.string()).optional().describe("Optional list of node types to restrict the scan to.")
+      })
+    },
+    async ({ graphId, minConnections, nodeTypes }) => {
+      const params = new URLSearchParams();
+      params.set("minConnections", String(minConnections));
+      if (nodeTypes?.length) params.set("nodeTypes", nodeTypes.join(","));
+      const data = await client2.get(
+        `/api/graphs/${graphId}/dense-nodes?${params.toString()}`
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/list-node-connections.ts
+import { z as z50 } from "zod";
+function registerListNodeConnections(server2, client2) {
+  server2.registerTool(
+    "naumu_list_node_connections",
+    {
+      title: "List Node Connections",
+      annotations: { readOnlyHint: true },
+      description: 'Return a single node\'s edges (non-system) with the connected node on the other side. Used during /restructure to confirm mini-hub candidates and verify reparenting outcomes. Filter with `edgeType` (relation label) and `direction` ("in" | "out" | "both", default both). Response: `{ node: {id,label,type}, edges: [{relation, direction, isParent, other: {id,label,type}}] }`.',
+      inputSchema: z50.object({
+        graphId: z50.string().describe("The graph ID"),
+        nodeId: z50.string().describe("The node ID to inspect"),
+        edgeType: z50.string().optional().describe('Restrict to a specific relation label (e.g. "ASSOCIATED_WITH"). Case-insensitive; non-alphanum chars are normalized.'),
+        direction: z50.enum(["in", "out", "both"]).optional().describe('Edge direction filter \u2014 "in" (incoming), "out" (outgoing), "both" (default).')
+      })
+    },
+    async ({ graphId, nodeId, edgeType, direction }) => {
+      const params = new URLSearchParams();
+      if (edgeType) params.set("edgeType", edgeType);
+      if (direction) params.set("direction", direction);
+      const qs = params.toString();
+      const path = `/api/graphs/${graphId}/nodes/${nodeId}/connections${qs ? `?${qs}` : ""}`;
+      const data = await client2.get(path);
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/reparent.ts
+import { z as z51 } from "zod";
+function registerReparent(server2, client2) {
+  server2.registerTool(
+    "naumu_reparent",
+    {
+      title: "Reparent Node",
+      annotations: { destructiveHint: true },
+      description: 'Atomically swap a node\'s parent edge. Deletes any existing `isParent: true` edges on the node and creates a new one to `newParentId` with relation `newRelation`. **Preserves the node\'s id, content, attributes, and embedding** \u2014 does NOT trigger embedding regeneration because only the parent edge changes. Idempotent: if the node already has the requested parent edge, response is `status: "skipped"`. Response shape: `{nodeId, oldParentId, newParentId, newRelation, status: "moved" | "skipped"}`. Use during /restructure to reparent children under newly-created mini-hubs.',
+      inputSchema: z51.object({
+        graphId: z51.string().describe("The graph ID"),
+        nodeId: z51.string().describe("The child node to reparent"),
+        newParentId: z51.string().describe("The new parent node id"),
+        newRelation: z51.string().describe('The new parent edge relation label (e.g. "PART_OF"). Must be valid per the schema for (child.type, relation, parent.type).')
+      })
+    },
+    async ({ graphId, nodeId, newParentId, newRelation }) => {
+      const data = await client2.post(
+        `/api/graphs/${graphId}/nodes/${nodeId}/reparent`,
+        { newParentId, newRelation }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/batch-reparent.ts
+import { z as z52 } from "zod";
+function registerBatchReparent(server2, client2) {
+  server2.registerTool(
+    "naumu_batch_reparent",
+    {
+      title: "Batch Reparent Nodes",
+      annotations: { destructiveHint: true },
+      description: 'Reparent 1\u201325 nodes onto a shared `newParentId` with the same `newRelation`. Same semantics as `naumu_reparent` per-node: atomic swap of the isParent edge, preserves id/content/attributes/embedding, no re-embedding. Idempotent per node (already-parented nodes return `status: "skipped"`). Per-node response array: `[{nodeId, oldParentId, newParentId, status: "moved" | "skipped" | "error", error?}]`. Used to move a same-typed cluster under a freshly-created mini-hub in /restructure.',
+      inputSchema: z52.object({
+        graphId: z52.string().describe("The graph ID"),
+        newParentId: z52.string().describe("Parent node id every nodeId in the batch will be parented to"),
+        newRelation: z52.string().describe("Parent edge relation label (must be valid per schema for child.type \u2192 parent.type)"),
+        nodeIds: z52.array(z52.string()).min(1).max(25).describe("1\u201325 child node ids to reparent under `newParentId`")
+      })
+    },
+    async ({ graphId, newParentId, newRelation, nodeIds }) => {
+      const data = await client2.post(`/api/graphs/${graphId}/reparent/bulk`, {
+        newParentId,
+        newRelation,
+        nodeIds
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/chatgpt-search.ts
+import { z as z53 } from "zod";
+
+// ../mcp-core/src/public-origin.ts
+function publicOrigin() {
+  const raw = process.env.NEXT_PUBLIC_URL || "http://localhost:3000";
+  return raw.replace(/\/+$/, "");
+}
+
+// ../mcp-core/src/tools/chatgpt-search.ts
+var PER_GRAPH_LIMIT = 10;
+var TOTAL_LIMIT = 20;
+function encodeResourceId(graphId, nodeId) {
+  return `${graphId}:${nodeId}`;
+}
+function mergeSearchResults(scoped, graphById, origin, totalLimit = TOTAL_LIMIT) {
+  const byGraph = /* @__PURE__ */ new Map();
+  for (const { graphId, hit } of scoped) {
+    const list = byGraph.get(graphId);
+    if (list) list.push(hit);
+    else byGraph.set(graphId, [hit]);
+  }
+  for (const hits of byGraph.values()) {
+    hits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+  }
+  const queues = Array.from(byGraph.entries());
+  const ordered = [];
+  for (let rank = 0; ordered.length < totalLimit; rank++) {
+    let advanced = false;
+    for (const [graphId, hits] of queues) {
+      if (rank >= hits.length) continue;
+      ordered.push({ graphId, hit: hits[rank] });
+      advanced = true;
+      if (ordered.length >= totalLimit) break;
+    }
+    if (!advanced) break;
+  }
+  return ordered.map(({ graphId, hit }) => {
+    const graph = graphById.get(graphId);
+    const slug = graph?.slug ?? graphId;
+    const label = hit.label || hit.id;
+    return {
+      id: encodeResourceId(graphId, hit.id),
+      title: graph?.name ? `${label} \u2014 ${graph.name}` : label,
+      url: `${origin}/spaces/${slug}/nodes/${hit.id}`
+    };
+  });
+}
+function registerChatgptSearch(server2, client2) {
+  server2.registerTool(
+    "search",
+    {
+      title: "Search",
+      annotations: { readOnlyHint: true },
+      description: "Search across all of the knowledge graphs (spaces) you can access and return the most relevant nodes. Returns `{ results: [{ id, title, url }] }`. Pass each result `id` to the `fetch` tool to read the full node. (This is the cross-space entry point for ChatGPT/Deep Research; within a single space, `naumu_search` exposes more controls.)",
+      inputSchema: z53.object({
+        query: z53.string().describe('Search query text. Mix synonyms and exact tokens freely (e.g. "auth login SSO 2fa").')
+      })
+    },
+    async ({ query }) => {
+      const origin = publicOrigin();
+      const graphs = await client2.get("/api/graphs") ?? [];
+      const graphById = /* @__PURE__ */ new Map();
+      for (const g of graphs) graphById.set(g.id, g);
+      const params = new URLSearchParams();
+      params.set("q", query);
+      params.set("limit", String(PER_GRAPH_LIMIT));
+      const perGraph = await Promise.all(
+        graphs.map(async (g) => {
+          try {
+            const hits = await client2.get(
+              `/api/graphs/${g.id}/search/hybrid?${params.toString()}`
+            );
+            return (hits ?? []).map((h) => ({ graphId: g.id, hit: h }));
+          } catch {
+            return [];
+          }
+        })
+      );
+      const results = mergeSearchResults(perGraph.flat(), graphById, origin);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ results }) }]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/chatgpt-fetch.ts
+import { z as z54 } from "zod";
+var NON_ATTRIBUTE_PROPS = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "title",
+  "name",
+  "type",
+  "content",
+  "connections",
+  "embedding",
+  "sortKey",
+  "createdByUserId",
+  "editableBy",
+  "visibility",
+  "defaultVisibility",
+  "createdAt",
+  "updatedAt",
+  "heatConvSignal",
+  "heatConvComputedAt",
+  "heatComputedAt"
+]);
+function parseResourceId(id) {
+  const sep = id.indexOf(":");
+  if (sep <= 0 || sep === id.length - 1) return null;
+  return { graphId: id.slice(0, sep), nodeId: id.slice(sep + 1) };
+}
+function pickTitle(node, fallback) {
+  return node.label || node.title || node.name || fallback;
+}
+function formatScalar(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function buildNodeText(node) {
+  const parts = [];
+  if (node.type) parts.push(`Type: ${String(node.type)}`);
+  if (typeof node.content === "string" && node.content.trim()) parts.push(node.content.trim());
+  const attrLines = Object.entries(node).filter(([key]) => !NON_ATTRIBUTE_PROPS.has(key)).map(([key, value]) => {
+    const scalar = formatScalar(value);
+    return scalar === null ? null : `- ${key}: ${scalar}`;
+  }).filter((line) => line !== null);
+  if (attrLines.length) parts.push(`Attributes:
+${attrLines.join("\n")}`);
+  const connections = node.connections;
+  const edgeLines = [];
+  for (const e of connections?.outgoing ?? []) {
+    if (!e?.target) continue;
+    edgeLines.push(`- ${e.label ?? "related"} \u2192 ${e.target}${e.isParent ? " (parent)" : ""}`);
+  }
+  for (const e of connections?.incoming ?? []) {
+    if (!e?.source) continue;
+    edgeLines.push(`- ${e.source} \u2192 ${e.label ?? "related"} (incoming)`);
+  }
+  if (edgeLines.length) parts.push(`Connections:
+${edgeLines.join("\n")}`);
+  return parts.join("\n\n");
+}
+function registerChatgptFetch(server2, client2) {
+  server2.registerTool(
+    "fetch",
+    {
+      title: "Fetch",
+      annotations: { readOnlyHint: true },
+      description: "Fetch the full contents of a node returned by the `search` tool. Pass the result `id` verbatim (format `<graphId>:<nodeId>`). Returns `{ id, title, text, url }` where `text` is the node content plus its type, attributes, and connections.",
+      inputSchema: z54.object({
+        id: z54.string().describe("A resource id from a previous `search` result, in the form `<graphId>:<nodeId>`.")
+      })
+    },
+    async ({ id }) => {
+      const parsed = parseResourceId(id);
+      if (!parsed) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: id "${id}" is not in the expected "<graphId>:<nodeId>" form. Use an id returned by the search tool.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const { graphId, nodeId } = parsed;
+      const origin = publicOrigin();
+      const node = await client2.get(`/api/graphs/${graphId}/nodes/${nodeId}`);
+      let slug = graphId;
+      try {
+        const meta = await client2.get(`/api/graphs/resolve/${graphId}`);
+        if (meta?.slug) slug = meta.slug;
+      } catch {
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              id,
+              title: pickTitle(node, nodeId),
+              text: buildNodeText(node),
+              url: `${origin}/spaces/${slug}/nodes/${nodeId}`
+            })
+          }
+        ]
+      };
+    }
+  );
+}
+
+// ../mcp-core/src/tools/index.ts
+var TOOL_REGISTRARS = {
+  naumu_list_graphs: registerListGraphs,
+  naumu_create_graph: registerCreateGraph,
+  naumu_get_schema: registerGetSchema,
+  naumu_update_schema: registerUpdateSchema,
+  naumu_add_node_type: registerAddNodeType,
+  naumu_add_connection: registerAddConnection,
+  naumu_add_attribute: registerAddAttribute,
+  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,
+  naumu_remove_node: registerRemoveNode,
+  naumu_remove_edge: registerRemoveEdge,
+  naumu_remove_edges_bulk: registerRemoveEdgesBulk,
+  naumu_ask: registerAsk,
+  naumu_get_ai_thread: registerGetAiThread,
+  naumu_traverse: registerTraverse,
+  naumu_list_canvases: registerListCanvases,
+  naumu_get_canvas_elements: registerGetCanvasElements,
+  naumu_get_canvas_image: registerGetCanvasImage,
+  naumu_post_message: registerPostMessage,
+  naumu_read_thread: registerReadThread,
+  naumu_ask_naumu: registerAskNaumu,
+  naumu_whoami: registerWhoami,
+  naumu_list_threads: registerListThreads,
+  naumu_get_thread: registerGetThread,
+  naumu_create_thread: registerCreateThread,
+  naumu_request_attachment_upload: registerRequestAttachmentUpload,
+  naumu_add_reaction: registerAddReaction,
+  naumu_remove_reaction: registerRemoveReaction,
+  naumu_typing: registerNaumuTyping,
+  naumu_note_read: registerNoteRead,
+  naumu_note_append: registerNoteAppend,
+  naumu_note_insert: registerNoteInsert,
+  naumu_note_replace_section: registerNoteReplaceSection,
+  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,
+  naumu_reparent: registerReparent,
+  naumu_batch_reparent: registerBatchReparent,
+  // ChatGPT / Deep Research compatibility: the OpenAI MCP surface requires
+  // tools literally named `search` and `fetch`. These wrap the cross-graph
+  // search + node read and emit the `{ results }` / `{ id, title, text, url }`
+  // shapes that client expects (see chatgpt-search.ts / chatgpt-fetch.ts).
+  search: registerChatgptSearch,
+  fetch: registerChatgptFetch
+};
+var ALL_TOOL_NAMES = Object.keys(TOOL_REGISTRARS);
+function registerAllTools(server2, client2) {
+  for (const [name, registrar] of Object.entries(TOOL_REGISTRARS)) {
+    if (name === "naumu_whoami") {
+      registerWhoami(server2, client2, ALL_TOOL_NAMES);
+    } else {
+      registrar(server2, client2);
+    }
+  }
+}
+function registerNamedTools(server2, client2, toolNames) {
+  const registered = [];
+  const skipped = [];
+  for (const name of toolNames) {
+    const registrar = TOOL_REGISTRARS[name];
+    if (registrar) {
+      registrar(server2, client2);
+      registered.push(name);
+    } else {
+      skipped.push(name);
+    }
+  }
+  if (skipped.length) {
+    console.error(
+      `[mcp] skipped ${skipped.length} tool(s) absent from this build: ${skipped.join(", ")}`
+    );
+  }
+  console.error(`[mcp] registered ${registered.length} tool(s) for bot key`);
+}
+
+// src/index.ts
+var DEFAULT_API_URL = "https://naumu.ai";
+var BOT_KEY_PREFIX = "nmu_bot_";
+var apiUrl = (process.env.NAUMU_API_URL || DEFAULT_API_URL).replace(/\/api\/?$/, "");
+var apiKey = process.env.NAUMU_API_KEY;
+if (!apiKey) {
+  console.error("Missing required environment variable: NAUMU_API_KEY");
+  process.exit(1);
+}
+var client = new NaumuClient(apiUrl, apiKey);
+var server = new McpServer(
+  {
+    name: "naumu",
+    version: "0.4.0"
+  },
+  {
+    instructions: NAUMU_INSTRUCTIONS
+  }
+);
+var isBotKey = apiKey.startsWith(BOT_KEY_PREFIX);
+if (isBotKey) {
+  try {
+    const manifest = await client.get("/api/identities/me/mcp-tool-manifest");
+    registerNamedTools(server, client, manifest.mcpTools);
+    console.error(
+      `[mcp] connected to ${apiUrl} as bot identity ${manifest.identityId} (${manifest.intelligenceKind}); ${manifest.mcpTools.length} tool(s) registered`
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[mcp] failed to fetch tool manifest: ${message}`);
+    process.exit(1);
+  }
+} else {
+  registerAllTools(server, client);
+  console.error(
+    `[mcp] connected to ${apiUrl} as user key (${process.env.NAUMU_IDENTITY_ID ?? "no identity id set"})`
+  );
 }
-const transport = new StdioServerTransport();
+var transport = new StdioServerTransport();
 await server.connect(transport);
-//# sourceMappingURL=index.js.map