mindgraph-mcp 0.23.0 → 0.25.0

package/dist/index.js

@@ -22,30 +22,85 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/index.ts
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_mindgraph3 = require("mindgraph");
-
-// src/hook-env.ts
+// src/call-ledger.ts
 var import_node_crypto = __toESM(require("crypto"));
 var import_node_fs = __toESM(require("fs"));
 var import_node_os = __toESM(require("os"));
 var import_node_path = __toESM(require("path"));
+var TTL_MS = 10 * 6e4;
+function callsDir(options) {
+  return import_node_path.default.join(
+    options.runtimeDir || process.env.MINDGRAPH_RUNTIME_DIR || import_node_path.default.join(import_node_os.default.homedir(), ".mindgraph", "runtime"),
+    "calls"
+  );
+}
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function bareToolName(name) {
+  const cut = name.lastIndexOf("__");
+  return cut === -1 ? name : name.slice(cut + 2);
+}
+function callKey(toolName, toolInput) {
+  return import_node_crypto.default.createHash("sha256").update(`${bareToolName(toolName)}\0${stableJson(toolInput)}`).digest("hex");
+}
+function resolvePendingCall(toolName, toolInput, options = {}) {
+  const now = (options.now ?? Date.now)();
+  const dir = callsDir(options);
+  const prefix = `${callKey(toolName, toolInput)}.`;
+  let names;
+  try {
+    names = import_node_fs.default.readdirSync(dir).filter((name) => name.startsWith(prefix) && name.endsWith(".json"));
+  } catch {
+    return void 0;
+  }
+  let matches = [];
+  for (const name of names) {
+    try {
+      const record = JSON.parse(
+        import_node_fs.default.readFileSync(import_node_path.default.join(dir, name), "utf8")
+      );
+      if (typeof record.createdAt === "number" && now - record.createdAt <= TTL_MS && record.fills && typeof record.fills === "object") {
+        matches.push(record);
+      }
+    } catch {
+    }
+  }
+  if (matches.length > 1) {
+    const projectDir = options.projectDir ?? process.env.CLAUDE_PROJECT_DIR;
+    matches = projectDir ? matches.filter((record) => record.projectDir === projectDir) : [];
+  }
+  return matches.length === 1 ? matches[0].fills : void 0;
+}
+
+// src/index.ts
+var import_stdio = require("@modelcontextprotocol/server/stdio");
+var import_mindgraph3 = require("mindgraph");
+
+// src/hook-env.ts
+var import_node_crypto2 = __toESM(require("crypto"));
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_os2 = __toESM(require("os"));
+var import_node_path2 = __toESM(require("path"));
 function stableAgentId() {
   let user = "user";
   try {
-    user = import_node_os.default.userInfo().username || "user";
+    user = import_node_os2.default.userInfo().username || "user";
   } catch {
   }
-  const digest = import_node_crypto.default.createHash("sha256").update(`${user}@${import_node_os.default.hostname()}`).digest("hex").slice(0, 12);
+  const digest = import_node_crypto2.default.createHash("sha256").update(`${user}@${import_node_os2.default.hostname()}`).digest("hex").slice(0, 12);
   return `u-${digest}`;
 }
 function hookEnvPath(dir) {
-  return import_node_path.default.join(dir || import_node_path.default.join(import_node_os.default.homedir(), ".mindgraph"), "hooks.json");
+  return import_node_path2.default.join(dir || import_node_path2.default.join(import_node_os2.default.homedir(), ".mindgraph"), "hooks.json");
 }
 function loadHookEnv(dir) {
   try {
-    const raw = import_node_fs.default.readFileSync(hookEnvPath(dir), "utf8");
+    const raw = import_node_fs2.default.readFileSync(hookEnvPath(dir), "utf8");
     const parsed = JSON.parse(raw);
     return {
       baseUrl: typeof parsed.baseUrl === "string" ? parsed.baseUrl : void 0,
@@ -61,9 +116,7 @@ function loadHookEnv(dir) {
 }
 
 // src/server.ts
-var import_server = require("@modelcontextprotocol/sdk/server/index.js");
-var import_webStandardStreamableHttp = require("@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js");
-var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_server = require("@modelcontextprotocol/server");
 
 // src/error-detail.ts
 var import_mindgraph = require("mindgraph");
@@ -357,6 +410,14 @@ function hiddenSections(payload) {
 function renderContext(response, maxChars) {
   const payload = obj(response);
   if (!payload) return void 0;
+  if (typeof payload.context_text === "string" && payload.context_text.length > 0) {
+    const text2 = payload.context_text;
+    if (maxChars !== void 0 && text2.length > maxChars) {
+      return `${text2.slice(0, maxChars)}
+[truncated to ${maxChars} characters]`;
+    }
+    return text2;
+  }
   const graph = obj(payload.graph);
   const rawNodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
   const shaped = rawNodes.filter(isNodeShaped);
@@ -579,15 +640,15 @@ function renderTraversal(response, maxChars) {
   const labelByUid = /* @__PURE__ */ new Map();
   for (const node of nodes) labelByUid.set(str(node.uid), str(node.label) || "?");
   if (paths.length > 0) {
-    const items = paths.map((raw) => obj(raw)).filter((path5) => Boolean(path5)).map((path5, index) => {
-      const uids = Array.isArray(path5.node_uids) ? path5.node_uids.map(String) : [];
-      const labels = Array.isArray(path5.labels) ? path5.labels.map(String) : Array.isArray(path5.nodes) ? path5.nodes.map((hop) => {
+    const items = paths.map((raw) => obj(raw)).filter((path6) => Boolean(path6)).map((path6, index) => {
+      const uids = Array.isArray(path6.node_uids) ? path6.node_uids.map(String) : [];
+      const labels = Array.isArray(path6.labels) ? path6.labels.map(String) : Array.isArray(path6.nodes) ? path6.nodes.map((hop) => {
         const hopNode = obj(hop);
         return str(hopNode?.label) || labelByUid.get(str(hopNode?.uid) || "") || str(hop) || "?";
       }) : [];
       const route = labels.length > 0 ? labels.join(" \u2192 ") : uids.join(" \u2192 ") || "(path)";
-      const cost = num(path5.cost) ?? num(path5.path_cost);
-      const confidence = num(path5.path_confidence);
+      const cost = num(path6.cost) ?? num(path6.path_cost);
+      const confidence = num(path6.path_confidence);
       const meta = [
         cost !== void 0 ? `cost ${cost}` : void 0,
         confidence !== void 0 ? `confidence ${confidence}` : void 0
@@ -1589,7 +1650,7 @@ ${conversation}`
 }
 
 // src/memory-tool.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var RESULT_SCHEMA_VERSION = "mindgraph.memory.result.v1";
 var DEFAULT_OUTPUT_CHARS = 8e3;
 var MIN_OUTPUT_CHARS = 512;
@@ -1737,15 +1798,15 @@ function obj2(value) {
 function text(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function stableJson(value) {
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+function stableJson2(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson2).join(",")}]`;
   if (value && typeof value === "object") {
-    return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
+    return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson2(item)}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
 function sha256(value) {
-  return (0, import_node_crypto2.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
 }
 function outputBudget(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_OUTPUT_CHARS;
@@ -2051,7 +2112,7 @@ async function handleMemoryTool(client2, args, config = {}) {
     scope_uids: Array.isArray(args.scope_uids) ? args.scope_uids.map(String) : void 0
   });
   const contextId = `ctx_${sha256(
-    stableJson({ mode, scope, strategy, query: text(args.query), rendered_hash: renderedHash })
+    stableJson2({ mode, scope, strategy, query: text(args.query), rendered_hash: renderedHash })
   ).slice(0, 24)}`;
   const bounded = candidates.length > items.length || rendered2.includes("item(s) omitted");
   const result = {
@@ -2212,15 +2273,15 @@ async function readGovernedResource(client2, uri, governanceConfig, memoryConfig
 }
 
 // src/tools.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 
 // src/codegraph.ts
 var import_node_child_process = require("child_process");
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_os2 = require("os");
-var import_node_path2 = require("path");
-var import_node_crypto3 = require("crypto");
+var import_node_os3 = require("os");
+var import_node_path3 = require("path");
+var import_node_crypto4 = require("crypto");
 var UnknownRepositoryError = class extends Error {
   constructor(repo) {
     super(
@@ -2251,14 +2312,14 @@ function unavailabilityCaveats(reason, message) {
 var DEFAULT_TIMEOUT_MS = 5e3;
 var DEFAULT_STATUS_TTL_MS = 6e4;
 var MAX_OUTPUT_BYTES = 5 * 1024 * 1024;
-function normalizePath(path5) {
-  return path5.replaceAll("\\", "/").replace(/^\.\//, "");
+function normalizePath(path6) {
+  return path6.replaceAll("\\", "/").replace(/^\.\//, "");
 }
 function normalizeSignature(signature) {
   return signature.replace(/\s+/g, " ").trim();
 }
-function languageFromPath(path5) {
-  const extension = (0, import_node_path2.extname)(path5).toLowerCase();
+function languageFromPath(path6) {
+  const extension = (0, import_node_path3.extname)(path6).toLowerCase();
   return {
     ".c": "c",
     ".cc": "cpp",
@@ -2307,30 +2368,30 @@ function normalizeRemote(remote) {
   }
 }
 function pathContains(root, candidate) {
-  const child = (0, import_node_path2.relative)(root, candidate);
-  return child === "" || child !== ".." && !child.startsWith(`..${import_node_path2.sep}`) && !(0, import_node_path2.isAbsolute)(child);
+  const child = (0, import_node_path3.relative)(root, candidate);
+  return child === "" || child !== ".." && !child.startsWith(`..${import_node_path3.sep}`) && !(0, import_node_path3.isAbsolute)(child);
 }
 function nearestExistingDirectory(candidate) {
-  let current = (0, import_node_path2.resolve)(candidate);
+  let current = (0, import_node_path3.resolve)(candidate);
   for (; ; ) {
-    if ((0, import_node_fs2.existsSync)(current)) {
+    if ((0, import_node_fs3.existsSync)(current)) {
       try {
-        return (0, import_node_fs2.statSync)(current).isDirectory() ? current : (0, import_node_path2.dirname)(current);
+        return (0, import_node_fs3.statSync)(current).isDirectory() ? current : (0, import_node_path3.dirname)(current);
       } catch {
       }
     }
-    const parent = (0, import_node_path2.dirname)(current);
+    const parent = (0, import_node_path3.dirname)(current);
     if (parent === current) return current;
     current = parent;
   }
 }
 function findWorkspaceFile(start, explicit) {
-  if (explicit) return (0, import_node_path2.resolve)(start, explicit);
-  let current = (0, import_node_path2.resolve)(start);
+  if (explicit) return (0, import_node_path3.resolve)(start, explicit);
+  let current = (0, import_node_path3.resolve)(start);
   for (; ; ) {
-    const candidate = (0, import_node_path2.join)(current, ".mindgraph", "workspace.json");
-    if ((0, import_node_fs2.existsSync)(candidate)) return candidate;
-    const parent = (0, import_node_path2.dirname)(current);
+    const candidate = (0, import_node_path3.join)(current, ".mindgraph", "workspace.json");
+    if ((0, import_node_fs3.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path3.dirname)(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -2417,7 +2478,7 @@ var CodegraphAdapter = class {
   async resolveRepository(repo, fallbackSpaceUid) {
     const configured = await this.resolveRepositories(fallbackSpaceUid);
     const selected = repo && configured.find((candidate) => candidate.repoId === repo) || repo && configured.find(
-      (candidate) => candidate.repoRoot === repo || (0, import_node_path2.basename)(candidate.repoRoot) === repo
+      (candidate) => candidate.repoRoot === repo || (0, import_node_path3.basename)(candidate.repoRoot) === repo
     ) || (!repo ? [...configured].sort((a, b) => b.repoRoot.length - a.repoRoot.length).find((candidate) => pathContains(candidate.repoRoot, this.cwd)) : void 0) || (!repo && configured.length === 1 ? configured[0] : void 0);
     if (selected) {
       return !repo && this.env.MINDGRAPH_REPO_ID ? this.resolveRepositoryIdentity(
@@ -2427,10 +2488,10 @@ var CodegraphAdapter = class {
       ) : selected;
     }
     if (repo) {
-      const requestedPath = await (0, import_promises.realpath)((0, import_node_path2.resolve)(this.cwd, repo)).catch(
-        () => (0, import_node_path2.resolve)(this.cwd, repo)
+      const requestedPath = await (0, import_promises.realpath)((0, import_node_path3.resolve)(this.cwd, repo)).catch(
+        () => (0, import_node_path3.resolve)(this.cwd, repo)
       );
-      if (!(0, import_node_fs2.existsSync)(requestedPath)) {
+      if (!(0, import_node_fs3.existsSync)(requestedPath)) {
         const current = await this.currentRepository(fallbackSpaceUid);
         if (current.repoId === repo) return current;
         throw new UnknownRepositoryError(repo);
@@ -2446,8 +2507,8 @@ var CodegraphAdapter = class {
   }
   async currentRepository(fallbackSpaceUid) {
     const requestedRoot = this.env.MINDGRAPH_REPO_ROOT || this.cwd;
-    const requestedPath = await (0, import_promises.realpath)((0, import_node_path2.resolve)(this.cwd, requestedRoot)).catch(
-      () => (0, import_node_path2.resolve)(this.cwd, requestedRoot)
+    const requestedPath = await (0, import_promises.realpath)((0, import_node_path3.resolve)(this.cwd, requestedRoot)).catch(
+      () => (0, import_node_path3.resolve)(this.cwd, requestedRoot)
     );
     const repoRoot = await this.gitRoot(requestedPath) ?? requestedPath;
     return this.resolveRepositoryIdentity(
@@ -2468,7 +2529,7 @@ var CodegraphAdapter = class {
     );
   }
   async resolveRepositoryIdentity(root, explicitRepoId, spaceUid) {
-    const repoRoot = await (0, import_promises.realpath)(root).catch(() => (0, import_node_path2.resolve)(root));
+    const repoRoot = await (0, import_promises.realpath)(root).catch(() => (0, import_node_path3.resolve)(root));
     const cacheKey = `${repoRoot}\0${explicitRepoId ?? ""}\0${spaceUid ?? ""}`;
     const cached = this.identityCache.get(cacheKey);
     if (cached) return cached;
@@ -2498,20 +2559,20 @@ var CodegraphAdapter = class {
       this.env
     ).catch(() => "");
     if (!rawCommonDir.trim()) {
-      return `local:${(0, import_node_path2.basename)(repoRoot)}`;
+      return `local:${(0, import_node_path3.basename)(repoRoot)}`;
     }
-    const commonDir = (0, import_node_path2.resolve)(repoRoot, rawCommonDir.trim());
-    const identityDir = (0, import_node_path2.join)(commonDir, "mindgraph");
-    const identityFile = (0, import_node_path2.join)(identityDir, "repository-id");
+    const commonDir = (0, import_node_path3.resolve)(repoRoot, rawCommonDir.trim());
+    const identityDir = (0, import_node_path3.join)(commonDir, "mindgraph");
+    const identityFile = (0, import_node_path3.join)(identityDir, "repository-id");
     try {
-      const existing = (0, import_node_fs2.readFileSync)(identityFile, "utf8").trim();
+      const existing = (0, import_node_fs3.readFileSync)(identityFile, "utf8").trim();
       if (existing) return existing;
     } catch {
     }
-    (0, import_node_fs2.mkdirSync)(identityDir, { recursive: true, mode: 448 });
-    const generated = (0, import_node_crypto3.randomUUID)();
+    (0, import_node_fs3.mkdirSync)(identityDir, { recursive: true, mode: 448 });
+    const generated = (0, import_node_crypto4.randomUUID)();
     try {
-      (0, import_node_fs2.writeFileSync)(identityFile, `${generated}
+      (0, import_node_fs3.writeFileSync)(identityFile, `${generated}
 `, {
         encoding: "utf8",
         flag: "wx",
@@ -2520,7 +2581,7 @@ var CodegraphAdapter = class {
       return generated;
     } catch (cause) {
       if (cause.code !== "EEXIST") throw cause;
-      const winner = (0, import_node_fs2.readFileSync)(identityFile, "utf8").trim();
+      const winner = (0, import_node_fs3.readFileSync)(identityFile, "utf8").trim();
       if (!winner) throw new Error(`empty repository identity file: ${identityFile}`);
       return winner;
     }
@@ -2533,12 +2594,12 @@ var CodegraphAdapter = class {
       Math.min(this.timeoutMs, 2e3),
       this.env
     ).catch(() => "");
-    return raw.trim() ? (0, import_node_path2.resolve)(start, raw.trim()) : void 0;
+    return raw.trim() ? (0, import_node_path3.resolve)(start, raw.trim()) : void 0;
   }
   /** Why the workspace map yielded no repositories — for callers that were
    * explicitly asked to fan out and would otherwise return silently empty. */
   workspaceDiagnostic() {
-    if (!this.workspaceFile || !(0, import_node_fs2.existsSync)(this.workspaceFile)) {
+    if (!this.workspaceFile || !(0, import_node_fs3.existsSync)(this.workspaceFile)) {
       return "no .mindgraph/workspace.json was found between the working directory and the filesystem root";
     }
     return `${this.workspaceFile} is malformed or declares no repositories`;
@@ -2658,7 +2719,7 @@ var CodegraphAdapter = class {
       return this.resolveRepository(ref.repo || defaultRepo, fallbackSpaceUid);
     }
     if (ref.path) {
-      const requested = (0, import_node_path2.isAbsolute)(ref.path) ? (0, import_node_path2.resolve)(ref.path) : (0, import_node_path2.resolve)(this.cwd, ref.path);
+      const requested = (0, import_node_path3.isAbsolute)(ref.path) ? (0, import_node_path3.resolve)(ref.path) : (0, import_node_path3.resolve)(this.cwd, ref.path);
       const absolute = await (0, import_promises.realpath)(requested).catch(() => requested);
       const configured = await this.resolveRepositories(fallbackSpaceUid);
       const defining = [...configured].sort((a, b) => b.repoRoot.length - a.repoRoot.length).find((candidate) => pathContains(candidate.repoRoot, absolute));
@@ -2735,19 +2796,19 @@ var CodegraphAdapter = class {
   }
   configuredRepositories() {
     const configured = [];
-    if (this.workspaceFile && (0, import_node_fs2.existsSync)(this.workspaceFile)) {
+    if (this.workspaceFile && (0, import_node_fs3.existsSync)(this.workspaceFile)) {
       try {
         const parsed = JSON.parse(
-          (0, import_node_fs2.readFileSync)(this.workspaceFile, "utf8")
+          (0, import_node_fs3.readFileSync)(this.workspaceFile, "utf8")
         );
         if (parsed.v === 1 && Array.isArray(parsed.repositories)) {
-          const configDirectory = (0, import_node_path2.dirname)(this.workspaceFile);
-          const base = (0, import_node_path2.basename)(configDirectory) === ".mindgraph" ? (0, import_node_path2.dirname)(configDirectory) : configDirectory;
+          const configDirectory = (0, import_node_path3.dirname)(this.workspaceFile);
+          const base = (0, import_node_path3.basename)(configDirectory) === ".mindgraph" ? (0, import_node_path3.dirname)(configDirectory) : configDirectory;
           for (const repository of parsed.repositories) {
             if (!repository || typeof repository.root !== "string") continue;
             configured.push({
               repoId: typeof repository.repo_id === "string" ? repository.repo_id : void 0,
-              repoRoot: (0, import_node_path2.resolve)(base, repository.root),
+              repoRoot: (0, import_node_path3.resolve)(base, repository.root),
               spaceUid: typeof repository.space_uid === "string" ? repository.space_uid : void 0
             });
           }
@@ -2762,7 +2823,7 @@ var CodegraphAdapter = class {
         for (const [repoId, config] of Object.entries(parsed)) {
           configured.push({
             repoId,
-            repoRoot: (0, import_node_path2.resolve)(
+            repoRoot: (0, import_node_path3.resolve)(
               this.cwd,
               typeof config === "string" ? config : config.root
             ),
@@ -2790,9 +2851,9 @@ var CodegraphAdapter = class {
       const hits = await this.runJson(args);
       let candidates = hits.map(asNode).map(toCandidate).filter((item) => item !== null);
       if (ref.path) {
-        const absolutePath = (0, import_node_path2.isAbsolute)(ref.path) ? await (0, import_promises.realpath)(ref.path).catch(() => ref.path) : void 0;
+        const absolutePath = (0, import_node_path3.isAbsolute)(ref.path) ? await (0, import_promises.realpath)(ref.path).catch(() => ref.path) : void 0;
         const wanted = normalizePath(
-          absolutePath ? (0, import_node_path2.relative)(repository.repoRoot, absolutePath) : ref.path
+          absolutePath ? (0, import_node_path3.relative)(repository.repoRoot, absolutePath) : ref.path
         );
         candidates = candidates.filter((candidate) => candidate.path === wanted);
       }
@@ -2893,7 +2954,7 @@ var CodegraphAdapter = class {
     const candidates = [
       this.env.MINDGRAPH_CODEGRAPH_BIN,
       "codegraph",
-      (0, import_node_path2.resolve)((0, import_node_os2.homedir)(), ".local", "bin", "codegraph")
+      (0, import_node_path3.resolve)((0, import_node_os3.homedir)(), ".local", "bin", "codegraph")
     ].filter((candidate, index, all) => {
       return Boolean(candidate) && all.indexOf(candidate) === index;
     });
@@ -3494,9 +3555,9 @@ function primaryUids(value) {
 }
 
 // src/sync-tool.ts
-var import_node_crypto4 = __toESM(require("crypto"));
-var import_node_fs3 = __toESM(require("fs"));
-var import_node_path3 = __toESM(require("path"));
+var import_node_crypto5 = __toESM(require("crypto"));
+var import_node_fs4 = __toESM(require("fs"));
+var import_node_path4 = __toESM(require("path"));
 var ok3 = (data) => ({
   content: [{ type: "text", text: JSON.stringify(data) }]
 });
@@ -3573,12 +3634,12 @@ var SYNC_TOOL = {
   }
 };
 function safePath(root, candidate) {
-  const absolute = import_node_path3.default.resolve(root, candidate);
-  const relative2 = import_node_path3.default.relative(root, absolute);
-  if (relative2.startsWith("..") || import_node_path3.default.isAbsolute(relative2)) {
+  const absolute = import_node_path4.default.resolve(root, candidate);
+  const relative2 = import_node_path4.default.relative(root, absolute);
+  if (relative2.startsWith("..") || import_node_path4.default.isAbsolute(relative2)) {
     throw new Error(`path escapes repository root: ${candidate}`);
   }
-  if (import_node_fs3.default.existsSync(absolute)) {
+  if (import_node_fs4.default.existsSync(absolute)) {
     if (!pathContains(realPathOf(root), realPathOf(absolute))) {
       throw new Error(`path escapes repository root via symlink: ${candidate}`);
     }
@@ -3587,26 +3648,26 @@ function safePath(root, candidate) {
 }
 function realPathOf(target) {
   try {
-    return import_node_fs3.default.realpathSync(target);
+    return import_node_fs4.default.realpathSync(target);
   } catch {
-    return import_node_path3.default.resolve(target);
+    return import_node_path4.default.resolve(target);
   }
 }
 function markdownFiles(target, realRoot, visited = /* @__PURE__ */ new Set()) {
-  if (!import_node_fs3.default.existsSync(target)) return [];
+  if (!import_node_fs4.default.existsSync(target)) return [];
   const real = realPathOf(target);
   if (!pathContains(realRoot, real)) return [];
-  const stat = import_node_fs3.default.statSync(target);
+  const stat = import_node_fs4.default.statSync(target);
   if (stat.isFile()) return target.endsWith(".md") ? [target] : [];
   if (!stat.isDirectory() || visited.has(real)) return [];
   visited.add(real);
-  return import_node_fs3.default.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(import_node_path3.default.join(target, entry.name), realRoot, visited));
+  return import_node_fs4.default.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(import_node_path4.default.join(target, entry.name), realRoot, visited));
 }
 function fileDescriptor(root, absolute) {
-  const content = import_node_fs3.default.readFileSync(absolute, "utf8");
+  const content = import_node_fs4.default.readFileSync(absolute, "utf8");
   return {
-    logical_path: import_node_path3.default.relative(root, absolute).split(import_node_path3.default.sep).join("/"),
-    content_hash: import_node_crypto4.default.createHash("sha256").update(content).digest("hex"),
+    logical_path: import_node_path4.default.relative(root, absolute).split(import_node_path4.default.sep).join("/"),
+    content_hash: import_node_crypto5.default.createHash("sha256").update(content).digest("hex"),
     bytes: Buffer.byteLength(content),
     content
   };
@@ -3675,7 +3736,7 @@ async function handleSyncTool(client2, args) {
     }
     if (action === "status" && request.logical_path && request.file_present !== false) {
       const absolute = safePath(root, String(request.logical_path));
-      request.file_present = import_node_fs3.default.existsSync(absolute);
+      request.file_present = import_node_fs4.default.existsSync(absolute);
       if (request.file_present && !request.content_hash) {
         request.content_hash = fileDescriptor(root, absolute).content_hash;
       }
@@ -3748,10 +3809,10 @@ var RESOLUTION_PROPERTIES = {
     description: "Alias for confirm_new on a near-duplicate response"
   }
 };
-function stableJson2(value) {
-  if (Array.isArray(value)) return `[${value.map(stableJson2).join(",")}]`;
+function stableJson3(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson3).join(",")}]`;
   if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson2(item)}`).join(",")}}`;
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson3(item)}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
@@ -3765,8 +3826,8 @@ function defaultWriteIdempotencyKey(tool, args) {
       ([key]) => key !== "invocation_context" && key !== "idempotency_key"
     )
   );
-  return (0, import_node_crypto5.createHash)("sha256").update(
-    stableJson2({
+  return (0, import_node_crypto6.createHash)("sha256").update(
+    stableJson3({
       harness_session_id: sessionId,
       harness_turn_id: context?.harnessTurnId ?? null,
       tool,
@@ -4478,6 +4539,15 @@ var TOOLS = [
           type: "string",
           description: "ISO-8601 date (e.g. '2021-06') for context: nodes with validity windows are annotated as of this date instead of today"
         },
+        as_of: {
+          type: "string",
+          description: "ISO-8601 date for context: answer with what had been STATED by this date (a node is admitted when one of its sources was stated on or before it; fact dates never exclude it). Use for 'what did we know / what was the value as of <date>' questions."
+        },
+        retrieval_mode: {
+          type: "string",
+          enum: ["normal", "exhaustive"],
+          description: "context: 'exhaustive' widens retrieval for list/count questions ('how many different \u2026 across', 'what two \u2026'); omitted lets the server's cue decide."
+        },
         created_after: {
           type: "number",
           description: "Unix seconds \u2014 'recent' action: only nodes ingested after this time"
@@ -5706,6 +5776,8 @@ async function handleRetrieve(client2, args, profile) {
     salience_min,
     article_limit,
     valid_at,
+    as_of,
+    retrieval_mode,
     created_after,
     created_before,
     explain,
@@ -5734,9 +5806,15 @@ async function handleRetrieve(client2, args, profile) {
           // the advertised knob must not get a silent no-op).
           ...article_limit !== void 0 ? { article_limit } : include_documents === false || profile === "coding" && !include_documents ? { article_limit: 0 } : {},
           valid_at,
+          as_of,
+          retrieval_mode,
           include_graph,
           graph_expansion_limit: graph_expansion_limit ?? 3,
-          graph_max_depth: graph_max_depth ?? 2
+          graph_max_depth: graph_max_depth ?? 2,
+          // Evidence plan R2: the server's canonical rendering under a token
+          // budget derived from the character budget; the local renderer is
+          // the fallback for servers that predate it.
+          ...format === "json" ? {} : { format: "text", max_tokens: Math.max(256, Math.floor((max_output_chars ?? 24e3) / 4)) }
         }),
         (raw) => renderContext(raw, max_output_chars)
       );
@@ -6190,14 +6268,14 @@ async function handleOntology(client2, args) {
 // src/server.ts
 function buildMindGraphServer(wiring) {
   const { client: client2, hosted } = wiring;
-  const server2 = new import_server.Server(
+  const server = new import_server.Server(
     { name: "mindgraph", version: wiring.serverVersion },
     {
       capabilities: { tools: {}, resources: {}, prompts: {} },
       instructions: wiring.instructions
     }
   );
-  server2.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+  server.setRequestHandler("tools/list", async () => {
     const generated = await getGeneratedTools(client2, wiring.generatedTools);
     const tools = [...toolsForProfile(wiring.profile), ...generated.tools];
     if (!hosted) return { tools };
@@ -6208,9 +6286,14 @@ function buildMindGraphServer(wiring) {
       ]
     };
   });
-  server2.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+  server.setRequestHandler("tools/call", async (request) => {
     const { name, arguments: args } = request.params;
-    const rawArgs = { ...args || {} };
+    const rawArgs = {
+      ...args || {},
+      // H1: session, lease and invocation fields the local hook recorded for
+      // this exact call (stdio only; hosted mode has no local hook).
+      ...hosted ? {} : wiring.resolveHookFields?.(name, args || {})
+    };
     const toolArgs = { ...rawArgs };
     let governanceConfig = wiring.governance;
     if (hosted) {
@@ -6250,20 +6333,20 @@ function buildMindGraphServer(wiring) {
     }
     return handleTool(client2, name, toolArgs, wiring.memory);
   });
-  server2.setRequestHandler(import_types.ListPromptsRequestSchema, async () => {
+  server.setRequestHandler("prompts/list", async () => {
     return { prompts: PROMPTS };
   });
-  server2.setRequestHandler(import_types.GetPromptRequestSchema, async (request) => {
+  server.setRequestHandler("prompts/get", async (request) => {
     const { name, arguments: args } = request.params;
     return getPrompt(name, args);
   });
-  server2.setRequestHandler(import_types.ListResourcesRequestSchema, async () => {
+  server.setRequestHandler("resources/list", async () => {
     return { resources: RESOURCES };
   });
-  server2.setRequestHandler(import_types.ListResourceTemplatesRequestSchema, async () => {
+  server.setRequestHandler("resources/templates/list", async () => {
     return { resourceTemplates: RESOURCE_TEMPLATES };
   });
-  server2.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
+  server.setRequestHandler("resources/read", async (request) => {
     return readGovernedResource(
       client2,
       request.params.uri,
@@ -6271,20 +6354,20 @@ function buildMindGraphServer(wiring) {
       wiring.memory
     );
   });
-  return server2;
+  return server;
 }
 
 // src/index.ts
-var import_node_path5 = __toESM(require("path"));
+var import_node_path6 = __toESM(require("path"));
 
 // src/hook-installer.ts
-var import_node_fs4 = __toESM(require("fs"));
-var import_node_os3 = __toESM(require("os"));
-var import_node_path4 = __toESM(require("path"));
-var import_node_crypto6 = __toESM(require("crypto"));
+var import_node_fs5 = __toESM(require("fs"));
+var import_node_os4 = __toESM(require("os"));
+var import_node_path5 = __toESM(require("path"));
+var import_node_crypto7 = __toESM(require("crypto"));
 function storedFeatures(homeDir) {
   const { promptRecall, capture } = loadHookEnv(
-    import_node_path4.default.join(homeDir || import_node_os3.default.homedir(), ".mindgraph")
+    import_node_path5.default.join(homeDir || import_node_os4.default.homedir(), ".mindgraph")
   );
   return { promptRecall, capture };
 }
@@ -6298,24 +6381,24 @@ function windowsCommand(harness) {
 }
 var RUNNER_VERSION_RELATIVE = `${RUNNER_RELATIVE}.version`;
 function installHookRunner(sourceFile, homeDir, version) {
-  const target = import_node_path4.default.join(homeDir || import_node_os3.default.homedir(), RUNNER_RELATIVE);
-  import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(target), { recursive: true });
-  const temporary = `${target}.${process.pid}.${import_node_crypto6.default.randomUUID()}.tmp`;
-  import_node_fs4.default.copyFileSync(sourceFile, temporary);
-  import_node_fs4.default.renameSync(temporary, target);
-  const versionPath = import_node_path4.default.join(homeDir || import_node_os3.default.homedir(), RUNNER_VERSION_RELATIVE);
+  const target = import_node_path5.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_RELATIVE);
+  import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(target), { recursive: true });
+  const temporary = `${target}.${process.pid}.${import_node_crypto7.default.randomUUID()}.tmp`;
+  import_node_fs5.default.copyFileSync(sourceFile, temporary);
+  import_node_fs5.default.renameSync(temporary, target);
+  const versionPath = import_node_path5.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_VERSION_RELATIVE);
   if (version) {
-    import_node_fs4.default.writeFileSync(versionPath, `${version}
+    import_node_fs5.default.writeFileSync(versionPath, `${version}
 `);
   } else {
-    import_node_fs4.default.rmSync(versionPath, { force: true });
+    import_node_fs5.default.rmSync(versionPath, { force: true });
   }
   return target;
 }
 function installedHookRunnerVersion(homeDir) {
   try {
-    const raw = import_node_fs4.default.readFileSync(
-      import_node_path4.default.join(homeDir || import_node_os3.default.homedir(), RUNNER_VERSION_RELATIVE),
+    const raw = import_node_fs5.default.readFileSync(
+      import_node_path5.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_VERSION_RELATIVE),
       "utf8"
     ).trim();
     return raw || void 0;
@@ -6340,22 +6423,22 @@ function refreshHookRunner(serverVersion, sourceBundle, homeDir) {
     if (process.env.MINDGRAPH_HOOK_AUTOUPDATE === "off") {
       return { refreshed: false, reason: "disabled" };
     }
-    const home = homeDir || import_node_os3.default.homedir();
-    if (!import_node_fs4.default.existsSync(import_node_path4.default.join(home, RUNNER_RELATIVE))) {
+    const home = homeDir || import_node_os4.default.homedir();
+    if (!import_node_fs5.default.existsSync(import_node_path5.default.join(home, RUNNER_RELATIVE))) {
       return { refreshed: false, reason: "no_runner" };
     }
-    if (!import_node_fs4.default.existsSync(sourceBundle)) {
+    if (!import_node_fs5.default.existsSync(sourceBundle)) {
       return { refreshed: false, reason: "no_source" };
     }
-    const server2 = parseSemver(serverVersion);
-    if (!server2) return { refreshed: false, reason: "unparseable" };
+    const server = parseSemver(serverVersion);
+    if (!server) return { refreshed: false, reason: "unparseable" };
     const runnerVersion = installedHookRunnerVersion(home);
     if (runnerVersion !== void 0) {
       const pinned = parseSemver(runnerVersion);
       if (!pinned) {
         return { refreshed: false, reason: "unparseable", runnerVersion };
       }
-      if (!semverNewer(server2, pinned)) {
+      if (!semverNewer(server, pinned)) {
         return {
           refreshed: false,
           reason: runnerVersion === serverVersion ? "current" : "downgrade",
@@ -6375,8 +6458,8 @@ function refreshOwnedClaudeHooks(projectDir = process.cwd(), homeDir) {
   for (const scope of scopes) {
     try {
       const file = settingsPath("claude-code", scope, projectDir, void 0, homeDir);
-      if (!import_node_fs4.default.existsSync(file)) continue;
-      if (!import_node_fs4.default.readFileSync(file, "utf8").includes(OWNER_MARKER)) continue;
+      if (!import_node_fs5.default.existsSync(file)) continue;
+      if (!import_node_fs5.default.readFileSync(file, "utf8").includes(OWNER_MARKER)) continue;
       installHooks(
         "claude-code",
         scope,
@@ -6396,15 +6479,15 @@ function versionSkewNote(serverVersion, homeDir) {
   if (!runnerVersion || runnerVersion === serverVersion) return void 0;
   return `NOTE: the installed MindGraph hook runner is v${runnerVersion} but this MCP server is v${serverVersion} \u2014 hook behavior and tool contracts may be out of sync. Tell the user to run: npx -y mindgraph-mcp@latest install-hooks (refreshes the pinned runner).`;
 }
-function settingsPath(harness, scope, projectDir = process.cwd(), codexHomeDir = process.env.CODEX_HOME || import_node_path4.default.join(import_node_os3.default.homedir(), ".codex"), homeDir) {
+function settingsPath(harness, scope, projectDir = process.cwd(), codexHomeDir = process.env.CODEX_HOME || import_node_path5.default.join(import_node_os4.default.homedir(), ".codex"), homeDir) {
   if (harness === "codex") {
-    return scope === "user" ? import_node_path4.default.join(codexHomeDir, "hooks.json") : import_node_path4.default.join(projectDir, ".codex", "hooks.json");
+    return scope === "user" ? import_node_path5.default.join(codexHomeDir, "hooks.json") : import_node_path5.default.join(projectDir, ".codex", "hooks.json");
   }
-  return scope === "user" ? import_node_path4.default.join(homeDir || import_node_os3.default.homedir(), ".claude", "settings.json") : import_node_path4.default.join(projectDir, ".claude", "settings.json");
+  return scope === "user" ? import_node_path5.default.join(homeDir || import_node_os4.default.homedir(), ".claude", "settings.json") : import_node_path5.default.join(projectDir, ".claude", "settings.json");
 }
 function readSettings(file) {
-  if (!import_node_fs4.default.existsSync(file)) return {};
-  return JSON.parse(import_node_fs4.default.readFileSync(file, "utf8"));
+  if (!import_node_fs5.default.existsSync(file)) return {};
+  return JSON.parse(import_node_fs5.default.readFileSync(file, "utf8"));
 }
 function ownedHook(harness, timeout, additionalContextLimit) {
   return {
@@ -6416,6 +6499,7 @@ function ownedHook(harness, timeout, additionalContextLimit) {
     ...additionalContextLimit === void 0 ? {} : { additionalContextLimit }
   };
 }
+var CLAUDE_POST_TOOL_MATCHER = "mcp__mindgraph__.*|Edit|MultiEdit|Write|NotebookEdit|Bash|Task|Agent";
 function desiredEntries(harness, features = {}) {
   const common = {
     SessionStart: [
@@ -6448,7 +6532,17 @@ function desiredEntries(harness, features = {}) {
     ],
     // PostToolUse awaits the lease renewal round-trip, which fires exactly
     // when the tenant is cold (post-idle reclaim) — 5s killed it mid-claim.
-    PostToolUse: [{ matcher: ".*", hooks: [ownedHook(harness, 10)] }],
+    // Claude Code: only the tools the hook acts on (MindGraph calls, edits,
+    // and the shell/agent calls that keep a lease alive). Read, Grep and Glob
+    // are most of a session's tool calls and the hook did nothing useful for
+    // them but start a process (roadmap H8). Codex names its tools
+    // differently, so it keeps the catch-all.
+    PostToolUse: [
+      {
+        matcher: harness === "claude-code" ? CLAUDE_POST_TOOL_MATCHER : ".*",
+        hooks: [ownedHook(harness, 10)]
+      }
+    ],
     Stop: [{ hooks: [ownedHook(harness, 5)] }],
     // SessionEnd makes up to two sequential cloud calls (abandon_iteration +
     // session close) — the SAME cold-tenant latency SessionStart needs 30s
@@ -6482,13 +6576,13 @@ function entryHasOwnedHook(value) {
   return Array.isArray(hooks) && hooks.some((hook) => hookCommand(hook)?.includes(OWNER_MARKER));
 }
 function writeSettings(file, settings) {
-  import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
-  const temporary = `${file}.${process.pid}.${import_node_crypto6.default.randomUUID()}.tmp`;
-  import_node_fs4.default.writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}
+  import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${import_node_crypto7.default.randomUUID()}.tmp`;
+  import_node_fs5.default.writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}
 `, {
     mode: 384
   });
-  import_node_fs4.default.renameSync(temporary, file);
+  import_node_fs5.default.renameSync(temporary, file);
 }
 function installHooks(harness, scope, projectDir = process.cwd(), codexHomeDir, homeDir, features = {}) {
   const file = settingsPath(harness, scope, projectDir, codexHomeDir, homeDir);
@@ -6613,7 +6707,7 @@ if (PROFILE === "coding") {
 - Capture corrections, decisions with rationale, fixes that survived meaningful failed attempts, durable invariants/preferences, and blockers with evidence.
 - If a write returns \`near_duplicate\`, choose \`reuse_uid\` or \`supersedes_uid\`; use \`confirm_new\` only for genuinely distinct facts.
 - Do not capture routine mechanics, transient command output, facts cheaply derivable from code, unsupported speculation as high-confidence lessons, or completion without evidence.
-- Adapter context is owned by ${HARNESS}; omit invocation_context because hooks replace it.`;
+- Adapter context is owned by ${HARNESS}; omit invocation_context because the adapter supplies it.`;
 } else {
   INSTRUCTIONS = INSTRUCTIONS.split("\n").filter(
     (line) => !line.includes("mindgraph_code") && !line.includes("`code`") && !line.includes("Typed code anchors")
@@ -6621,7 +6715,7 @@ if (PROFILE === "coding") {
 }
 var RUNNER_REFRESH = (() => {
   try {
-    return refreshHookRunner("0.23.0", import_node_path5.default.join(__dirname, "cli.js"));
+    return refreshHookRunner("0.25.0", import_node_path6.default.join(__dirname, "cli.js"));
   } catch {
     return void 0;
   }
@@ -6635,12 +6729,12 @@ if (RUNNER_REFRESH?.refreshed) {
     }
   })();
   console.error(
-    `[mindgraph-mcp] refreshed pinned hook runner ${RUNNER_REFRESH.runnerVersion ? `v${RUNNER_REFRESH.runnerVersion}` : "(pre-sidecar)"} \u2192 v${"0.23.0"}` + (refreshedSettings.length > 0 ? `; refreshed owned hook entries in ${refreshedSettings.join(", ")}` : "")
+    `[mindgraph-mcp] refreshed pinned hook runner ${RUNNER_REFRESH.runnerVersion ? `v${RUNNER_REFRESH.runnerVersion}` : "(pre-sidecar)"} \u2192 v${"0.25.0"}` + (refreshedSettings.length > 0 ? `; refreshed owned hook entries in ${refreshedSettings.join(", ")}` : "")
   );
 }
 var HOOK_SKEW_NOTE = (() => {
   try {
-    return versionSkewNote("0.23.0");
+    return versionSkewNote("0.25.0");
   } catch {
     return void 0;
   }
@@ -6661,27 +6755,29 @@ var GOVERNANCE_CONFIG = {
   }
 };
 var MEMORY_RUNTIME_CONFIG = {
-  serverVersion: "0.23.0",
+  serverVersion: "0.25.0",
   baseUrl: BASE_URL,
   profile: PROFILE,
   harness: HARNESS,
   orgId: ORG_ID,
   agentId: AGENT_ID
 };
-var server = buildMindGraphServer({
+var buildServer = () => buildMindGraphServer({
   client,
-  serverVersion: "0.23.0",
+  serverVersion: "0.25.0",
   instructions: INSTRUCTIONS,
   profile: PROFILE,
   agentId: AGENT_ID,
   governance: GOVERNANCE_CONFIG,
-  memory: MEMORY_RUNTIME_CONFIG
+  memory: MEMORY_RUNTIME_CONFIG,
+  resolveHookFields: (name, args) => resolvePendingCall(name, args)
 });
 async function main() {
-  const transport = new import_stdio.StdioServerTransport();
-  await server.connect(transport);
+  (0, import_stdio.serveStdio)(buildServer, {
+    onerror: (error2) => console.error("MindGraph MCP transport error:", error2.message)
+  });
   console.error(
-    `MindGraph MCP server v${"0.23.0"} running on stdio (${BASE_URL})`
+    `MindGraph MCP server v${"0.25.0"} running on stdio (${BASE_URL})`
   );
 }
 main().catch((error2) => {