mindgraph-mcp 0.13.4 → 0.13.5

package/dist/cli.js

@@ -1486,9 +1486,13 @@ var init_tools = __esm({
 
 // src/generated-tools.ts
 async function getGeneratedTools(client2) {
-  if (cache && Date.now() - cache.fetchedAt < CACHE_TTL_MS) {
+  const now = Date.now();
+  if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {
     return { tools: cache.tools, byName: cache.byName };
   }
+  if (now < retryNotBefore) {
+    return cache ? { tools: cache.tools, byName: cache.byName } : EMPTY;
+  }
   try {
     const c = client2;
     if (typeof c.listOntologyTools !== "function") {
@@ -1512,11 +1516,12 @@ async function getGeneratedTools(client2) {
       });
     }
     cache = { tools, byName, fetchedAt: Date.now() };
+    retryNotBefore = 0;
     return { tools, byName };
   } catch (error) {
     if (error instanceof DuplicateGeneratedToolError) throw error;
-    cache = { tools: [], byName: /* @__PURE__ */ new Map(), fetchedAt: Date.now() };
-    return { tools: cache.tools, byName: cache.byName };
+    retryNotBefore = Date.now() + FAILURE_COOLDOWN_MS;
+    return cache ? { tools: cache.tools, byName: cache.byName } : EMPTY;
   }
 }
 async function handleGeneratedTool(client2, desc, args) {
@@ -1586,11 +1591,14 @@ async function handleGeneratedTool(client2, desc, args) {
             "structured ontology tools require a graph-aware version of the mindgraph SDK"
           );
         }
-        return ok2(await ontologyClient.queryDomainStructured({
-          ...args,
+        const request = {
           schema_id: desc.schema_id,
           select
-        }));
+        };
+        for (const field of STRUCTURED_QUERY_PASSTHROUGH) {
+          if (args[field] !== void 0) request[field] = args[field];
+        }
+        return ok2(await ontologyClient.queryDomainStructured(request));
       }
       default:
         return err2(`unknown generated tool mapping: ${desc.maps_to}`);
@@ -1599,7 +1607,7 @@ async function handleGeneratedTool(client2, desc, args) {
     return err2(e instanceof Error ? e.message : String(e));
   }
 }
-var ok2, err2, CACHE_TTL_MS, cache, DuplicateGeneratedToolError;
+var ok2, err2, CACHE_TTL_MS, FAILURE_COOLDOWN_MS, cache, retryNotBefore, EMPTY, DuplicateGeneratedToolError, STRUCTURED_QUERY_PASSTHROUGH;
 var init_generated_tools = __esm({
   "src/generated-tools.ts"() {
     "use strict";
@@ -1611,13 +1619,33 @@ var init_generated_tools = __esm({
       isError: true
     });
     CACHE_TTL_MS = 5 * 60 * 1e3;
+    FAILURE_COOLDOWN_MS = 15 * 1e3;
     cache = null;
+    retryNotBefore = 0;
+    EMPTY = {
+      tools: [],
+      byName: /* @__PURE__ */ new Map()
+    };
     DuplicateGeneratedToolError = class extends Error {
     };
+    STRUCTURED_QUERY_PASSTHROUGH = [
+      "anchor",
+      "path",
+      "where",
+      "include",
+      "page",
+      "aggregate"
+    ];
   }
 });
 
 // src/governance.ts
+function isTransientStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function headers(apiKey, orgId) {
   const value = {
     authorization: `Bearer ${apiKey}`,
@@ -1633,41 +1661,81 @@ function unsupportedResponse(status, body) {
   return lower.includes("unknown governance action") || lower.includes("unknown action") || lower.includes("invalid_governance_action");
 }
 async function checkMcpGovernance(toolName, args, config) {
-  if (config.disabled || capability === "unsupported") return { allowed: true };
+  if (config.disabled) return { allowed: true };
+  if (capability === "unsupported") {
+    if (Date.now() < unsupportedUntil) return { allowed: true };
+    capability = "unknown";
+  }
   const fetchImpl = config.fetchImpl ?? fetch;
+  const retryDelays = config.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
   let response;
-  let body;
-  try {
-    response = await fetchImpl(`${config.baseUrl.replace(/\/$/, "")}/agent/governance`, {
-      method: "POST",
-      headers: headers(config.apiKey, config.orgId),
-      body: JSON.stringify({
-        action: "check",
-        act: "tool_invoke",
-        agent_id: String(args.agent_id || config.agentId),
-        target: { tool_name: toolName },
-        context: { adapter: "mindgraph-mcp" },
-        tier: "checkpoint"
-      })
-    });
-    body = await response.text();
-  } catch (error) {
+  let body = "";
+  let lastFailure = "";
+  for (let attempt = 0; attempt <= retryDelays.length; attempt++) {
+    try {
+      const candidate = await fetchImpl(
+        `${config.baseUrl.replace(/\/$/, "")}/agent/governance`,
+        {
+          method: "POST",
+          headers: headers(config.apiKey, config.orgId),
+          body: JSON.stringify({
+            action: "check",
+            act: "tool_invoke",
+            agent_id: String(args.agent_id || config.agentId),
+            target: { tool_name: toolName },
+            context: { adapter: "mindgraph-mcp", ...config.context },
+            tier: "checkpoint"
+          })
+        }
+      );
+      const candidateBody = await candidate.text();
+      if (isTransientStatus(candidate.status) && attempt < retryDelays.length) {
+        lastFailure = `HTTP ${candidate.status}`;
+        await sleep(retryDelays[attempt]);
+        continue;
+      }
+      response = candidate;
+      body = candidateBody;
+      break;
+    } catch (error) {
+      lastFailure = error instanceof Error ? error.message : String(error);
+      if (attempt < retryDelays.length) {
+        await sleep(retryDelays[attempt]);
+        continue;
+      }
+    }
+  }
+  if (!response) {
     return {
       allowed: false,
-      message: `MindGraph governance could not establish permission: ${error instanceof Error ? error.message : String(error)}`
+      message: `MindGraph governance could not establish permission after ${retryDelays.length + 1} attempts (${lastFailure}). Set MINDGRAPH_GOVERNANCE=off to run this adapter ungoverned.`
     };
   }
   if (!response.ok) {
     if (capability === "unknown" && unsupportedResponse(response.status, body)) {
       capability = "unsupported";
+      unsupportedUntil = Date.now() + UNSUPPORTED_LEASE_MS;
+      if (!unsupportedLogged) {
+        unsupportedLogged = true;
+        console.error(
+          `[mindgraph-mcp] This MindGraph server does not implement the governance checkpoint (HTTP ${response.status}); tool calls proceed ungoverned. Re-probing every ${Math.round(UNSUPPORTED_LEASE_MS / 6e4)} minutes.`
+        );
+      }
       return { allowed: true };
     }
+    if (response.status === 401 || response.status === 403) {
+      return {
+        allowed: false,
+        message: `This credential is not permitted to evaluate MindGraph governance (HTTP ${response.status}). Use a user-scoped API key, or set MINDGRAPH_GOVERNANCE=off to run this adapter ungoverned.`
+      };
+    }
     return {
       allowed: false,
       message: `MindGraph governance check failed (${response.status})`
     };
   }
   capability = "supported";
+  unsupportedLogged = false;
   let decision;
   try {
     decision = JSON.parse(body);
@@ -1701,15 +1769,130 @@ async function checkMcpGovernance(toolName, args, config) {
     message: verdict === "conditional" ? `Approval is required${policy ? ` by policy ${policy}` : ""}${approvalUid ? ` (approval ${approvalUid})` : ""}` : `Denied by MindGraph governance${policy ? ` policy ${policy}` : ""}`
   };
 }
-var capability, KNOWN_DUTIES;
+var capability, UNSUPPORTED_LEASE_MS, unsupportedUntil, unsupportedLogged, DEFAULT_RETRY_DELAYS_MS, KNOWN_DUTIES;
 var init_governance = __esm({
   "src/governance.ts"() {
     "use strict";
     capability = "unknown";
+    UNSUPPORTED_LEASE_MS = 5 * 60 * 1e3;
+    unsupportedUntil = 0;
+    unsupportedLogged = false;
+    DEFAULT_RETRY_DELAYS_MS = [150, 600];
     KNOWN_DUTIES = /* @__PURE__ */ new Set(["log", "require_approval"]);
   }
 });
 
+// src/resources.ts
+function json(uri, data) {
+  return {
+    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(data, null, 2) }]
+  };
+}
+async function readResource(client2, uri) {
+  switch (uri) {
+    case "mindgraph://stats":
+      return json(uri, await client2.stats());
+    case "mindgraph://goals":
+      return json(uri, await client2.getGoals());
+    case "mindgraph://questions":
+      return json(uri, await client2.getOpenQuestions());
+    case "mindgraph://contradictions":
+      return json(uri, await client2.getContradictions());
+    case "mindgraph://decisions":
+      return json(uri, await client2.getOpenDecisions());
+  }
+  const nodeMatch = uri.match(/^mindgraph:\/\/node\/(.+)$/);
+  if (nodeMatch) {
+    const uid = decodeURIComponent(nodeMatch[1]);
+    const node = await client2.getNode(uid);
+    const edges = await client2.getEdges({ from_uid: uid });
+    const inEdges = await client2.getEdges({ to_uid: uid });
+    return json(uri, { node, outgoing_edges: edges, incoming_edges: inEdges });
+  }
+  const searchMatch = uri.match(/^mindgraph:\/\/search\/(.+)$/);
+  if (searchMatch) {
+    const query = decodeURIComponent(searchMatch[1]);
+    return json(uri, await client2.search(query, { limit: 20 }));
+  }
+  const layerMatch = uri.match(/^mindgraph:\/\/layer\/(.+)$/);
+  if (layerMatch) {
+    const layer = decodeURIComponent(layerMatch[1]);
+    return json(uri, await client2.getNodes({ layer, limit: 50 }));
+  }
+  throw new Error(`Unknown resource: ${uri}`);
+}
+async function readGovernedResource(client2, uri, governanceConfig) {
+  const governance = await checkMcpGovernance(
+    RESOURCE_GOVERNANCE_TOOL,
+    {},
+    { ...governanceConfig, context: { resource_uri: uri } }
+  );
+  if (!governance.allowed) {
+    throw new Error(governance.message);
+  }
+  return readResource(client2, uri);
+}
+var RESOURCES, RESOURCE_TEMPLATES, RESOURCE_GOVERNANCE_TOOL;
+var init_resources = __esm({
+  "src/resources.ts"() {
+    "use strict";
+    init_governance();
+    RESOURCES = [
+      {
+        uri: "mindgraph://stats",
+        name: "Graph Statistics",
+        description: "Current knowledge graph statistics: node counts, edge counts, and layer distribution",
+        mimeType: "application/json"
+      },
+      {
+        uri: "mindgraph://goals",
+        name: "Active Goals",
+        description: "All active goals in the knowledge graph",
+        mimeType: "application/json"
+      },
+      {
+        uri: "mindgraph://questions",
+        name: "Open Questions",
+        description: "All open questions in the knowledge graph",
+        mimeType: "application/json"
+      },
+      {
+        uri: "mindgraph://contradictions",
+        name: "Contradictions",
+        description: "Contradictory claims in the knowledge graph",
+        mimeType: "application/json"
+      },
+      {
+        uri: "mindgraph://decisions",
+        name: "Open Decisions",
+        description: "Unresolved decisions awaiting resolution",
+        mimeType: "application/json"
+      }
+    ];
+    RESOURCE_TEMPLATES = [
+      {
+        uriTemplate: "mindgraph://node/{uid}",
+        name: "Graph Node",
+        description: "Retrieve a specific node by its UID, including all properties, edges, and version history",
+        mimeType: "application/json"
+      },
+      {
+        uriTemplate: "mindgraph://search/{query}",
+        name: "Search Results",
+        description: "BM25 keyword search across all nodes \u2014 pass 1\u20133 discriminating terms (e.g. 'Kissinger NATO'), not natural language sentences",
+        mimeType: "application/json"
+      },
+      {
+        uriTemplate: "mindgraph://layer/{layer}",
+        name: "Layer Nodes",
+        description: "List all nodes in a specific cognitive layer (reality, epistemic, intent, action, memory, agent)",
+        mimeType: "application/json"
+      }
+    ];
+    RESOURCE_GOVERNANCE_TOOL = "mindgraph_retrieve";
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 async function main() {
@@ -1719,7 +1902,7 @@ async function main() {
     `MindGraph MCP server v0.7.1 running on stdio (${BASE_URL})`
   );
 }
-var import_server, import_stdio, import_types, import_mindgraph, API_KEY, BASE_URL, AGENT_ID, ORG_ID, client, INSTRUCTIONS, server, PROMPTS;
+var import_server, import_stdio, import_types, import_mindgraph, API_KEY, BASE_URL, AGENT_ID, ORG_ID, client, INSTRUCTIONS, server, GOVERNANCE_CONFIG, PROMPTS;
 var init_src = __esm({
   "src/index.ts"() {
     "use strict";
@@ -1730,6 +1913,7 @@ var init_src = __esm({
     init_tools();
     init_generated_tools();
     init_governance();
+    init_resources();
     API_KEY = process.env.MINDGRAPH_API_KEY;
     BASE_URL = process.env.MINDGRAPH_BASE_URL || "https://api.mindgraph.cloud";
     AGENT_ID = process.env.MINDGRAPH_AGENT_ID || "mcp";
@@ -1827,7 +2011,7 @@ Capture knowledge when the user shares something worth remembering:
     server = new import_server.Server(
       {
         name: "mindgraph",
-        version: "0.13.4"
+        version: "0.13.5"
       },
       {
         capabilities: {
@@ -1842,19 +2026,23 @@ Capture knowledge when the user shares something worth remembering:
       const generated = await getGeneratedTools(client);
       return { tools: [...TOOLS, ...generated.tools] };
     });
+    GOVERNANCE_CONFIG = {
+      baseUrl: BASE_URL,
+      apiKey: API_KEY,
+      orgId: ORG_ID,
+      agentId: AGENT_ID,
+      get disabled() {
+        return process.env.MINDGRAPH_GOVERNANCE === "off";
+      }
+    };
     server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
       const { name, arguments: args } = request.params;
-      const toolArgs = { ...args || {} };
+      const rawArgs = { ...args || {} };
+      const toolArgs = { ...rawArgs };
       if (!toolArgs.agent_id) {
         toolArgs.agent_id = AGENT_ID;
       }
-      const governance = await checkMcpGovernance(name, toolArgs, {
-        baseUrl: BASE_URL,
-        apiKey: API_KEY,
-        orgId: ORG_ID,
-        agentId: AGENT_ID,
-        disabled: process.env.MINDGRAPH_GOVERNANCE === "off"
-      });
+      const governance = await checkMcpGovernance(name, toolArgs, GOVERNANCE_CONFIG);
       if (!governance.allowed) {
         return {
           content: [{ type: "text", text: JSON.stringify({ error: governance.message, ...governance }) }],
@@ -1864,7 +2052,7 @@ Capture knowledge when the user shares something worth remembering:
       const generated = await getGeneratedTools(client);
       const desc = generated.byName.get(name);
       if (desc) {
-        return handleGeneratedTool(client, desc, toolArgs);
+        return handleGeneratedTool(client, desc, rawArgs);
       }
       return handleTool(client, name, toolArgs);
     });
@@ -2025,178 +2213,13 @@ ${conversation}`
       }
     });
     server.setRequestHandler(import_types.ListResourcesRequestSchema, async () => {
-      return {
-        resources: [
-          {
-            uri: "mindgraph://stats",
-            name: "Graph Statistics",
-            description: "Current knowledge graph statistics: node counts, edge counts, and layer distribution",
-            mimeType: "application/json"
-          },
-          {
-            uri: "mindgraph://goals",
-            name: "Active Goals",
-            description: "All active goals in the knowledge graph",
-            mimeType: "application/json"
-          },
-          {
-            uri: "mindgraph://questions",
-            name: "Open Questions",
-            description: "All open questions in the knowledge graph",
-            mimeType: "application/json"
-          },
-          {
-            uri: "mindgraph://contradictions",
-            name: "Contradictions",
-            description: "Contradictory claims in the knowledge graph",
-            mimeType: "application/json"
-          },
-          {
-            uri: "mindgraph://decisions",
-            name: "Open Decisions",
-            description: "Unresolved decisions awaiting resolution",
-            mimeType: "application/json"
-          }
-        ]
-      };
+      return { resources: RESOURCES };
     });
     server.setRequestHandler(import_types.ListResourceTemplatesRequestSchema, async () => {
-      return {
-        resourceTemplates: [
-          {
-            uriTemplate: "mindgraph://node/{uid}",
-            name: "Graph Node",
-            description: "Retrieve a specific node by its UID, including all properties, edges, and version history",
-            mimeType: "application/json"
-          },
-          {
-            uriTemplate: "mindgraph://search/{query}",
-            name: "Search Results",
-            description: "BM25 keyword search across all nodes \u2014 pass 1\u20133 discriminating terms (e.g. 'Kissinger NATO'), not natural language sentences",
-            mimeType: "application/json"
-          },
-          {
-            uriTemplate: "mindgraph://layer/{layer}",
-            name: "Layer Nodes",
-            description: "List all nodes in a specific cognitive layer (reality, epistemic, intent, action, memory, agent)",
-            mimeType: "application/json"
-          }
-        ]
-      };
+      return { resourceTemplates: RESOURCE_TEMPLATES };
     });
     server.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
-      const { uri } = request.params;
-      switch (uri) {
-        case "mindgraph://stats": {
-          const stats = await client.stats();
-          return {
-            contents: [
-              {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(stats, null, 2)
-              }
-            ]
-          };
-        }
-        case "mindgraph://goals": {
-          const goals = await client.getGoals();
-          return {
-            contents: [
-              {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(goals, null, 2)
-              }
-            ]
-          };
-        }
-        case "mindgraph://questions": {
-          const questions = await client.getOpenQuestions();
-          return {
-            contents: [
-              {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(questions, null, 2)
-              }
-            ]
-          };
-        }
-        case "mindgraph://contradictions": {
-          const contradictions = await client.getContradictions();
-          return {
-            contents: [
-              {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(contradictions, null, 2)
-              }
-            ]
-          };
-        }
-        case "mindgraph://decisions": {
-          const decisions = await client.getOpenDecisions();
-          return {
-            contents: [
-              {
-                uri,
-                mimeType: "application/json",
-                text: JSON.stringify(decisions, null, 2)
-              }
-            ]
-          };
-        }
-      }
-      const nodeMatch = uri.match(/^mindgraph:\/\/node\/(.+)$/);
-      if (nodeMatch) {
-        const uid = decodeURIComponent(nodeMatch[1]);
-        const node = await client.getNode(uid);
-        const edges = await client.getEdges({ from_uid: uid });
-        const inEdges = await client.getEdges({ to_uid: uid });
-        return {
-          contents: [
-            {
-              uri,
-              mimeType: "application/json",
-              text: JSON.stringify(
-                { node, outgoing_edges: edges, incoming_edges: inEdges },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
-      const searchMatch = uri.match(/^mindgraph:\/\/search\/(.+)$/);
-      if (searchMatch) {
-        const query = decodeURIComponent(searchMatch[1]);
-        const results = await client.search(query, { limit: 20 });
-        return {
-          contents: [
-            {
-              uri,
-              mimeType: "application/json",
-              text: JSON.stringify(results, null, 2)
-            }
-          ]
-        };
-      }
-      const layerMatch = uri.match(/^mindgraph:\/\/layer\/(.+)$/);
-      if (layerMatch) {
-        const layer = decodeURIComponent(layerMatch[1]);
-        const nodes = await client.getNodes({ layer, limit: 50 });
-        return {
-          contents: [
-            {
-              uri,
-              mimeType: "application/json",
-              text: JSON.stringify(nodes, null, 2)
-            }
-          ]
-        };
-      }
-      throw new Error(`Unknown resource: ${uri}`);
+      return readGovernedResource(client, request.params.uri, GOVERNANCE_CONFIG);
     });
     main().catch((error) => {
       console.error("Fatal error:", error);

package/dist/index.js

@@ -1467,13 +1467,23 @@ var err2 = (message) => ({
   isError: true
 });
 var CACHE_TTL_MS = 5 * 60 * 1e3;
+var FAILURE_COOLDOWN_MS = 15 * 1e3;
 var cache = null;
+var retryNotBefore = 0;
+var EMPTY = {
+  tools: [],
+  byName: /* @__PURE__ */ new Map()
+};
 var DuplicateGeneratedToolError = class extends Error {
 };
 async function getGeneratedTools(client2) {
-  if (cache && Date.now() - cache.fetchedAt < CACHE_TTL_MS) {
+  const now = Date.now();
+  if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {
     return { tools: cache.tools, byName: cache.byName };
   }
+  if (now < retryNotBefore) {
+    return cache ? { tools: cache.tools, byName: cache.byName } : EMPTY;
+  }
   try {
     const c = client2;
     if (typeof c.listOntologyTools !== "function") {
@@ -1497,13 +1507,22 @@ async function getGeneratedTools(client2) {
       });
     }
     cache = { tools, byName, fetchedAt: Date.now() };
+    retryNotBefore = 0;
     return { tools, byName };
   } catch (error) {
     if (error instanceof DuplicateGeneratedToolError) throw error;
-    cache = { tools: [], byName: /* @__PURE__ */ new Map(), fetchedAt: Date.now() };
-    return { tools: cache.tools, byName: cache.byName };
+    retryNotBefore = Date.now() + FAILURE_COOLDOWN_MS;
+    return cache ? { tools: cache.tools, byName: cache.byName } : EMPTY;
   }
 }
+var STRUCTURED_QUERY_PASSTHROUGH = [
+  "anchor",
+  "path",
+  "where",
+  "include",
+  "page",
+  "aggregate"
+];
 async function handleGeneratedTool(client2, desc, args) {
   try {
     const ontologyClient = client2;
@@ -1571,11 +1590,14 @@ async function handleGeneratedTool(client2, desc, args) {
             "structured ontology tools require a graph-aware version of the mindgraph SDK"
           );
         }
-        return ok2(await ontologyClient.queryDomainStructured({
-          ...args,
+        const request = {
           schema_id: desc.schema_id,
           select
-        }));
+        };
+        for (const field of STRUCTURED_QUERY_PASSTHROUGH) {
+          if (args[field] !== void 0) request[field] = args[field];
+        }
+        return ok2(await ontologyClient.queryDomainStructured(request));
       }
       default:
         return err2(`unknown generated tool mapping: ${desc.maps_to}`);
@@ -1587,6 +1609,16 @@ async function handleGeneratedTool(client2, desc, args) {
 
 // src/governance.ts
 var capability = "unknown";
+var UNSUPPORTED_LEASE_MS = 5 * 60 * 1e3;
+var unsupportedUntil = 0;
+var unsupportedLogged = false;
+var DEFAULT_RETRY_DELAYS_MS = [150, 600];
+function isTransientStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 var KNOWN_DUTIES = /* @__PURE__ */ new Set(["log", "require_approval"]);
 function headers(apiKey, orgId) {
   const value = {
@@ -1603,41 +1635,81 @@ function unsupportedResponse(status, body) {
   return lower.includes("unknown governance action") || lower.includes("unknown action") || lower.includes("invalid_governance_action");
 }
 async function checkMcpGovernance(toolName, args, config) {
-  if (config.disabled || capability === "unsupported") return { allowed: true };
+  if (config.disabled) return { allowed: true };
+  if (capability === "unsupported") {
+    if (Date.now() < unsupportedUntil) return { allowed: true };
+    capability = "unknown";
+  }
   const fetchImpl = config.fetchImpl ?? fetch;
+  const retryDelays = config.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
   let response;
-  let body;
-  try {
-    response = await fetchImpl(`${config.baseUrl.replace(/\/$/, "")}/agent/governance`, {
-      method: "POST",
-      headers: headers(config.apiKey, config.orgId),
-      body: JSON.stringify({
-        action: "check",
-        act: "tool_invoke",
-        agent_id: String(args.agent_id || config.agentId),
-        target: { tool_name: toolName },
-        context: { adapter: "mindgraph-mcp" },
-        tier: "checkpoint"
-      })
-    });
-    body = await response.text();
-  } catch (error) {
+  let body = "";
+  let lastFailure = "";
+  for (let attempt = 0; attempt <= retryDelays.length; attempt++) {
+    try {
+      const candidate = await fetchImpl(
+        `${config.baseUrl.replace(/\/$/, "")}/agent/governance`,
+        {
+          method: "POST",
+          headers: headers(config.apiKey, config.orgId),
+          body: JSON.stringify({
+            action: "check",
+            act: "tool_invoke",
+            agent_id: String(args.agent_id || config.agentId),
+            target: { tool_name: toolName },
+            context: { adapter: "mindgraph-mcp", ...config.context },
+            tier: "checkpoint"
+          })
+        }
+      );
+      const candidateBody = await candidate.text();
+      if (isTransientStatus(candidate.status) && attempt < retryDelays.length) {
+        lastFailure = `HTTP ${candidate.status}`;
+        await sleep(retryDelays[attempt]);
+        continue;
+      }
+      response = candidate;
+      body = candidateBody;
+      break;
+    } catch (error) {
+      lastFailure = error instanceof Error ? error.message : String(error);
+      if (attempt < retryDelays.length) {
+        await sleep(retryDelays[attempt]);
+        continue;
+      }
+    }
+  }
+  if (!response) {
     return {
       allowed: false,
-      message: `MindGraph governance could not establish permission: ${error instanceof Error ? error.message : String(error)}`
+      message: `MindGraph governance could not establish permission after ${retryDelays.length + 1} attempts (${lastFailure}). Set MINDGRAPH_GOVERNANCE=off to run this adapter ungoverned.`
     };
   }
   if (!response.ok) {
     if (capability === "unknown" && unsupportedResponse(response.status, body)) {
       capability = "unsupported";
+      unsupportedUntil = Date.now() + UNSUPPORTED_LEASE_MS;
+      if (!unsupportedLogged) {
+        unsupportedLogged = true;
+        console.error(
+          `[mindgraph-mcp] This MindGraph server does not implement the governance checkpoint (HTTP ${response.status}); tool calls proceed ungoverned. Re-probing every ${Math.round(UNSUPPORTED_LEASE_MS / 6e4)} minutes.`
+        );
+      }
       return { allowed: true };
     }
+    if (response.status === 401 || response.status === 403) {
+      return {
+        allowed: false,
+        message: `This credential is not permitted to evaluate MindGraph governance (HTTP ${response.status}). Use a user-scoped API key, or set MINDGRAPH_GOVERNANCE=off to run this adapter ungoverned.`
+      };
+    }
     return {
       allowed: false,
       message: `MindGraph governance check failed (${response.status})`
     };
   }
   capability = "supported";
+  unsupportedLogged = false;
   let decision;
   try {
     decision = JSON.parse(body);
@@ -1672,6 +1744,110 @@ async function checkMcpGovernance(toolName, args, config) {
   };
 }
 
+// src/resources.ts
+var RESOURCES = [
+  {
+    uri: "mindgraph://stats",
+    name: "Graph Statistics",
+    description: "Current knowledge graph statistics: node counts, edge counts, and layer distribution",
+    mimeType: "application/json"
+  },
+  {
+    uri: "mindgraph://goals",
+    name: "Active Goals",
+    description: "All active goals in the knowledge graph",
+    mimeType: "application/json"
+  },
+  {
+    uri: "mindgraph://questions",
+    name: "Open Questions",
+    description: "All open questions in the knowledge graph",
+    mimeType: "application/json"
+  },
+  {
+    uri: "mindgraph://contradictions",
+    name: "Contradictions",
+    description: "Contradictory claims in the knowledge graph",
+    mimeType: "application/json"
+  },
+  {
+    uri: "mindgraph://decisions",
+    name: "Open Decisions",
+    description: "Unresolved decisions awaiting resolution",
+    mimeType: "application/json"
+  }
+];
+var RESOURCE_TEMPLATES = [
+  {
+    uriTemplate: "mindgraph://node/{uid}",
+    name: "Graph Node",
+    description: "Retrieve a specific node by its UID, including all properties, edges, and version history",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "mindgraph://search/{query}",
+    name: "Search Results",
+    description: "BM25 keyword search across all nodes \u2014 pass 1\u20133 discriminating terms (e.g. 'Kissinger NATO'), not natural language sentences",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "mindgraph://layer/{layer}",
+    name: "Layer Nodes",
+    description: "List all nodes in a specific cognitive layer (reality, epistemic, intent, action, memory, agent)",
+    mimeType: "application/json"
+  }
+];
+var RESOURCE_GOVERNANCE_TOOL = "mindgraph_retrieve";
+function json(uri, data) {
+  return {
+    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(data, null, 2) }]
+  };
+}
+async function readResource(client2, uri) {
+  switch (uri) {
+    case "mindgraph://stats":
+      return json(uri, await client2.stats());
+    case "mindgraph://goals":
+      return json(uri, await client2.getGoals());
+    case "mindgraph://questions":
+      return json(uri, await client2.getOpenQuestions());
+    case "mindgraph://contradictions":
+      return json(uri, await client2.getContradictions());
+    case "mindgraph://decisions":
+      return json(uri, await client2.getOpenDecisions());
+  }
+  const nodeMatch = uri.match(/^mindgraph:\/\/node\/(.+)$/);
+  if (nodeMatch) {
+    const uid = decodeURIComponent(nodeMatch[1]);
+    const node = await client2.getNode(uid);
+    const edges = await client2.getEdges({ from_uid: uid });
+    const inEdges = await client2.getEdges({ to_uid: uid });
+    return json(uri, { node, outgoing_edges: edges, incoming_edges: inEdges });
+  }
+  const searchMatch = uri.match(/^mindgraph:\/\/search\/(.+)$/);
+  if (searchMatch) {
+    const query = decodeURIComponent(searchMatch[1]);
+    return json(uri, await client2.search(query, { limit: 20 }));
+  }
+  const layerMatch = uri.match(/^mindgraph:\/\/layer\/(.+)$/);
+  if (layerMatch) {
+    const layer = decodeURIComponent(layerMatch[1]);
+    return json(uri, await client2.getNodes({ layer, limit: 50 }));
+  }
+  throw new Error(`Unknown resource: ${uri}`);
+}
+async function readGovernedResource(client2, uri, governanceConfig) {
+  const governance = await checkMcpGovernance(
+    RESOURCE_GOVERNANCE_TOOL,
+    {},
+    { ...governanceConfig, context: { resource_uri: uri } }
+  );
+  if (!governance.allowed) {
+    throw new Error(governance.message);
+  }
+  return readResource(client2, uri);
+}
+
 // src/index.ts
 var API_KEY = process.env.MINDGRAPH_API_KEY;
 var BASE_URL = process.env.MINDGRAPH_BASE_URL || "https://api.mindgraph.cloud";
@@ -1770,7 +1946,7 @@ Capture knowledge when the user shares something worth remembering:
 var server = new import_server.Server(
   {
     name: "mindgraph",
-    version: "0.13.4"
+    version: "0.13.5"
   },
   {
     capabilities: {
@@ -1785,19 +1961,23 @@ server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
   const generated = await getGeneratedTools(client);
   return { tools: [...TOOLS, ...generated.tools] };
 });
+var GOVERNANCE_CONFIG = {
+  baseUrl: BASE_URL,
+  apiKey: API_KEY,
+  orgId: ORG_ID,
+  agentId: AGENT_ID,
+  get disabled() {
+    return process.env.MINDGRAPH_GOVERNANCE === "off";
+  }
+};
 server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
-  const toolArgs = { ...args || {} };
+  const rawArgs = { ...args || {} };
+  const toolArgs = { ...rawArgs };
   if (!toolArgs.agent_id) {
     toolArgs.agent_id = AGENT_ID;
   }
-  const governance = await checkMcpGovernance(name, toolArgs, {
-    baseUrl: BASE_URL,
-    apiKey: API_KEY,
-    orgId: ORG_ID,
-    agentId: AGENT_ID,
-    disabled: process.env.MINDGRAPH_GOVERNANCE === "off"
-  });
+  const governance = await checkMcpGovernance(name, toolArgs, GOVERNANCE_CONFIG);
   if (!governance.allowed) {
     return {
       content: [{ type: "text", text: JSON.stringify({ error: governance.message, ...governance }) }],
@@ -1807,7 +1987,7 @@ server.setRequestHandler(import_types.CallToolRequestSchema, async (request) =>
   const generated = await getGeneratedTools(client);
   const desc = generated.byName.get(name);
   if (desc) {
-    return handleGeneratedTool(client, desc, toolArgs);
+    return handleGeneratedTool(client, desc, rawArgs);
   }
   return handleTool(client, name, toolArgs);
 });
@@ -1968,178 +2148,13 @@ ${conversation}`
   }
 });
 server.setRequestHandler(import_types.ListResourcesRequestSchema, async () => {
-  return {
-    resources: [
-      {
-        uri: "mindgraph://stats",
-        name: "Graph Statistics",
-        description: "Current knowledge graph statistics: node counts, edge counts, and layer distribution",
-        mimeType: "application/json"
-      },
-      {
-        uri: "mindgraph://goals",
-        name: "Active Goals",
-        description: "All active goals in the knowledge graph",
-        mimeType: "application/json"
-      },
-      {
-        uri: "mindgraph://questions",
-        name: "Open Questions",
-        description: "All open questions in the knowledge graph",
-        mimeType: "application/json"
-      },
-      {
-        uri: "mindgraph://contradictions",
-        name: "Contradictions",
-        description: "Contradictory claims in the knowledge graph",
-        mimeType: "application/json"
-      },
-      {
-        uri: "mindgraph://decisions",
-        name: "Open Decisions",
-        description: "Unresolved decisions awaiting resolution",
-        mimeType: "application/json"
-      }
-    ]
-  };
+  return { resources: RESOURCES };
 });
 server.setRequestHandler(import_types.ListResourceTemplatesRequestSchema, async () => {
-  return {
-    resourceTemplates: [
-      {
-        uriTemplate: "mindgraph://node/{uid}",
-        name: "Graph Node",
-        description: "Retrieve a specific node by its UID, including all properties, edges, and version history",
-        mimeType: "application/json"
-      },
-      {
-        uriTemplate: "mindgraph://search/{query}",
-        name: "Search Results",
-        description: "BM25 keyword search across all nodes \u2014 pass 1\u20133 discriminating terms (e.g. 'Kissinger NATO'), not natural language sentences",
-        mimeType: "application/json"
-      },
-      {
-        uriTemplate: "mindgraph://layer/{layer}",
-        name: "Layer Nodes",
-        description: "List all nodes in a specific cognitive layer (reality, epistemic, intent, action, memory, agent)",
-        mimeType: "application/json"
-      }
-    ]
-  };
+  return { resourceTemplates: RESOURCE_TEMPLATES };
 });
 server.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
-  const { uri } = request.params;
-  switch (uri) {
-    case "mindgraph://stats": {
-      const stats = await client.stats();
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(stats, null, 2)
-          }
-        ]
-      };
-    }
-    case "mindgraph://goals": {
-      const goals = await client.getGoals();
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(goals, null, 2)
-          }
-        ]
-      };
-    }
-    case "mindgraph://questions": {
-      const questions = await client.getOpenQuestions();
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(questions, null, 2)
-          }
-        ]
-      };
-    }
-    case "mindgraph://contradictions": {
-      const contradictions = await client.getContradictions();
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(contradictions, null, 2)
-          }
-        ]
-      };
-    }
-    case "mindgraph://decisions": {
-      const decisions = await client.getOpenDecisions();
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(decisions, null, 2)
-          }
-        ]
-      };
-    }
-  }
-  const nodeMatch = uri.match(/^mindgraph:\/\/node\/(.+)$/);
-  if (nodeMatch) {
-    const uid = decodeURIComponent(nodeMatch[1]);
-    const node = await client.getNode(uid);
-    const edges = await client.getEdges({ from_uid: uid });
-    const inEdges = await client.getEdges({ to_uid: uid });
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: JSON.stringify(
-            { node, outgoing_edges: edges, incoming_edges: inEdges },
-            null,
-            2
-          )
-        }
-      ]
-    };
-  }
-  const searchMatch = uri.match(/^mindgraph:\/\/search\/(.+)$/);
-  if (searchMatch) {
-    const query = decodeURIComponent(searchMatch[1]);
-    const results = await client.search(query, { limit: 20 });
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: JSON.stringify(results, null, 2)
-        }
-      ]
-    };
-  }
-  const layerMatch = uri.match(/^mindgraph:\/\/layer\/(.+)$/);
-  if (layerMatch) {
-    const layer = decodeURIComponent(layerMatch[1]);
-    const nodes = await client.getNodes({ layer, limit: 50 });
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: JSON.stringify(nodes, null, 2)
-        }
-      ]
-    };
-  }
-  throw new Error(`Unknown resource: ${uri}`);
+  return readGovernedResource(client, request.params.uri, GOVERNANCE_CONFIG);
 });
 async function main() {
   const transport = new import_stdio.StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindgraph-mcp",
-  "version": "0.13.4",
+  "version": "0.13.5",
   "description": "MCP server for MindGraph — connect Claude Desktop, Claude Code, and any MCP client to your knowledge graph",
   "repository": {
     "type": "git",