mindgraph-mcp 0.23.0 → 0.25.0

package/dist/cli.js

@@ -35,14 +35,14 @@ function errorFields(body) {
     ...typeof fields.retriable === "boolean" ? { retriable: fields.retriable } : {}
   };
 }
-function canRetryRequest(method, path8, body) {
+function canRetryRequest(method, path9, body) {
   if (method === "GET" || method === "HEAD") return true;
   if (method !== "POST") return false;
-  if (READ_POSTS.has(path8)) return true;
+  if (READ_POSTS.has(path9)) return true;
   const fields = body && typeof body === "object" && !Array.isArray(body) ? body : {};
   if (typeof fields.action !== "string") return false;
-  if (Object.prototype.hasOwnProperty.call(READ_ACTIONS, path8) && READ_ACTIONS[path8].includes(fields.action)) return true;
-  return path8 === "/agent/plan" && IDEMPOTENT_WORK.has(fields.action) && typeof fields.idempotency_key === "string" && fields.idempotency_key.trim().length > 0;
+  if (Object.prototype.hasOwnProperty.call(READ_ACTIONS, path9) && READ_ACTIONS[path9].includes(fields.action)) return true;
+  return path9 === "/agent/plan" && IDEMPOTENT_WORK.has(fields.action) && typeof fields.idempotency_key === "string" && fields.idempotency_key.trim().length > 0;
 }
 function permitsRetry(fields) {
   return fields.retriable !== false && ![
@@ -179,8 +179,8 @@ var init_dist = __esm({
         }
       }
       // ---- HTTP helpers ----
-      async request(method, path8, body) {
-        const url = `${this.baseUrl}${path8}`;
+      async request(method, path9, body) {
+        const url = `${this.baseUrl}${path9}`;
         const requestId = createRequestId();
         const init = {
           method,
@@ -195,12 +195,12 @@ var init_dist = __esm({
         }
         const retrySafe = canRetryRequest(
           method,
-          path8,
+          path9,
           typeof init.body === "string" ? JSON.parse(init.body) : void 0
         );
         let lastError;
         for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-          const res = await this.fetchWithDeadline(url, init, method, path8);
+          const res = await this.fetchWithDeadline(url, init, method, path9);
           if (!res.ok) {
             const text22 = await res.text().catch(() => "");
             let parsed;
@@ -210,7 +210,7 @@ var init_dist = __esm({
               parsed = text22;
             }
             const err6 = new MindGraphError(
-              `${method} ${path8} failed: ${res.status}`,
+              `${method} ${path9} failed: ${res.status}`,
               res.status,
               parsed
             );
@@ -234,7 +234,7 @@ var init_dist = __esm({
        * "timeout"`, `status: 0`). Without it the request is sent unchanged — no
        * AbortSignal is attached, preserving the pre-0.16 behaviour.
        */
-      async fetchWithDeadline(url, init, method, path8) {
+      async fetchWithDeadline(url, init, method, path9) {
         if (this.timeoutMs === void 0) {
           return fetch(url, init);
         }
@@ -245,7 +245,7 @@ var init_dist = __esm({
         } catch (error2) {
           if (controller.signal.aborted) {
             throw new MindGraphError(
-              `${method} ${path8} timed out after ${this.timeoutMs}ms`,
+              `${method} ${path9} timed out after ${this.timeoutMs}ms`,
               0,
               { error: "timeout", code: "timeout", retriable: false }
             );
@@ -255,17 +255,17 @@ var init_dist = __esm({
           clearTimeout(timer);
         }
       }
-      get(path8) {
-        return this.request("GET", path8);
+      get(path9) {
+        return this.request("GET", path9);
       }
-      post(path8, body) {
-        return this.request("POST", path8, body);
+      post(path9, body) {
+        return this.request("POST", path9, body);
       }
-      patch(path8, body) {
-        return this.request("PATCH", path8, body);
+      patch(path9, body) {
+        return this.request("PATCH", path9, body);
       }
-      del(path8) {
-        return this.request("DELETE", path8);
+      del(path9) {
+        return this.request("DELETE", path9);
       }
       // ---- Health ----
       async health() {
@@ -1240,14 +1240,14 @@ function unavailabilityCaveats(reason, message) {
   }
   return caveats;
 }
-function normalizePath(path8) {
-  return path8.replaceAll("\\", "/").replace(/^\.\//, "");
+function normalizePath(path9) {
+  return path9.replaceAll("\\", "/").replace(/^\.\//, "");
 }
 function normalizeSignature(signature) {
   return signature.replace(/\s+/g, " ").trim();
 }
-function languageFromPath(path8) {
-  const extension = (0, import_node_path2.extname)(path8).toLowerCase();
+function languageFromPath(path9) {
+  const extension = (0, import_node_path2.extname)(path9).toLowerCase();
   return {
     ".c": "c",
     ".cc": "cpp",
@@ -2564,10 +2564,111 @@ var init_code_tool = __esm({
   }
 });
 
+// src/call-ledger.ts
+function callsDir(options) {
+  return import_node_path3.default.join(
+    options.runtimeDir || process.env.MINDGRAPH_RUNTIME_DIR || import_node_path3.default.join(import_node_os3.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_crypto4.default.createHash("sha256").update(`${bareToolName(toolName)}\0${stableJson(toolInput)}`).digest("hex");
+}
+function sessionKey(sessionId) {
+  return import_node_crypto4.default.createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+}
+function prune(dir, now) {
+  let names;
+  try {
+    names = import_node_fs3.default.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const file = import_node_path3.default.join(dir, name);
+    try {
+      if (now - import_node_fs3.default.statSync(file).mtimeMs > TTL_MS) import_node_fs3.default.unlinkSync(file);
+    } catch {
+    }
+  }
+}
+function recordPendingCall(toolName, toolInput, harnessSessionId, fills, options = {}) {
+  const now = (options.now ?? Date.now)();
+  const dir = callsDir(options);
+  try {
+    import_node_fs3.default.mkdirSync(dir, { recursive: true, mode: 448 });
+    prune(dir, now);
+    const record = {
+      harnessSessionId,
+      projectDir: options.projectDir ?? process.env.CLAUDE_PROJECT_DIR,
+      fills,
+      createdAt: now
+    };
+    const file = import_node_path3.default.join(
+      dir,
+      `${callKey(toolName, toolInput)}.${sessionKey(harnessSessionId)}.json`
+    );
+    const temporary = `${file}.${process.pid}.${import_node_crypto4.default.randomUUID()}.tmp`;
+    import_node_fs3.default.writeFileSync(temporary, JSON.stringify(record), { mode: 384 });
+    import_node_fs3.default.renameSync(temporary, file);
+  } catch {
+  }
+}
+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_fs3.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_fs3.default.readFileSync(import_node_path3.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;
+}
+var import_node_crypto4, import_node_fs3, import_node_os3, import_node_path3, TTL_MS;
+var init_call_ledger = __esm({
+  "src/call-ledger.ts"() {
+    "use strict";
+    import_node_crypto4 = __toESM(require("crypto"));
+    import_node_fs3 = __toESM(require("fs"));
+    import_node_os3 = __toESM(require("os"));
+    import_node_path3 = __toESM(require("path"));
+    TTL_MS = 10 * 6e4;
+  }
+});
+
 // src/hook-installer.ts
 function storedFeatures(homeDir) {
   const { promptRecall: promptRecall2, capture } = loadHookEnv(
-    import_node_path4.default.join(homeDir || import_node_os4.default.homedir(), ".mindgraph")
+    import_node_path5.default.join(homeDir || import_node_os5.default.homedir(), ".mindgraph")
   );
   return { promptRecall: promptRecall2, capture };
 }
@@ -2578,24 +2679,24 @@ function windowsCommand(harness) {
   return `node "%USERPROFILE%\\.mindgraph\\bin\\mindgraph-hook.cjs" hook --harness ${harness} --owner mindgraph`;
 }
 function installHookRunner(sourceFile, homeDir, version) {
-  const target = import_node_path4.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_RELATIVE);
-  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(target), { recursive: true });
-  const temporary = `${target}.${process.pid}.${import_node_crypto5.default.randomUUID()}.tmp`;
-  import_node_fs5.default.copyFileSync(sourceFile, temporary);
-  import_node_fs5.default.renameSync(temporary, target);
-  const versionPath = import_node_path4.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_VERSION_RELATIVE);
+  const target = import_node_path5.default.join(homeDir || import_node_os5.default.homedir(), RUNNER_RELATIVE);
+  import_node_fs6.default.mkdirSync(import_node_path5.default.dirname(target), { recursive: true });
+  const temporary = `${target}.${process.pid}.${import_node_crypto6.default.randomUUID()}.tmp`;
+  import_node_fs6.default.copyFileSync(sourceFile, temporary);
+  import_node_fs6.default.renameSync(temporary, target);
+  const versionPath = import_node_path5.default.join(homeDir || import_node_os5.default.homedir(), RUNNER_VERSION_RELATIVE);
   if (version) {
-    import_node_fs5.default.writeFileSync(versionPath, `${version}
+    import_node_fs6.default.writeFileSync(versionPath, `${version}
 `);
   } else {
-    import_node_fs5.default.rmSync(versionPath, { force: true });
+    import_node_fs6.default.rmSync(versionPath, { force: true });
   }
   return target;
 }
 function installedHookRunnerVersion(homeDir) {
   try {
-    const raw = import_node_fs5.default.readFileSync(
-      import_node_path4.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_VERSION_RELATIVE),
+    const raw = import_node_fs6.default.readFileSync(
+      import_node_path5.default.join(homeDir || import_node_os5.default.homedir(), RUNNER_VERSION_RELATIVE),
       "utf8"
     ).trim();
     return raw || void 0;
@@ -2620,22 +2721,22 @@ function refreshHookRunner(serverVersion, sourceBundle, homeDir) {
     if (process.env.MINDGRAPH_HOOK_AUTOUPDATE === "off") {
       return { refreshed: false, reason: "disabled" };
     }
-    const home = homeDir || import_node_os4.default.homedir();
-    if (!import_node_fs5.default.existsSync(import_node_path4.default.join(home, RUNNER_RELATIVE))) {
+    const home = homeDir || import_node_os5.default.homedir();
+    if (!import_node_fs6.default.existsSync(import_node_path5.default.join(home, RUNNER_RELATIVE))) {
       return { refreshed: false, reason: "no_runner" };
     }
-    if (!import_node_fs5.default.existsSync(sourceBundle)) {
+    if (!import_node_fs6.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",
@@ -2655,8 +2756,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_fs5.default.existsSync(file)) continue;
-      if (!import_node_fs5.default.readFileSync(file, "utf8").includes(OWNER_MARKER)) continue;
+      if (!import_node_fs6.default.existsSync(file)) continue;
+      if (!import_node_fs6.default.readFileSync(file, "utf8").includes(OWNER_MARKER)) continue;
       installHooks(
         "claude-code",
         scope,
@@ -2676,15 +2777,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_os4.default.homedir(), ".codex"), homeDir) {
+function settingsPath(harness, scope, projectDir = process.cwd(), codexHomeDir = process.env.CODEX_HOME || import_node_path5.default.join(import_node_os5.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_os4.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_os5.default.homedir(), ".claude", "settings.json") : import_node_path5.default.join(projectDir, ".claude", "settings.json");
 }
 function readSettings(file) {
-  if (!import_node_fs5.default.existsSync(file)) return {};
-  return JSON.parse(import_node_fs5.default.readFileSync(file, "utf8"));
+  if (!import_node_fs6.default.existsSync(file)) return {};
+  return JSON.parse(import_node_fs6.default.readFileSync(file, "utf8"));
 }
 function ownedHook(harness, timeout, additionalContextLimit) {
   return {
@@ -2728,7 +2829,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
@@ -2762,13 +2873,13 @@ function entryHasOwnedHook(value) {
   return Array.isArray(hooks) && hooks.some((hook) => hookCommand(hook)?.includes(OWNER_MARKER));
 }
 function writeSettings(file, settings) {
-  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
-  const temporary = `${file}.${process.pid}.${import_node_crypto5.default.randomUUID()}.tmp`;
-  import_node_fs5.default.writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}
+  import_node_fs6.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${import_node_crypto6.default.randomUUID()}.tmp`;
+  import_node_fs6.default.writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}
 `, {
     mode: 384
   });
-  import_node_fs5.default.renameSync(temporary, file);
+  import_node_fs6.default.renameSync(temporary, file);
 }
 function installHooks(harness, scope, projectDir = process.cwd(), codexHomeDir, homeDir, features = {}) {
   const file = settingsPath(harness, scope, projectDir, codexHomeDir, homeDir);
@@ -2802,7 +2913,7 @@ function installHooks(harness, scope, projectDir = process.cwd(), codexHomeDir,
 }
 function uninstallHooks(harness, scope, projectDir = process.cwd(), codexHomeDir) {
   const file = settingsPath(harness, scope, projectDir, codexHomeDir);
-  if (!import_node_fs5.default.existsSync(file)) return { path: file, removed: 0 };
+  if (!import_node_fs6.default.existsSync(file)) return { path: file, removed: 0 };
   const settings = readSettings(file);
   const hooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
   let removed = 0;
@@ -2848,18 +2959,19 @@ function installCodexHooks(scope, projectDir = process.cwd(), codexHomeDir) {
 function uninstallCodexHooks(scope, projectDir = process.cwd(), codexHomeDir) {
   return uninstallHooks("codex", scope, projectDir, codexHomeDir);
 }
-var import_node_fs5, import_node_os4, import_node_path4, import_node_crypto5, OWNER_MARKER, RUNNER_RELATIVE, RUNNER_VERSION_RELATIVE;
+var import_node_fs6, import_node_os5, import_node_path5, import_node_crypto6, OWNER_MARKER, RUNNER_RELATIVE, RUNNER_VERSION_RELATIVE, CLAUDE_POST_TOOL_MATCHER;
 var init_hook_installer = __esm({
   "src/hook-installer.ts"() {
     "use strict";
-    import_node_fs5 = __toESM(require("fs"));
-    import_node_os4 = __toESM(require("os"));
-    import_node_path4 = __toESM(require("path"));
-    import_node_crypto5 = __toESM(require("crypto"));
+    import_node_fs6 = __toESM(require("fs"));
+    import_node_os5 = __toESM(require("os"));
+    import_node_path5 = __toESM(require("path"));
+    import_node_crypto6 = __toESM(require("crypto"));
     init_hook_env();
     OWNER_MARKER = "--owner mindgraph";
     RUNNER_RELATIVE = ".mindgraph/bin/mindgraph-hook.cjs";
     RUNNER_VERSION_RELATIVE = `${RUNNER_RELATIVE}.version`;
+    CLAUDE_POST_TOOL_MATCHER = "mcp__mindgraph__.*|Edit|MultiEdit|Write|NotebookEdit|Bash|Task|Agent";
   }
 });
 
@@ -3101,6 +3213,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);
@@ -3323,15 +3443,15 @@ function renderTraversal(response, maxChars) {
   const labelByUid = /* @__PURE__ */ new Map();
   for (const node of nodes) labelByUid.set(str2(node.uid), str2(node.label) || "?");
   if (paths.length > 0) {
-    const items = paths.map((raw) => obj(raw)).filter((path8) => Boolean(path8)).map((path8, index) => {
-      const uids = Array.isArray(path8.node_uids) ? path8.node_uids.map(String) : [];
-      const labels = Array.isArray(path8.labels) ? path8.labels.map(String) : Array.isArray(path8.nodes) ? path8.nodes.map((hop) => {
+    const items = paths.map((raw) => obj(raw)).filter((path9) => Boolean(path9)).map((path9, index) => {
+      const uids = Array.isArray(path9.node_uids) ? path9.node_uids.map(String) : [];
+      const labels = Array.isArray(path9.labels) ? path9.labels.map(String) : Array.isArray(path9.nodes) ? path9.nodes.map((hop) => {
         const hopNode = obj(hop);
         return str2(hopNode?.label) || labelByUid.get(str2(hopNode?.uid) || "") || str2(hop) || "?";
       }) : [];
       const route = labels.length > 0 ? labels.join(" \u2192 ") : uids.join(" \u2192 ") || "(path)";
-      const cost = num(path8.cost) ?? num(path8.path_cost);
-      const confidence = num(path8.path_confidence);
+      const cost = num(path9.cost) ?? num(path9.path_cost);
+      const confidence = num(path9.path_confidence);
       const meta = [
         cost !== void 0 ? `cost ${cost}` : void 0,
         confidence !== void 0 ? `confidence ${confidence}` : void 0
@@ -4383,15 +4503,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 sha2562(value) {
-  return (0, import_node_crypto6.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto7.createHash)("sha256").update(value).digest("hex");
 }
 function outputBudget(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_OUTPUT_CHARS;
@@ -4697,7 +4817,7 @@ async function handleMemoryTool(client2, args, config = {}) {
     scope_uids: Array.isArray(args.scope_uids) ? args.scope_uids.map(String) : void 0
   });
   const contextId = `ctx_${sha2562(
-    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 = {
@@ -4742,11 +4862,11 @@ async function handleMemoryTool(client2, args, config = {}) {
     structuredContent: result
   };
 }
-var import_node_crypto6, RESULT_SCHEMA_VERSION, DEFAULT_OUTPUT_CHARS, MIN_OUTPUT_CHARS, MAX_OUTPUT_CHARS, HIDDEN_CONTEXT_NODE_TYPES, HIDDEN_CONTEXT_EDGE_TYPES, MEMORY_TOOL;
+var import_node_crypto7, RESULT_SCHEMA_VERSION, DEFAULT_OUTPUT_CHARS, MIN_OUTPUT_CHARS, MAX_OUTPUT_CHARS, HIDDEN_CONTEXT_NODE_TYPES, HIDDEN_CONTEXT_EDGE_TYPES, MEMORY_TOOL;
 var init_memory_tool = __esm({
   "src/memory-tool.ts"() {
     "use strict";
-    import_node_crypto6 = require("crypto");
+    import_node_crypto7 = require("crypto");
     init_render();
     RESULT_SCHEMA_VERSION = "mindgraph.memory.result.v1";
     DEFAULT_OUTPUT_CHARS = 8e3;
@@ -5016,12 +5136,12 @@ var init_resources = __esm({
 
 // src/sync-tool.ts
 function safePath(root, candidate) {
-  const absolute = import_node_path5.default.resolve(root, candidate);
-  const relative2 = import_node_path5.default.relative(root, absolute);
-  if (relative2.startsWith("..") || import_node_path5.default.isAbsolute(relative2)) {
+  const absolute = import_node_path6.default.resolve(root, candidate);
+  const relative2 = import_node_path6.default.relative(root, absolute);
+  if (relative2.startsWith("..") || import_node_path6.default.isAbsolute(relative2)) {
     throw new Error(`path escapes repository root: ${candidate}`);
   }
-  if (import_node_fs6.default.existsSync(absolute)) {
+  if (import_node_fs7.default.existsSync(absolute)) {
     if (!pathContains(realPathOf(root), realPathOf(absolute))) {
       throw new Error(`path escapes repository root via symlink: ${candidate}`);
     }
@@ -5030,26 +5150,26 @@ function safePath(root, candidate) {
 }
 function realPathOf(target) {
   try {
-    return import_node_fs6.default.realpathSync(target);
+    return import_node_fs7.default.realpathSync(target);
   } catch {
-    return import_node_path5.default.resolve(target);
+    return import_node_path6.default.resolve(target);
   }
 }
 function markdownFiles(target, realRoot, visited = /* @__PURE__ */ new Set()) {
-  if (!import_node_fs6.default.existsSync(target)) return [];
+  if (!import_node_fs7.default.existsSync(target)) return [];
   const real = realPathOf(target);
   if (!pathContains(realRoot, real)) return [];
-  const stat = import_node_fs6.default.statSync(target);
+  const stat = import_node_fs7.default.statSync(target);
   if (stat.isFile()) return target.endsWith(".md") ? [target] : [];
   if (!stat.isDirectory() || visited.has(real)) return [];
   visited.add(real);
-  return import_node_fs6.default.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(import_node_path5.default.join(target, entry.name), realRoot, visited));
+  return import_node_fs7.default.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(import_node_path6.default.join(target, entry.name), realRoot, visited));
 }
 function fileDescriptor(root, absolute) {
-  const content = import_node_fs6.default.readFileSync(absolute, "utf8");
+  const content = import_node_fs7.default.readFileSync(absolute, "utf8");
   return {
-    logical_path: import_node_path5.default.relative(root, absolute).split(import_node_path5.default.sep).join("/"),
-    content_hash: import_node_crypto7.default.createHash("sha256").update(content).digest("hex"),
+    logical_path: import_node_path6.default.relative(root, absolute).split(import_node_path6.default.sep).join("/"),
+    content_hash: import_node_crypto8.default.createHash("sha256").update(content).digest("hex"),
     bytes: Buffer.byteLength(content),
     content
   };
@@ -5118,7 +5238,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_fs6.default.existsSync(absolute);
+      request.file_present = import_node_fs7.default.existsSync(absolute);
       if (request.file_present && !request.content_hash) {
         request.content_hash = fileDescriptor(root, absolute).content_hash;
       }
@@ -5162,13 +5282,13 @@ async function scanRepository(remote, repository, requested, provider, agentId)
     files: results
   };
 }
-var import_node_crypto7, import_node_fs6, import_node_path5, ok3, err4, SYNC_TOOL;
+var import_node_crypto8, import_node_fs7, import_node_path6, ok3, err4, SYNC_TOOL;
 var init_sync_tool = __esm({
   "src/sync-tool.ts"() {
     "use strict";
-    import_node_crypto7 = __toESM(require("crypto"));
-    import_node_fs6 = __toESM(require("fs"));
-    import_node_path5 = __toESM(require("path"));
+    import_node_crypto8 = __toESM(require("crypto"));
+    import_node_fs7 = __toESM(require("fs"));
+    import_node_path6 = __toESM(require("path"));
     init_codegraph();
     init_error_detail();
     ok3 = (data) => ({
@@ -5250,10 +5370,10 @@ var init_sync_tool = __esm({
 });
 
 // src/tools.ts
-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);
 }
@@ -5267,8 +5387,8 @@ function defaultWriteIdempotencyKey(tool, args) {
       ([key]) => key !== "invocation_context" && key !== "idempotency_key"
     )
   );
-  return (0, import_node_crypto8.createHash)("sha256").update(
-    stableJson2({
+  return (0, import_node_crypto9.createHash)("sha256").update(
+    stableJson3({
       harness_session_id: sessionId,
       harness_turn_id: context?.harnessTurnId ?? null,
       tool,
@@ -6073,6 +6193,8 @@ async function handleRetrieve(client2, args, profile) {
     salience_min,
     article_limit,
     valid_at,
+    as_of,
+    retrieval_mode,
     created_after,
     created_before,
     explain,
@@ -6101,9 +6223,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)
       );
@@ -6553,11 +6681,11 @@ async function handleOntology(client2, args) {
       return err5(`Unknown ontology action: ${action}`);
   }
 }
-var import_node_crypto8, RESOLUTION_PROPERTIES, TOOLS, INVOCATION_CONTEXT_SCHEMA;
+var import_node_crypto9, RESOLUTION_PROPERTIES, TOOLS, INVOCATION_CONTEXT_SCHEMA;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
-    import_node_crypto8 = require("crypto");
+    import_node_crypto9 = require("crypto");
     init_error_detail();
     init_code_tool();
     init_codegraph();
@@ -7282,6 +7410,15 @@ var init_tools = __esm({
               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"
@@ -7732,14 +7869,14 @@ var init_tools = __esm({
 // 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 };
@@ -7750,9 +7887,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) {
@@ -7792,20 +7934,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,
@@ -7813,15 +7955,13 @@ function buildMindGraphServer(wiring) {
       wiring.memory
     );
   });
-  return server2;
+  return server;
 }
-var import_server, import_webStandardStreamableHttp, import_types;
+var import_server;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
-    import_server = require("@modelcontextprotocol/sdk/server/index.js");
-    import_webStandardStreamableHttp = require("@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js");
-    import_types = require("@modelcontextprotocol/sdk/types.js");
+    import_server = require("@modelcontextprotocol/server");
     init_generated_tools();
     init_governance();
     init_hosted_tools();
@@ -7834,21 +7974,23 @@ var init_server = __esm({
 // src/index.ts
 var src_exports = {};
 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})`
   );
 }
-var import_stdio, import_node_path6, API_KEY, BASE_URL, AGENT_ID, ORG_ID, PROFILE, HARNESS, client, INSTRUCTIONS, RUNNER_REFRESH, HOOK_SKEW_NOTE, GOVERNANCE_CONFIG, MEMORY_RUNTIME_CONFIG, server;
+var import_stdio, import_node_path7, API_KEY, BASE_URL, AGENT_ID, ORG_ID, PROFILE, HARNESS, client, INSTRUCTIONS, RUNNER_REFRESH, HOOK_SKEW_NOTE, GOVERNANCE_CONFIG, MEMORY_RUNTIME_CONFIG, buildServer;
 var init_src = __esm({
   "src/index.ts"() {
     "use strict";
-    import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+    init_call_ledger();
+    import_stdio = require("@modelcontextprotocol/server/stdio");
     init_dist();
     init_hook_env();
     init_server();
-    import_node_path6 = __toESM(require("path"));
+    import_node_path7 = __toESM(require("path"));
     init_hook_installer();
     API_KEY = process.env.MINDGRAPH_API_KEY;
     BASE_URL = process.env.MINDGRAPH_BASE_URL || "https://api.mindgraph.cloud";
@@ -7941,7 +8083,7 @@ Capture knowledge when the user shares something worth remembering:
 - 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")
@@ -7949,7 +8091,7 @@ Capture knowledge when the user shares something worth remembering:
     }
     RUNNER_REFRESH = (() => {
       try {
-        return refreshHookRunner("0.23.0", import_node_path6.default.join(__dirname, "cli.js"));
+        return refreshHookRunner("0.25.0", import_node_path7.default.join(__dirname, "cli.js"));
       } catch {
         return void 0;
       }
@@ -7963,12 +8105,12 @@ Capture knowledge when the user shares something worth remembering:
         }
       })();
       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(", ")}` : "")
       );
     }
     HOOK_SKEW_NOTE = (() => {
       try {
-        return versionSkewNote("0.23.0");
+        return versionSkewNote("0.25.0");
       } catch {
         return void 0;
       }
@@ -7989,21 +8131,22 @@ ${HOOK_SKEW_NOTE}`;
       }
     };
     MEMORY_RUNTIME_CONFIG = {
-      serverVersion: "0.23.0",
+      serverVersion: "0.25.0",
       baseUrl: BASE_URL,
       profile: PROFILE,
       harness: HARNESS,
       orgId: ORG_ID,
       agentId: AGENT_ID
     };
-    server = buildMindGraphServer({
+    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)
     });
     main().catch((error2) => {
       console.error("Fatal error:", error2);
@@ -8013,10 +8156,10 @@ ${HOOK_SKEW_NOTE}`;
 });
 
 // src/cli.ts
-var fs7 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
-var os4 = __toESM(require("os"));
-var crypto5 = __toESM(require("crypto"));
+var fs8 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+var os5 = __toESM(require("os"));
+var crypto6 = __toESM(require("crypto"));
 var import_child_process = require("child_process");
 init_dist();
 init_hook_env();
@@ -8498,24 +8641,25 @@ async function skillsPush(api, skillPath) {
 }
 
 // src/hook-core.ts
-var import_node_crypto4 = __toESM(require("crypto"));
-var import_node_fs4 = __toESM(require("fs"));
-var import_node_os3 = __toESM(require("os"));
-var import_node_path3 = __toESM(require("path"));
+var import_node_crypto5 = __toESM(require("crypto"));
+var import_node_fs5 = __toESM(require("fs"));
+var import_node_os4 = __toESM(require("os"));
+var import_node_path4 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
 init_codegraph();
 init_code_tool();
+init_call_ledger();
 init_error_detail();
 init_hook_env();
 
 // src/hook-memory.ts
-var import_node_fs3 = __toESM(require("fs"));
+var import_node_fs4 = __toESM(require("fs"));
 var PROMPT_RECALL_LIMIT = 5;
 var PROMPT_RECALL_MAX_CHARS = 4e3;
 var MIN_PROMPT_RECALL_CHARS = 12;
 var CAPTURE_MAX_CHARS = 2e5;
 var STOPWORDS = new Set(
-  "a an and are as at be but by can could did do does for from had has have how i if in into is it its me my of on or our please should so that the their them then there these they this to us was we were what when where which who why will with would you your about just also any some tell know want need let lets like get got make".split(" ")
+  "a an and are as at be but by can could did do does for from had has have how i if in into is it its me my of on or our please should so that the their them then there these they this to us was we were what when where which who why will with would you your about just also any some tell know want need let lets like get got make yes no not ok okay sure may might must up down out off over under again after before while without within including include use using used keep now next here than very more most other each both all one two been being am done going go".split(" ")
 );
 var WORD = /[A-Za-z0-9][A-Za-z0-9_.\-/#+]*/g;
 var SECRET_PATTERNS = [
@@ -8560,6 +8704,27 @@ function promptRecallRequest(query) {
     graph_max_depth: 2
   };
 }
+function wordParts(text2) {
+  return text2.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+var sameWord = (left, right) => left === right || left.length >= 4 && right.length >= 4 && (left.startsWith(right) || right.startsWith(left));
+function recallTermOverlap(query, text2) {
+  const hay = wordParts(text2);
+  let matched = 0;
+  let usable = 0;
+  for (const term of new Set(query.split(/\s+/).filter(Boolean))) {
+    const parts = wordParts(term).filter((part) => part.length >= 3 && !/^\d+$/.test(part));
+    if (parts.length === 0) continue;
+    usable += 1;
+    if (parts.some((part) => hay.some((word) => sameWord(word, part)))) matched += 1;
+  }
+  return { matched, usable };
+}
+function relevant(query, text2) {
+  if (query === void 0) return true;
+  const { matched, usable } = recallTermOverlap(query, text2);
+  return usable > 0 && matched >= Math.min(2, usable);
+}
 var rec = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 var str = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
 var oneLine = (value, max) => {
@@ -8571,7 +8736,7 @@ function nodeType(node) {
   const plain = str(node.node_type);
   return (plain && plain !== "Custom" ? plain : void 0) ?? str(rec(node.node_type)?.Custom) ?? plain ?? "Node";
 }
-function renderPromptRecall(response) {
+function renderPromptRecall(response, query) {
   const payload = rec(response);
   if (!payload) return void 0;
   const lines = [];
@@ -8585,6 +8750,9 @@ function renderPromptRecall(response) {
     const label = str(node.label) ?? str(props?.label) ?? str(props?.name);
     if (!label) continue;
     const summary = str(node.summary) ?? str(props?.summary) ?? str(props?.description) ?? str(props?.content);
+    const informative = summary && summary !== label ? summary : void 0;
+    if (!informative && type === "Entity") continue;
+    if (!relevant(query, `${label} ${informative ?? ""}`)) continue;
     const docs = Array.isArray(node.source_documents) ? node.source_documents : [];
     const source = str(rec(docs[0])?.title);
     let line = `- [${type}] ${oneLine(label, 140)}`;
@@ -8600,6 +8768,7 @@ function renderPromptRecall(response) {
     const label = str(article.label);
     if (!label) continue;
     const content = str(article.content);
+    if (!relevant(query, `${label} ${content ?? ""}`)) continue;
     lines.push(`- [Article] ${oneLine(label, 140)}${content ? ` \u2014 ${oneLine(content, 240)}` : ""}`);
   }
   if (lines.length === 0) return void 0;
@@ -8649,7 +8818,7 @@ function renderTranscript(turns) {
   return start >= 0 ? tail.slice(start + 2) : tail;
 }
 function readTranscriptSince(file, offset = 0) {
-  const buffer = import_node_fs3.default.readFileSync(file);
+  const buffer = import_node_fs4.default.readFileSync(file);
   const start = offset > buffer.length ? 0 : offset;
   const lastNewline = buffer.lastIndexOf(10);
   if (lastNewline < start) return { text: "", nextOffset: start };
@@ -8693,33 +8862,33 @@ function defaultLedger(sessionId, options) {
   };
 }
 function runtimeDir(options) {
-  return options.runtimeDir || process.env.MINDGRAPH_RUNTIME_DIR || import_node_path3.default.join(import_node_os3.default.homedir(), ".mindgraph", "runtime");
+  return options.runtimeDir || process.env.MINDGRAPH_RUNTIME_DIR || import_node_path4.default.join(import_node_os4.default.homedir(), ".mindgraph", "runtime");
 }
 function ledgerPath(sessionId, options) {
   const harness = "harness" in options ? options.harness : "claude-code";
-  const key = import_node_crypto4.default.createHash("sha256").update(`${harness}\0${sessionId}`).digest("hex");
-  return import_node_path3.default.join(runtimeDir(options), `${key}.json`);
+  const key = import_node_crypto5.default.createHash("sha256").update(`${harness}\0${sessionId}`).digest("hex");
+  return import_node_path4.default.join(runtimeDir(options), `${key}.json`);
 }
 function waitBriefly(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 function withLedger(sessionId, options, update) {
   const file = ledgerPath(sessionId, options);
-  import_node_fs4.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true, mode: 448 });
+  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true, mode: 448 });
   try {
-    import_node_fs4.default.chmodSync(import_node_path3.default.dirname(file), 448);
+    import_node_fs5.default.chmodSync(import_node_path4.default.dirname(file), 448);
   } catch {
   }
   const lock = `${file}.lock`;
   let lockFd;
   for (let attempt = 0; attempt < 400; attempt++) {
     try {
-      lockFd = import_node_fs4.default.openSync(lock, "wx", 384);
+      lockFd = import_node_fs5.default.openSync(lock, "wx", 384);
       break;
     } catch (error2) {
       if (error2.code !== "EEXIST") throw error2;
       try {
-        if (Date.now() - import_node_fs4.default.statSync(lock).mtimeMs > 3e3) import_node_fs4.default.unlinkSync(lock);
+        if (Date.now() - import_node_fs5.default.statSync(lock).mtimeMs > 3e3) import_node_fs5.default.unlinkSync(lock);
       } catch {
       }
       waitBriefly(10);
@@ -8733,25 +8902,25 @@ function withLedger(sessionId, options, update) {
     try {
       ledger = {
         ...ledger,
-        ...JSON.parse(import_node_fs4.default.readFileSync(file, "utf8"))
+        ...JSON.parse(import_node_fs5.default.readFileSync(file, "utf8"))
       };
     } catch {
     }
     const result = update(ledger);
     ledger.updatedAt = Date.now();
-    const temporary = `${file}.${process.pid}.${import_node_crypto4.default.randomUUID()}.tmp`;
-    import_node_fs4.default.writeFileSync(temporary, `${JSON.stringify(ledger)}
+    const temporary = `${file}.${process.pid}.${import_node_crypto5.default.randomUUID()}.tmp`;
+    import_node_fs5.default.writeFileSync(temporary, `${JSON.stringify(ledger)}
 `, { mode: 384 });
-    import_node_fs4.default.renameSync(temporary, file);
+    import_node_fs5.default.renameSync(temporary, file);
     try {
-      import_node_fs4.default.chmodSync(file, 384);
+      import_node_fs5.default.chmodSync(file, 384);
     } catch {
     }
     return result;
   } finally {
-    import_node_fs4.default.closeSync(lockFd);
+    import_node_fs5.default.closeSync(lockFd);
     try {
-      import_node_fs4.default.unlinkSync(lock);
+      import_node_fs5.default.unlinkSync(lock);
     } catch {
     }
   }
@@ -9021,30 +9190,30 @@ function hasMindgraphServer(servers) {
   return false;
 }
 function pathIsWithin(ancestor, descendant) {
-  const base = import_node_path3.default.resolve(ancestor);
-  const target = import_node_path3.default.resolve(descendant);
-  return target === base || target.startsWith(base + import_node_path3.default.sep);
+  const base = import_node_path4.default.resolve(ancestor);
+  const target = import_node_path4.default.resolve(descendant);
+  return target === base || target.startsWith(base + import_node_path4.default.sep);
 }
 function claudeMcpRegistrationNote(input, options) {
   if (options.harness !== "claude-code") return void 0;
   if (process.env.MINDGRAPH_SKIP_MCP_REGISTRATION_CHECK === "1") return void 0;
   try {
-    const configPath = options.claudeConfigPath || import_node_path3.default.join(import_node_os3.default.homedir(), ".claude.json");
-    if (!import_node_fs4.default.existsSync(configPath)) return void 0;
-    const config = JSON.parse(import_node_fs4.default.readFileSync(configPath, "utf8"));
+    const configPath = options.claudeConfigPath || import_node_path4.default.join(import_node_os4.default.homedir(), ".claude.json");
+    if (!import_node_fs5.default.existsSync(configPath)) return void 0;
+    const config = JSON.parse(import_node_fs5.default.readFileSync(configPath, "utf8"));
     if (hasMindgraphServer(config.mcpServers)) return void 0;
-    const cwd = import_node_path3.default.resolve(input.cwd || ".");
+    const cwd = import_node_path4.default.resolve(input.cwd || ".");
     for (const [projectDir, project] of Object.entries(config.projects || {})) {
       if (!pathIsWithin(projectDir, cwd)) continue;
       if (hasMindgraphServer(project?.mcpServers)) return void 0;
     }
-    for (let dir = cwd; ; dir = import_node_path3.default.dirname(dir)) {
-      const candidate = import_node_path3.default.join(dir, ".mcp.json");
-      if (import_node_fs4.default.existsSync(candidate)) {
-        const parsed = JSON.parse(import_node_fs4.default.readFileSync(candidate, "utf8"));
+    for (let dir = cwd; ; dir = import_node_path4.default.dirname(dir)) {
+      const candidate = import_node_path4.default.join(dir, ".mcp.json");
+      if (import_node_fs5.default.existsSync(candidate)) {
+        const parsed = JSON.parse(import_node_fs5.default.readFileSync(candidate, "utf8"));
         if (hasMindgraphServer(parsed.mcpServers)) return void 0;
       }
-      if (dir === import_node_path3.default.dirname(dir)) break;
+      if (dir === import_node_path4.default.dirname(dir)) break;
     }
   } catch {
     return void 0;
@@ -9147,7 +9316,7 @@ async function sessionStart(input, client2, options) {
   const contextText = registrationNote ? `${registrationNote}
 
 ${briefText}` : briefText;
-  const briefHash = import_node_crypto4.default.createHash("sha256").update(contextText).digest("hex");
+  const briefHash = import_node_crypto5.default.createHash("sha256").update(contextText).digest("hex");
   const shouldInject = withLedger(input.session_id, options, (ledger) => {
     const changed = ledger.lastBriefHash !== briefHash;
     const reinjectCompact = options.reinjectUnchangedCompact && input.source === "compact";
@@ -9222,6 +9391,20 @@ async function preTool(input, options) {
   if (targetsLedgerTask && fencedAction && ledger.taskVersion !== void 0 && updatedInput.expected_version === void 0) {
     updatedInput.expected_version = ledger.taskVersion;
   }
+  if (options.harness === "claude-code") {
+    const fills = Object.fromEntries(
+      Object.entries(updatedInput).filter(
+        ([key, value]) => key === "invocation_context" || original[key] !== value
+      )
+    );
+    recordPendingCall(
+      input.tool_name || "",
+      original,
+      input.session_id,
+      fills,
+      { runtimeDir: options.runtimeDir, now: options.now }
+    );
+  }
   return { kind: "rewrite", updatedInput };
 }
 var FENCED_PLAN_ACTIONS = /* @__PURE__ */ new Set([
@@ -9448,9 +9631,9 @@ async function promptRecall(input, client2, options) {
       client2.retrieveContext(promptRecallRequest(query)),
       options.promptRecallTimeoutMs ?? 4e3
     );
-    const block = renderPromptRecall(response);
+    const block = renderPromptRecall(response, query);
     if (!block) return NOOP;
-    const hash = import_node_crypto4.default.createHash("sha256").update(block).digest("hex");
+    const hash = import_node_crypto5.default.createHash("sha256").update(block).digest("hex");
     const fresh = withLedger(input.session_id, options, (ledger) => {
       if (ledger.lastRecallHash === hash) return false;
       ledger.lastRecallHash = hash;
@@ -9501,6 +9684,32 @@ async function captureTranscript(input, client2, options) {
   }
 }
 async function runHookCore(input, client2, options) {
+  const started = performance.now();
+  const output = await dispatchHook(input, client2, options);
+  if (input.session_id && !(input.hook_event_name === "PreToolUse" && output.kind === "noop")) {
+    try {
+      const elapsed = Math.round(performance.now() - started);
+      const injected = output.kind === "context" ? output.context.length : 0;
+      withLedger(input.session_id, options, (ledger) => {
+        const stats = ledger.hookStats ??= {};
+        const entry = stats[input.hook_event_name] ??= {
+          count: 0,
+          totalMs: 0,
+          maxMs: 0,
+          injectedChars: 0
+        };
+        entry.count += 1;
+        entry.totalMs += elapsed;
+        entry.maxMs = Math.max(entry.maxMs, elapsed);
+        entry.injectedChars += injected;
+        return void 0;
+      });
+    } catch {
+    }
+  }
+  return output;
+}
+async function dispatchHook(input, client2, options) {
   switch (input.hook_event_name) {
     case "SessionStart":
       return sessionStart(input, client2, options);
@@ -9545,7 +9754,7 @@ function previewCapture(transcriptPath, sessionId, options = {}) {
   let ledger = {};
   try {
     ledger = JSON.parse(
-      import_node_fs4.default.readFileSync(
+      import_node_fs5.default.readFileSync(
         ledgerPath(sessionId, { ...options, harness: "claude-code" }),
         "utf8"
       )
@@ -9561,6 +9770,34 @@ function previewCapture(transcriptPath, sessionId, options = {}) {
     offset
   };
 }
+function readHookStats(sessionId, options = {}) {
+  const dir = runtimeDir(options);
+  let best;
+  let names = [];
+  try {
+    names = import_node_fs5.default.readdirSync(dir).filter((name) => /^[0-9a-f]{64}\.json$/.test(name));
+  } catch {
+    return void 0;
+  }
+  for (const name of names) {
+    try {
+      const ledger = JSON.parse(import_node_fs5.default.readFileSync(import_node_path4.default.join(dir, name), "utf8"));
+      if (!ledger.harnessSessionId || !ledger.hookStats) continue;
+      if (sessionId && ledger.harnessSessionId !== sessionId) continue;
+      const updatedAt = Number(ledger.updatedAt) || 0;
+      if (!best || updatedAt > best.updatedAt) {
+        best = {
+          harness: String(ledger.harness ?? "unknown"),
+          sessionId: ledger.harnessSessionId,
+          updatedAt,
+          events: ledger.hookStats
+        };
+      }
+    } catch {
+    }
+  }
+  return best;
+}
 
 // src/claude-hooks.ts
 async function runClaudeHook(input, client2, options = {}) {
@@ -9580,12 +9817,7 @@ async function runClaudeHook(input, client2, options = {}) {
         }
       };
     case "rewrite":
-      return {
-        hookSpecificOutput: {
-          hookEventName: "PreToolUse",
-          updatedInput: output.updatedInput
-        }
-      };
+      return {};
     case "block":
       return { decision: "block", reason: output.reason };
     case "noop":
@@ -9628,15 +9860,15 @@ async function runCodexHook(input, client2, options = {}) {
 init_hook_installer();
 function recordHookHealth(harness, error2) {
   try {
-    const dir = process.env.MINDGRAPH_RUNTIME_DIR || path7.join(os4.homedir(), ".mindgraph", "runtime");
-    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
-    const file = path7.join(dir, "hook-health.json");
+    const dir = process.env.MINDGRAPH_RUNTIME_DIR || path8.join(os5.homedir(), ".mindgraph", "runtime");
+    fs8.mkdirSync(dir, { recursive: true, mode: 448 });
+    const file = path8.join(dir, "hook-health.json");
     let failures = 0;
     try {
-      failures = Number(JSON.parse(fs7.readFileSync(file, "utf8")).consecutiveFailures) || 0;
+      failures = Number(JSON.parse(fs8.readFileSync(file, "utf8")).consecutiveFailures) || 0;
     } catch {
     }
-    fs7.writeFileSync(
+    fs8.writeFileSync(
       file,
       `${JSON.stringify({
         harness,
@@ -9652,14 +9884,14 @@ function recordHookHealth(harness, error2) {
 }
 function clearHookHealth(harness) {
   try {
-    const file = path7.join(
-      process.env.MINDGRAPH_RUNTIME_DIR || path7.join(os4.homedir(), ".mindgraph", "runtime"),
+    const file = path8.join(
+      process.env.MINDGRAPH_RUNTIME_DIR || path8.join(os5.homedir(), ".mindgraph", "runtime"),
       "hook-health.json"
     );
-    if (!fs7.existsSync(file)) return;
-    const current = JSON.parse(fs7.readFileSync(file, "utf8"));
+    if (!fs8.existsSync(file)) return;
+    const current = JSON.parse(fs8.readFileSync(file, "utf8"));
     if (!Number(current.consecutiveFailures)) return;
-    fs7.writeFileSync(
+    fs8.writeFileSync(
       file,
       `${JSON.stringify({
         harness,
@@ -9675,22 +9907,22 @@ function clearHookHealth(harness) {
 function getClaudeDesktopConfigPath() {
   switch (process.platform) {
     case "darwin":
-      return path7.join(
-        os4.homedir(),
+      return path8.join(
+        os5.homedir(),
         "Library",
         "Application Support",
         "Claude",
         "claude_desktop_config.json"
       );
     case "win32":
-      return path7.join(
-        process.env.APPDATA || path7.join(os4.homedir(), "AppData", "Roaming"),
+      return path8.join(
+        process.env.APPDATA || path8.join(os5.homedir(), "AppData", "Roaming"),
         "Claude",
         "claude_desktop_config.json"
       );
     case "linux":
-      return path7.join(
-        os4.homedir(),
+      return path8.join(
+        os5.homedir(),
         ".config",
         "Claude",
         "claude_desktop_config.json"
@@ -9700,16 +9932,16 @@ function getClaudeDesktopConfigPath() {
   }
 }
 function readJsonFile(filePath) {
-  if (!fs7.existsSync(filePath)) return {};
-  const content = fs7.readFileSync(filePath, "utf-8");
+  if (!fs8.existsSync(filePath)) return {};
+  const content = fs8.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJsonFile(filePath, data) {
-  const dir = path7.dirname(filePath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const dir = path8.dirname(filePath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
-  fs7.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs8.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 function getMcpServerEntry(apiKey, baseUrl) {
   const env = { MINDGRAPH_API_KEY: apiKey };
@@ -9796,7 +10028,7 @@ function installClaudeCode(apiKey, baseUrl, agentId) {
 }
 function uninstallClaudeDesktop() {
   const configPath = getClaudeDesktopConfigPath();
-  if (!fs7.existsSync(configPath)) {
+  if (!fs8.existsSync(configPath)) {
     console.log("Claude Desktop config not found. Nothing to remove.");
     return;
   }
@@ -9823,7 +10055,7 @@ function uninstallClaudeCode() {
 }
 function printStatus() {
   const desktopPath = getClaudeDesktopConfigPath();
-  if (fs7.existsSync(desktopPath)) {
+  if (fs8.existsSync(desktopPath)) {
     const config = readJsonFile(desktopPath);
     const servers = config.mcpServers;
     if (servers && "mindgraph" in servers) {
@@ -9841,12 +10073,12 @@ function printStatus() {
     `MINDGRAPH_BASE_URL: ${process.env.MINDGRAPH_BASE_URL || "https://api.mindgraph.cloud (default)"}`
   );
   try {
-    const healthFile = path7.join(
-      process.env.MINDGRAPH_RUNTIME_DIR || path7.join(os4.homedir(), ".mindgraph", "runtime"),
+    const healthFile = path8.join(
+      process.env.MINDGRAPH_RUNTIME_DIR || path8.join(os5.homedir(), ".mindgraph", "runtime"),
       "hook-health.json"
     );
-    if (fs7.existsSync(healthFile)) {
-      const health = JSON.parse(fs7.readFileSync(healthFile, "utf8"));
+    if (fs8.existsSync(healthFile)) {
+      const health = JSON.parse(fs8.readFileSync(healthFile, "utf8"));
       const failures = Number(health.consecutiveFailures) || 0;
       console.log(
         failures > 0 ? `Hooks: FAILING (${failures} consecutive; last: ${health.lastError} at ${health.lastFailureAt})` : `Hooks: healthy (last recovery ${health.lastOkAt || "unknown"})`
@@ -9875,21 +10107,21 @@ function printClaudeHookFeatures(features) {
   );
 }
 function latestTranscript(cwd) {
-  const dir = path7.join(
-    os4.homedir(),
+  const dir = path8.join(
+    os5.homedir(),
     ".claude",
     "projects",
     cwd.replace(/[^A-Za-z0-9]/g, "-")
   );
   try {
-    return fs7.readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => path7.join(dir, name)).sort((a, b) => fs7.statSync(b).mtimeMs - fs7.statSync(a).mtimeMs)[0];
+    return fs8.readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => path8.join(dir, name)).sort((a, b) => fs8.statSync(b).mtimeMs - fs8.statSync(a).mtimeMs)[0];
   } catch {
     return void 0;
   }
 }
 function finishCodeInstall(apiKey, baseUrl, withHooks, agentId) {
   if (withHooks) {
-    const runner = installHookRunner(__filename, void 0, "0.23.0");
+    const runner = installHookRunner(__filename, void 0, "0.25.0");
     console.log(`Installed pinned hook runner at ${runner}`);
     const features = claudeHookFeatures();
     const result = installClaudeHooks("user", void 0, features);
@@ -9942,6 +10174,9 @@ USAGE:
   mindgraph-mcp hooks preview [transcript_path] [--session-id <id>]
                                  Print exactly what transcript capture would
                                  send (POST /ingest/session); sends nothing.
+  mindgraph-mcp hooks stats [--session-id <id>]
+                                 Per-event hook calls, time and characters
+                                 injected for a session (latest by default).
   mindgraph-mcp status           Show installation status
   mindgraph-mcp skills pull [--dir .claude/skills]
                                  Write your org's published+granted skills as
@@ -9987,7 +10222,7 @@ var DASHBOARD_URL = process.env.MINDGRAPH_DASHBOARD_URL || "https://mindgraph.cl
 var POLL_INTERVAL = 2e3;
 var POLL_TIMEOUT = 10 * 60 * 1e3;
 function generateCode() {
-  return crypto5.randomBytes(32).toString("hex");
+  return crypto6.randomBytes(32).toString("hex");
 }
 function openBrowser(url) {
   try {
@@ -10214,7 +10449,7 @@ ${total} skill(s) synced.`);
       if (hookHarness !== "claude-code" && hookHarness !== "codex") {
         throw new Error("--harness must be claude-code or codex");
       }
-      const runner = installHookRunner(__filename, void 0, "0.23.0");
+      const runner = installHookRunner(__filename, void 0, "0.25.0");
       console.log(`Installed pinned hook runner at ${runner}`);
       const features = hookHarness === "claude-code" ? claudeHookFeatures() : void 0;
       const result = hookHarness === "codex" ? installCodexHooks(scope, projectDir) : installClaudeHooks(scope, projectDir, features);
@@ -10318,18 +10553,42 @@ ${total} skill(s) synced.`);
       break;
     }
     case "hooks": {
+      if (positionals[0] === "stats") {
+        const stats = readHookStats(parseArgs(process.argv).sessionId);
+        if (!stats) {
+          console.error(
+            "No hook statistics recorded yet. They are kept per session once the hooks from this version have run."
+          );
+          process.exit(1);
+        }
+        const rows = Object.entries(stats.events).sort(([a], [b]) => a.localeCompare(b));
+        const injected = rows.reduce((sum, [, row]) => sum + row.injectedChars, 0);
+        console.log(`Session ${stats.sessionId} (${stats.harness}), last active ${new Date(stats.updatedAt).toISOString()}`);
+        console.log("event               calls   avg ms   max ms   injected chars");
+        for (const [event, row] of rows) {
+          console.log(
+            `${event.padEnd(18)} ${String(row.count).padStart(6)} ${String(Math.round(row.totalMs / Math.max(row.count, 1))).padStart(8)} ${String(row.maxMs).padStart(8)} ${String(row.injectedChars).padStart(16)}`
+          );
+        }
+        console.log(
+          `Injected into context: ${injected} characters (about ${Math.round(injected / 4)} tokens). Times are measured inside the hook and exclude process start.`
+        );
+        break;
+      }
       if (positionals[0] !== "preview") {
-        console.error("Usage: mindgraph-mcp hooks preview [transcript_path] [--session-id <id>]");
+        console.error(
+          "Usage: mindgraph-mcp hooks preview [transcript_path] [--session-id <id>]\n       mindgraph-mcp hooks stats [--session-id <id>]"
+        );
         process.exit(1);
       }
       const transcript = positionals[1] || latestTranscript(process.cwd());
-      if (!transcript || !fs7.existsSync(transcript)) {
+      if (!transcript || !fs8.existsSync(transcript)) {
         console.error(
           "No transcript found. Pass a Claude Code transcript path (~/.claude/projects/<dir>/<session>.jsonl)."
         );
         process.exit(1);
       }
-      const sessionId = parseArgs(process.argv).sessionId || path7.basename(transcript, ".jsonl");
+      const sessionId = parseArgs(process.argv).sessionId || path8.basename(transcript, ".jsonl");
       const preview = previewCapture(transcript, sessionId, {
         agentId: process.env.MINDGRAPH_AGENT_ID || loadHookEnv().agentId
       });