mindgraph-mcp 0.22.0 → 0.23.0

package/dist/cli.js

@@ -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)}
 `, {
@@ -2561,6 +2565,12 @@ var init_code_tool = __esm({
 });
 
 // src/hook-installer.ts
+function storedFeatures(homeDir) {
+  const { promptRecall: promptRecall2, capture } = loadHookEnv(
+    import_node_path4.default.join(homeDir || import_node_os4.default.homedir(), ".mindgraph")
+  );
+  return { promptRecall: promptRecall2, capture };
+}
 function command(harness) {
   return `node "$HOME/${RUNNER_RELATIVE}" hook --harness ${harness} --owner mindgraph`;
 }
@@ -2569,22 +2579,22 @@ function windowsCommand(harness) {
 }
 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 });
+  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(target), { recursive: true });
   const temporary = `${target}.${process.pid}.${import_node_crypto5.default.randomUUID()}.tmp`;
-  import_node_fs4.default.copyFileSync(sourceFile, temporary);
-  import_node_fs4.default.renameSync(temporary, target);
+  import_node_fs5.default.copyFileSync(sourceFile, temporary);
+  import_node_fs5.default.renameSync(temporary, target);
   const versionPath = import_node_path4.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_VERSION_RELATIVE);
   if (version) {
-    import_node_fs4.default.writeFileSync(versionPath, `${version}
+    import_node_fs5.default.writeFileSync(versionPath, `${version}
 `);
   } else {
-    import_node_fs4.default.rmSync(versionPath, { force: true });
+    import_node_fs5.default.rmSync(versionPath, { force: true });
   }
   return target;
 }
 function installedHookRunnerVersion(homeDir) {
   try {
-    const raw = import_node_fs4.default.readFileSync(
+    const raw = import_node_fs5.default.readFileSync(
       import_node_path4.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_VERSION_RELATIVE),
       "utf8"
     ).trim();
@@ -2611,10 +2621,10 @@ function refreshHookRunner(serverVersion, sourceBundle, homeDir) {
       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))) {
+    if (!import_node_fs5.default.existsSync(import_node_path4.default.join(home, RUNNER_RELATIVE))) {
       return { refreshed: false, reason: "no_runner" };
     }
-    if (!import_node_fs4.default.existsSync(sourceBundle)) {
+    if (!import_node_fs5.default.existsSync(sourceBundle)) {
       return { refreshed: false, reason: "no_source" };
     }
     const server2 = parseSemver(serverVersion);
@@ -2645,9 +2655,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_fs5.default.existsSync(file)) continue;
+      if (!import_node_fs5.default.readFileSync(file, "utf8").includes(OWNER_MARKER)) continue;
+      installHooks(
+        "claude-code",
+        scope,
+        projectDir,
+        void 0,
+        homeDir,
+        storedFeatures(homeDir)
+      );
       refreshed.push(file);
     } catch {
     }
@@ -2666,8 +2683,8 @@ function settingsPath(harness, scope, projectDir = process.cwd(), codexHomeDir =
   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");
 }
 function readSettings(file) {
-  if (!import_node_fs4.default.existsSync(file)) return {};
-  return JSON.parse(import_node_fs4.default.readFileSync(file, "utf8"));
+  if (!import_node_fs5.default.existsSync(file)) return {};
+  return JSON.parse(import_node_fs5.default.readFileSync(file, "utf8"));
 }
 function ownedHook(harness, timeout, additionalContextLimit) {
   return {
@@ -2679,7 +2696,7 @@ function ownedHook(harness, timeout, additionalContextLimit) {
     ...additionalContextLimit === void 0 ? {} : { additionalContextLimit }
   };
 }
-function desiredEntries(harness) {
+function desiredEntries(harness, features = {}) {
   const common = {
     SessionStart: [
       {
@@ -2722,11 +2739,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 +2762,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 });
+  import_node_fs5.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
   const temporary = `${file}.${process.pid}.${import_node_crypto5.default.randomUUID()}.tmp`;
-  import_node_fs4.default.writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}
+  import_node_fs5.default.writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}
 `, {
     mode: 384
   });
-  import_node_fs4.default.renameSync(temporary, file);
+  import_node_fs5.default.renameSync(temporary, file);
 }
-function installHooks(harness, scope, projectDir = process.cwd(), codexHomeDir, homeDir) {
+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 +2802,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_fs5.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 +2836,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,14 +2848,15 @@ 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_fs5, import_node_os4, import_node_path4, import_node_crypto5, OWNER_MARKER, RUNNER_RELATIVE, RUNNER_VERSION_RELATIVE;
 var init_hook_installer = __esm({
   "src/hook-installer.ts"() {
     "use strict";
-    import_node_fs4 = __toESM(require("fs"));
+    import_node_fs5 = __toESM(require("fs"));
     import_node_os4 = __toESM(require("os"));
     import_node_path4 = __toESM(require("path"));
     import_node_crypto5 = __toESM(require("crypto"));
+    init_hook_env();
     OWNER_MARKER = "--owner mindgraph";
     RUNNER_RELATIVE = ".mindgraph/bin/mindgraph-hook.cjs";
     RUNNER_VERSION_RELATIVE = `${RUNNER_RELATIVE}.version`;
@@ -2834,14 +2867,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 +2884,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 +2893,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 +2919,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 +2932,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 +2940,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 +2966,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 +2980,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 +3011,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 +3084,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 }];
 }
@@ -3071,7 +3104,7 @@ function renderContext(response, maxChars) {
   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 +3114,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 +3122,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 +3141,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 +3165,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 +3186,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,13 +3321,13 @@ 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 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);
@@ -3312,12 +3345,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 +3369,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 +3389,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 +3400,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 +3422,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 +3456,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 +3504,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 +3533,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 +4058,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 +4121,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 +4212,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 : "";
   }
 });
 
@@ -4414,7 +4447,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 +4460,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,
@@ -4988,7 +5021,7 @@ function safePath(root, candidate) {
   if (relative2.startsWith("..") || import_node_path5.default.isAbsolute(relative2)) {
     throw new Error(`path escapes repository root: ${candidate}`);
   }
-  if (import_node_fs5.default.existsSync(absolute)) {
+  if (import_node_fs6.default.existsSync(absolute)) {
     if (!pathContains(realPathOf(root), realPathOf(absolute))) {
       throw new Error(`path escapes repository root via symlink: ${candidate}`);
     }
@@ -4997,23 +5030,23 @@ function safePath(root, candidate) {
 }
 function realPathOf(target) {
   try {
-    return import_node_fs5.default.realpathSync(target);
+    return import_node_fs6.default.realpathSync(target);
   } catch {
     return import_node_path5.default.resolve(target);
   }
 }
 function markdownFiles(target, realRoot, visited = /* @__PURE__ */ new Set()) {
-  if (!import_node_fs5.default.existsSync(target)) return [];
+  if (!import_node_fs6.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_fs6.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_fs6.default.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(import_node_path5.default.join(target, entry.name), realRoot, visited));
 }
 function fileDescriptor(root, absolute) {
-  const content = import_node_fs5.default.readFileSync(absolute, "utf8");
+  const content = import_node_fs6.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"),
@@ -5085,7 +5118,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_fs6.default.existsSync(absolute);
       if (request.file_present && !request.content_hash) {
         request.content_hash = fileDescriptor(root, absolute).content_hash;
       }
@@ -5129,12 +5162,12 @@ 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_crypto7, import_node_fs6, import_node_path5, 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_fs6 = __toESM(require("fs"));
     import_node_path5 = __toESM(require("path"));
     init_codegraph();
     init_error_detail();
@@ -7804,7 +7837,7 @@ 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.23.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;
@@ -7916,7 +7949,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.23.0", import_node_path6.default.join(__dirname, "cli.js"));
       } catch {
         return void 0;
       }
@@ -7930,12 +7963,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.23.0"}` + (refreshedSettings.length > 0 ? `; refreshed owned hook entries in ${refreshedSettings.join(", ")}` : "")
       );
     }
     HOOK_SKEW_NOTE = (() => {
       try {
-        return versionSkewNote("0.22.0");
+        return versionSkewNote("0.23.0");
       } catch {
         return void 0;
       }
@@ -7956,7 +7989,7 @@ ${HOOK_SKEW_NOTE}`;
       }
     };
     MEMORY_RUNTIME_CONFIG = {
-      serverVersion: "0.22.0",
+      serverVersion: "0.23.0",
       baseUrl: BASE_URL,
       profile: PROFILE,
       harness: HARNESS,
@@ -7965,7 +7998,7 @@ ${HOOK_SKEW_NOTE}`;
     };
     server = buildMindGraphServer({
       client,
-      serverVersion: "0.22.0",
+      serverVersion: "0.23.0",
       instructions: INSTRUCTIONS,
       profile: PROFILE,
       agentId: AGENT_ID,
@@ -7980,7 +8013,7 @@ ${HOOK_SKEW_NOTE}`;
 });
 
 // src/cli.ts
-var fs6 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 var path7 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 var crypto5 = __toESM(require("crypto"));
@@ -8001,6 +8034,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 +8069,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 +8112,10 @@ function parseArgs(argv) {
     hooks,
     agentId,
     positionals,
-    dir
+    dir,
+    promptRecall: promptRecall2,
+    capture,
+    sessionId
   };
 }
 function mcpAddFailureOutput(e) {
@@ -8445,7 +8499,7 @@ 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_fs4 = __toESM(require("fs"));
 var import_node_os3 = __toESM(require("os"));
 var import_node_path3 = __toESM(require("path"));
 var import_node_child_process2 = require("child_process");
@@ -8453,6 +8507,175 @@ init_codegraph();
 init_code_tool();
 init_error_detail();
 init_hook_env();
+
+// src/hook-memory.ts
+var import_node_fs3 = __toESM(require("fs"));
+var PROMPT_RECALL_LIMIT = 5;
+var PROMPT_RECALL_MAX_CHARS = 4e3;
+var MIN_PROMPT_RECALL_CHARS = 12;
+var CAPTURE_MAX_CHARS = 2e5;
+var STOPWORDS = new Set(
+  "a an and are as at be but by can could did do does for from had has have how i if in into is it its me my of on or our please should so that the their them then there these they this to us was we were what when where which who why will with would you your about just also any some tell know want need let lets like get got make".split(" ")
+);
+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
+  };
+}
+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) {
+  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 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);
+    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_fs3.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 {
@@ -8482,21 +8705,21 @@ function waitBriefly(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_fs4.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true, mode: 448 });
   try {
-    import_node_fs3.default.chmodSync(import_node_path3.default.dirname(file), 448);
+    import_node_fs4.default.chmodSync(import_node_path3.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_fs4.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_fs4.default.statSync(lock).mtimeMs > 3e3) import_node_fs4.default.unlinkSync(lock);
       } catch {
       }
       waitBriefly(10);
@@ -8510,25 +8733,25 @@ function withLedger(sessionId, options, update) {
     try {
       ledger = {
         ...ledger,
-        ...JSON.parse(import_node_fs3.default.readFileSync(file, "utf8"))
+        ...JSON.parse(import_node_fs4.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)}
+    import_node_fs4.default.writeFileSync(temporary, `${JSON.stringify(ledger)}
 `, { mode: 384 });
-    import_node_fs3.default.renameSync(temporary, file);
+    import_node_fs4.default.renameSync(temporary, file);
     try {
-      import_node_fs3.default.chmodSync(file, 384);
+      import_node_fs4.default.chmodSync(file, 384);
     } catch {
     }
     return result;
   } finally {
-    import_node_fs3.default.closeSync(lockFd);
+    import_node_fs4.default.closeSync(lockFd);
     try {
-      import_node_fs3.default.unlinkSync(lock);
+      import_node_fs4.default.unlinkSync(lock);
     } catch {
     }
   }
@@ -8807,8 +9030,8 @@ function claudeMcpRegistrationNote(input, options) {
   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"));
+    if (!import_node_fs4.default.existsSync(configPath)) return void 0;
+    const config = JSON.parse(import_node_fs4.default.readFileSync(configPath, "utf8"));
     if (hasMindgraphServer(config.mcpServers)) return void 0;
     const cwd = import_node_path3.default.resolve(input.cwd || ".");
     for (const [projectDir, project] of Object.entries(config.projects || {})) {
@@ -8817,8 +9040,8 @@ function claudeMcpRegistrationNote(input, options) {
     }
     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"));
+      if (import_node_fs4.default.existsSync(candidate)) {
+        const parsed = JSON.parse(import_node_fs4.default.readFileSync(candidate, "utf8"));
         if (hasMindgraphServer(parsed.mcpServers)) return void 0;
       }
       if (dir === import_node_path3.default.dirname(dir)) break;
@@ -9170,6 +9393,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,6 +9429,77 @@ 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);
+    if (!block) return NOOP;
+    const hash = import_node_crypto4.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) {
   switch (input.hook_event_name) {
     case "SessionStart":
@@ -9228,6 +9525,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 +9541,26 @@ 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_fs4.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
+  };
+}
 
 // src/claude-hooks.ts
 async function runClaudeHook(input, client2, options = {}) {
@@ -9253,7 +9575,7 @@ async function runClaudeHook(input, client2, options = {}) {
     case "context":
       return {
         hookSpecificOutput: {
-          hookEventName: "SessionStart",
+          hookEventName: output.event ?? "SessionStart",
           additionalContext: output.context
         }
       };
@@ -9283,7 +9605,7 @@ async function runCodexHook(input, client2, options = {}) {
     case "context":
       return {
         hookSpecificOutput: {
-          hookEventName: "SessionStart",
+          hookEventName: output.event ?? "SessionStart",
           additionalContext: output.context
         }
       };
@@ -9307,14 +9629,14 @@ 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 });
+    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
     const file = path7.join(dir, "hook-health.json");
     let failures = 0;
     try {
-      failures = Number(JSON.parse(fs6.readFileSync(file, "utf8")).consecutiveFailures) || 0;
+      failures = Number(JSON.parse(fs7.readFileSync(file, "utf8")).consecutiveFailures) || 0;
     } catch {
     }
-    fs6.writeFileSync(
+    fs7.writeFileSync(
       file,
       `${JSON.stringify({
         harness,
@@ -9334,10 +9656,10 @@ function clearHookHealth(harness) {
       process.env.MINDGRAPH_RUNTIME_DIR || path7.join(os4.homedir(), ".mindgraph", "runtime"),
       "hook-health.json"
     );
-    if (!fs6.existsSync(file)) return;
-    const current = JSON.parse(fs6.readFileSync(file, "utf8"));
+    if (!fs7.existsSync(file)) return;
+    const current = JSON.parse(fs7.readFileSync(file, "utf8"));
     if (!Number(current.consecutiveFailures)) return;
-    fs6.writeFileSync(
+    fs7.writeFileSync(
       file,
       `${JSON.stringify({
         harness,
@@ -9378,16 +9700,16 @@ function getClaudeDesktopConfigPath() {
   }
 }
 function readJsonFile(filePath) {
-  if (!fs6.existsSync(filePath)) return {};
-  const content = fs6.readFileSync(filePath, "utf-8");
+  if (!fs7.existsSync(filePath)) return {};
+  const content = fs7.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 });
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
-  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs7.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 function getMcpServerEntry(apiKey, baseUrl) {
   const env = { MINDGRAPH_API_KEY: apiKey };
@@ -9474,7 +9796,7 @@ function installClaudeCode(apiKey, baseUrl, agentId) {
 }
 function uninstallClaudeDesktop() {
   const configPath = getClaudeDesktopConfigPath();
-  if (!fs6.existsSync(configPath)) {
+  if (!fs7.existsSync(configPath)) {
     console.log("Claude Desktop config not found. Nothing to remove.");
     return;
   }
@@ -9501,7 +9823,7 @@ function uninstallClaudeCode() {
 }
 function printStatus() {
   const desktopPath = getClaudeDesktopConfigPath();
-  if (fs6.existsSync(desktopPath)) {
+  if (fs7.existsSync(desktopPath)) {
     const config = readJsonFile(desktopPath);
     const servers = config.mcpServers;
     if (servers && "mindgraph" in servers) {
@@ -9523,8 +9845,8 @@ function printStatus() {
       process.env.MINDGRAPH_RUNTIME_DIR || path7.join(os4.homedir(), ".mindgraph", "runtime"),
       "hook-health.json"
     );
-    if (fs6.existsSync(healthFile)) {
-      const health = JSON.parse(fs6.readFileSync(healthFile, "utf8"));
+    if (fs7.existsSync(healthFile)) {
+      const health = JSON.parse(fs7.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 +9861,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 = path7.join(
+    os4.homedir(),
+    ".claude",
+    "projects",
+    cwd.replace(/[^A-Za-z0-9]/g, "-")
+  );
+  try {
+    return fs7.readdirSync(dir).filter((name) => name.endsWith(".jsonl")).map((name) => path7.join(dir, name)).sort((a, b) => fs7.statSync(b).mtimeMs - fs7.statSync(a).mtimeMs)[0];
+  } 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.23.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 +9939,9 @@ 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 status           Show installation status
   mindgraph-mcp skills pull [--dir .claude/skills]
                                  Write your org's published+granted skills as
@@ -9610,6 +9964,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:
@@ -9856,16 +10214,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.23.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 +10278,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 +10300,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 +10317,35 @@ ${total} skill(s) synced.`);
       }
       break;
     }
+    case "hooks": {
+      if (positionals[0] !== "preview") {
+        console.error("Usage: mindgraph-mcp hooks preview [transcript_path] [--session-id <id>]");
+        process.exit(1);
+      }
+      const transcript = positionals[1] || latestTranscript(process.cwd());
+      if (!transcript || !fs7.existsSync(transcript)) {
+        console.error(
+          "No transcript found. Pass a Claude Code transcript path (~/.claude/projects/<dir>/<session>.jsonl)."
+        );
+        process.exit(1);
+      }
+      const sessionId = parseArgs(process.argv).sessionId || path7.basename(transcript, ".jsonl");
+      const 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;