mindgraph-mcp 0.22.0 → 0.24.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() {
@@ -1184,7 +1184,9 @@ function loadHookEnv(dir) {
       baseUrl: typeof parsed.baseUrl === "string" ? parsed.baseUrl : void 0,
       apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : void 0,
       agentId: typeof parsed.agentId === "string" ? parsed.agentId : void 0,
-      orgId: typeof parsed.orgId === "string" ? parsed.orgId : void 0
+      orgId: typeof parsed.orgId === "string" ? parsed.orgId : void 0,
+      promptRecall: typeof parsed.promptRecall === "boolean" ? parsed.promptRecall : void 0,
+      capture: typeof parsed.capture === "boolean" ? parsed.capture : void 0
     };
   } catch {
     return {};
@@ -1198,7 +1200,9 @@ function saveHookEnv(env, dir) {
     baseUrl: env.baseUrl ?? existing.baseUrl,
     apiKey: env.apiKey ?? existing.apiKey,
     agentId: env.agentId ?? existing.agentId,
-    orgId: env.orgId === null ? void 0 : env.orgId ?? existing.orgId
+    orgId: env.orgId === null ? void 0 : env.orgId ?? existing.orgId,
+    promptRecall: env.promptRecall ?? existing.promptRecall,
+    capture: env.capture ?? existing.capture
   };
   import_node_fs.default.writeFileSync(file, `${JSON.stringify(merged, null, 2)}
 `, {
@@ -1236,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",
@@ -2560,7 +2564,114 @@ 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_path5.default.join(homeDir || import_node_os5.default.homedir(), ".mindgraph")
+  );
+  return { promptRecall: promptRecall2, capture };
+}
 function command(harness) {
   return `node "$HOME/${RUNNER_RELATIVE}" hook --harness ${harness} --owner mindgraph`;
 }
@@ -2568,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_fs4.default.mkdirSync(import_node_path4.default.dirname(target), { recursive: true });
-  const temporary = `${target}.${process.pid}.${import_node_crypto5.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_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_fs4.default.writeFileSync(versionPath, `${version}
+    import_node_fs6.default.writeFileSync(versionPath, `${version}
 `);
   } else {
-    import_node_fs4.default.rmSync(versionPath, { force: true });
+    import_node_fs6.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_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;
@@ -2610,11 +2721,11 @@ 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_fs4.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_fs4.default.existsSync(sourceBundle)) {
+    if (!import_node_fs6.default.existsSync(sourceBundle)) {
       return { refreshed: false, reason: "no_source" };
     }
     const server2 = parseSemver(serverVersion);
@@ -2645,9 +2756,16 @@ 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;
-      installHooks("claude-code", scope, projectDir, void 0, homeDir);
+      if (!import_node_fs6.default.existsSync(file)) continue;
+      if (!import_node_fs6.default.readFileSync(file, "utf8").includes(OWNER_MARKER)) continue;
+      installHooks(
+        "claude-code",
+        scope,
+        projectDir,
+        void 0,
+        homeDir,
+        storedFeatures(homeDir)
+      );
       refreshed.push(file);
     } catch {
     }
@@ -2659,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_fs4.default.existsSync(file)) return {};
-  return JSON.parse(import_node_fs4.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 {
@@ -2679,7 +2797,7 @@ function ownedHook(harness, timeout, additionalContextLimit) {
     ...additionalContextLimit === void 0 ? {} : { additionalContextLimit }
   };
 }
-function desiredEntries(harness) {
+function desiredEntries(harness, features = {}) {
   const common = {
     SessionStart: [
       {
@@ -2711,7 +2829,17 @@ function desiredEntries(harness) {
     ],
     // 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
@@ -2722,11 +2850,17 @@ function desiredEntries(harness) {
       { hooks: [ownedHook(harness, harness === "codex" ? 3 : 30)] }
     ]
   };
-  return harness === "claude-code" ? {
+  if (harness !== "claude-code") return common;
+  return {
     ...common,
     TaskCreated: [{ hooks: [ownedHook(harness, 3)] }],
-    TaskCompleted: [{ hooks: [ownedHook(harness, 3)] }]
-  } : common;
+    TaskCompleted: [{ hooks: [ownedHook(harness, 3)] }],
+    // Bounded recall per prompt: the core gives up at 4s and fails open, so
+    // a 5s budget never holds the prompt longer than that.
+    ...features.promptRecall !== false ? { UserPromptSubmit: [{ hooks: [ownedHook(harness, 5)] }] } : {},
+    // Opt-in transcript capture before compaction (cold-tenant ingest).
+    ...features.capture === true ? { PreCompact: [{ hooks: [ownedHook(harness, 30)] }] } : {}
+  };
 }
 function hookCommand(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
@@ -2739,21 +2873,30 @@ 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_crypto5.default.randomUUID()}.tmp`;
-  import_node_fs4.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_fs4.default.renameSync(temporary, file);
+  import_node_fs6.default.renameSync(temporary, file);
 }
-function installHooks(harness, scope, projectDir = process.cwd(), codexHomeDir, homeDir) {
+function installHooks(harness, scope, projectDir = process.cwd(), codexHomeDir, homeDir, features = {}) {
   const file = settingsPath(harness, scope, projectDir, codexHomeDir, homeDir);
   const settings = readSettings(file);
   const hooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
   let added = 0;
   let updated = 0;
-  for (const [event, wanted] of Object.entries(desiredEntries(harness))) {
+  const desired = desiredEntries(harness, features);
+  for (const optional of ["UserPromptSubmit", "PreCompact"]) {
+    if (optional in desired || !Array.isArray(hooks[optional])) continue;
+    const kept = hooks[optional].filter(
+      (entry) => !entryHasOwnedHook(entry)
+    );
+    if (kept.length > 0) hooks[optional] = kept;
+    else delete hooks[optional];
+  }
+  for (const [event, wanted] of Object.entries(desired)) {
     const current = Array.isArray(hooks[event]) ? [...hooks[event]] : [];
     const kept = current.filter((entry) => !entryHasOwnedHook(entry));
     const hadOwned = kept.length !== current.length;
@@ -2770,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_fs4.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;
@@ -2804,8 +2947,8 @@ function uninstallHooks(harness, scope, projectDir = process.cwd(), codexHomeDir
   writeSettings(file, settings);
   return { path: file, removed };
 }
-function installClaudeHooks(scope, projectDir = process.cwd()) {
-  return installHooks("claude-code", scope, projectDir);
+function installClaudeHooks(scope, projectDir = process.cwd(), features = {}) {
+  return installHooks("claude-code", scope, projectDir, void 0, void 0, features);
 }
 function uninstallClaudeHooks(scope, projectDir = process.cwd()) {
   return uninstallHooks("claude-code", scope, projectDir);
@@ -2816,17 +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_fs4, 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_fs4 = __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";
   }
 });
 
@@ -2834,14 +2979,14 @@ var init_hook_installer = __esm({
 function obj(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-function str(value) {
+function str2(value) {
   return typeof value === "string" && value ? value : void 0;
 }
 function num(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function edgeTypeName(value) {
-  return str(value) ?? str(obj(value)?.Custom);
+  return str2(value) ?? str2(obj(value)?.Custom);
 }
 function renderBudget(requested) {
   if (requested === void 0 || !Number.isFinite(requested)) return RENDER_CHAR_BUDGET;
@@ -2851,7 +2996,7 @@ function renderBudget(requested) {
   );
 }
 function clip(value, max, state) {
-  const text2 = str(value);
+  const text2 = str2(value);
   if (!text2) return void 0;
   if (text2.length <= max) return text2;
   state.bounded = true;
@@ -2860,13 +3005,13 @@ function clip(value, max, state) {
 function isNodeShaped(value) {
   const node = obj(value);
   return Boolean(
-    node && str(node.uid) && (str(node.label) || str(node.node_type) || obj(node.node_type))
+    node && str2(node.uid) && (str2(node.label) || str2(node.node_type) || obj(node.node_type))
   );
 }
 function nodeDisplayType(node) {
   const props = obj(node.props);
-  const plain = str(node.node_type);
-  return (plain && plain !== "Custom" ? plain : void 0) ?? str(obj(node.node_type)?.Custom) ?? str(props?.object_type) ?? str(props?.type_name) ?? str(obj(props?.data)?.domain_type) ?? plain ?? "Node";
+  const plain = str2(node.node_type);
+  return (plain && plain !== "Custom" ? plain : void 0) ?? str2(obj(node.node_type)?.Custom) ?? str2(props?.object_type) ?? str2(props?.type_name) ?? str2(obj(props?.data)?.domain_type) ?? plain ?? "Node";
 }
 function nodeFields(node) {
   const props = obj(node.props);
@@ -2886,10 +3031,10 @@ function statusTag(node) {
   const tags = [];
   if (node.superseded === true) {
     tags.push(
-      node.superseded_by ? `SUPERSEDED by ${str(node.superseded_by)}` : "SUPERSEDED"
+      node.superseded_by ? `SUPERSEDED by ${str2(node.superseded_by)}` : "SUPERSEDED"
     );
   }
-  const truth = str(node.truth_status) ?? str(obj(node.props)?.truth_status);
+  const truth = str2(node.truth_status) ?? str2(obj(node.props)?.truth_status);
   if (truth && truth !== "accepted") tags.push(`truth: ${truth}`);
   if (node.currently_valid === false) tags.push("OUTSIDE ITS VALIDITY WINDOW");
   if (node.valid_at_time === false) tags.push("NOT VALID AT THE REQUESTED TIME");
@@ -2899,7 +3044,7 @@ function firstQuote(node, state) {
   const chunks = Array.isArray(node.source_chunks) ? node.source_chunks : [];
   for (const raw of chunks) {
     const chunk = obj(raw);
-    const quote = str(chunk?.quote) ?? str(obj(chunk?.anchor)?.exact);
+    const quote = str2(chunk?.quote) ?? str2(obj(chunk?.anchor)?.exact);
     if (quote) return clip(quote, QUOTE_MAX, state);
   }
   return void 0;
@@ -2907,7 +3052,7 @@ function firstQuote(node, state) {
 function sourceTag(node) {
   const docs = Array.isArray(node.source_documents) ? node.source_documents : [];
   const first = obj(docs[0]);
-  const title = str(first?.title);
+  const title = str2(first?.title);
   if (!title) return void 0;
   const extra = docs.length > 1 ? ` (+${docs.length - 1} more)` : "";
   return `from: ${title}${extra}`;
@@ -2933,7 +3078,7 @@ function nodeLines(node, state) {
     confidence !== void 0 ? `confidence ${confidence}` : void 0,
     score !== void 0 ? `score ${Math.round(score * 100) / 100}` : void 0
   ].filter(Boolean).join(", ");
-  const head = `- **${label}** [${str(node.uid) || "?"}] (${parenthetical})${statusTag(node)}`;
+  const head = `- **${label}** [${str2(node.uid) || "?"}] (${parenthetical})${statusTag(node)}`;
   const summary = nodeSummaryText(node, state);
   const lines = [summary && summary !== label ? `${head}: ${summary}` : head];
   const fields = layer7Fields(node, state);
@@ -2947,7 +3092,7 @@ function nodeLines(node, state) {
     const rendered2 = believers.slice(0, 3).map((raw) => {
       const believer = obj(raw);
       const conf = num(believer?.confidence);
-      return `${str(believer?.agent_label) || "?"}${conf !== void 0 ? ` (${conf})` : ""}`;
+      return `${str2(believer?.agent_label) || "?"}${conf !== void 0 ? ` (${conf})` : ""}`;
     }).join(", ");
     lines.push(`  - believed by: ${rendered2}`);
   }
@@ -2978,8 +3123,8 @@ function relationshipItems(edges, labelByUid, state, options) {
     const edge = obj(raw);
     if (!edge) continue;
     const type = edgeTypeName(edge.edge_type) || "?";
-    const from = str(edge.from_uid);
-    const to = str(edge.to_uid);
+    const from = str2(edge.from_uid);
+    const to = str2(edge.to_uid);
     if (CURATION_EDGE_TYPES.has(type)) continue;
     if (!from || !to || from === to) continue;
     const fromLabel = labelByUid.get(from) ?? (options?.fallbackToUid ? `[${from}]` : void 0);
@@ -3051,7 +3196,7 @@ function policySections(payload, state) {
   if (policies.length === 0) return [];
   const items = policies.map((raw) => obj(raw)).filter((policy) => Boolean(policy)).map((policy) => {
     const rules = Array.isArray(policy.prose_rules) ? policy.prose_rules.map(String).join("; ") : policy.prose_rules;
-    return `- ${str(policy.name) || "(unnamed policy)"}: ${clip(rules, SUMMARY_MAX, state) || "(structured rules apply)"}`;
+    return `- ${str2(policy.name) || "(unnamed policy)"}: ${clip(rules, SUMMARY_MAX, state) || "(structured rules apply)"}`;
   });
   return [{ heading: "## Applicable policies", items }];
 }
@@ -3068,10 +3213,18 @@ 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);
-  const nodes = shaped.filter((node) => !INFRA_NODE_TYPES.has(str(node.node_type) || ""));
+  const nodes = shaped.filter((node) => !INFRA_NODE_TYPES.has(str2(node.node_type) || ""));
   const infraOnly = shaped.length - nodes.length;
   const articles = Array.isArray(payload.articles) ? payload.articles : [];
   const chunks = Array.isArray(payload.chunks) ? payload.chunks : [];
@@ -3081,7 +3234,7 @@ function renderContext(response, maxChars) {
     sections.push({
       heading: "## Knowledge articles",
       items: articles.map((raw) => obj(raw)).filter((article) => Boolean(article)).map(
-        (article) => `### ${str(article.label) || "(untitled)"} [${str(article.uid) || "?"}]
+        (article) => `### ${str2(article.label) || "(untitled)"} [${str2(article.uid) || "?"}]
 ${clip(article.content, ARTICLE_MAX, state) || ""}`
       )
     });
@@ -3089,7 +3242,7 @@ ${clip(article.content, ARTICLE_MAX, state) || ""}`
   if (nodes.length > 0) {
     sections.push(...groupedNodeSections(nodes, state, "## Knowledge graph\n\n"));
     const labelByUid = /* @__PURE__ */ new Map();
-    for (const node of nodes) labelByUid.set(str(node.uid), str(node.label) || "?");
+    for (const node of nodes) labelByUid.set(str2(node.uid), str2(node.label) || "?");
     const relationships = relationshipItems(
       Array.isArray(graph?.edges) ? graph.edges : [],
       labelByUid,
@@ -3108,7 +3261,7 @@ ${clip(article.content, ARTICLE_MAX, state) || ""}`
     sections.push({
       heading: "## Source excerpts",
       items: chunks.map((raw) => obj(raw)).filter((chunk) => Boolean(chunk)).map(
-        (chunk) => `- [${str(chunk.chunk_uid) || "?"}] from "${str(chunk.document_title) || "unknown document"}": "${clip(chunk.content, CHUNK_MAX, state) || ""}"`
+        (chunk) => `- [${str2(chunk.chunk_uid) || "?"}] from "${str2(chunk.document_title) || "unknown document"}": "${clip(chunk.content, CHUNK_MAX, state) || ""}"`
       )
     });
   }
@@ -3132,15 +3285,15 @@ function resumeEntry(raw, state, fallbackType) {
   if (!wrapper) return void 0;
   const value = obj(wrapper.node) ?? wrapper;
   if (isNodeShaped(value)) return nodeLines(value, state);
-  const uid = str(value.uid);
+  const uid = str2(value.uid);
   const props = obj(value.props);
   const label = clip(value.label, LABEL_MAX, state) ?? clip(value.name, LABEL_MAX, state) ?? clip(value.title, LABEL_MAX, state) ?? clip(value.action, LABEL_MAX, state) ?? fallbackType;
-  const status = str(value.status) ?? str(props?.status);
+  const status = str2(value.status) ?? str2(props?.status);
   const summary = clip(value.summary, SUMMARY_MAX, state) ?? clip(value.description, SUMMARY_MAX, state) ?? clip(value.content, SUMMARY_MAX, state) ?? clip(value.outcome_summary, SUMMARY_MAX, state) ?? clip(props?.summary, SUMMARY_MAX, state);
   const details = [
     status ? `status ${status}` : void 0,
-    str(value.path) ? `path ${str(value.path)}` : void 0,
-    str(value.symbol) ? `symbol ${str(value.symbol)}` : void 0
+    str2(value.path) ? `path ${str2(value.path)}` : void 0,
+    str2(value.symbol) ? `symbol ${str2(value.symbol)}` : void 0
   ].filter(Boolean);
   const head = `- **${label}**${uid ? ` [${uid}]` : ""}${details.length > 0 ? ` (${details.join(", ")})` : ""}`;
   return summary && summary !== label ? `${head}: ${summary}` : head;
@@ -3153,7 +3306,7 @@ function renderResumeContext(response, maxChars) {
   const payload = obj(response);
   if (!payload) return void 0;
   const state = { bounded: false, omitted: 0 };
-  const status = str(payload.status);
+  const status = str2(payload.status);
   if (!payload.task && status === "no_eligible_work") {
     const scopedOut = Array.isArray(payload.scoped_out_tasks) ? payload.scoped_out_tasks.length : 0;
     const note = scopedOut > 0 ? ` ${scopedOut} task(s) exist outside the requested scope.` : "";
@@ -3288,17 +3441,17 @@ function renderTraversal(response, maxChars) {
   const state = { bounded: false, omitted: 0 };
   const sections = [];
   const labelByUid = /* @__PURE__ */ new Map();
-  for (const node of nodes) labelByUid.set(str(node.uid), str(node.label) || "?");
+  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 str(hopNode?.label) || labelByUid.get(str(hopNode?.uid) || "") || str(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
@@ -3312,12 +3465,12 @@ function renderTraversal(response, maxChars) {
   if (hasSteps) {
     const stepItems = rawSteps.map((raw) => obj(raw)).filter((step) => Boolean(step)).map((step) => {
       const depth = num(step.depth);
-      const uid = str(step.node_uid) ?? str(step.uid) ?? str(step.edge_to_uid) ?? "?";
-      const parent = str(step.parent_uid) ?? str(step.edge_from_uid);
-      const label = str(step.label) || "(unlabeled)";
+      const uid = str2(step.node_uid) ?? str2(step.uid) ?? str2(step.edge_to_uid) ?? "?";
+      const parent = str2(step.parent_uid) ?? str2(step.edge_from_uid);
+      const label = str2(step.label) || "(unlabeled)";
       const relation = edgeTypeName(step.edge_type);
-      const role = str(step.traversal_role);
-      const type = str(step.node_type) ?? str(obj(step.node_type)?.Custom);
+      const role = str2(step.traversal_role);
+      const type = str2(step.node_type) ?? str2(obj(step.node_type)?.Custom);
       const cost = num(step.path_cost);
       const confidence = num(step.path_confidence);
       const prefix = [
@@ -3336,9 +3489,9 @@ function renderTraversal(response, maxChars) {
     if (stepItems.length > 0) {
       sections.push({ heading: "## Traversal steps", items: stepItems });
     } else {
-      const start = str(body.start_uid) || "?";
-      const end = str(body.end_uid);
-      const mode2 = str(body.mode);
+      const start = str2(body.start_uid) || "?";
+      const end = str2(body.end_uid);
+      const mode2 = str2(body.mode);
       sections.push({
         heading: mode2 === "path" && end ? `No path found from [${start}] to [${end}].` : `No traversal steps returned from [${start}].`,
         items: []
@@ -3356,7 +3509,7 @@ function renderTraversal(response, maxChars) {
       sections.push({ heading: "## Relationships", items: relationships });
     }
   }
-  const mode = str(body.mode);
+  const mode = str2(body.mode);
   return assemble(
     `# Graph traversal${mode ? ` (${mode})` : ""}`,
     sections,
@@ -3367,9 +3520,9 @@ function renderTraversal(response, maxChars) {
 function neighborLine(value) {
   const node = obj(value);
   if (!node) return void 0;
-  const label = str(node.label) || "(unlabeled)";
-  const uid = str(node.uid);
-  const type = str(node.node_type);
+  const label = str2(node.label) || "(unlabeled)";
+  const uid = str2(node.uid);
+  const type = str2(node.node_type);
   return `- ${label}${uid ? ` [${uid}]` : ""}${type ? ` (${type})` : ""}`;
 }
 function renderOntologyAnswer(response) {
@@ -3389,20 +3542,20 @@ function renderOntologyAnswer(response) {
     sections.push(...groupedNodeSections(objects, state));
   }
   const labelByUid = /* @__PURE__ */ new Map();
-  for (const node of objects) labelByUid.set(str(node.uid), str(node.label) || "?");
+  for (const node of objects) labelByUid.set(str2(node.uid), str2(node.label) || "?");
   const graph = obj(payload.graph);
   for (const raw of Array.isArray(graph?.nodes) ? graph.nodes : []) {
     const node = obj(raw);
-    const uid = str(node?.uid);
-    if (uid && !labelByUid.has(uid)) labelByUid.set(uid, str(node?.label) || "?");
+    const uid = str2(node?.uid);
+    if (uid && !labelByUid.has(uid)) labelByUid.set(uid, str2(node?.label) || "?");
   }
   if (cognitive) {
     for (const rawNodes of Object.values(cognitive)) {
       if (!Array.isArray(rawNodes)) continue;
       for (const raw of rawNodes) {
         const node = obj(raw);
-        const uid = str(node?.uid);
-        if (uid && !labelByUid.has(uid)) labelByUid.set(uid, str(node?.label) || "?");
+        const uid = str2(node?.uid);
+        if (uid && !labelByUid.has(uid)) labelByUid.set(uid, str2(node?.label) || "?");
       }
     }
   }
@@ -3423,9 +3576,9 @@ function renderOntologyAnswer(response) {
   if (provenance.length > 0) {
     const items = provenance.map((raw) => obj(raw)).filter((entry) => Boolean(entry)).map((entry) => {
       const span = clip(entry.text_span, QUOTE_MAX, state) || "";
-      const by = str(entry.ingested_by_name);
-      const suffix = `${by ? ` (ingested by ${by})` : ""} [source ${str(entry.source_uid) || "?"}]`;
-      return str(entry.span_kind) === "anchor" ? `- "${span}"${suffix}` : `- context: ${span}${suffix}`;
+      const by = str2(entry.ingested_by_name);
+      const suffix = `${by ? ` (ingested by ${by})` : ""} [source ${str2(entry.source_uid) || "?"}]`;
+      return str2(entry.span_kind) === "anchor" ? `- "${span}"${suffix}` : `- context: ${span}${suffix}`;
     });
     sections.push({ heading: "## Sources", items });
   }
@@ -3471,20 +3624,20 @@ function renderJobs(response) {
   const items = shown.map((job) => {
     const progress = obj(job.progress);
     const failure = obj(job.error_details);
-    const message = str(failure?.message) ?? str(job.error);
+    const message = str2(failure?.message) ?? str2(job.error);
     const done = num(progress?.processed_chunks);
     const totalChunks = num(progress?.total_chunks);
     const bits = [
-      str(job.status) || "?",
+      str2(job.status) || "?",
       done !== void 0 && totalChunks !== void 0 ? `${done}/${totalChunks} chunks` : void 0,
       num(progress?.nodes_created) !== void 0 ? `${num(progress?.nodes_created)} nodes` : void 0,
       num(job.queue_position) !== void 0 ? `queue #${num(job.queue_position)}` : void 0,
       message ? `error: ${clip(message, 160, state)}` : void 0,
-      str(failure?.code) ? `code: ${clip(failure?.code, 80, state)}` : void 0,
+      str2(failure?.code) ? `code: ${clip(failure?.code, 80, state)}` : void 0,
       num(failure?.status) !== void 0 ? `status: ${num(failure?.status)}` : void 0,
       typeof failure?.retriable === "boolean" ? `retriable: ${failure.retriable}` : void 0
     ].filter(Boolean);
-    return `- [${str(job.id) || "?"}] ${clip(job.title, 120, state) || "(untitled)"} \u2014 ${bits.join(", ")}`;
+    return `- [${str2(job.id) || "?"}] ${clip(job.title, 120, state) || "(untitled)"} \u2014 ${bits.join(", ")}`;
   });
   return assemble(
     `# Ingestion jobs (${shown.length}${shown.length < sorted.length ? ` of ${sorted.length}` : ""})`,
@@ -3500,13 +3653,13 @@ function renderSignals(response) {
   for (const [key, value] of Object.entries(payload)) {
     if (!Array.isArray(value) || value.length === 0) continue;
     const items = value.map((raw) => obj(raw)).filter((item) => Boolean(item)).map((item) => {
-      const fromLabel = str(item.from_label);
-      const toLabel = str(item.to_label);
+      const fromLabel = str2(item.from_label);
+      const toLabel = str2(item.to_label);
       const anyLabelKey = Object.keys(item).find(
-        (k) => k.endsWith("_label") && str(item[k])
+        (k) => k.endsWith("_label") && str2(item[k])
       );
-      const label = str(item.label) ?? str(item.title) ?? str(item.name) ?? (fromLabel && toLabel ? `${fromLabel} \u2194 ${toLabel}` : void 0) ?? (anyLabelKey ? str(item[anyLabelKey]) : void 0) ?? str(item.uid) ?? str(item.target_uid) ?? "(item)";
-      const uid = str(item.uid) ?? str(item.target_uid);
+      const label = str2(item.label) ?? str2(item.title) ?? str2(item.name) ?? (fromLabel && toLabel ? `${fromLabel} \u2194 ${toLabel}` : void 0) ?? (anyLabelKey ? str2(item[anyLabelKey]) : void 0) ?? str2(item.uid) ?? str2(item.target_uid) ?? "(item)";
+      const uid = str2(item.uid) ?? str2(item.target_uid);
       const numbers = Object.entries(item).filter(([, v]) => typeof v === "number").slice(0, 4).map(([k, v]) => `${k} ${Math.round(v * 100) / 100}`);
       const lists = Object.entries(item).filter(([, v]) => Array.isArray(v) && v.length > 0).slice(0, 2).map(([k, v]) => `${k}: ${v.length}`);
       const meta = [...numbers, ...lists].join(", ");
@@ -4025,19 +4178,19 @@ async function handleHostedTool(name, args, client2, identity) {
   try {
     switch (name) {
       case "search": {
-        const query = str2(args.query).trim();
+        const query = str3(args.query).trim();
         if (!query) return err3("query is required");
         const nodes = await contextNodes(client2, query, SEARCH_LIMIT);
         const results = nodes.slice(0, SEARCH_LIMIT).map((node) => ({
-          id: str2(node.uid),
-          title: str2(node.label),
-          url: `${EXPLORER_URL}${encodeURIComponent(str2(node.uid))}`,
-          snippet: str2(node.summary)
+          id: str3(node.uid),
+          title: str3(node.label),
+          url: `${EXPLORER_URL}${encodeURIComponent(str3(node.uid))}`,
+          snippet: str3(node.summary)
         }));
         return twin({ results });
       }
       case "fetch": {
-        const id = str2(args.id).trim();
+        const id = str3(args.id).trim();
         if (!id) return err3("id is required");
         let node;
         try {
@@ -4088,7 +4241,7 @@ async function handleHostedTool(name, args, client2, identity) {
     return toolError(e);
   }
 }
-var EXPLORER_URL, SEARCH_LIMIT, FETCH_TEXT_LIMIT, READ_TOOLS, EVOLVE_TOOLS, SEARCH_OUTPUT_SCHEMA, FETCH_OUTPUT_SCHEMA, HOSTED_TOOLS, HOSTED_TOOL_NAMES, str2;
+var EXPLORER_URL, SEARCH_LIMIT, FETCH_TEXT_LIMIT, READ_TOOLS, EVOLVE_TOOLS, SEARCH_OUTPUT_SCHEMA, FETCH_OUTPUT_SCHEMA, HOSTED_TOOLS, HOSTED_TOOL_NAMES, str3;
 var init_hosted_tools = __esm({
   "src/hosted-tools.ts"() {
     "use strict";
@@ -4179,7 +4332,7 @@ var init_hosted_tools = __esm({
       }
     ];
     HOSTED_TOOL_NAMES = new Set(HOSTED_TOOLS.map((tool) => tool.name));
-    str2 = (value) => typeof value === "string" ? value : "";
+    str3 = (value) => typeof value === "string" ? value : "";
   }
 });
 
@@ -4350,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;
@@ -4414,7 +4567,7 @@ function memoryStatus(config = {}) {
     ]
   };
 }
-function nodeType(node) {
+function nodeType2(node) {
   const raw = node.node_type;
   if (typeof raw === "string") return raw;
   return text(obj2(raw)?.Custom) ?? "Node";
@@ -4427,7 +4580,7 @@ function compactItem(raw, fallbackType) {
   if (!uid) return void 0;
   return defined({
     uid,
-    type: fallbackType ?? nodeType(value),
+    type: fallbackType ?? nodeType2(value),
     label: text(value.label) ?? text(value.document_title),
     truth_status: text(value.truth_status) ?? text(obj2(value.props)?.truth_status),
     superseded: value.superseded === true ? true : void 0,
@@ -4664,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 = {
@@ -4709,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;
@@ -4983,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_fs5.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}`);
     }
@@ -4997,26 +5150,26 @@ function safePath(root, candidate) {
 }
 function realPathOf(target) {
   try {
-    return import_node_fs5.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_fs5.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_fs5.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_fs5.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_fs5.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
   };
@@ -5085,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_fs5.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;
       }
@@ -5129,13 +5282,13 @@ async function scanRepository(remote, repository, requested, provider, agentId)
     files: results
   };
 }
-var import_node_crypto7, import_node_fs5, 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_fs5 = __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) => ({
@@ -5217,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);
 }
@@ -5234,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,
@@ -6040,6 +6193,8 @@ async function handleRetrieve(client2, args, profile) {
     salience_min,
     article_limit,
     valid_at,
+    as_of,
+    retrieval_mode,
     created_after,
     created_before,
     explain,
@@ -6068,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)
       );
@@ -6520,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();
@@ -7249,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"
@@ -7719,7 +7889,12 @@ function buildMindGraphServer(wiring) {
   });
   server2.setRequestHandler(import_types.CallToolRequestSchema, 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) {
@@ -7804,18 +7979,19 @@ async function main() {
   const transport = new import_stdio.StdioServerTransport();
   await server.connect(transport);
   console.error(
-    `MindGraph MCP server v${"0.22.0"} running on stdio (${BASE_URL})`
+    `MindGraph MCP server v${"0.24.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, server;
 var init_src = __esm({
   "src/index.ts"() {
     "use strict";
+    init_call_ledger();
     import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
     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";
@@ -7908,7 +8084,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")
@@ -7916,7 +8092,7 @@ Capture knowledge when the user shares something worth remembering:
     }
     RUNNER_REFRESH = (() => {
       try {
-        return refreshHookRunner("0.22.0", import_node_path6.default.join(__dirname, "cli.js"));
+        return refreshHookRunner("0.24.0", import_node_path7.default.join(__dirname, "cli.js"));
       } catch {
         return void 0;
       }
@@ -7930,12 +8106,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.22.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.24.0"}` + (refreshedSettings.length > 0 ? `; refreshed owned hook entries in ${refreshedSettings.join(", ")}` : "")
       );
     }
     HOOK_SKEW_NOTE = (() => {
       try {
-        return versionSkewNote("0.22.0");
+        return versionSkewNote("0.24.0");
       } catch {
         return void 0;
       }
@@ -7956,7 +8132,7 @@ ${HOOK_SKEW_NOTE}`;
       }
     };
     MEMORY_RUNTIME_CONFIG = {
-      serverVersion: "0.22.0",
+      serverVersion: "0.24.0",
       baseUrl: BASE_URL,
       profile: PROFILE,
       harness: HARNESS,
@@ -7965,12 +8141,13 @@ ${HOOK_SKEW_NOTE}`;
     };
     server = buildMindGraphServer({
       client,
-      serverVersion: "0.22.0",
+      serverVersion: "0.24.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);
@@ -7980,10 +8157,10 @@ ${HOOK_SKEW_NOTE}`;
 });
 
 // src/cli.ts
-var fs6 = __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();
@@ -8001,6 +8178,9 @@ function parseArgs(argv) {
   let agentId = process.env.MINDGRAPH_AGENT_ID;
   const positionals = [];
   let dir;
+  let promptRecall2;
+  let capture;
+  let sessionId;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     switch (arg) {
@@ -8033,6 +8213,21 @@ function parseArgs(argv) {
       case "--hooks":
         hooks = true;
         break;
+      case "--prompt-recall":
+        promptRecall2 = true;
+        break;
+      case "--no-prompt-recall":
+        promptRecall2 = false;
+        break;
+      case "--capture":
+        capture = true;
+        break;
+      case "--no-capture":
+        capture = false;
+        break;
+      case "--session-id":
+        sessionId = args[++i];
+        break;
       case "--owner":
         ++i;
         break;
@@ -8061,7 +8256,10 @@ function parseArgs(argv) {
     hooks,
     agentId,
     positionals,
-    dir
+    dir,
+    promptRecall: promptRecall2,
+    capture,
+    sessionId
   };
 }
 function mcpAddFailureOutput(e) {
@@ -8444,15 +8642,210 @@ async function skillsPush(api, skillPath) {
 }
 
 // src/hook-core.ts
-var import_node_crypto4 = __toESM(require("crypto"));
-var import_node_fs3 = __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_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 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 = [
+  [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "[REDACTED]"],
+  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, "[REDACTED]"],
+  [/\b(?:mg|sk|pk|rk)[_-](?:live[_-]|test[_-]|ant[_-]|proj[_-])?[A-Za-z0-9_-]{16,}/g, "[REDACTED]"],
+  [/\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{20,})/g, "[REDACTED]"],
+  [/\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, "[REDACTED]"],
+  [/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, "[REDACTED]"],
+  [/\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/gi, "Bearer [REDACTED]"],
+  [
+    /\b((?:api[_-]?key|secret|token|password|passwd|access[_-]?key|client[_-]?secret)\b["']?\s*[:=]\s*)["']?[^\s"',;]{8,}["']?/gi,
+    "$1[REDACTED]"
+  ]
+];
+function redactSecrets(text2) {
+  let out = text2;
+  for (const [pattern, replacement] of SECRET_PATTERNS) {
+    out = out.replace(pattern, replacement);
+  }
+  return out;
+}
+function promptRecallQuery(prompt, maxTerms = 8) {
+  if (typeof prompt !== "string") return "";
+  const trimmed = prompt.trim();
+  if (trimmed.length < MIN_PROMPT_RECALL_CHARS || trimmed.startsWith("/")) return "";
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of redactSecrets(trimmed.slice(0, 600)).matchAll(WORD)) {
+    const key = match[0].toLowerCase().replace(/^[.\-/]+|[.\-/]+$/g, "");
+    if (key.length < 2 || STOPWORDS.has(key) || key === "redacted" || seen.has(key)) continue;
+    seen.add(key);
+    if (seen.size >= maxTerms) break;
+  }
+  return [...seen].join(" ");
+}
+function promptRecallRequest(query) {
+  return {
+    query,
+    node_limit: PROMPT_RECALL_LIMIT,
+    chunk_limit: 0,
+    graph_expansion_limit: 3,
+    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) => {
+  const flat = value.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max - 1)}\u2026`;
+};
+var INFRA_TYPES = /* @__PURE__ */ new Set(["Chunk", "Document", "Article", "Session"]);
+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, query) {
+  const payload = rec(response);
+  if (!payload) return void 0;
+  const lines = [];
+  const nodes = Array.isArray(rec(payload.graph)?.nodes) ? rec(payload.graph).nodes : [];
+  for (const raw of nodes) {
+    const node = rec(raw);
+    if (!node || lines.length >= PROMPT_RECALL_LIMIT) continue;
+    const type = nodeType(node);
+    if (INFRA_TYPES.has(type)) continue;
+    const props = rec(node.props);
+    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)}`;
+    if (node.superseded === true) line += " (superseded)";
+    if (summary && summary !== label) line += ` \u2014 ${oneLine(summary, 240)}`;
+    if (source) line += ` (source: ${oneLine(source, 100)})`;
+    lines.push(line);
+  }
+  const articles = Array.isArray(payload.articles) ? payload.articles : [];
+  for (const raw of articles) {
+    const article = rec(raw);
+    if (!article || lines.length >= PROMPT_RECALL_LIMIT) continue;
+    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;
+  let block = "MindGraph recall (bounded):";
+  for (const line of lines) {
+    if (block.length + 1 + line.length > PROMPT_RECALL_MAX_CHARS) break;
+    block += `
+${line}`;
+  }
+  return block;
+}
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  const parts = content.map((block) => rec(block)).filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text);
+  return parts.length > 0 ? parts.join("\n") : void 0;
+}
+function stripHarnessNoise(text2) {
+  return text2.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").replace(/<local-command-(stdout|stderr)>[\s\S]*?<\/local-command-\1>/g, "").replace(/<command-(name|message|args)>[\s\S]*?<\/command-\1>/g, "").replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, "").trim();
+}
+function extractTranscriptTurns(jsonl) {
+  const turns = [];
+  for (const line of jsonl.split("\n")) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = rec(JSON.parse(line));
+    } catch {
+      continue;
+    }
+    if (!entry || entry.type !== "user" && entry.type !== "assistant") continue;
+    if (entry.isMeta === true || entry.isSidechain === true || entry.isCompactSummary === true) continue;
+    const message = rec(entry.message);
+    const raw = messageText(message?.content);
+    if (!raw) continue;
+    const text2 = stripHarnessNoise(raw);
+    if (!text2) continue;
+    turns.push({ role: entry.type, text: text2 });
+  }
+  return turns;
+}
+function renderTranscript(turns) {
+  const rendered2 = turns.map((turn) => `${turn.role === "user" ? "User" : "Assistant"}: ${redactSecrets(turn.text)}`).join("\n\n");
+  if (rendered2.length <= CAPTURE_MAX_CHARS) return rendered2;
+  const tail = rendered2.slice(rendered2.length - CAPTURE_MAX_CHARS);
+  const start = tail.search(/\n\n(User|Assistant): /);
+  return start >= 0 ? tail.slice(start + 2) : tail;
+}
+function readTranscriptSince(file, offset = 0) {
+  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 };
+  return {
+    text: buffer.subarray(start, lastNewline + 1).toString("utf8"),
+    nextOffset: lastNewline + 1
+  };
+}
+function buildCaptureRequest(transcriptPath, sessionId, offset, ids) {
+  const { text: text2, nextOffset } = readTranscriptSince(transcriptPath, offset);
+  const turns = extractTranscriptTurns(text2);
+  const content = renderTranscript(turns);
+  if (!content) return { nextOffset, turns: 0 };
+  return {
+    body: {
+      content,
+      title: `Claude Code session ${sessionId}`,
+      ...ids.sessionUid ? { session_uid: ids.sessionUid } : {},
+      ...ids.agentId ? { agent_id: ids.agentId } : {}
+    },
+    nextOffset,
+    turns: turns.length
+  };
+}
+
+// src/hook-core.ts
 var NOOP = { kind: "noop" };
 function defaultLedger(sessionId, options) {
   return {
@@ -8470,33 +8863,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_fs3.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_fs3.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_fs3.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_fs3.default.statSync(lock).mtimeMs > 3e3) import_node_fs3.default.unlinkSync(lock);
+        if (Date.now() - import_node_fs5.default.statSync(lock).mtimeMs > 3e3) import_node_fs5.default.unlinkSync(lock);
       } catch {
       }
       waitBriefly(10);
@@ -8510,25 +8903,25 @@ function withLedger(sessionId, options, update) {
     try {
       ledger = {
         ...ledger,
-        ...JSON.parse(import_node_fs3.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_fs3.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_fs3.default.renameSync(temporary, file);
+    import_node_fs5.default.renameSync(temporary, file);
     try {
-      import_node_fs3.default.chmodSync(file, 384);
+      import_node_fs5.default.chmodSync(file, 384);
     } catch {
     }
     return result;
   } finally {
-    import_node_fs3.default.closeSync(lockFd);
+    import_node_fs5.default.closeSync(lockFd);
     try {
-      import_node_fs3.default.unlinkSync(lock);
+      import_node_fs5.default.unlinkSync(lock);
     } catch {
     }
   }
@@ -8798,30 +9191,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_fs3.default.existsSync(configPath)) return void 0;
-    const config = JSON.parse(import_node_fs3.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_fs3.default.existsSync(candidate)) {
-        const parsed = JSON.parse(import_node_fs3.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;
@@ -8924,7 +9317,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";
@@ -8999,6 +9392,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([
@@ -9170,6 +9577,9 @@ function stop(input, options) {
 }
 async function sessionEnd(input, client2, options) {
   const harnessLabel = options.harness === "claude-code" ? "Claude Code" : "Codex";
+  if (options.harness === "claude-code") {
+    await captureTranscript(input, client2, options);
+  }
   const ledger = readLedger(input.session_id, options);
   if (ledger.executionUid && ledger.taskUid && ledger.sessionUid && ledger.taskVersion !== void 0 && ledger.leaseEpoch !== void 0) {
     try {
@@ -9203,7 +9613,104 @@ async function sessionEnd(input, client2, options) {
   }
   return NOOP;
 }
+function withDeadline(promise, ms) {
+  let timer;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error("deadline")), ms);
+    timer.unref?.();
+  });
+  return Promise.race([promise, deadline]).finally(() => clearTimeout(timer));
+}
+async function promptRecall(input, client2, options) {
+  if (options.promptRecall === false || process.env.MINDGRAPH_HOOK_PROMPT_RECALL === "off" || !client2.retrieveContext) {
+    return NOOP;
+  }
+  const query = promptRecallQuery(input.prompt);
+  if (!query) return NOOP;
+  try {
+    const response = await withDeadline(
+      client2.retrieveContext(promptRecallRequest(query)),
+      options.promptRecallTimeoutMs ?? 4e3
+    );
+    const block = renderPromptRecall(response, query);
+    if (!block) return NOOP;
+    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;
+      return true;
+    });
+    return fresh ? { kind: "context", context: block, event: "UserPromptSubmit" } : NOOP;
+  } catch {
+    return NOOP;
+  }
+}
+async function captureTranscript(input, client2, options) {
+  const enabled = process.env.MINDGRAPH_HOOK_CAPTURE === "on" || options.capture === true && process.env.MINDGRAPH_HOOK_CAPTURE !== "off";
+  if (!enabled || !client2.ingestSession || !input.transcript_path) return;
+  try {
+    const agentId = resolveAgentId(options);
+    const ledger = readLedger(input.session_id, options);
+    let sessionUid = ledger.sessionUid;
+    const prepared = buildCaptureRequest(
+      input.transcript_path,
+      input.session_id,
+      ledger.captureOffset ?? 0,
+      { sessionUid, agentId }
+    );
+    if (prepared.body && !sessionUid) {
+      const opened = object(
+        await client2.session({
+          action: "open",
+          label: `Claude Code ${input.session_id}`,
+          harness: options.harness,
+          harness_session_id: input.session_id,
+          model: input.model,
+          agent_id: agentId
+        })
+      );
+      sessionUid = string(opened?.uid);
+      if (sessionUid) prepared.body.session_uid = sessionUid;
+    }
+    if (prepared.body) await client2.ingestSession(prepared.body);
+    withLedger(input.session_id, options, (current) => {
+      if (sessionUid) current.sessionUid ??= sessionUid;
+      current.captureOffset = Math.max(current.captureOffset ?? 0, prepared.nextOffset);
+      return void 0;
+    });
+  } catch (error2) {
+    console.error(
+      `mindgraph-hook: transcript capture failed (${error2?.message || "unknown error"})`
+    );
+  }
+}
 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);
@@ -9228,6 +9735,11 @@ async function runHookCore(input, client2, options) {
       return stop(input, options);
     case "SessionEnd":
       return sessionEnd(input, client2, options);
+    case "UserPromptSubmit":
+      return promptRecall(input, client2, options);
+    case "PreCompact":
+      await captureTranscript(input, client2, options);
+      return NOOP;
     default:
       return NOOP;
   }
@@ -9239,6 +9751,54 @@ async function readHookInput(stream = process.stdin) {
   }
   return JSON.parse(Buffer.concat(chunks).toString("utf8"));
 }
+function previewCapture(transcriptPath, sessionId, options = {}) {
+  let ledger = {};
+  try {
+    ledger = JSON.parse(
+      import_node_fs5.default.readFileSync(
+        ledgerPath(sessionId, { ...options, harness: "claude-code" }),
+        "utf8"
+      )
+    );
+  } catch {
+  }
+  const offset = ledger.captureOffset ?? 0;
+  return {
+    ...buildCaptureRequest(transcriptPath, sessionId, offset, {
+      sessionUid: ledger.sessionUid,
+      agentId: options.agentId || process.env.MINDGRAPH_AGENT_ID || stableAgentId()
+    }),
+    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 = {}) {
@@ -9253,17 +9813,12 @@ async function runClaudeHook(input, client2, options = {}) {
     case "context":
       return {
         hookSpecificOutput: {
-          hookEventName: "SessionStart",
+          hookEventName: output.event ?? "SessionStart",
           additionalContext: output.context
         }
       };
     case "rewrite":
-      return {
-        hookSpecificOutput: {
-          hookEventName: "PreToolUse",
-          updatedInput: output.updatedInput
-        }
-      };
+      return {};
     case "block":
       return { decision: "block", reason: output.reason };
     case "noop":
@@ -9283,7 +9838,7 @@ async function runCodexHook(input, client2, options = {}) {
     case "context":
       return {
         hookSpecificOutput: {
-          hookEventName: "SessionStart",
+          hookEventName: output.event ?? "SessionStart",
           additionalContext: output.context
         }
       };
@@ -9306,15 +9861,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");
-    fs6.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(fs6.readFileSync(file, "utf8")).consecutiveFailures) || 0;
+      failures = Number(JSON.parse(fs8.readFileSync(file, "utf8")).consecutiveFailures) || 0;
     } catch {
     }
-    fs6.writeFileSync(
+    fs8.writeFileSync(
       file,
       `${JSON.stringify({
         harness,
@@ -9330,14 +9885,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 (!fs6.existsSync(file)) return;
-    const current = JSON.parse(fs6.readFileSync(file, "utf8"));
+    if (!fs8.existsSync(file)) return;
+    const current = JSON.parse(fs8.readFileSync(file, "utf8"));
     if (!Number(current.consecutiveFailures)) return;
-    fs6.writeFileSync(
+    fs8.writeFileSync(
       file,
       `${JSON.stringify({
         harness,
@@ -9353,22 +9908,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"
@@ -9378,16 +9933,16 @@ function getClaudeDesktopConfigPath() {
   }
 }
 function readJsonFile(filePath) {
-  if (!fs6.existsSync(filePath)) return {};
-  const content = fs6.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 (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  const dir = path8.dirname(filePath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
-  fs6.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 };
@@ -9474,7 +10029,7 @@ function installClaudeCode(apiKey, baseUrl, agentId) {
 }
 function uninstallClaudeDesktop() {
   const configPath = getClaudeDesktopConfigPath();
-  if (!fs6.existsSync(configPath)) {
+  if (!fs8.existsSync(configPath)) {
     console.log("Claude Desktop config not found. Nothing to remove.");
     return;
   }
@@ -9501,7 +10056,7 @@ function uninstallClaudeCode() {
 }
 function printStatus() {
   const desktopPath = getClaudeDesktopConfigPath();
-  if (fs6.existsSync(desktopPath)) {
+  if (fs8.existsSync(desktopPath)) {
     const config = readJsonFile(desktopPath);
     const servers = config.mcpServers;
     if (servers && "mindgraph" in servers) {
@@ -9519,12 +10074,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 (fs6.existsSync(healthFile)) {
-      const health = JSON.parse(fs6.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"})`
@@ -9539,17 +10094,46 @@ function printStatus() {
 function withHooksFlag() {
   return process.argv.includes("--hooks");
 }
+function claudeHookFeatures() {
+  const flags = parseArgs(process.argv);
+  const stored = loadHookEnv();
+  return {
+    promptRecall: flags.promptRecall ?? stored.promptRecall ?? true,
+    capture: flags.capture ?? stored.capture ?? false
+  };
+}
+function printClaudeHookFeatures(features) {
+  console.log(
+    `Prompt recall (UserPromptSubmit): ${features.promptRecall ? "on" : "off"}; transcript capture (PreCompact/SessionEnd): ${features.capture ? "ON \u2014 user and assistant text (never tool calls or tool output), secrets redacted, is sent to MindGraph /ingest/session" : "off (enable with --capture)"}`
+  );
+}
+function latestTranscript(cwd) {
+  const dir = path8.join(
+    os5.homedir(),
+    ".claude",
+    "projects",
+    cwd.replace(/[^A-Za-z0-9]/g, "-")
+  );
+  try {
+    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.22.0");
+    const runner = installHookRunner(__filename, void 0, "0.24.0");
     console.log(`Installed pinned hook runner at ${runner}`);
-    const result = installClaudeHooks("user");
+    const features = claudeHookFeatures();
+    const result = installClaudeHooks("user", void 0, features);
     console.log(
       `Installed ${result.added} and refreshed ${result.updated} MindGraph Claude Code hook entries in ${result.path}`
     );
+    printClaudeHookFeatures(features);
     const envPath = saveHookEnv({
       apiKey,
       baseUrl,
+      ...features,
       // Default the stable per-user identity only when nothing is stored —
       // an explicit or previously persisted agentId must survive reinstalls.
       agentId: agentId || process.env.MINDGRAPH_AGENT_ID || loadHookEnv().agentId || stableAgentId(),
@@ -9588,6 +10172,12 @@ USAGE:
   mindgraph-mcp uninstall-code   Remove from Claude Code
   mindgraph-mcp install-hooks --harness claude-code|codex [--scope user|project]
   mindgraph-mcp uninstall-hooks --harness claude-code|codex [--scope user|project]
+  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
@@ -9610,6 +10200,10 @@ OPTIONS:
   --scope <scope>     Hook settings scope: project (default) or user
   --project-dir <dir> Project root for project-scoped hooks
   --harness <name>    Hook harness (claude-code or codex)
+  --no-prompt-recall  Claude hooks: omit per-prompt recall (UserPromptSubmit)
+  --capture           Claude hooks: send user/assistant text to MindGraph
+                      before compaction and at session end (off by default;
+                      --no-capture turns it back off)
   --help, -h          Show this help message
 
 EXAMPLES:
@@ -9629,7 +10223,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 {
@@ -9856,16 +10450,19 @@ ${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.22.0");
+      const runner = installHookRunner(__filename, void 0, "0.24.0");
       console.log(`Installed pinned hook runner at ${runner}`);
-      const result = hookHarness === "codex" ? installCodexHooks(scope, projectDir) : installClaudeHooks(scope, projectDir);
+      const features = hookHarness === "claude-code" ? claudeHookFeatures() : void 0;
+      const result = hookHarness === "codex" ? installCodexHooks(scope, projectDir) : installClaudeHooks(scope, projectDir, features);
       console.log(
         `Installed ${result.added} and refreshed ${result.updated} MindGraph ${hookHarness === "codex" ? "Codex" : "Claude Code"} hook entries in ${result.path}`
       );
+      if (features) printClaudeHookFeatures(features);
       printCodegraphStatus();
       const envPath = saveHookEnv({
         apiKey,
         baseUrl,
+        ...features || {},
         // Default the stable per-user identity only when nothing is stored —
         // an explicit or previously persisted agentId must survive
         // reinstalls.
@@ -9917,9 +10514,14 @@ ${total} skill(s) synced.`);
           // DEFAULT org while the MCP tools write to the pinned one.
           orgId: process.env.MINDGRAPH_ORG_ID || stored.orgId,
           maxRetries: 0,
-          telemetrySurface: "mcp"
+          telemetrySurface: "mcp",
+          // Prompt recall must never hold the prompt: abort the request at
+          // the same 4s deadline the core races it against.
+          ...input.hook_event_name === "UserPromptSubmit" ? { timeoutMs: 4e3 } : {}
         });
         const hookOptions = {
+          promptRecall: stored.promptRecall,
+          capture: stored.capture,
           // No harness-name fallback here: hook-core derives a stable
           // per-user default shared by both harnesses, which is what lets a
           // task claimed under Codex rebind under Claude Code.
@@ -9934,9 +10536,11 @@ ${total} skill(s) synced.`);
           client2,
           hookOptions
         );
-        process.stdout.write(`${JSON.stringify(output)}
-`);
         clearHookHealth(hookHarness);
+        process.stdout.write(`${JSON.stringify(output)}
+`, () => {
+          if (input.hook_event_name === "UserPromptSubmit") process.exit(0);
+        });
       } catch (error2) {
         recordHookHealth(
           hookHarness,
@@ -9949,6 +10553,59 @@ ${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>]\n       mindgraph-mcp hooks stats [--session-id <id>]"
+        );
+        process.exit(1);
+      }
+      const transcript = positionals[1] || latestTranscript(process.cwd());
+      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 || path8.basename(transcript, ".jsonl");
+      const preview = previewCapture(transcript, sessionId, {
+        agentId: process.env.MINDGRAPH_AGENT_ID || loadHookEnv().agentId
+      });
+      const enabled = loadHookEnv().capture === true;
+      console.error(
+        `Transcript: ${transcript}
+Session: ${sessionId}
+Capture is ${enabled ? "ON" : "OFF (nothing is sent; enable with install-hooks --capture)"}
+Would send ${preview.turns} turn(s) from byte ${preview.offset} as POST /ingest/session (nothing sent by this preview):`
+      );
+      process.stdout.write(
+        `${JSON.stringify(preview.body ?? null, null, 2)}
+`
+      );
+      break;
+    }
     case "status":
       printStatus();
       break;