mindgraph-mcp 0.19.0 → 0.20.0

package/dist/cli.js

@@ -83,12 +83,12 @@ var init_dist = __esm({
         for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
           const res = await fetch(url, init);
           if (!res.ok) {
-            const text2 = await res.text().catch(() => "");
+            const text22 = await res.text().catch(() => "");
             let parsed;
             try {
-              parsed = JSON.parse(text2);
+              parsed = JSON.parse(text22);
             } catch {
-              parsed = text2;
+              parsed = text22;
             }
             const err5 = new MindGraphError(
               `${method} ${path8} failed: ${res.status}`,
@@ -104,9 +104,9 @@ var init_dist = __esm({
             }
             throw err5;
           }
-          const text = await res.text();
-          if (!text) return void 0;
-          return JSON.parse(text);
+          const text2 = await res.text();
+          if (!text2) return void 0;
+          return JSON.parse(text2);
         }
         throw lastError;
       }
@@ -232,10 +232,10 @@ var init_dist = __esm({
        * Resolve text to an existing entity via alias matching.
        * Returns `{ uid: string | null }`.
        */
-      async resolveEntity(text, agentId) {
+      async resolveEntity(text2, agentId) {
         return this.post("/reality/entity", {
           action: "resolve",
-          text,
+          text: text2,
           agent_id: agentId
         });
       }
@@ -243,10 +243,10 @@ var init_dist = __esm({
        * Fuzzy-match text against existing entities.
        * Returns `{ matches: [{ uid, label, score }] }`.
        */
-      async fuzzyResolveEntity(text, limit = 5, agentId) {
+      async fuzzyResolveEntity(text2, limit = 5, agentId) {
         return this.post("/reality/entity", {
           action: "fuzzy_resolve",
-          text,
+          text: text2,
           limit,
           agent_id: agentId
         });
@@ -545,8 +545,8 @@ var init_dist = __esm({
       async getAliases(uid) {
         return this.get(`/aliases/${seg(uid)}`);
       }
-      async resolveAlias(text) {
-        return this.get(`/resolve?text=${encodeURIComponent(text)}`);
+      async resolveAlias(text2) {
+        return this.get(`/resolve?text=${encodeURIComponent(text2)}`);
       }
       // ---- Export / Import ----
       async exportGraph() {
@@ -1163,29 +1163,29 @@ async function runProcess(executable, args, timeoutMs, env, cwd) {
     child.stderr.on("data", collect(stderr));
     child.on("error", (cause) => {
       clearTimeout(timer);
-      const error = new Error(cause.message);
-      error.kind = cause.code === "ENOENT" ? "absent" : "command_failed";
-      rejectPromise(error);
+      const error2 = new Error(cause.message);
+      error2.kind = cause.code === "ENOENT" ? "absent" : "command_failed";
+      rejectPromise(error2);
     });
     child.on("close", (code) => {
       clearTimeout(timer);
       if (timedOut) {
-        const error = new Error(`command timed out after ${timeoutMs}ms`);
-        error.kind = "timeout";
-        rejectPromise(error);
+        const error2 = new Error(`command timed out after ${timeoutMs}ms`);
+        error2.kind = "timeout";
+        rejectPromise(error2);
         return;
       }
       if (outputBytes > MAX_OUTPUT_BYTES) {
-        const error = new Error("codegraph output exceeded 5 MiB");
-        error.kind = "command_failed";
-        rejectPromise(error);
+        const error2 = new Error("codegraph output exceeded 5 MiB");
+        error2.kind = "command_failed";
+        rejectPromise(error2);
         return;
       }
       if (code !== 0) {
-        const error = new Error(Buffer.concat(stderr).toString("utf8").trim());
-        error.kind = "command_failed";
-        error.exitCode = code;
-        rejectPromise(error);
+        const error2 = new Error(Buffer.concat(stderr).toString("utf8").trim());
+        error2.kind = "command_failed";
+        error2.exitCode = code;
+        rejectPromise(error2);
         return;
       }
       resolvePromise(Buffer.concat(stdout).toString("utf8"));
@@ -1213,9 +1213,7 @@ function codeRefIdentityKey(ref) {
     qualified_name: ref.qualifiedName,
     disambiguator: {
       signature: ref.signature ?? "",
-      path: ref.path,
-      start_line: ref.startLine,
-      end_line: ref.endLine
+      path: ref.path
     }
   };
 }
@@ -2104,7 +2102,7 @@ async function anchorCodeRef(client2, ref, repositoryUid, spaceUid, agentId) {
     identity_space_uid: spaceUid,
     agent_id: agentId
   });
-  if (response.uid) {
+  if (response.uid && response.created !== false && response.status !== "existing") {
     await client2.entity({
       action: "relate",
       source_uid: response.uid,
@@ -2739,8 +2737,8 @@ async function handleSyncTool(client2, args) {
       }
     }
     return ok2(await remote.memorySync(request));
-  } catch (error) {
-    return err2("sync_failed", errorDetail(error));
+  } catch (error2) {
+    return err2("sync_failed", errorDetail(error2));
   }
 }
 async function scanRepository(remote, repository, requested, provider, agentId) {
@@ -2874,12 +2872,22 @@ function str(value) {
 function num(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+function edgeTypeName(value) {
+  return str(value) ?? str(obj(value)?.Custom);
+}
+function renderBudget(requested) {
+  if (requested === void 0 || !Number.isFinite(requested)) return RENDER_CHAR_BUDGET;
+  return Math.min(
+    RENDER_CHAR_BUDGET,
+    Math.max(MIN_RENDER_CHAR_BUDGET, Math.floor(requested))
+  );
+}
 function clip(value, max, state) {
-  const text = str(value);
-  if (!text) return void 0;
-  if (text.length <= max) return text;
+  const text2 = str(value);
+  if (!text2) return void 0;
+  if (text2.length <= max) return text2;
   state.bounded = true;
-  return `${text.slice(0, max - 1)}\u2026`;
+  return `${text2.slice(0, max - 1)}\u2026`;
 }
 function isNodeShaped(value) {
   const node = obj(value);
@@ -3001,7 +3009,7 @@ function relationshipItems(edges, labelByUid, state, options) {
   for (const raw of edges) {
     const edge = obj(raw);
     if (!edge) continue;
-    const type = str(edge.edge_type) || "?";
+    const type = edgeTypeName(edge.edge_type) || "?";
     const from = str(edge.from_uid);
     const to = str(edge.to_uid);
     if (CURATION_EDGE_TYPES.has(type)) continue;
@@ -3014,25 +3022,29 @@ function relationshipItems(edges, labelByUid, state, options) {
   if (lines.length > RELATIONSHIP_MAX) {
     state.bounded = true;
     const extra = lines.length - RELATIONSHIP_MAX;
+    state.omitted += extra;
     return [...lines.slice(0, RELATIONSHIP_MAX), `- (+${extra} more relationships)`];
   }
   return lines;
 }
-function assemble(header, sections, state) {
+function assemble(header, sections, state, maxChars) {
+  const budget = renderBudget(maxChars);
+  const packingBudget = Math.max(header.length, budget - BOUNDED_MARKER_RESERVE);
   const lines = [header];
   let used = header.length;
   for (const section of sections) {
     if (section.items.length === 0 && !section.heading) continue;
     const headingCost = section.heading.length + 2;
-    if (used + headingCost > RENDER_CHAR_BUDGET) {
+    if (used + headingCost > packingBudget) {
       state.bounded = true;
+      state.omitted += Math.max(1, section.items.length);
       continue;
     }
     let sectionUsed = 0;
     const kept = [];
     let dropped = 0;
     for (const item of section.items) {
-      if (used + headingCost + sectionUsed + item.length + 1 > RENDER_CHAR_BUDGET) {
+      if (used + headingCost + sectionUsed + item.length + 1 > packingBudget) {
         dropped += 1;
         continue;
       }
@@ -3041,13 +3053,17 @@ function assemble(header, sections, state) {
     }
     if (kept.length === 0 && section.items.length > 0) {
       state.bounded = true;
+      state.omitted += dropped;
       continue;
     }
     if (dropped > 0) {
       state.bounded = true;
+      state.omitted += dropped;
       const marker = `(+${dropped} more not shown)`;
-      kept.push(marker);
-      sectionUsed += marker.length + 1;
+      if (used + headingCost + sectionUsed + marker.length + 1 <= packingBudget) {
+        kept.push(marker);
+        sectionUsed += marker.length + 1;
+      }
     }
     lines.push(
       section.items.length === 0 ? section.heading : section.heading ? `${section.heading}
@@ -3057,10 +3073,10 @@ ${kept.join("\n")}` : kept.join("\n")
   }
   if (state.bounded) {
     lines.push(
-      '\u2026[rendered context bounded \u2014 fetch full node content by uid, or pass format: "json" for the raw response]'
+      `\u2026[rendered context bounded to ${budget} chars; ${state.omitted} item(s) omitted \u2014 fetch full node content by uid, narrow the query, raise max_output_chars, or pass format: "json" for the raw response]`
     );
   }
-  return lines.join("\n\n");
+  return lines.join("\n\n").slice(0, budget);
 }
 function policySections(payload, state) {
   const policies = Array.isArray(payload.applicable_policies) ? payload.applicable_policies : [];
@@ -3081,7 +3097,7 @@ function hiddenSections(payload) {
     }
   ];
 }
-function renderContext(response) {
+function renderContext(response, maxChars) {
   const payload = obj(response);
   if (!payload) return void 0;
   const graph = obj(payload.graph);
@@ -3091,7 +3107,7 @@ function renderContext(response) {
   const infraOnly = shaped.length - nodes.length;
   const articles = Array.isArray(payload.articles) ? payload.articles : [];
   const chunks = Array.isArray(payload.chunks) ? payload.chunks : [];
-  const state = { bounded: false };
+  const state = { bounded: false, omitted: 0 };
   const sections = [];
   if (articles.length > 0) {
     sections.push({
@@ -3134,11 +3150,129 @@ ${clip(article.content, ARTICLE_MAX, state) || ""}`
     return "No results found for this search.";
   }
   if (nodes.length === 0 && articles.length === 0 && chunks.length === 0) {
-    return assemble("# Retrieved context\n\nNo graph results matched this search.", sections, state);
+    return assemble(
+      "# Retrieved context\n\nNo graph results matched this search.",
+      sections,
+      state,
+      maxChars
+    );
+  }
+  return assemble("# Retrieved context", sections, state, maxChars);
+}
+function resumeEntry(raw, state, fallbackType) {
+  const wrapper = obj(raw);
+  if (!wrapper) return void 0;
+  const value = obj(wrapper.node) ?? wrapper;
+  if (isNodeShaped(value)) return nodeLines(value, state);
+  const uid = str(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 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
+  ].filter(Boolean);
+  const head = `- **${label}**${uid ? ` [${uid}]` : ""}${details.length > 0 ? ` (${details.join(", ")})` : ""}`;
+  return summary && summary !== label ? `${head}: ${summary}` : head;
+}
+function resumeSection(heading, values, state, fallbackType) {
+  const items = values.map((value) => resumeEntry(value, state, fallbackType)).filter((value) => Boolean(value));
+  return items.length > 0 ? { heading, items } : void 0;
+}
+function renderResumeContext(response, maxChars) {
+  const payload = obj(response);
+  if (!payload) return void 0;
+  const state = { bounded: false, omitted: 0 };
+  const status = str(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.` : "";
+    return assemble(
+      "# Resume context",
+      [{ heading: `No eligible work was found in the requested scope.${note}`, items: [] }],
+      state,
+      maxChars
+    );
   }
-  return assemble("# Retrieved context", sections, state);
+  const sections = [];
+  const push = (section) => {
+    if (section) sections.push(section);
+  };
+  push(resumeSection("## Current task", [payload.task], state, "Task"));
+  push(
+    resumeSection(
+      "## Goal and project",
+      [payload.goal, payload.project].filter(Boolean),
+      state,
+      "Scope"
+    )
+  );
+  push(resumeSection("## Plan", [payload.plan], state, "Plan"));
+  push(
+    resumeSection(
+      "## Next steps",
+      Array.isArray(payload.next_steps) ? payload.next_steps : [],
+      state,
+      "Next step"
+    )
+  );
+  push(
+    resumeSection(
+      "## Blockers",
+      Array.isArray(payload.blockers) ? payload.blockers : [],
+      state,
+      "Blocker"
+    )
+  );
+  const knowledge = obj(payload.knowledge);
+  push(
+    resumeSection(
+      "## Relevant lessons and risks",
+      [
+        ...Array.isArray(knowledge?.lessons) ? knowledge.lessons : [],
+        ...Array.isArray(knowledge?.risks) ? knowledge.risks : []
+      ],
+      state,
+      "Knowledge"
+    )
+  );
+  push(
+    resumeSection(
+      "## Active execution",
+      [payload.active_execution].filter(Boolean),
+      state,
+      "Execution"
+    )
+  );
+  push(
+    resumeSection(
+      "## Recent executions",
+      Array.isArray(payload.recent_executions) ? payload.recent_executions : [],
+      state,
+      "Execution"
+    )
+  );
+  push(
+    resumeSection(
+      "## Code targets",
+      Array.isArray(payload.code_targets) ? payload.code_targets : [],
+      state,
+      "Code target"
+    )
+  );
+  push(resumeSection("## Lease", [payload.lease].filter(Boolean), state, "Lease"));
+  const warning = clip(payload.warning, SUMMARY_MAX, state);
+  if (warning) sections.push({ heading: "## Warning", items: [`- ${warning}`] });
+  const selectionReason = clip(payload.selection_reason, SUMMARY_MAX, state);
+  if (selectionReason) {
+    sections.push({ heading: "## Selection", items: [`- ${selectionReason}`] });
+  }
+  if (sections.length === 0) return void 0;
+  return assemble("# Resume context", sections, state, maxChars);
 }
-function renderNodeList(response, title, limit) {
+function renderNodeList(response, title, limit, maxChars) {
   let candidates = [];
   if (Array.isArray(response)) {
     candidates = response;
@@ -3156,8 +3290,9 @@ function renderNodeList(response, title, limit) {
   let nodes = candidates.map(unwrapSearchResult).filter((node) => Boolean(node));
   if (nodes.length === 0) return void 0;
   const total = nodes.length;
-  const state = { bounded: false };
+  const state = { bounded: false, omitted: 0 };
   if (limit !== void 0 && limit > 0 && nodes.length > limit) {
+    state.omitted += nodes.length - limit;
     nodes = nodes.slice(0, limit);
     state.bounded = true;
   }
@@ -3166,18 +3301,23 @@ function renderNodeList(response, title, limit) {
   return assemble(
     `# ${title} (${shown === total ? total : `${shown} of ${total}`})`,
     sections,
-    state
+    state,
+    maxChars
   );
 }
-function renderTraversal(response) {
+function renderTraversal(response, maxChars) {
+  const directSteps = Array.isArray(response) ? response : void 0;
   const payload = obj(response);
-  if (!payload) return void 0;
-  const container = obj(payload.graph) ?? payload;
+  if (!payload && !directSteps) return void 0;
+  const body = payload ?? {};
+  const container = obj(body.graph) ?? body;
   const rawNodes = Array.isArray(container.nodes) ? container.nodes : [];
   const nodes = rawNodes.filter(isNodeShaped);
-  const paths = Array.isArray(payload.paths) ? payload.paths : [];
-  if (nodes.length === 0 && paths.length === 0) return void 0;
-  const state = { bounded: false };
+  const paths = Array.isArray(body.paths) ? body.paths : [];
+  const hasSteps = directSteps !== void 0 || Object.hasOwn(body, "steps");
+  const rawSteps = directSteps ?? (Array.isArray(body.steps) ? body.steps : []);
+  if (nodes.length === 0 && paths.length === 0 && !hasSteps) return void 0;
+  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) || "?");
@@ -3201,6 +3341,42 @@ function renderTraversal(response) {
     });
     sections.push({ heading: "## Paths", items });
   }
+  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 relation = edgeTypeName(step.edge_type);
+      const role = str(step.traversal_role);
+      const type = str(step.node_type) ?? str(obj(step.node_type)?.Custom);
+      const cost = num(step.path_cost);
+      const confidence = num(step.path_confidence);
+      const prefix = [
+        depth !== void 0 ? `depth ${depth}` : void 0,
+        role,
+        relation ? `\u2014${relation}\u2192` : void 0
+      ].filter(Boolean).join(" ");
+      const meta = [
+        type,
+        parent ? `parent ${parent}` : void 0,
+        cost !== void 0 ? `cost ${cost}` : void 0,
+        confidence !== void 0 ? `confidence ${confidence}` : void 0
+      ].filter(Boolean).join(", ");
+      return `- ${prefix ? `${prefix}: ` : ""}**${label}** [${uid}]${meta ? ` (${meta})` : ""}`;
+    });
+    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);
+      sections.push({
+        heading: mode2 === "path" && end ? `No path found from [${start}] to [${end}].` : `No traversal steps returned from [${start}].`,
+        items: []
+      });
+    }
+  }
   if (nodes.length > 0) {
     sections.push(...groupedNodeSections(nodes, state, "## Nodes\n\n"));
     const relationships = relationshipItems(
@@ -3212,7 +3388,13 @@ function renderTraversal(response) {
       sections.push({ heading: "## Relationships", items: relationships });
     }
   }
-  return assemble("# Graph traversal", sections, state);
+  const mode = str(body.mode);
+  return assemble(
+    `# Graph traversal${mode ? ` (${mode})` : ""}`,
+    sections,
+    state,
+    maxChars
+  );
 }
 function neighborLine(value) {
   const node = obj(value);
@@ -3233,7 +3415,7 @@ function renderOntologyAnswer(response) {
   if (objects.length === 0 && cognitiveEmpty && provenance.length === 0) {
     return hasQuerySignature ? "No matching domain objects." : void 0;
   }
-  const state = { bounded: false };
+  const state = { bounded: false, omitted: 0 };
   const sections = [];
   if (objects.length > 0) {
     sections.push(...groupedNodeSections(objects, state));
@@ -3299,7 +3481,7 @@ function renderObjectList(response, title) {
   if (items.length === 0) {
     return rawItems ? `# ${title} (0 results)` : void 0;
   }
-  const state = { bounded: false };
+  const state = { bounded: false, omitted: 0 };
   const sections = groupedNodeSections(items, state);
   const total = num(payload.total_count);
   const truncations = Array.isArray(payload.truncation_reasons) ? payload.truncation_reasons.filter((reason) => typeof reason === "string") : [];
@@ -3314,7 +3496,7 @@ function renderJobs(response) {
   const jobs = Array.isArray(response) ? response : obj(response)?.jobs;
   if (!Array.isArray(jobs)) return void 0;
   if (jobs.length === 0) return "No ingestion jobs.";
-  const state = { bounded: false };
+  const state = { bounded: false, omitted: 0 };
   const sorted = jobs.map((raw) => obj(raw)).filter((job) => Boolean(job)).sort((a, b) => (num(b.created_at) ?? 0) - (num(a.created_at) ?? 0));
   const shown = sorted.slice(0, JOBS_RENDER_MAX);
   if (shown.length < sorted.length) state.bounded = true;
@@ -3340,7 +3522,7 @@ function renderJobs(response) {
 function renderSignals(response) {
   const payload = obj(response);
   if (!payload) return void 0;
-  const state = { bounded: false };
+  const state = { bounded: false, omitted: 0 };
   const sections = [];
   for (const [key, value] of Object.entries(payload)) {
     if (!Array.isArray(value) || value.length === 0) continue;
@@ -3364,7 +3546,7 @@ function renderSignals(response) {
   if (sections.length === 0) return void 0;
   return assemble("# Synthesis signals", sections, state);
 }
-var LABEL_MAX, SUMMARY_MAX, QUOTE_MAX, ARTICLE_MAX, CHUNK_MAX, RELATIONSHIP_MAX, RENDER_CHAR_BUDGET, CURATION_EDGE_TYPES, INFRA_NODE_TYPES, JOBS_RENDER_MAX;
+var LABEL_MAX, SUMMARY_MAX, QUOTE_MAX, ARTICLE_MAX, CHUNK_MAX, RELATIONSHIP_MAX, RENDER_CHAR_BUDGET, MIN_RENDER_CHAR_BUDGET, BOUNDED_MARKER_RESERVE, CURATION_EDGE_TYPES, INFRA_NODE_TYPES, JOBS_RENDER_MAX;
 var init_render = __esm({
   "src/render.ts"() {
     "use strict";
@@ -3375,13 +3557,570 @@ var init_render = __esm({
     CHUNK_MAX = 6e3;
     RELATIONSHIP_MAX = 40;
     RENDER_CHAR_BUDGET = 24e3;
+    MIN_RENDER_CHAR_BUDGET = 512;
+    BOUNDED_MARKER_RESERVE = 220;
     CURATION_EDGE_TYPES = /* @__PURE__ */ new Set(["POSSIBLE_DUPLICATE", "PossibleDuplicate"]);
     INFRA_NODE_TYPES = /* @__PURE__ */ new Set(["Chunk", "Document", "Article"]);
     JOBS_RENDER_MAX = 20;
   }
 });
 
+// src/memory-tool.ts
+function obj2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+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(",")}]`;
+  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);
+}
+function sha2562(value) {
+  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;
+  return Math.min(MAX_OUTPUT_CHARS, Math.max(MIN_OUTPUT_CHARS, Math.floor(value)));
+}
+function defined(values) {
+  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
+}
+function memoryStatus(config = {}) {
+  return {
+    schema_version: RESULT_SCHEMA_VERSION,
+    action: "status",
+    profile: "M0",
+    server: defined({
+      name: "mindgraph-mcp",
+      version: config.serverVersion ?? "unknown",
+      base_url: config.baseUrl
+    }),
+    integration: {
+      adapter_state: "model_controlled",
+      harness: config.harness ?? "generic",
+      configured_tool_profile: config.profile ?? "general",
+      automatic_capture: false,
+      automatic_delivery: false,
+      delivery_verification: "unsupported",
+      curator_mode: "disabled"
+    },
+    scope: defined({ org_id: config.orgId, agent_id: config.agentId }),
+    capabilities: {
+      status: true,
+      topic_context: true,
+      authoritative_resume_context: true,
+      bounded_rendering: true,
+      structured_content: true,
+      typed_explicit_writes: true,
+      lifecycle_event_ingest: false,
+      automatic_context_injection: false,
+      curator_mutation: false
+    },
+    degradation: [
+      {
+        code: "automatic_capture_unavailable",
+        message: "M0 does not observe host lifecycle events; explicit typed write tools remain available."
+      },
+      {
+        code: "delivery_unverified",
+        message: "A successful MCP read does not prove that the host injected or used the returned context."
+      },
+      {
+        code: "curator_disabled",
+        message: "Curator proposals and autonomous mutation are not enabled in M0."
+      }
+    ]
+  };
+}
+function nodeType(node) {
+  const raw = node.node_type;
+  if (typeof raw === "string") return raw;
+  return text(obj2(raw)?.Custom) ?? "Node";
+}
+function compactItem(raw, fallbackType) {
+  const wrapper = obj2(raw);
+  if (!wrapper) return void 0;
+  const value = obj2(wrapper.node) ?? obj2(wrapper.object) ?? wrapper;
+  const uid = text(value.uid) ?? text(value.chunk_uid);
+  if (!uid) return void 0;
+  return defined({
+    uid,
+    type: fallbackType ?? nodeType(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,
+    currently_valid: value.currently_valid === false ? false : void 0,
+    valid_at_time: value.valid_at_time === false ? false : void 0,
+    retrieval_origin: text(value.retrieval_origin),
+    retrieval_depth: typeof value.retrieval_depth === "number" ? value.retrieval_depth : void 0
+  });
+}
+function topicCandidates(raw) {
+  const payload = obj2(raw);
+  if (!payload) return [];
+  const graph = obj2(payload.graph);
+  const items = [];
+  for (const article of Array.isArray(payload.articles) ? payload.articles : []) {
+    const item = compactItem(article, "Article");
+    if (item) items.push(item);
+  }
+  const rawNodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+  const labels = /* @__PURE__ */ new Map();
+  for (const node of rawNodes) {
+    const item = compactItem(node);
+    if (item) {
+      if (HIDDEN_CONTEXT_NODE_TYPES.has(text(item.type) ?? "")) continue;
+      items.push(item);
+      const uid = text(item.uid);
+      const label = text(item.label);
+      if (uid && label) labels.set(uid, label);
+    }
+  }
+  for (const rawEdge of Array.isArray(graph?.edges) ? graph.edges : []) {
+    const edge = obj2(rawEdge);
+    const fromUid = text(edge?.from_uid);
+    const toUid = text(edge?.to_uid);
+    const edgeType = text(edge?.edge_type) ?? text(obj2(edge?.edge_type)?.Custom);
+    if (!fromUid || !toUid || !edgeType || HIDDEN_CONTEXT_EDGE_TYPES.has(edgeType) || !labels.has(fromUid) || !labels.has(toUid)) {
+      continue;
+    }
+    items.push(
+      defined({
+        type: "Relationship",
+        from_uid: fromUid,
+        to_uid: toUid,
+        edge_type: edgeType,
+        from_label: labels.get(fromUid),
+        to_label: labels.get(toUid)
+      })
+    );
+  }
+  for (const chunk of Array.isArray(payload.chunks) ? payload.chunks : []) {
+    const item = compactItem(chunk, "SourceExcerpt");
+    if (item) items.push(item);
+  }
+  return items;
+}
+function resumeCandidates(raw) {
+  const payload = obj2(raw);
+  if (!payload) return [];
+  const items = [];
+  for (const key of ["task", "goal", "project", "plan", "active_execution", "lease"]) {
+    const item = compactItem(payload[key], key);
+    if (item) items.push(item);
+  }
+  for (const key of ["next_steps", "recent_executions", "blockers", "code_targets"]) {
+    for (const value of Array.isArray(payload[key]) ? payload[key] : []) {
+      const item = compactItem(value, key.replace(/s$/, ""));
+      if (item) items.push(item);
+    }
+  }
+  const knowledge = obj2(payload.knowledge);
+  for (const key of ["lessons", "risks"]) {
+    for (const value of Array.isArray(knowledge?.[key]) ? knowledge[key] : []) {
+      const item = compactItem(value, key.replace(/s$/, ""));
+      if (item) items.push(item);
+    }
+  }
+  return items;
+}
+function visibleItems(candidates, rendered2) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((item) => {
+    const uid = text(item.uid);
+    if (uid) {
+      if (seen.has(uid) || !rendered2.includes(`[${uid}]`)) return false;
+      seen.add(uid);
+      return true;
+    }
+    if (item.type === "Relationship") {
+      const from = text(item.from_label);
+      const to = text(item.to_label);
+      const edgeType = text(item.edge_type);
+      if (!from || !to || !edgeType) return false;
+      const key = `${text(item.from_uid)}:${edgeType}:${text(item.to_uid)}`;
+      if (seen.has(key) || !rendered2.includes(`${from} \u2014${edgeType}\u2192 ${to}`)) return false;
+      seen.add(key);
+      return true;
+    }
+    return false;
+  });
+}
+function latestTimestamp(value) {
+  let latest;
+  const visit = (current) => {
+    if (Array.isArray(current)) {
+      for (const item of current) visit(item);
+      return;
+    }
+    const record = obj2(current);
+    if (!record) return;
+    for (const [key, item] of Object.entries(record)) {
+      if (["updated_at", "created_at", "completed_at", "started_at", "observed_at"].includes(key) && typeof item === "string" && !Number.isNaN(Date.parse(item)) && (!latest || Date.parse(item) > Date.parse(latest))) {
+        latest = item;
+      }
+      visit(item);
+    }
+  };
+  visit(value);
+  return latest;
+}
+function contextWarnings(raw, rendered2, available, returned) {
+  const warnings = [
+    {
+      code: "delivery_unverified",
+      message: "The MCP server returned this context but cannot verify that the host injected or used it."
+    }
+  ];
+  const serialized = JSON.stringify(raw);
+  if (available > returned || rendered2.includes("item(s) omitted")) {
+    warnings.push({
+      code: "context_bounded",
+      message: `${Math.max(0, available - returned)} structured item(s) were omitted from the rendered context.`
+    });
+  }
+  if (/"superseded":true/.test(serialized)) {
+    warnings.push({ code: "superseded_items_present", message: "Some retrieved items are superseded." });
+  }
+  if (/"currently_valid":false|"valid_at_time":false/.test(serialized)) {
+    warnings.push({
+      code: "validity_warning",
+      message: "Some retrieved items are outside their current or requested validity window."
+    });
+  }
+  const payload = obj2(raw);
+  if (payload?.truncated === true || obj2(payload?.truncation)) {
+    const truncation = obj2(payload?.truncation);
+    if (payload?.truncated === true || Object.values(truncation ?? {}).some(Boolean)) {
+      warnings.push({ code: "source_truncated", message: "The authoritative source reported truncated fields." });
+    }
+  }
+  if (text(payload?.warning)) {
+    warnings.push({ code: "source_warning", message: text(payload?.warning) });
+  }
+  return warnings;
+}
+function error(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+async function handleMemoryTool(client2, args, config = {}) {
+  const action = text(args.action);
+  if (action === "status") {
+    const status = memoryStatus({ ...config, agentId: text(args.agent_id) ?? config.agentId });
+    return {
+      content: [{ type: "text", text: JSON.stringify(status) }],
+      structuredContent: status
+    };
+  }
+  if (action !== "context") {
+    return error("action must be 'status' or 'context'");
+  }
+  const mode = text(args.mode) ?? (text(args.query) ? "topic" : void 0);
+  if (!mode || !["topic", "continuity", "resume"].includes(mode)) {
+    return error("action='context' requires mode='topic', 'continuity', or 'resume'");
+  }
+  const budget = outputBudget(args.max_output_chars);
+  const agentId = text(args.agent_id) ?? config.agentId;
+  let raw;
+  let rendered2;
+  let strategy;
+  let candidates;
+  if (mode === "topic") {
+    const query = text(args.query);
+    if (!query) return error("mode='topic' requires a non-empty query of 1-3 discriminating keywords");
+    const limit = typeof args.limit === "number" && Number.isFinite(args.limit) ? Math.min(50, Math.max(1, Math.floor(args.limit))) : 8;
+    const request = defined({
+      query,
+      project_uid: text(args.project_uid),
+      node_limit: limit,
+      node_types: Array.isArray(args.node_types) ? args.node_types.map(String) : void 0,
+      layer: text(args.layer),
+      chunk_limit: args.include_chunks === true ? limit : 0,
+      article_limit: args.include_documents === true ? limit : 0,
+      valid_at: text(args.valid_at),
+      include_graph: true,
+      graph_expansion_limit: typeof args.graph_expansion_limit === "number" ? args.graph_expansion_limit : 3,
+      graph_max_depth: typeof args.graph_max_depth === "number" ? args.graph_max_depth : 2
+    });
+    raw = await client2.retrieveContext(request);
+    rendered2 = renderContext(raw, budget) ?? "No results found for this search.";
+    strategy = "retrieve_context";
+    candidates = topicCandidates(raw);
+  } else {
+    const scopeUids = Array.from(
+      /* @__PURE__ */ new Set([
+        ...Array.isArray(args.scope_uids) ? args.scope_uids.map(String) : [],
+        ...text(args.project_uid) ? [text(args.project_uid)] : []
+      ])
+    );
+    raw = await client2.plan(
+      defined({
+        action: "resume_work",
+        task_uid: text(args.task_uid),
+        session_uid: text(args.session_uid),
+        scope_uids: scopeUids.length > 0 ? scopeUids : void 0,
+        limit: 1,
+        agent_id: agentId
+      })
+    );
+    rendered2 = renderResumeContext(raw, budget) ?? "No eligible work was found in the requested scope.";
+    strategy = "resume_work";
+    candidates = resumeCandidates(raw);
+  }
+  const items = visibleItems(candidates, rendered2);
+  const renderedHash = sha2562(rendered2);
+  const scope = defined({
+    org_id: config.orgId,
+    agent_id: agentId,
+    harness: config.harness ?? "generic",
+    project_uid: text(args.project_uid),
+    task_uid: text(args.task_uid),
+    session_uid: text(args.session_uid),
+    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 })
+  ).slice(0, 24)}`;
+  const bounded = candidates.length > items.length || rendered2.includes("item(s) omitted");
+  const result = {
+    schema_version: RESULT_SCHEMA_VERSION,
+    action: "context",
+    context_id: contextId,
+    mode,
+    scope,
+    rendered_context: rendered2,
+    rendered_hash: renderedHash,
+    items,
+    retrieval_trace: defined({
+      strategy,
+      query: text(args.query),
+      project_uid: text(args.project_uid),
+      task_uid: text(args.task_uid),
+      session_uid: text(args.session_uid),
+      node_types: Array.isArray(args.node_types) ? args.node_types.map(String) : void 0,
+      graph_expansion_limit: mode === "topic" ? args.graph_expansion_limit ?? 3 : void 0,
+      graph_max_depth: mode === "topic" ? args.graph_max_depth ?? 2 : void 0,
+      available_items: candidates.length,
+      returned_items: items.length,
+      omitted_items: Math.max(0, candidates.length - items.length)
+    }),
+    budget: {
+      unit: "characters",
+      requested_chars: budget,
+      used_chars: rendered2.length,
+      available_items: candidates.length,
+      returned_items: items.length,
+      omitted_items: Math.max(0, candidates.length - items.length),
+      bounded
+    },
+    freshness: defined({
+      valid_at: text(args.valid_at),
+      latest_source_timestamp: latestTimestamp(raw)
+    }),
+    warnings: contextWarnings(raw, rendered2, candidates.length, items.length)
+  };
+  return {
+    content: [{ type: "text", text: rendered2 }],
+    structuredContent: result
+  };
+}
+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_crypto7 = require("crypto");
+    init_render();
+    RESULT_SCHEMA_VERSION = "mindgraph.memory.result.v1";
+    DEFAULT_OUTPUT_CHARS = 8e3;
+    MIN_OUTPUT_CHARS = 512;
+    MAX_OUTPUT_CHARS = 24e3;
+    HIDDEN_CONTEXT_NODE_TYPES = /* @__PURE__ */ new Set(["Chunk", "Document", "Article"]);
+    HIDDEN_CONTEXT_EDGE_TYPES = /* @__PURE__ */ new Set(["POSSIBLE_DUPLICATE", "PossibleDuplicate"]);
+    MEMORY_TOOL = {
+      name: "mindgraph_memory",
+      description: "Read the portable MindGraph memory surface. Use action='context' with mode='resume' or 'continuity' for authoritative task-first work state, and mode='topic' with a short keyword query for prior knowledge relevant to the user's request. Use action='status' to inspect integration capabilities and limitations. This tool never writes; durable capture and correction use the existing typed MindGraph write tools.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["status", "context"],
+            description: "Read integration status or bounded memory context"
+          },
+          mode: {
+            type: "string",
+            enum: ["topic", "continuity", "resume"],
+            description: "Context strategy. topic uses query-shaped retrieval; continuity/resume use authoritative task-first resume_work."
+          },
+          query: {
+            type: "string",
+            description: "Required for mode='topic': 1-3 discriminating BM25 keywords, not a full sentence"
+          },
+          project_uid: { type: "string", description: "Optional project scope" },
+          task_uid: { type: "string", description: "Optional task scope for resume context" },
+          session_uid: { type: "string", description: "Optional durable session scope" },
+          scope_uids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional explicit graph scopes for continuity/resume"
+          },
+          node_types: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional node-type filter for topic context"
+          },
+          layer: {
+            type: "string",
+            enum: ["reality", "epistemic", "intent", "action", "memory", "agent"],
+            description: "Optional cognitive-layer filter for topic context"
+          },
+          limit: {
+            type: "integer",
+            minimum: 1,
+            maximum: 50,
+            default: 8,
+            description: "Maximum direct graph items requested before bounded expansion"
+          },
+          include_chunks: {
+            type: "boolean",
+            default: false,
+            description: "Include bounded source excerpts when topic summaries are insufficient"
+          },
+          include_documents: {
+            type: "boolean",
+            default: false,
+            description: "Include bounded knowledge articles for topic context"
+          },
+          valid_at: {
+            type: "string",
+            description: "Optional ISO timestamp for time-aware topic retrieval"
+          },
+          graph_expansion_limit: {
+            type: "integer",
+            minimum: 0,
+            maximum: 20,
+            default: 3,
+            description: "Bounded graph neighbors added after direct topic matches"
+          },
+          graph_max_depth: {
+            type: "integer",
+            minimum: 0,
+            maximum: 5,
+            default: 2,
+            description: "Maximum graph-expansion depth for topic context"
+          },
+          max_output_chars: {
+            type: "integer",
+            minimum: MIN_OUTPUT_CHARS,
+            maximum: MAX_OUTPUT_CHARS,
+            default: DEFAULT_OUTPUT_CHARS,
+            description: "Hard character budget for model-ready context; whole items are retained or omitted"
+          },
+          agent_id: { type: "string", description: "Agent identity" }
+        },
+        required: ["action"]
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          schema_version: { type: "string", const: RESULT_SCHEMA_VERSION },
+          action: { type: "string", enum: ["status", "context"] },
+          profile: { type: "string" },
+          server: { type: "object" },
+          integration: { type: "object" },
+          capabilities: { type: "object" },
+          degradation: { type: "array", items: { type: "object" } },
+          context_id: { type: "string" },
+          mode: { type: "string", enum: ["topic", "continuity", "resume"] },
+          scope: { type: "object" },
+          rendered_context: { type: "string" },
+          rendered_hash: { type: "string" },
+          items: { type: "array", items: { type: "object" } },
+          retrieval_trace: { type: "object" },
+          budget: { type: "object" },
+          freshness: { type: "object" },
+          warnings: { type: "array", items: { type: "object" } }
+        },
+        required: ["schema_version", "action"],
+        oneOf: [
+          {
+            properties: { action: { const: "status" } },
+            required: ["profile", "server", "integration", "scope", "capabilities", "degradation"]
+          },
+          {
+            properties: { action: { const: "context" } },
+            required: [
+              "context_id",
+              "mode",
+              "scope",
+              "rendered_context",
+              "rendered_hash",
+              "items",
+              "retrieval_trace",
+              "budget",
+              "freshness",
+              "warnings"
+            ]
+          }
+        ]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    };
+  }
+});
+
 // src/tools.ts
+function stableJson2(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson2).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 JSON.stringify(value);
+}
+function defaultWriteIdempotencyKey(tool, args) {
+  if (typeof args.idempotency_key === "string") return args.idempotency_key;
+  const context = args.invocation_context;
+  const sessionId = context?.harnessSessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) return void 0;
+  const canonicalArgs = Object.fromEntries(
+    Object.entries(args).filter(
+      ([key]) => key !== "invocation_context" && key !== "idempotency_key"
+    )
+  );
+  return (0, import_node_crypto8.createHash)("sha256").update(
+    stableJson2({
+      harness_session_id: sessionId,
+      harness_turn_id: context?.harnessTurnId ?? null,
+      tool,
+      action: args.action ?? null,
+      args: canonicalArgs
+    })
+  ).digest("hex");
+}
+function resolutionFields(args) {
+  return Object.fromEntries(
+    [
+      "idempotency_key",
+      "reuse_uid",
+      "supersedes_uid",
+      "contradicts_uid",
+      "confirm_new",
+      "on_near_duplicate"
+    ].filter((key) => args[key] !== void 0).map((key) => [key, args[key]])
+  );
+}
 function toolsForProfile(profile = process.env.MINDGRAPH_PROFILE || "general") {
   if (profile === "coding") return TOOLS;
   return TOOLS.filter(
@@ -3395,8 +4134,8 @@ function ok3(data) {
 }
 function renderedResult(format, raw, render) {
   if (format === "json") return ok3(raw);
-  const text = render(raw);
-  return text !== void 0 ? { content: [{ type: "text", text }] } : ok3(raw);
+  const text2 = render(raw);
+  return text2 !== void 0 ? { content: [{ type: "text", text: text2 }] } : ok3(raw);
 }
 function err3(message) {
   return {
@@ -3404,8 +4143,22 @@ function err3(message) {
     isError: true
   };
 }
-async function handleTool(client2, name, args) {
+async function handleTool(client2, name, args, memoryConfig = {}) {
   try {
+    if (["mindgraph_capture", "mindgraph_reason", "mindgraph_commit"].includes(name) && args.action !== "get_open_decisions") {
+      const key = defaultWriteIdempotencyKey(name, args);
+      if (key) args = { ...args, idempotency_key: key };
+      const dispositions = [
+        args.reuse_uid,
+        args.supersedes_uid,
+        args.contradicts_uid,
+        args.confirm_new === true ? true : void 0,
+        args.on_near_duplicate
+      ].filter((value) => value !== void 0);
+      if (dispositions.length > 1) {
+        return err3("resolution dispositions are mutually exclusive");
+      }
+    }
     let result;
     switch (name) {
       case "mindgraph_capture":
@@ -3423,6 +4176,9 @@ async function handleTool(client2, name, args) {
       case "mindgraph_retrieve":
         result = await handleRetrieve(client2, args);
         break;
+      case "mindgraph_memory":
+        result = await handleMemoryTool(client2, args, memoryConfig);
+        break;
       case "mindgraph_series_query":
         result = await handleSeriesQuery(client2, args);
         break;
@@ -3504,7 +4260,11 @@ async function handleCapture(client2, args) {
     work_uid,
     execution_uid,
     idempotency_key,
+    reuse_uid,
     supersedes_uid,
+    contradicts_uid,
+    confirm_new,
+    on_near_duplicate,
     summarizes_uids,
     entity_type,
     source_uid,
@@ -3528,7 +4288,11 @@ async function handleCapture(client2, args) {
           work_uid,
           execution_uid,
           idempotency_key,
+          reuse_uid,
           supersedes_uid,
+          contradicts_uid,
+          confirm_new,
+          on_near_duplicate,
           summarizes_uids,
           props,
           agent_id
@@ -3574,27 +4338,32 @@ async function handleCapture(client2, args) {
       const journalProps = { content };
       if (mood) journalProps.mood = mood;
       if (tags) journalProps.tags = tags;
-      return ok3(await client2.journal(label, journalProps, { agent_id }));
+      return ok3(await client2.journal(label, journalProps, {
+        agent_id,
+        idempotency_key,
+        reuse_uid,
+        supersedes_uid,
+        contradicts_uid,
+        confirm_new,
+        on_near_duplicate
+      }));
     }
     case "entity": {
       const type = entity_type || "concept";
       const entityProps = { ...props };
       if (summary) entityProps.description = summary;
-      switch (type) {
-        case "person":
-          return ok3(await client2.findOrCreatePerson(label, entityProps, agent_id));
-        case "organization":
-          return ok3(await client2.findOrCreateOrganization(label, entityProps, agent_id));
-        case "nation":
-          return ok3(await client2.findOrCreateNation(label, entityProps, agent_id));
-        case "event":
-          return ok3(await client2.findOrCreateEvent(label, entityProps, agent_id));
-        case "place":
-          return ok3(await client2.findOrCreatePlace(label, entityProps, agent_id));
-        case "concept":
-        default:
-          return ok3(await client2.findOrCreateConcept(label, entityProps, agent_id));
-      }
+      return ok3(await client2.entity({
+        action: "create",
+        label,
+        props: { ...entityProps, entity_type: type },
+        agent_id,
+        idempotency_key,
+        reuse_uid,
+        supersedes_uid,
+        contradicts_uid,
+        confirm_new,
+        on_near_duplicate
+      }));
     }
     case "observation":
       return ok3(
@@ -3605,7 +4374,13 @@ async function handleCapture(client2, args) {
           confidence,
           salience,
           props,
-          agent_id
+          agent_id,
+          idempotency_key,
+          reuse_uid,
+          supersedes_uid,
+          contradicts_uid,
+          confirm_new,
+          on_near_duplicate
         })
       );
     case "source":
@@ -3617,7 +4392,13 @@ async function handleCapture(client2, args) {
           confidence,
           salience,
           props,
-          agent_id
+          agent_id,
+          idempotency_key,
+          reuse_uid,
+          supersedes_uid,
+          contradicts_uid,
+          confirm_new,
+          on_near_duplicate
         })
       );
     case "snippet":
@@ -3630,26 +4411,38 @@ async function handleCapture(client2, args) {
           confidence,
           salience,
           props,
-          agent_id
+          agent_id,
+          idempotency_key,
+          reuse_uid,
+          supersedes_uid,
+          contradicts_uid,
+          confirm_new,
+          on_near_duplicate
         })
       );
     case "concept":
-      return ok3(
-        await client2.structure({
-          action: "concept",
-          label,
-          summary,
-          confidence,
-          salience,
-          props,
-          agent_id
-        })
-      );
+      return ok3(await client2.entity({
+        action: "create",
+        label,
+        props: {
+          ...props,
+          entity_type: "concept",
+          ...summary ? { description: summary } : {}
+        },
+        agent_id,
+        idempotency_key,
+        reuse_uid,
+        supersedes_uid,
+        contradicts_uid,
+        confirm_new,
+        on_near_duplicate
+      }));
     default:
       return err3(`Unknown capture action: ${action}`);
   }
 }
 async function handleReason(client2, args) {
+  const resolution = resolutionFields(args);
   const {
     action,
     label,
@@ -3682,7 +4475,8 @@ async function handleReason(client2, args) {
           ...warrant.content ? { props: { content: warrant.content } } : {}
         } : void 0,
         argument,
-        agent_id
+        agent_id,
+        ...resolution
       })
     );
   }
@@ -3695,11 +4489,13 @@ async function handleReason(client2, args) {
       confidence,
       salience,
       props,
-      agent_id
+      agent_id,
+      ...resolution
     })
   );
 }
 async function handleCommit(client2, args) {
+  const resolution = resolutionFields(args);
   const {
     action,
     label,
@@ -3730,16 +4526,17 @@ async function handleCommit(client2, args) {
           confidence,
           salience,
           props,
-          agent_id
+          agent_id,
+          ...resolution
         })
       );
     case "open_decision":
       if (!label) return err3("label is required for open_decision");
-      return ok3(await client2.openDecision(label, { summary, props, agent_id }));
+      return ok3(await client2.openDecision(label, { summary, props, agent_id, ...resolution }));
     case "add_option":
       if (!decision_uid) return err3("decision_uid is required for add_option");
       if (!label) return err3("label is required for add_option");
-      return ok3(await client2.addOption(decision_uid, label, { summary, props, agent_id }));
+      return ok3(await client2.addOption(decision_uid, label, { summary, props, agent_id, ...resolution }));
     case "add_constraint":
       if (!decision_uid) return err3("decision_uid is required for add_constraint");
       return ok3(
@@ -3749,7 +4546,8 @@ async function handleCommit(client2, args) {
           decision_uid,
           summary,
           props,
-          agent_id
+          agent_id,
+          ...resolution
         })
       );
     case "resolve_decision":
@@ -3763,7 +4561,8 @@ async function handleCommit(client2, args) {
           as_of_date,
           session_id,
           retrieval_trace_id,
-          agent_id
+          agent_id,
+          ...resolution
         })
       );
     case "get_open_decisions":
@@ -3844,7 +4643,7 @@ async function handlePlan(client2, args) {
     output_snapshot,
     side_effects,
     outcome,
-    error,
+    error: error2,
     next_action,
     checkpoint_summary,
     test_summary,
@@ -3907,7 +4706,7 @@ async function handlePlan(client2, args) {
           output_snapshot,
           side_effects,
           outcome,
-          error,
+          error: error2,
           next_action,
           checkpoint_summary,
           test_summary,
@@ -3956,7 +4755,7 @@ async function handlePlan(client2, args) {
           output_snapshot,
           side_effects,
           outcome,
-          error,
+          error: error2,
           props,
           agent_id
         })
@@ -4042,6 +4841,7 @@ async function handleRetrieve(client2, args) {
   const {
     action,
     format,
+    max_output_chars,
     query,
     start_uid,
     end_uid,
@@ -4096,7 +4896,7 @@ async function handleRetrieve(client2, args) {
           graph_expansion_limit: graph_expansion_limit ?? 3,
           graph_max_depth: graph_max_depth ?? 2
         }),
-        renderContext
+        (raw) => renderContext(raw, max_output_chars)
       );
     case "text":
       if (!query) return err3("query is required for text search");
@@ -4110,7 +4910,7 @@ async function handleRetrieve(client2, args) {
           explain,
           agent_id
         }),
-        (raw) => renderNodeList(raw, `Text search: ${query}`)
+        (raw) => renderNodeList(raw, `Text search: ${query}`, void 0, max_output_chars)
       );
     case "semantic":
       if (!query) return err3("query is required for semantic search");
@@ -4124,7 +4924,7 @@ async function handleRetrieve(client2, args) {
           explain,
           agent_id
         }),
-        (raw) => renderNodeList(raw, `Semantic search: ${query}`)
+        (raw) => renderNodeList(raw, `Semantic search: ${query}`, void 0, max_output_chars)
       );
     case "hybrid":
       if (!query) return err3("query is required for hybrid search");
@@ -4139,7 +4939,7 @@ async function handleRetrieve(client2, args) {
           agent_id
         }),
         // With explain, per-leg scoring must survive — raw JSON only.
-        explain ? () => void 0 : (raw) => renderNodeList(raw, `Hybrid search: ${query}`)
+        explain ? () => void 0 : (raw) => renderNodeList(raw, `Hybrid search: ${query}`, void 0, max_output_chars)
       );
     // Structured queries. These go through the generic /retrieve action
     // dispatch rather than the SDK's no-argument convenience methods — the
@@ -4157,7 +4957,7 @@ async function handleRetrieve(client2, args) {
           offset,
           agent_id
         }),
-        (raw) => renderNodeList(raw, action.replace(/_/g, " "), limit)
+        (raw) => renderNodeList(raw, action.replace(/_/g, " "), limit, max_output_chars)
       );
     case "stale_derivations":
       return rendered2(
@@ -4166,7 +4966,7 @@ async function handleRetrieve(client2, args) {
           limit,
           offset
         }),
-        (raw) => renderNodeList(raw, "stale derivations", limit)
+        (raw) => renderNodeList(raw, "stale derivations", limit, max_output_chars)
       );
     case "preferences":
       return rendered2(
@@ -4176,7 +4976,7 @@ async function handleRetrieve(client2, args) {
           limit,
           agent_id
         }),
-        (raw) => renderNodeList(raw, "Preferences", limit)
+        (raw) => renderNodeList(raw, "Preferences", limit, max_output_chars)
       );
     case "layer":
       if (!layer) return err3("layer is required for layer retrieval");
@@ -4188,7 +4988,7 @@ async function handleRetrieve(client2, args) {
           node_types,
           agent_id
         }),
-        (raw) => renderNodeList(raw, `Layer: ${layer}`, limit)
+        (raw) => renderNodeList(raw, `Layer: ${layer}`, limit, max_output_chars)
       );
     case "recent":
       return rendered2(
@@ -4202,7 +5002,7 @@ async function handleRetrieve(client2, args) {
           created_before,
           agent_id
         }),
-        (raw) => renderNodeList(raw, "Recently ingested", limit)
+        (raw) => renderNodeList(raw, "Recently ingested", limit, max_output_chars)
       );
     // Document inventory
     case "document_index":
@@ -4211,7 +5011,7 @@ async function handleRetrieve(client2, args) {
           node_type: "Document",
           limit: limit ?? 100
         }),
-        (raw) => renderNodeList(raw, "Ingested documents")
+        (raw) => renderNodeList(raw, "Ingested documents", void 0, max_output_chars)
       );
     // Graph traversal
     case "chain":
@@ -4225,7 +5025,7 @@ async function handleRetrieve(client2, args) {
           include_provenance,
           max_nodes
         }),
-        renderTraversal
+        (raw) => renderTraversal(raw, max_output_chars)
       );
     case "neighborhood":
       if (!start_uid) return err3("start_uid is required for neighborhood traversal");
@@ -4240,7 +5040,7 @@ async function handleRetrieve(client2, args) {
           include_provenance,
           max_nodes
         }),
-        renderTraversal
+        (raw) => renderTraversal(raw, max_output_chars)
       );
     case "path":
       if (!start_uid) return err3("start_uid is required for path traversal");
@@ -4257,7 +5057,7 @@ async function handleRetrieve(client2, args) {
           include_provenance,
           max_nodes
         }),
-        renderTraversal
+        (raw) => renderTraversal(raw, max_output_chars)
       );
     case "subgraph":
       if (!start_uid) return err3("start_uid is required for subgraph traversal");
@@ -4272,7 +5072,7 @@ async function handleRetrieve(client2, args) {
           include_provenance,
           max_nodes
         }),
-        renderTraversal
+        (raw) => renderTraversal(raw, max_output_chars)
       );
     case "top_k_paths":
       if (!start_uid) return err3("start_uid is required for top_k_paths");
@@ -4288,7 +5088,7 @@ async function handleRetrieve(client2, args) {
           edge_types,
           exclude_edge_types
         }),
-        renderTraversal
+        (raw) => renderTraversal(raw, max_output_chars)
       );
     default:
       return err3(`Unknown retrieve action: ${action}`);
@@ -4544,15 +5344,44 @@ async function handleOntology(client2, args) {
       return err3(`Unknown ontology action: ${action}`);
   }
 }
-var TOOLS, INVOCATION_CONTEXT_SCHEMA;
+var import_node_crypto8, RESOLUTION_PROPERTIES, TOOLS, INVOCATION_CONTEXT_SCHEMA;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
+    import_node_crypto8 = require("crypto");
     init_error_detail();
     init_code_tool();
     init_codegraph();
     init_sync_tool();
+    init_memory_tool();
     init_render();
+    RESOLUTION_PROPERTIES = {
+      idempotency_key: {
+        type: "string",
+        description: "Stable retry key; a mismatched replay is rejected"
+      },
+      reuse_uid: {
+        type: "string",
+        description: "Reuse this live same-scope node after a duplicate response"
+      },
+      supersedes_uid: {
+        type: "string",
+        description: "Create and mark this same-scope node as superseded"
+      },
+      contradicts_uid: {
+        type: "string",
+        description: "Create and mark this same-scope node as contradicted"
+      },
+      confirm_new: {
+        type: "boolean",
+        description: "Confirm that the new fact is genuinely distinct"
+      },
+      on_near_duplicate: {
+        type: "string",
+        enum: ["create"],
+        description: "Alias for confirm_new on a near-duplicate response"
+      }
+    };
     TOOLS = [
       {
         name: "mindgraph_capture",
@@ -4617,14 +5446,7 @@ var init_tools = __esm({
               type: "string",
               description: "Material Execution that produced the lesson"
             },
-            idempotency_key: {
-              type: "string",
-              description: "Stable retry key for an intentional capture"
-            },
-            supersedes_uid: {
-              type: "string",
-              description: "Earlier capture corrected or superseded by this one"
-            },
+            ...RESOLUTION_PROPERTIES,
             summarizes_uids: {
               type: "array",
               items: { type: "string" },
@@ -4722,6 +5544,7 @@ var init_tools = __esm({
         inputSchema: {
           type: "object",
           properties: {
+            ...RESOLUTION_PROPERTIES,
             action: {
               type: "string",
               enum: [
@@ -4816,6 +5639,7 @@ var init_tools = __esm({
         inputSchema: {
           type: "object",
           properties: {
+            ...RESOLUTION_PROPERTIES,
             action: {
               type: "string",
               enum: [
@@ -5174,6 +5998,12 @@ var init_tools = __esm({
               enum: ["text", "json"],
               description: "Output format (default 'text'): a compact rendered context block \u2014 labels, uids, summaries, status tags, relationships. Pass 'json' for the raw server response (full props, source-chunk offsets, retrieval metadata)."
             },
+            max_output_chars: {
+              type: "integer",
+              minimum: 512,
+              maximum: 24e3,
+              description: "Hard character budget for rendered text output (512-24000; default 24000). Normal per-field clipping still applies. Whole evidence items are then kept or omitted rather than cut to satisfy this budget; the final marker reports omissions. Ignored when format='json'."
+            },
             query: {
               type: "string",
               description: "Search query \u2014 for 'text'/'context': 1-3 BM25 keywords, drop filler words. For 'semantic'/'hybrid': natural language is OK since it uses vector similarity."
@@ -5600,6 +6430,7 @@ var init_tools = __esm({
           required: ["action"]
         }
       },
+      MEMORY_TOOL,
       SYNC_TOOL,
       CODE_TOOL
     ];
@@ -5620,7 +6451,7 @@ var init_tools = __esm({
       }
     };
     for (const tool of TOOLS) {
-      if (tool.name === "mindgraph_retrieve") continue;
+      if (tool.name === "mindgraph_retrieve" || tool.name === "mindgraph_memory") continue;
       const schema = tool.inputSchema;
       if (schema.properties && !schema.properties.invocation_context) {
         schema.properties.invocation_context = INVOCATION_CONTEXT_SCHEMA;
@@ -5674,8 +6505,8 @@ async function getGeneratedTools(client2) {
     cache = { tools, byName, fetchedAt: Date.now() };
     retryNotBefore = 0;
     return { tools, byName };
-  } catch (error) {
-    if (error instanceof DuplicateGeneratedToolError) throw error;
+  } catch (error2) {
+    if (error2 instanceof DuplicateGeneratedToolError) throw error2;
     retryNotBefore = Date.now() + FAILURE_COOLDOWN_MS;
     return cache ? { tools: cache.tools, byName: cache.byName } : EMPTY;
   }
@@ -5788,8 +6619,8 @@ var init_generated_tools = __esm({
     });
     rendered = (format, raw, render) => {
       if (format === "json") return ok4(raw);
-      const text = render(raw);
-      return text !== void 0 ? { content: [{ type: "text", text }] } : ok4(raw);
+      const text2 = render(raw);
+      return text2 !== void 0 ? { content: [{ type: "text", text: text2 }] } : ok4(raw);
     };
     err4 = (message) => ({
       content: [{ type: "text", text: JSON.stringify({ error: message }) }],
@@ -5838,6 +6669,7 @@ function unsupportedResponse(status, body) {
   return lower.includes("unknown governance action") || lower.includes("unknown action") || lower.includes("invalid_governance_action");
 }
 function toolMutability(toolName, action) {
+  if (toolName === "mindgraph_memory") return "read";
   if (toolName === "mindgraph_retrieve") return "read";
   if (toolName === "mindgraph_series_query") return "read";
   if (toolName === "mindgraph_plan") {
@@ -5921,8 +6753,8 @@ async function checkMcpGovernance(toolName, args, config) {
       response = candidate;
       body = candidateBody;
       break;
-    } catch (error) {
-      lastFailure = error instanceof Error ? error.message : String(error);
+    } catch (error2) {
+      lastFailure = error2 instanceof Error ? error2.message : String(error2);
       if (attempt < retryDelays.length) {
         await sleep(retryDelays[attempt]);
         continue;
@@ -6067,8 +6899,10 @@ function json(uri, data) {
     contents: [{ uri, mimeType: "application/json", text: JSON.stringify(data) }]
   };
 }
-async function readResource(client2, uri) {
+async function readResource(client2, uri, memoryConfig = {}) {
   switch (uri) {
+    case "mindgraph://memory/status":
+      return json(uri, memoryStatus(memoryConfig));
     case "mindgraph://stats":
       return json(uri, await client2.stats());
     case "mindgraph://goals":
@@ -6100,23 +6934,32 @@ async function readResource(client2, uri) {
   }
   throw new Error(`Unknown resource: ${uri}`);
 }
-async function readGovernedResource(client2, uri, governanceConfig) {
+async function readGovernedResource(client2, uri, governanceConfig, memoryConfig = {}) {
+  const toolName = uri === "mindgraph://memory/status" ? "mindgraph_memory" : RESOURCE_GOVERNANCE_TOOL;
+  const toolArgs = uri === "mindgraph://memory/status" ? { action: "status" } : {};
   const governance = await checkMcpGovernance(
-    RESOURCE_GOVERNANCE_TOOL,
-    {},
+    toolName,
+    toolArgs,
     { ...governanceConfig, context: { resource_uri: uri } }
   );
   if (!governance.allowed) {
     throw new Error(governance.message);
   }
-  return readResource(client2, uri);
+  return readResource(client2, uri, memoryConfig);
 }
 var RESOURCES, RESOURCE_TEMPLATES, RESOURCE_GOVERNANCE_TOOL;
 var init_resources = __esm({
   "src/resources.ts"() {
     "use strict";
     init_governance();
+    init_memory_tool();
     RESOURCES = [
+      {
+        uri: "mindgraph://memory/status",
+        name: "Memory Integration Status",
+        description: "Portable memory profile, adapter state, supported capabilities, and explicit limitations",
+        mimeType: "application/json"
+      },
       {
         uri: "mindgraph://stats",
         name: "Graph Statistics",
@@ -6178,10 +7021,10 @@ async function main() {
   const transport = new import_stdio.StdioServerTransport();
   await server.connect(transport);
   console.error(
-    `MindGraph MCP server v${"0.19.0"} running on stdio (${BASE_URL})`
+    `MindGraph MCP server v${"0.20.0"} running on stdio (${BASE_URL})`
   );
 }
-var import_server, import_stdio, import_types, import_node_path6, API_KEY, BASE_URL, AGENT_ID, ORG_ID, PROFILE, HARNESS, client, INSTRUCTIONS, RUNNER_REFRESH, HOOK_SKEW_NOTE, server, GOVERNANCE_CONFIG, PROMPTS;
+var import_server, import_stdio, import_types, import_node_path6, API_KEY, BASE_URL, AGENT_ID, ORG_ID, PROFILE, HARNESS, client, INSTRUCTIONS, RUNNER_REFRESH, HOOK_SKEW_NOTE, server, GOVERNANCE_CONFIG, MEMORY_RUNTIME_CONFIG, PROMPTS;
 var init_src = __esm({
   "src/index.ts"() {
     "use strict";
@@ -6219,56 +7062,29 @@ var init_src = __esm({
     });
     INSTRUCTIONS = `You have access to a persistent knowledge graph via MindGraph, plus any ontology tools generated by the active schema.
 
-## #1 RULE: Go straight to the user's topic
-
-When the user asks about something, your FIRST and ONLY action should be a SINGLE \`mindgraph_retrieve\` call with action "context" and keyword terms from their message. Nothing else first.
-
-**NEVER do any of these before addressing the user's topic:**
-- Do NOT retrieve active_goals, open_questions, contradictions, or weak_claims
-- Do NOT follow a "session lifecycle" or "warm-up" sequence
-- Do NOT make multiple serial retrieve calls when one "context" call covers it
-
-There is no session to open. There is no context to pre-load. Just search for what the user asked about.
+## Default memory workflow: orient \u2192 answer \u2192 preserve
 
-**Example:** User says "Tell me about Indian philosophy and Taoism"
-\u2713 CORRECT: \`mindgraph_retrieve({action: "context", query: "Indian philosophy Taoism"})\`
-\u2717 WRONG: First retrieve active_goals, then open_questions, then search
-\u2717 WRONG: \`mindgraph_retrieve({action: "context", query: "Tell me about Indian philosophy and Taoism"})\` \u2014 natural language won't match BM25
+**Orient only when prior durable state may matter.** Self-contained questions do not require a memory call or a warm-up sequence.
 
-## Two-phase retrieval protocol
+- Resuming work, asking what was in progress, or continuing a task: call \`mindgraph_memory\` once with action \`context\` and mode \`resume\` or \`continuity\`. This uses authoritative, task-first, lease-aware work state.
+- Asking about a topic that may depend on prior knowledge: call \`mindgraph_memory\` once with action \`context\`, mode \`topic\`, and 1\u20133 discriminating keywords.
+- Asking about integration capability or automatic behavior: call \`mindgraph_memory\` with action \`status\`.
+- Use the comprehensive read tools below only when the high-level result is insufficient or the user asks for a specific graph operation.
 
-**Phase 1 \u2014 Orient (default, fast, lightweight):**
-Use \`action: "context"\` with keywords. By default this returns only graph nodes \u2014 structured knowledge with labels, summaries, types, confidence scores, and edges. This is usually sufficient and keeps results compact.
+**Answer from the bounded result.** Treat superseded, refuted, or out-of-validity items as warnings, not current facts. Retrieval proves only that the server returned context; it does not prove that a host automatically injected or used it.
 
-**Phase 2 \u2014 Fetch source text (only when needed):**
-If you need the original source text behind a node (for verbatim quotes, citations, or when graph summaries lack detail), use \`action: "context"\` with \`include_chunks: true\`. This adds full document chunks (400-800 words each) to the response.
+**Preserve selectively after material durable change.** Use the existing typed write tool for a fact, correction, decision, work-state transition, or reusable lesson. Do not write ephemeral conversation, routine mechanics, unsupported guesses, or information already represented accurately. An explicit no-write is the correct outcome when nothing durable changed.
 
-**Orientation shortcut:**
-- \`action: "document_index"\` \u2014 list all ingested documents (titles, dates, UIDs) to see what's in the graph
+## Topic retrieval details
 
-## Search strategy \u2014 keyword first, semantic as fallback
+Topic context is graph-only by default. Set \`include_chunks: true\` only for source text needed for quotes, citations, or missing detail. Query with a few proper nouns or technical terms rather than a full sentence. If keyword retrieval fails, use \`mindgraph_retrieve\` with \`semantic\` or \`hybrid\`; use \`document_index\` to inspect ingested sources.
 
-The default search uses BM25 keyword matching. Query with 1\u20133 discriminating terms (proper nouns, technical terms). Drop filler words.
+## Comprehensive read tools
 
-**Keyword examples:**
-- "What is Kissinger's view on NATO?" \u2192 query: \`"Kissinger NATO"\`
-- "Tell me about async in Rust" \u2192 query: \`"Rust async runtime"\`
-- "Implications of carbon tax?" \u2192 query: \`"carbon tax"\`
-
-If keyword search returns no results, escalate:
-1. Try synonyms (e.g. \`"global warming"\` instead of \`"climate change"\`)
-2. Use \`action: "semantic"\` \u2014 vector similarity, natural language OK (e.g. \`"ways to manage stress"\` finds "mental health" nodes)
-3. Use \`action: "hybrid"\` \u2014 combines BM25 + semantic for best coverage
-
-## When to READ
-
-- User asks about topic X \u2192 \`mindgraph_retrieve\` action "context", query "X keywords"
-- User asks "what documents are in my graph?" \u2192 action "document_index"
-- User explicitly asks "what are my goals?" \u2192 action "active_goals"
-- User explicitly asks about open questions \u2192 action "open_questions"
-- User asks for advice or a recommendation ("suggest a hotel", "what should I read?") \u2192 action "preferences", query "topic keywords" \u2014 tailor the answer to what they like
-- Explore around a known node \u2192 action "neighborhood" with start_uid
-- Find connections between nodes \u2192 action "path" with start_uid + end_uid
+- Explicit graph inventory or state questions \u2192 the matching \`mindgraph_retrieve\` action such as \`document_index\`, \`active_goals\`, or \`open_questions\`
+- Advice or recommendations \u2192 \`mindgraph_retrieve\` action \`preferences\`, with topic keywords
+- Explore around a known node \u2192 \`mindgraph_retrieve\` action \`neighborhood\` with start_uid
+- Find connections between nodes \u2192 \`mindgraph_retrieve\` action \`path\` with start_uid + end_uid
 
 ## When to WRITE
 
@@ -6303,13 +7119,14 @@ Capture knowledge when the user shares something worth remembering:
 
 ## Coding profile
 
-**Recall order (overrides the #1 rule above for work and code questions):**
-- "What was I working on?" / current work state / resuming anything: call \`mindgraph_plan\` action \`resume_work\` FIRST. Work state is structural; never answer it from keyword search ("recent work" famously retrieves people named Work).
+**Coding recall order:**
+- "What was I working on?" / current work state / resuming anything: call \`mindgraph_memory\` action \`context\`, mode \`resume\` FIRST. It delegates to structural \`resume_work\`; never answer work state from keyword search ("recent work" famously retrieves people named Work).
 - Knowledge about specific code (a function, file, or route): \`mindgraph_code\` action \`recall\` \u2014 anchor-based, not keyword-based.
 - Broad knowledge searches: \`mindgraph_retrieve\` as usual, but when searching for work artifacts pass node_types filters (Task, Lesson, RiskAssessment, Claim) to keep personal-graph content out of engineering answers.
 
 - Use mindgraph_sync for explicit, one-way project memory-file imports. It discovers and hashes files, but you deliberately map durable assertions with record; it never writes graph state back to files.
 - 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.`;
     } else {
@@ -6319,7 +7136,7 @@ Capture knowledge when the user shares something worth remembering:
     }
     RUNNER_REFRESH = (() => {
       try {
-        return refreshHookRunner("0.19.0", import_node_path6.default.join(__dirname, "cli.js"));
+        return refreshHookRunner("0.20.0", import_node_path6.default.join(__dirname, "cli.js"));
       } catch {
         return void 0;
       }
@@ -6333,12 +7150,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.19.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.20.0"}` + (refreshedSettings.length > 0 ? `; refreshed owned hook entries in ${refreshedSettings.join(", ")}` : "")
       );
     }
     HOOK_SKEW_NOTE = (() => {
       try {
-        return versionSkewNote("0.19.0");
+        return versionSkewNote("0.20.0");
       } catch {
         return void 0;
       }
@@ -6352,7 +7169,7 @@ ${HOOK_SKEW_NOTE}`;
     server = new import_server.Server(
       {
         name: "mindgraph",
-        version: "0.19.0"
+        version: "0.20.0"
       },
       {
         capabilities: {
@@ -6376,6 +7193,14 @@ ${HOOK_SKEW_NOTE}`;
         return process.env.MINDGRAPH_GOVERNANCE === "off";
       }
     };
+    MEMORY_RUNTIME_CONFIG = {
+      serverVersion: "0.20.0",
+      baseUrl: BASE_URL,
+      profile: PROFILE,
+      harness: HARNESS,
+      orgId: ORG_ID,
+      agentId: AGENT_ID
+    };
     server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
       const { name, arguments: args } = request.params;
       const rawArgs = { ...args || {} };
@@ -6395,7 +7220,7 @@ ${HOOK_SKEW_NOTE}`;
       if (desc) {
         return handleGeneratedTool(client, desc, rawArgs);
       }
-      return handleTool(client, name, toolArgs);
+      return handleTool(client, name, toolArgs, MEMORY_RUNTIME_CONFIG);
     });
     PROMPTS = [
       {
@@ -6560,10 +7385,15 @@ ${conversation}`
       return { resourceTemplates: RESOURCE_TEMPLATES };
     });
     server.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
-      return readGovernedResource(client, request.params.uri, GOVERNANCE_CONFIG);
+      return readGovernedResource(
+        client,
+        request.params.uri,
+        GOVERNANCE_CONFIG,
+        MEMORY_RUNTIME_CONFIG
+      );
     });
-    main().catch((error) => {
-      console.error("Fatal error:", error);
+    main().catch((error2) => {
+      console.error("Fatal error:", error2);
       process.exit(1);
     });
   }
@@ -6761,12 +7591,12 @@ function scalar(raw) {
   }
   return trimmed;
 }
-function parseSkillMd(text) {
-  if (!text.startsWith("---\n")) return null;
-  const end = text.indexOf("\n---\n", 4);
+function parseSkillMd(text2) {
+  if (!text2.startsWith("---\n")) return null;
+  const end = text2.indexOf("\n---\n", 4);
   if (end < 0) return null;
-  const frontmatter = text.slice(4, end + 1);
-  const body = text.slice(end + 5).replace(/^\n/, "").replace(/\n$/, "");
+  const frontmatter = text2.slice(4, end + 1);
+  const body = text2.slice(end + 5).replace(/^\n/, "").replace(/\n$/, "");
   const entries = [];
   for (const line of frontmatter.split("\n")) {
     const top = /^([A-Za-z0-9_-]+):(.*)$/.exec(line);
@@ -6812,8 +7642,8 @@ ${line}`;
   return result;
 }
 var STATE_FILE = ".mindgraph-skills-state.json";
-function sha256(text) {
-  return (0, import_node_crypto2.createHash)("sha256").update(text).digest("hex");
+function sha256(text2) {
+  return (0, import_node_crypto2.createHash)("sha256").update(text2).digest("hex");
 }
 function loadState(dir) {
   try {
@@ -6959,13 +7789,13 @@ async function skillsPush(api, skillPath) {
   if (isSymlink(file)) {
     return { outcome: "error", message: `${file} is a symlink; refusing` };
   }
-  let text;
+  let text2;
   try {
-    text = fs2.readFileSync(file, "utf8");
+    text2 = fs2.readFileSync(file, "utf8");
   } catch {
     return { outcome: "error", message: `could not read ${file}` };
   }
-  const parsed = parseSkillMd(text);
+  const parsed = parseSkillMd(text2);
   if (!parsed) {
     return {
       outcome: "error",
@@ -7083,8 +7913,8 @@ function withLedger(sessionId, options, update) {
     try {
       lockFd = import_node_fs3.default.openSync(lock, "wx", 384);
       break;
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
+    } 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);
       } catch {
@@ -7189,11 +8019,11 @@ var BRIEF_CHAR_BUDGET = 9e3;
 function renderBrief(brief, meta) {
   let bounded = false;
   const clipTracked = (value, max) => {
-    const text = string(value);
-    if (!text) return void 0;
-    if (text.length <= max) return text;
+    const text2 = string(value);
+    if (!text2) return void 0;
+    if (text2.length <= max) return text2;
     bounded = true;
-    return `${text.slice(0, max - 1)}\u2026`;
+    return `${text2.slice(0, max - 1)}\u2026`;
   };
   const nodeLine = (value, summaryMax) => {
     const node = object(value);
@@ -7352,9 +8182,9 @@ async function repositoryScopeUids(input, client2, options, agentId) {
           `${repository.repoId}: ${string(payload?.status) || "unresolved"}`
         );
         return void 0;
-      } catch (error) {
+      } catch (error2) {
         failures.push(
-          `${repository.repoId}: ${error?.message || "resolve failed"}`
+          `${repository.repoId}: ${error2?.message || "resolve failed"}`
         );
         return void 0;
       }
@@ -7378,12 +8208,12 @@ function hasMindgraphServer(servers) {
   for (const [name, entry] of Object.entries(servers)) {
     if (name === "mindgraph") return true;
     const cfg = entry && typeof entry === "object" ? entry : void 0;
-    const text = [
+    const text2 = [
       String(cfg?.command ?? ""),
       Array.isArray(cfg?.args) ? cfg.args.join(" ") : "",
       String(cfg?.url ?? "")
     ].join(" ");
-    if (text.includes("mindgraph-mcp")) return true;
+    if (text2.includes("mindgraph-mcp")) return true;
   }
   return false;
 }
@@ -7613,7 +8443,7 @@ async function postTool(input, client2, options) {
       ledger.mutatingOperations += 1;
     }
     if (!payload?.error) {
-      if (name.includes("mindgraph_capture") && ["lesson", "journal", "skill"].includes(action || "") || name.includes("mindgraph_commit") && action === "resolve_decision" || name.includes("mindgraph_plan") && action === "assess_risk") {
+      if (name.includes("mindgraph_capture") && (["lesson", "journal", "skill"].includes(action || "") || ["observation", "entity"].includes(action || "") && (Array.isArray(args.code_refs) || typeof args.supersedes_uid === "string")) || name.includes("mindgraph_commit") && action === "resolve_decision" || name.includes("mindgraph_plan") && action === "assess_risk") {
         ledger.memoryWritten = true;
       }
     }
@@ -7894,7 +8724,7 @@ async function runCodexHook(input, client2, options = {}) {
 
 // src/cli.ts
 init_hook_installer();
-function recordHookHealth(harness, error) {
+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 });
@@ -7908,7 +8738,7 @@ function recordHookHealth(harness, error) {
       file,
       `${JSON.stringify({
         harness,
-        lastError: error.slice(0, 500),
+        lastError: error2.slice(0, 500),
         lastFailureAt: (/* @__PURE__ */ new Date()).toISOString(),
         consecutiveFailures: failures + 1
       })}
@@ -8131,7 +8961,7 @@ function withHooksFlag() {
 }
 function finishCodeInstall(apiKey, baseUrl, withHooks, agentId) {
   if (withHooks) {
-    const runner = installHookRunner(__filename, void 0, "0.19.0");
+    const runner = installHookRunner(__filename, void 0, "0.20.0");
     console.log(`Installed pinned hook runner at ${runner}`);
     const result = installClaudeHooks("user");
     console.log(
@@ -8446,7 +9276,7 @@ ${total} skill(s) synced.`);
       if (hookHarness !== "claude-code" && hookHarness !== "codex") {
         throw new Error("--harness must be claude-code or codex");
       }
-      const runner = installHookRunner(__filename, void 0, "0.19.0");
+      const runner = installHookRunner(__filename, void 0, "0.20.0");
       console.log(`Installed pinned hook runner at ${runner}`);
       const result = hookHarness === "codex" ? installCodexHooks(scope, projectDir) : installClaudeHooks(scope, projectDir);
       console.log(
@@ -8527,13 +9357,13 @@ ${total} skill(s) synced.`);
         process.stdout.write(`${JSON.stringify(output)}
 `);
         clearHookHealth(hookHarness);
-      } catch (error) {
+      } catch (error2) {
         recordHookHealth(
           hookHarness,
-          error?.message || "hook failed"
+          error2?.message || "hook failed"
         );
         console.error(
-          `mindgraph-hook: failing open (${error?.message || "unknown error"})`
+          `mindgraph-hook: failing open (${error2?.message || "unknown error"})`
         );
         process.stdout.write("{}\n");
       }
@@ -8552,7 +9382,7 @@ ${total} skill(s) synced.`);
       process.exit(1);
   }
 }
-main2().catch((error) => {
-  console.error("Error:", error.message || error);
+main2().catch((error2) => {
+  console.error("Error:", error2.message || error2);
   process.exit(1);
 });