mindgraph-mcp 0.18.0 → 0.20.0

package/dist/cli.js

@@ -65,8 +65,8 @@ var init_dist = __esm({
         this.retryBackoffMs = config.retryBackoffMs ?? 1e3;
       }
       // ---- HTTP helpers ----
-      async request(method, path7, body) {
-        const url = `${this.baseUrl}${path7}`;
+      async request(method, path8, body) {
+        const url = `${this.baseUrl}${path8}`;
         const requestId = createRequestId();
         const init = {
           method,
@@ -83,43 +83,44 @@ 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} ${path7} failed: ${res.status}`,
+              `${method} ${path8} failed: ${res.status}`,
               res.status,
               parsed
             );
             if (res.status === 503 && attempt < this.maxRetries) {
               lastError = err5;
-              const delay = this.retryBackoffMs * 2 ** attempt;
+              const retryAfterSecs = Number(res.headers.get("retry-after"));
+              const delay = Number.isFinite(retryAfterSecs) && retryAfterSecs > 0 ? Math.min(retryAfterSecs * 1e3, 1e4) : this.retryBackoffMs * 2 ** attempt;
               await new Promise((r) => setTimeout(r, delay));
               continue;
             }
             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;
       }
-      get(path7) {
-        return this.request("GET", path7);
+      get(path8) {
+        return this.request("GET", path8);
       }
-      post(path7, body) {
-        return this.request("POST", path7, body);
+      post(path8, body) {
+        return this.request("POST", path8, body);
       }
-      patch(path7, body) {
-        return this.request("PATCH", path7, body);
+      patch(path8, body) {
+        return this.request("PATCH", path8, body);
       }
-      del(path7) {
-        return this.request("DELETE", path7);
+      del(path8) {
+        return this.request("DELETE", path8);
       }
       // ---- Health ----
       async health() {
@@ -148,6 +149,52 @@ var init_dist = __esm({
       async entity(req) {
         return this.post("/reality/entity", req);
       }
+      async series(req) {
+        return this.post("/reality/series", req);
+      }
+      async createSeries(req) {
+        return this.post("/reality/series", { action: "create", ...req });
+      }
+      async appendSeries(req) {
+        return this.post("/reality/series", { action: "append", ...req });
+      }
+      async seriesWindow(req) {
+        return this.post("/reality/series", { action: "window", ...req });
+      }
+      async aggregateSeries(req) {
+        return this.post("/reality/series", { action: "aggregate", ...req });
+      }
+      async latestSeries(seriesUid, options) {
+        return this.post("/reality/series", {
+          action: "latest",
+          series_uid: seriesUid,
+          ...options
+        });
+      }
+      async listSeriesForEntity(entityUid, options) {
+        return this.post("/reality/series", {
+          action: "list_for_entity",
+          entity_uid: entityUid,
+          ...options
+        });
+      }
+      async batchLatestSeries(entityUids, options) {
+        return this.post("/reality/series", {
+          action: "batch_latest",
+          entity_uids: entityUids,
+          ...options
+        });
+      }
+      async batchAggregateSeries(req) {
+        return this.post("/reality/series", { action: "batch_aggregate", ...req });
+      }
+      async deleteSeries(seriesUid, options) {
+        return this.post("/reality/series", {
+          action: "delete_series",
+          series_uid: seriesUid,
+          ...options
+        });
+      }
       /** Convenience: create or find an entity by label. */
       async findOrCreateEntity(label, props, agentId) {
         return this.post("/reality/entity", {
@@ -185,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
         });
       }
@@ -196,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
         });
@@ -498,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() {
@@ -717,6 +764,20 @@ var init_dist = __esm({
       async getOntologySchema(id) {
         return this.get(`/v1/ontology/schemas/${seg(id)}`);
       }
+      async createOntologySeriesBinding(schemaId, request) {
+        return this.post(`/v1/ontology/schemas/${seg(schemaId)}/series-bindings`, request);
+      }
+      async syncOntologySeriesBinding(bindingId, mode) {
+        return this.post(
+          `/v1/ontology/series-bindings/${seg(bindingId)}/sync`,
+          mode ? { mode } : {}
+        );
+      }
+      async archiveOntologySeriesBinding(schemaId, bindingId) {
+        return this.del(
+          `/v1/ontology/schemas/${seg(schemaId)}/series-bindings/${seg(bindingId)}`
+        );
+      }
       async createOntologySchema(req) {
         return this.post("/v1/ontology/schemas", req);
       }
@@ -988,14 +1049,14 @@ function unavailabilityCaveats(reason, message) {
   }
   return caveats;
 }
-function normalizePath(path7) {
-  return path7.replaceAll("\\", "/").replace(/^\.\//, "");
+function normalizePath(path8) {
+  return path8.replaceAll("\\", "/").replace(/^\.\//, "");
 }
 function normalizeSignature(signature) {
   return signature.replace(/\s+/g, " ").trim();
 }
-function languageFromPath(path7) {
-  const extension = (0, import_node_path2.extname)(path7).toLowerCase();
+function languageFromPath(path8) {
+  const extension = (0, import_node_path2.extname)(path8).toLowerCase();
   return {
     ".c": "c",
     ".cc": "cpp",
@@ -1102,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"));
@@ -1152,13 +1213,11 @@ 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
     }
   };
 }
-var import_node_child_process, import_node_fs2, import_promises, import_node_os2, import_node_path2, import_node_crypto2, UnknownRepositoryError, DEFAULT_TIMEOUT_MS, DEFAULT_STATUS_TTL_MS, MAX_OUTPUT_BYTES, CodegraphAdapter;
+var import_node_child_process, import_node_fs2, import_promises, import_node_os2, import_node_path2, import_node_crypto3, UnknownRepositoryError, DEFAULT_TIMEOUT_MS, DEFAULT_STATUS_TTL_MS, MAX_OUTPUT_BYTES, CodegraphAdapter;
 var init_codegraph = __esm({
   "src/codegraph.ts"() {
     "use strict";
@@ -1167,7 +1226,7 @@ var init_codegraph = __esm({
     import_promises = require("fs/promises");
     import_node_os2 = require("os");
     import_node_path2 = require("path");
-    import_node_crypto2 = require("crypto");
+    import_node_crypto3 = require("crypto");
     UnknownRepositoryError = class extends Error {
       constructor(repo) {
         super(
@@ -1296,7 +1355,7 @@ var init_codegraph = __esm({
         } catch {
         }
         (0, import_node_fs2.mkdirSync)(identityDir, { recursive: true, mode: 448 });
-        const generated = (0, import_node_crypto2.randomUUID)();
+        const generated = (0, import_node_crypto3.randomUUID)();
         try {
           (0, import_node_fs2.writeFileSync)(identityFile, `${generated}
 `, {
@@ -2043,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,
@@ -2308,7 +2367,7 @@ 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 });
-  const temporary = `${target}.${process.pid}.${import_node_crypto4.default.randomUUID()}.tmp`;
+  const temporary = `${target}.${process.pid}.${import_node_crypto5.default.randomUUID()}.tmp`;
   import_node_fs4.default.copyFileSync(sourceFile, temporary);
   import_node_fs4.default.renameSync(temporary, target);
   const versionPath = import_node_path4.default.join(homeDir || import_node_os4.default.homedir(), RUNNER_VERSION_RELATIVE);
@@ -2478,7 +2537,7 @@ function entryHasOwnedHook(value) {
 }
 function writeSettings(file, settings) {
   import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
-  const temporary = `${file}.${process.pid}.${import_node_crypto4.default.randomUUID()}.tmp`;
+  const temporary = `${file}.${process.pid}.${import_node_crypto5.default.randomUUID()}.tmp`;
   import_node_fs4.default.writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}
 `, {
     mode: 384
@@ -2554,14 +2613,14 @@ 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_crypto4, OWNER_MARKER, RUNNER_RELATIVE, RUNNER_VERSION_RELATIVE;
+var import_node_fs4, 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_os4 = __toESM(require("os"));
     import_node_path4 = __toESM(require("path"));
-    import_node_crypto4 = __toESM(require("crypto"));
+    import_node_crypto5 = __toESM(require("crypto"));
     OWNER_MARKER = "--owner mindgraph";
     RUNNER_RELATIVE = ".mindgraph/bin/mindgraph-hook.cjs";
     RUNNER_VERSION_RELATIVE = `${RUNNER_RELATIVE}.version`;
@@ -2603,7 +2662,7 @@ function fileDescriptor(root, absolute) {
   const content = import_node_fs5.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_crypto5.default.createHash("sha256").update(content).digest("hex"),
+    content_hash: import_node_crypto6.default.createHash("sha256").update(content).digest("hex"),
     bytes: Buffer.byteLength(content),
     content
   };
@@ -2678,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) {
@@ -2716,11 +2775,11 @@ async function scanRepository(remote, repository, requested, provider, agentId)
     files: results
   };
 }
-var import_node_crypto5, import_node_fs5, import_node_path5, ok2, err2, SYNC_TOOL;
+var import_node_crypto6, import_node_fs5, import_node_path5, ok2, err2, SYNC_TOOL;
 var init_sync_tool = __esm({
   "src/sync-tool.ts"() {
     "use strict";
-    import_node_crypto5 = __toESM(require("crypto"));
+    import_node_crypto6 = __toESM(require("crypto"));
     import_node_fs5 = __toESM(require("fs"));
     import_node_path5 = __toESM(require("path"));
     init_codegraph();
@@ -2813,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);
@@ -2940,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;
@@ -2953,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;
       }
@@ -2980,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}
@@ -2996,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 : [];
@@ -3020,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);
@@ -3030,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({
@@ -3073,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;
@@ -3095,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;
   }
@@ -3105,31 +3301,36 @@ 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) || "?");
   if (paths.length > 0) {
-    const items = paths.map((raw) => obj(raw)).filter((path7) => Boolean(path7)).map((path7, index) => {
-      const uids = Array.isArray(path7.node_uids) ? path7.node_uids.map(String) : [];
-      const labels = Array.isArray(path7.labels) ? path7.labels.map(String) : Array.isArray(path7.nodes) ? path7.nodes.map((hop) => {
+    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) || "?";
       }) : [];
       const route = labels.length > 0 ? labels.join(" \u2192 ") : uids.join(" \u2192 ") || "(path)";
-      const cost = num(path7.cost) ?? num(path7.path_cost);
-      const confidence = num(path7.path_confidence);
+      const cost = num(path8.cost) ?? num(path8.path_cost);
+      const confidence = num(path8.path_confidence);
       const meta = [
         cost !== void 0 ? `cost ${cost}` : void 0,
         confidence !== void 0 ? `confidence ${confidence}` : void 0
@@ -3140,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(
@@ -3151,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);
@@ -3172,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));
@@ -3238,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") : [];
@@ -3253,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;
@@ -3279,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;
@@ -3303,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";
@@ -3314,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(
@@ -3334,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 {
@@ -3343,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":
@@ -3362,6 +4176,12 @@ 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;
       case "mindgraph_ingest":
         result = await handleIngest(client2, args);
         break;
@@ -3406,17 +4226,45 @@ async function handleTool(client2, name, args) {
     return err3(errorDetail(e));
   }
 }
+async function handleSeriesQuery(client2, args) {
+  const action = typeof args.action === "string" ? args.action : "";
+  if (!["list_for_entity", "latest", "window", "aggregate"].includes(action)) {
+    return err3(`Unknown series query action: ${action}`);
+  }
+  if (action === "list_for_entity" && typeof args.entity_uid !== "string") {
+    return err3("entity_uid is required for action='list_for_entity'");
+  }
+  if (action !== "list_for_entity" && typeof args.series_uid !== "string") {
+    return err3(`series_uid is required for action='${action}'`);
+  }
+  if ((action === "window" || action === "aggregate") && (typeof args.from !== "number" || typeof args.to !== "number")) {
+    return err3(`from and to are required for action='${action}'`);
+  }
+  if (action === "aggregate" && (typeof args.bucket !== "string" || typeof args.agg !== "string")) {
+    return err3("bucket and agg are required for action='aggregate'");
+  }
+  return ok3(
+    await client2.series(args)
+  );
+}
 async function handleCapture(client2, args) {
   const {
     action,
     label,
     summary,
     content,
+    name,
+    description,
+    license,
     session_uid,
     work_uid,
     execution_uid,
     idempotency_key,
+    reuse_uid,
     supersedes_uid,
+    contradicts_uid,
+    confirm_new,
+    on_near_duplicate,
     summarizes_uids,
     entity_type,
     source_uid,
@@ -3440,38 +4288,82 @@ 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
         })
       );
+    case "skill": {
+      if (!name) return err3("name is required for action=skill");
+      if (!description) return err3("description is required for action=skill");
+      if (content === void 0) return err3("content is required for action=skill");
+      const hasProvenance = [session_uid, work_uid, execution_uid].some(
+        (uid) => typeof uid === "string" && uid.length > 0
+      ) || Array.isArray(summarizes_uids) && summarizes_uids.some((uid) => typeof uid === "string" && uid.length > 0);
+      if (!hasProvenance) {
+        return err3(
+          "at least one of session_uid, work_uid, execution_uid, or summarizes_uids is required for action=skill"
+        );
+      }
+      return ok3(
+        await client2.distill({
+          label,
+          output_type: "skill",
+          summary,
+          confidence,
+          salience,
+          session_uid,
+          work_uid,
+          execution_uid,
+          idempotency_key,
+          supersedes_uid,
+          summarizes_uids,
+          props: {
+            name,
+            description,
+            content,
+            ...license ? { license } : {}
+          },
+          agent_id
+        })
+      );
+    }
     case "journal": {
       if (!content) return err3("content is required for action=journal");
       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(
@@ -3482,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":
@@ -3494,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":
@@ -3507,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,
@@ -3559,7 +4475,8 @@ async function handleReason(client2, args) {
           ...warrant.content ? { props: { content: warrant.content } } : {}
         } : void 0,
         argument,
-        agent_id
+        agent_id,
+        ...resolution
       })
     );
   }
@@ -3572,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,
@@ -3607,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(
@@ -3626,7 +4546,8 @@ async function handleCommit(client2, args) {
           decision_uid,
           summary,
           props,
-          agent_id
+          agent_id,
+          ...resolution
         })
       );
     case "resolve_decision":
@@ -3640,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":
@@ -3721,7 +4643,7 @@ async function handlePlan(client2, args) {
     output_snapshot,
     side_effects,
     outcome,
-    error,
+    error: error2,
     next_action,
     checkpoint_summary,
     test_summary,
@@ -3784,7 +4706,7 @@ async function handlePlan(client2, args) {
           output_snapshot,
           side_effects,
           outcome,
-          error,
+          error: error2,
           next_action,
           checkpoint_summary,
           test_summary,
@@ -3833,7 +4755,7 @@ async function handlePlan(client2, args) {
           output_snapshot,
           side_effects,
           outcome,
-          error,
+          error: error2,
           props,
           agent_id
         })
@@ -3919,6 +4841,7 @@ async function handleRetrieve(client2, args) {
   const {
     action,
     format,
+    max_output_chars,
     query,
     start_uid,
     end_uid,
@@ -3973,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");
@@ -3987,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");
@@ -4001,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");
@@ -4016,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
@@ -4034,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(
@@ -4043,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(
@@ -4053,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");
@@ -4065,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(
@@ -4079,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":
@@ -4088,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":
@@ -4102,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");
@@ -4117,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");
@@ -4134,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");
@@ -4149,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");
@@ -4165,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}`);
@@ -4421,19 +5344,48 @@ 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",
-        description: "Capture knowledge into the graph. Use 'entity' for people/orgs/places/events/nations/concepts (auto-deduplicates \u2014 safe to call even if already exists), 'observation' for factual statements, 'source' for documents/URLs, 'snippet' for quotes from a source, and 'concept' for abstract ideas. Use 'journal' for quick personal notes and 'lesson' for a durable learning attributable to a session or source nodes. Prefer 'entity'/'observation' for objective facts, 'journal' for informal notes, and 'lesson' only for reusable knowledge.",
+        description: "Capture knowledge into the graph. Use 'entity' for people/orgs/places/events/nations/concepts (auto-deduplicates \u2014 safe to call even if already exists), 'observation' for factual statements, 'source' for documents/URLs, 'snippet' for quotes from a source, and 'concept' for abstract ideas. Use 'journal' for quick personal notes, 'lesson' for a durable learning, and 'skill' for a reusable procedure authored from completed work. Skill capture always creates a candidate requiring admin review; it never publishes. Skill names must be 1-64 lowercase a-z, digits, or hyphens, with no leading/trailing/consecutive hyphens and no 'anthropic' or 'claude'. Provide at least one provenance field and write instructions, not a transcript dump.",
         inputSchema: {
           type: "object",
           properties: {
@@ -4446,7 +5398,8 @@ var init_tools = __esm({
                 "snippet",
                 "concept",
                 "journal",
-                "lesson"
+                "lesson",
+                "skill"
               ],
               description: "Type of knowledge to capture"
             },
@@ -4460,11 +5413,30 @@ var init_tools = __esm({
             },
             content: {
               type: "string",
-              description: "Journal content/body text (for action=journal)"
+              maxLength: 65536,
+              description: "Journal body (action=journal) or complete SKILL.md instructions, at most 64 KiB UTF-8 (action=skill)"
+            },
+            name: {
+              type: "string",
+              minLength: 1,
+              maxLength: 64,
+              pattern: "^(?!.*(?:anthropic|claude))(?!-)(?!.*--)[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$",
+              description: "Stable skill identifier using lowercase a-z, digits, and hyphens (for action=skill)"
+            },
+            description: {
+              type: "string",
+              minLength: 1,
+              maxLength: 1024,
+              description: "When the skill should be used; XML tags are rejected (for action=skill)"
+            },
+            license: {
+              type: "string",
+              description: "Optional skill license (for action=skill)"
             },
             session_uid: {
               type: "string",
-              description: "Session UID that produced a lesson (for action=lesson)"
+              minLength: 1,
+              description: "Session UID that produced a lesson or skill"
             },
             work_uid: {
               type: "string",
@@ -4474,18 +5446,12 @@ 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" },
-              description: "Source node UIDs the lesson was learned from (for action=lesson)"
+              minItems: 1,
+              description: "Source node UIDs the lesson or skill was learned from"
             },
             entity_type: {
               type: "string",
@@ -4552,7 +5518,24 @@ var init_tools = __esm({
               description: "Agent identity"
             }
           },
-          required: ["action", "label"]
+          required: ["action", "label"],
+          allOf: [
+            {
+              if: {
+                properties: { action: { const: "skill" } },
+                required: ["action"]
+              },
+              then: {
+                required: ["name", "description", "content"],
+                anyOf: [
+                  { required: ["session_uid"] },
+                  { required: ["work_uid"] },
+                  { required: ["execution_uid"] },
+                  { required: ["summarizes_uids"] }
+                ]
+              }
+            }
+          ]
         }
       },
       {
@@ -4561,6 +5544,7 @@ var init_tools = __esm({
         inputSchema: {
           type: "object",
           properties: {
+            ...RESOLUTION_PROPERTIES,
             action: {
               type: "string",
               enum: [
@@ -4655,6 +5639,7 @@ var init_tools = __esm({
         inputSchema: {
           type: "object",
           properties: {
+            ...RESOLUTION_PROPERTIES,
             action: {
               type: "string",
               enum: [
@@ -5013,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."
@@ -5138,6 +6129,42 @@ var init_tools = __esm({
           required: ["action"]
         }
       },
+      {
+        name: "mindgraph_series_query",
+        description: "Read dense numeric time series without placing raw points in general retrieval context. Use list_for_entity to discover series, latest for cached statistics, window for [from,to) keyset pages, and aggregate for bounded calendar buckets.",
+        inputSchema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            action: {
+              type: "string",
+              enum: ["list_for_entity", "latest", "window", "aggregate"]
+            },
+            entity_uid: { type: "string" },
+            series_uid: { type: "string" },
+            from: { type: "number" },
+            to: { type: "number" },
+            cursor: { type: "number" },
+            limit: { type: "number", minimum: 1, maximum: 1e4 },
+            bucket: {
+              type: "string",
+              enum: ["year", "quarter", "month", "week", "day", "hour"]
+            },
+            agg: {
+              type: "string",
+              enum: ["sum", "mean", "min", "max", "count", "std_dev", "last"]
+            },
+            fill: { type: "string", enum: ["none", "null", "prev"] }
+          },
+          required: ["action"]
+        },
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        }
+      },
       {
         name: "mindgraph_ingest",
         description: "Ingest long-form content (articles, transcripts, documents, meeting notes) into the knowledge graph. The pipeline automatically chunks the text, extracts entities/claims/relationships via LLM, and deduplicates against existing nodes. Use 'chunk' for a single passage (synchronous), 'document' for full documents (async \u2014 returns a job ID), 'session' for conversation transcripts. Use 'job_status' to check progress. For short individual facts, use the specific cognitive tools instead.",
@@ -5403,6 +6430,7 @@ var init_tools = __esm({
           required: ["action"]
         }
       },
+      MEMORY_TOOL,
       SYNC_TOOL,
       CODE_TOOL
     ];
@@ -5423,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;
@@ -5477,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;
   }
@@ -5591,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 }) }],
@@ -5624,7 +6652,7 @@ function isTransientStatus(status) {
   return status === 408 || status === 425 || status === 429 || status >= 500;
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function headers(apiKey, orgId) {
   const value = {
@@ -5641,7 +6669,9 @@ 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") {
     return action && PLAN_READ_ACTIONS.has(action) ? "read" : "write";
   }
@@ -5723,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;
@@ -5826,6 +6856,8 @@ var init_governance = __esm({
     UID_FIELDS = [
       "uid",
       "source_uid",
+      "entity_uid",
+      "series_uid",
       "session_uid",
       "work_uid",
       "goal_uid",
@@ -5867,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":
@@ -5900,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",
@@ -5978,10 +7021,10 @@ async function main() {
   const transport = new import_stdio.StdioServerTransport();
   await server.connect(transport);
   console.error(
-    `MindGraph MCP server v${"0.18.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";
@@ -6019,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.
+## Default memory workflow: orient \u2192 answer \u2192 preserve
 
-**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
+**Orient only when prior durable state may matter.** Self-contained questions do not require a memory call or a warm-up sequence.
 
-There is no session to open. There is no context to pre-load. Just search for what the user asked about.
+- 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.
 
-**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
+**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.
 
-## Two-phase retrieval protocol
+**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.
 
-**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.
+## Topic retrieval details
 
-**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.
+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.
 
-**Orientation shortcut:**
-- \`action: "document_index"\` \u2014 list all ingested documents (titles, dates, UIDs) to see what's in the graph
+## Comprehensive read tools
 
-## Search strategy \u2014 keyword first, semantic as fallback
-
-The default search uses BM25 keyword matching. Query with 1\u20133 discriminating terms (proper nouns, technical terms). Drop filler words.
-
-**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
 
@@ -6103,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 {
@@ -6119,7 +7136,7 @@ Capture knowledge when the user shares something worth remembering:
     }
     RUNNER_REFRESH = (() => {
       try {
-        return refreshHookRunner("0.18.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;
       }
@@ -6133,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.18.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.18.0");
+        return versionSkewNote("0.20.0");
       } catch {
         return void 0;
       }
@@ -6152,7 +7169,7 @@ ${HOOK_SKEW_NOTE}`;
     server = new import_server.Server(
       {
         name: "mindgraph",
-        version: "0.18.0"
+        version: "0.20.0"
       },
       {
         capabilities: {
@@ -6176,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 || {} };
@@ -6195,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 = [
       {
@@ -6360,18 +7385,23 @@ ${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);
     });
   }
 });
 
 // src/cli.ts
-var fs5 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 var crypto5 = __toESM(require("crypto"));
 var import_child_process = require("child_process");
@@ -6389,6 +7419,8 @@ function parseArgs(argv) {
   let harness;
   let hooks = false;
   let agentId = process.env.MINDGRAPH_AGENT_ID;
+  const positionals = [];
+  let dir;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     switch (arg) {
@@ -6409,6 +7441,9 @@ function parseArgs(argv) {
       case "--project-dir":
         projectDir = args[++i];
         break;
+      case "--dir":
+        dir = args[++i];
+        break;
       case "--harness":
         harness = args[++i];
         break;
@@ -6427,12 +7462,27 @@ function parseArgs(argv) {
         break;
       default:
         if (!arg.startsWith("-")) {
-          command2 = arg;
+          if (command2 === "serve") {
+            command2 = arg;
+          } else {
+            positionals.push(arg);
+          }
         }
         break;
     }
   }
-  return { command: command2, apiKey, baseUrl, scope, projectDir, harness, hooks, agentId };
+  return {
+    command: command2,
+    apiKey,
+    baseUrl,
+    scope,
+    projectDir,
+    harness,
+    hooks,
+    agentId,
+    positionals,
+    dir
+  };
 }
 function mcpAddFailureOutput(e) {
   const err5 = e;
@@ -6446,8 +7496,375 @@ function classifyMcpAddFailure(e) {
   return "other";
 }
 
+// src/skills-cli.ts
+var import_node_crypto2 = require("crypto");
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+function httpSkillsApi(baseUrl, apiKey, agentId) {
+  const endpoint = `${baseUrl.replace(/\/$/, "")}/action/skill`;
+  const call = async (body) => {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(
+        agentId ? { agent_id: agentId, ...body } : body
+      )
+    });
+    let parsed = {};
+    try {
+      parsed = await response.json();
+    } catch {
+      parsed = { error: `non-JSON response (HTTP ${response.status})` };
+    }
+    return { status: response.status, body: parsed };
+  };
+  return {
+    async list(grantedTo) {
+      const { status, body } = await call({
+        action: "list",
+        ...grantedTo ? { granted_to: grantedTo } : {}
+      });
+      if (status !== 200) {
+        throw new Error(
+          `skill list failed (HTTP ${status}): ${String(body.error ?? "")}`
+        );
+      }
+      return body.skills ?? [];
+    },
+    async get(uid) {
+      const { status, body } = await call({ action: "get", uid });
+      if (status === 404) return null;
+      if (status !== 200) {
+        throw new Error(
+          `skill get failed (HTTP ${status}): ${String(body.error ?? "")}`
+        );
+      }
+      const props = body.props ?? {};
+      return {
+        uid: String(body.uid ?? uid),
+        name: String(props.name ?? ""),
+        description: String(props.description ?? ""),
+        content: String(props.content ?? ""),
+        license: props.license ?? null,
+        status: String(props.status ?? "candidate"),
+        status_reason: props.status_reason ?? null,
+        content_hash: String(props.content_hash ?? ""),
+        version: Number(body.version ?? 0)
+      };
+    },
+    send: call
+  };
+}
+function isValidSkillName(name) {
+  return name.length >= 1 && name.length <= 64 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
+}
+function renderSkillMd(skill) {
+  const lines = [
+    "---",
+    `name: ${JSON.stringify(skill.name)}`,
+    `description: ${JSON.stringify(skill.description)}`
+  ];
+  if (skill.license) {
+    lines.push(`license: ${JSON.stringify(skill.license)}`);
+  }
+  lines.push(
+    "metadata:",
+    `  mindgraph-uid: ${JSON.stringify(skill.uid)}`,
+    `  mindgraph-version: ${JSON.stringify(String(skill.version))}`,
+    `  mindgraph-content-hash: ${JSON.stringify(skill.content_hash)}`,
+    "---",
+    "",
+    skill.content
+  );
+  return `${lines.join("\n")}
+`;
+}
+function scalar(raw) {
+  const trimmed = raw.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed === "string") return parsed;
+  } catch {
+  }
+  return trimmed;
+}
+function parseSkillMd(text2) {
+  if (!text2.startsWith("---\n")) return null;
+  const end = text2.indexOf("\n---\n", 4);
+  if (end < 0) return null;
+  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);
+    if (top) {
+      entries.push({ key: top[1], raw: top[2] });
+    } else if (entries.length > 0) {
+      entries[entries.length - 1].raw += `
+${line}`;
+    }
+  }
+  const result = { unknown: {}, body };
+  for (const { key, raw } of entries) {
+    switch (key) {
+      case "name":
+        result.name = scalar(raw);
+        break;
+      case "description":
+        result.description = scalar(raw);
+        break;
+      case "license":
+        result.license = scalar(raw);
+        break;
+      case "metadata": {
+        const uid = /mindgraph-uid:\s*(.+)/.exec(raw);
+        const version = /mindgraph-version:\s*(.+)/.exec(raw);
+        const hash = /mindgraph-content-hash:\s*(.+)/.exec(raw);
+        if (uid) {
+          result.pin = {
+            uid: scalar(uid[1]),
+            version: version ? scalar(version[1]) : void 0,
+            contentHash: hash ? scalar(hash[1]) : void 0
+          };
+        } else if (raw.trim().length > 0) {
+          result.unknown[key] = raw;
+        }
+        break;
+      }
+      default:
+        result.unknown[key] = raw;
+        break;
+    }
+  }
+  return result;
+}
+var STATE_FILE = ".mindgraph-skills-state.json";
+function sha256(text2) {
+  return (0, import_node_crypto2.createHash)("sha256").update(text2).digest("hex");
+}
+function loadState(dir) {
+  try {
+    return JSON.parse(
+      fs2.readFileSync(path2.join(dir, STATE_FILE), "utf8")
+    );
+  } catch {
+    return {};
+  }
+}
+function saveState(dir, state) {
+  fs2.writeFileSync(
+    path2.join(dir, STATE_FILE),
+    `${JSON.stringify(state, null, 2)}
+`
+  );
+}
+function isSymlink(target) {
+  try {
+    return fs2.lstatSync(target).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function safeSkillPaths(dir, name) {
+  if (!isValidSkillName(name)) {
+    return `invalid skill name ${JSON.stringify(name)}`;
+  }
+  const root = path2.resolve(dir);
+  const skillDir = path2.resolve(root, name);
+  if (skillDir !== path2.join(root, name) || !skillDir.startsWith(root + path2.sep)) {
+    return "resolved path escapes the target directory";
+  }
+  if (isSymlink(skillDir)) {
+    return "target directory is a symlink";
+  }
+  const skillFile = path2.join(skillDir, "SKILL.md");
+  if (isSymlink(skillFile)) {
+    return "target SKILL.md is a symlink";
+  }
+  return { skillDir, skillFile };
+}
+async function skillsPull(api, dir, grantedTo) {
+  const report = {
+    written: [],
+    unchanged: [],
+    locallyEdited: [],
+    conflicts: [],
+    removed: [],
+    refused: []
+  };
+  fs2.mkdirSync(dir, { recursive: true });
+  const state = loadState(dir);
+  const summaries = await api.list(grantedTo);
+  const fetched = /* @__PURE__ */ new Set();
+  for (const summary of summaries) {
+    const detail = await api.get(summary.uid);
+    if (!detail || detail.status !== "published") continue;
+    fetched.add(detail.name);
+    const paths = safeSkillPaths(dir, detail.name);
+    if (typeof paths === "string") {
+      report.refused.push({ name: detail.name, reason: paths });
+      continue;
+    }
+    const { skillDir, skillFile } = paths;
+    const rendered2 = renderSkillMd(detail);
+    let existing = null;
+    try {
+      existing = fs2.readFileSync(skillFile, "utf8");
+    } catch {
+      existing = null;
+    }
+    if (existing === rendered2) {
+      state[detail.name] = {
+        uid: detail.uid,
+        content_hash: detail.content_hash,
+        file_sha256: sha256(rendered2)
+      };
+      report.unchanged.push(detail.name);
+      continue;
+    }
+    const recorded = state[detail.name];
+    const locallyModified = existing !== null && (!recorded || sha256(existing) !== recorded.file_sha256);
+    if (locallyModified) {
+      if (recorded && recorded.content_hash === detail.content_hash) {
+        report.locallyEdited.push(detail.name);
+        continue;
+      }
+      fs2.writeFileSync(`${skillFile}.conflict`, rendered2);
+      report.conflicts.push(detail.name);
+      continue;
+    }
+    fs2.mkdirSync(skillDir, { recursive: true });
+    fs2.writeFileSync(skillFile, rendered2);
+    state[detail.name] = {
+      uid: detail.uid,
+      content_hash: detail.content_hash,
+      file_sha256: sha256(rendered2)
+    };
+    report.written.push(detail.name);
+  }
+  for (const [name, recorded] of Object.entries(state)) {
+    if (fetched.has(name)) continue;
+    const paths = safeSkillPaths(dir, name);
+    if (typeof paths === "string") {
+      delete state[name];
+      continue;
+    }
+    const { skillDir, skillFile } = paths;
+    let statusReason = null;
+    try {
+      const gone = await api.get(recorded.uid);
+      statusReason = gone?.status_reason ?? (gone ? `status: ${gone.status}` : null);
+    } catch {
+      statusReason = null;
+    }
+    let existing = null;
+    try {
+      existing = fs2.readFileSync(skillFile, "utf8");
+    } catch {
+      existing = null;
+    }
+    if (existing === null) {
+      delete state[name];
+      continue;
+    }
+    const locallyModified = sha256(existing) !== recorded.file_sha256;
+    if (locallyModified) {
+      fs2.renameSync(skillFile, `${skillFile}.conflict`);
+      report.removed.push({ name, statusReason, kept: true });
+    } else {
+      fs2.rmSync(skillDir, { recursive: true, force: true });
+      report.removed.push({ name, statusReason, kept: false });
+    }
+    delete state[name];
+  }
+  saveState(dir, state);
+  return report;
+}
+async function skillsPush(api, skillPath) {
+  const resolved = path2.resolve(skillPath);
+  const file = resolved.endsWith("SKILL.md") ? resolved : path2.join(resolved, "SKILL.md");
+  if (isSymlink(file)) {
+    return { outcome: "error", message: `${file} is a symlink; refusing` };
+  }
+  let text2;
+  try {
+    text2 = fs2.readFileSync(file, "utf8");
+  } catch {
+    return { outcome: "error", message: `could not read ${file}` };
+  }
+  const parsed = parseSkillMd(text2);
+  if (!parsed) {
+    return {
+      outcome: "error",
+      message: "SKILL.md must start with a --- frontmatter block"
+    };
+  }
+  if (!parsed.name || !parsed.description) {
+    return {
+      outcome: "error",
+      message: "SKILL.md frontmatter requires name and description"
+    };
+  }
+  if (parsed.pin?.uid) {
+    const { status: status2, body: body2 } = await api.send({
+      action: "update",
+      uid: parsed.pin.uid,
+      name: parsed.name,
+      description: parsed.description,
+      content: parsed.body,
+      ...parsed.license ? { license: parsed.license } : {}
+    });
+    if (status2 === 200) {
+      return {
+        outcome: "updated",
+        message: `updated candidate ${parsed.name} (${parsed.pin.uid})`,
+        uid: parsed.pin.uid
+      };
+    }
+    return {
+      outcome: status2 === 409 ? "conflict" : "error",
+      message: `update failed (HTTP ${status2}): ${String(body2.error ?? "")}`,
+      existingUid: body2.existing_uid ?? void 0,
+      existingStatus: body2.existing_status ?? void 0
+    };
+  }
+  const { status, body } = await api.send({
+    action: "create",
+    skill_source: "imported",
+    name: parsed.name,
+    description: parsed.description,
+    content: parsed.body,
+    ...parsed.license ? { license: parsed.license } : {},
+    ...Object.keys(parsed.unknown).length > 0 ? { imported_frontmatter: parsed.unknown } : {},
+    import_origin: `skills-push:${path2.basename(resolved)}`
+  });
+  if (status === 200 && body.replayed === true) {
+    return {
+      outcome: "replayed",
+      message: `unchanged: ${parsed.name} already imported (${String(body.uid)})`,
+      uid: String(body.uid)
+    };
+  }
+  if (status === 200) {
+    return {
+      outcome: "created",
+      message: `imported ${parsed.name} as a candidate (${String(body.uid)}) \u2014 review and publish in the dashboard`,
+      uid: String(body.uid)
+    };
+  }
+  return {
+    outcome: status === 409 ? "conflict" : "error",
+    message: `import failed (HTTP ${status}): ${String(body.error ?? "")}`,
+    existingUid: body.existing_uid ?? void 0,
+    existingStatus: body.existing_status ?? void 0
+  };
+}
+
 // src/hook-core.ts
-var import_node_crypto3 = __toESM(require("crypto"));
+var import_node_crypto4 = __toESM(require("crypto"));
 var import_node_fs3 = __toESM(require("fs"));
 var import_node_os3 = __toESM(require("os"));
 var import_node_path3 = __toESM(require("path"));
@@ -6477,7 +7894,7 @@ function runtimeDir(options) {
 }
 function ledgerPath(sessionId, options) {
   const harness = "harness" in options ? options.harness : "claude-code";
-  const key = import_node_crypto3.default.createHash("sha256").update(`${harness}\0${sessionId}`).digest("hex");
+  const key = import_node_crypto4.default.createHash("sha256").update(`${harness}\0${sessionId}`).digest("hex");
   return import_node_path3.default.join(runtimeDir(options), `${key}.json`);
 }
 function waitBriefly(ms) {
@@ -6496,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 {
@@ -6519,7 +7936,7 @@ function withLedger(sessionId, options, update) {
     }
     const result = update(ledger);
     ledger.updatedAt = Date.now();
-    const temporary = `${file}.${process.pid}.${import_node_crypto3.default.randomUUID()}.tmp`;
+    const temporary = `${file}.${process.pid}.${import_node_crypto4.default.randomUUID()}.tmp`;
     import_node_fs3.default.writeFileSync(temporary, `${JSON.stringify(ledger)}
 `, { mode: 384 });
     import_node_fs3.default.renameSync(temporary, file);
@@ -6602,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);
@@ -6765,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;
       }
@@ -6791,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;
 }
@@ -6927,7 +8344,7 @@ async function sessionStart(input, client2, options) {
   const contextText = registrationNote ? `${registrationNote}
 
 ${briefText}` : briefText;
-  const briefHash = import_node_crypto3.default.createHash("sha256").update(contextText).digest("hex");
+  const briefHash = import_node_crypto4.default.createHash("sha256").update(contextText).digest("hex");
   const shouldInject = withLedger(input.session_id, options, (ledger) => {
     const changed = ledger.lastBriefHash !== briefHash;
     const reinjectCompact = options.reinjectUnchangedCompact && input.source === "compact";
@@ -7026,7 +8443,7 @@ async function postTool(input, client2, options) {
       ledger.mutatingOperations += 1;
     }
     if (!payload?.error) {
-      if (name.includes("mindgraph_capture") && ["lesson", "journal"].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;
       }
     }
@@ -7307,21 +8724,21 @@ 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 || path6.join(os4.homedir(), ".mindgraph", "runtime");
-    fs5.mkdirSync(dir, { recursive: true, mode: 448 });
-    const file = path6.join(dir, "hook-health.json");
+    const dir = process.env.MINDGRAPH_RUNTIME_DIR || path7.join(os4.homedir(), ".mindgraph", "runtime");
+    fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+    const file = path7.join(dir, "hook-health.json");
     let failures = 0;
     try {
-      failures = Number(JSON.parse(fs5.readFileSync(file, "utf8")).consecutiveFailures) || 0;
+      failures = Number(JSON.parse(fs6.readFileSync(file, "utf8")).consecutiveFailures) || 0;
     } catch {
     }
-    fs5.writeFileSync(
+    fs6.writeFileSync(
       file,
       `${JSON.stringify({
         harness,
-        lastError: error.slice(0, 500),
+        lastError: error2.slice(0, 500),
         lastFailureAt: (/* @__PURE__ */ new Date()).toISOString(),
         consecutiveFailures: failures + 1
       })}
@@ -7333,14 +8750,14 @@ function recordHookHealth(harness, error) {
 }
 function clearHookHealth(harness) {
   try {
-    const file = path6.join(
-      process.env.MINDGRAPH_RUNTIME_DIR || path6.join(os4.homedir(), ".mindgraph", "runtime"),
+    const file = path7.join(
+      process.env.MINDGRAPH_RUNTIME_DIR || path7.join(os4.homedir(), ".mindgraph", "runtime"),
       "hook-health.json"
     );
-    if (!fs5.existsSync(file)) return;
-    const current = JSON.parse(fs5.readFileSync(file, "utf8"));
+    if (!fs6.existsSync(file)) return;
+    const current = JSON.parse(fs6.readFileSync(file, "utf8"));
     if (!Number(current.consecutiveFailures)) return;
-    fs5.writeFileSync(
+    fs6.writeFileSync(
       file,
       `${JSON.stringify({
         harness,
@@ -7356,7 +8773,7 @@ function clearHookHealth(harness) {
 function getClaudeDesktopConfigPath() {
   switch (process.platform) {
     case "darwin":
-      return path6.join(
+      return path7.join(
         os4.homedir(),
         "Library",
         "Application Support",
@@ -7364,13 +8781,13 @@ function getClaudeDesktopConfigPath() {
         "claude_desktop_config.json"
       );
     case "win32":
-      return path6.join(
-        process.env.APPDATA || path6.join(os4.homedir(), "AppData", "Roaming"),
+      return path7.join(
+        process.env.APPDATA || path7.join(os4.homedir(), "AppData", "Roaming"),
         "Claude",
         "claude_desktop_config.json"
       );
     case "linux":
-      return path6.join(
+      return path7.join(
         os4.homedir(),
         ".config",
         "Claude",
@@ -7381,16 +8798,16 @@ function getClaudeDesktopConfigPath() {
   }
 }
 function readJsonFile(filePath) {
-  if (!fs5.existsSync(filePath)) return {};
-  const content = fs5.readFileSync(filePath, "utf-8");
+  if (!fs6.existsSync(filePath)) return {};
+  const content = fs6.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJsonFile(filePath, data) {
-  const dir = path6.dirname(filePath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(filePath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
-  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 function getMcpServerEntry(apiKey, baseUrl) {
   const env = { MINDGRAPH_API_KEY: apiKey };
@@ -7477,7 +8894,7 @@ function installClaudeCode(apiKey, baseUrl, agentId) {
 }
 function uninstallClaudeDesktop() {
   const configPath = getClaudeDesktopConfigPath();
-  if (!fs5.existsSync(configPath)) {
+  if (!fs6.existsSync(configPath)) {
     console.log("Claude Desktop config not found. Nothing to remove.");
     return;
   }
@@ -7504,7 +8921,7 @@ function uninstallClaudeCode() {
 }
 function printStatus() {
   const desktopPath = getClaudeDesktopConfigPath();
-  if (fs5.existsSync(desktopPath)) {
+  if (fs6.existsSync(desktopPath)) {
     const config = readJsonFile(desktopPath);
     const servers = config.mcpServers;
     if (servers && "mindgraph" in servers) {
@@ -7522,12 +8939,12 @@ function printStatus() {
     `MINDGRAPH_BASE_URL: ${process.env.MINDGRAPH_BASE_URL || "https://api.mindgraph.cloud (default)"}`
   );
   try {
-    const healthFile = path6.join(
-      process.env.MINDGRAPH_RUNTIME_DIR || path6.join(os4.homedir(), ".mindgraph", "runtime"),
+    const healthFile = path7.join(
+      process.env.MINDGRAPH_RUNTIME_DIR || path7.join(os4.homedir(), ".mindgraph", "runtime"),
       "hook-health.json"
     );
-    if (fs5.existsSync(healthFile)) {
-      const health = JSON.parse(fs5.readFileSync(healthFile, "utf8"));
+    if (fs6.existsSync(healthFile)) {
+      const health = JSON.parse(fs6.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"})`
@@ -7544,7 +8961,7 @@ function withHooksFlag() {
 }
 function finishCodeInstall(apiKey, baseUrl, withHooks, agentId) {
   if (withHooks) {
-    const runner = installHookRunner(__filename, void 0, "0.18.0");
+    const runner = installHookRunner(__filename, void 0, "0.20.0");
     console.log(`Installed pinned hook runner at ${runner}`);
     const result = installClaudeHooks("user");
     console.log(
@@ -7592,6 +9009,20 @@ USAGE:
   mindgraph-mcp install-hooks --harness claude-code|codex [--scope user|project]
   mindgraph-mcp uninstall-hooks --harness claude-code|codex [--scope user|project]
   mindgraph-mcp status           Show installation status
+  mindgraph-mcp skills pull [--dir .claude/skills]
+                                 Write your org's published+granted skills as
+                                 SKILL.md directories (allowlisted frontmatter
+                                 only). Revoked/archived skills are withdrawn;
+                                 local edits are never overwritten (.conflict
+                                 sidecars). NOTE: coding harnesses hot-reload
+                                 skill files \u2014 running sessions adopt pulled
+                                 changes immediately; session pinning exists
+                                 on the managed-agent leg only.
+  mindgraph-mcp skills push <path>
+                                 Import a SKILL.md directory as a review
+                                 candidate (nothing auto-publishes). A
+                                 previously pulled directory routes to the
+                                 candidate-only update path.
 
 OPTIONS:
   --api-key <key>     MindGraph API key (or set MINDGRAPH_API_KEY env var)
@@ -7655,7 +9086,7 @@ async function pollForKey(code) {
     } catch (e) {
       if (e instanceof Error && e.message.includes("Session")) throw e;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL));
+    await new Promise((resolve3) => setTimeout(resolve3, POLL_INTERVAL));
   }
   throw new Error("Timed out waiting for authorization.");
 }
@@ -7665,7 +9096,7 @@ async function interactiveInit(baseUrl) {
     input: process.stdin,
     output: process.stdout
   });
-  const ask = (q) => new Promise((resolve2) => rl.question(q, resolve2));
+  const ask = (q) => new Promise((resolve3) => rl.question(q, resolve3));
   console.log("\nMindGraph MCP Server Setup\n");
   console.log("  1. Sign in via browser (recommended)");
   console.log("  2. Enter API key manually");
@@ -7736,8 +9167,79 @@ async function interactiveInit(baseUrl) {
   console.log("\nDone! Your knowledge graph is now connected.");
 }
 async function main2() {
-  const { command: command2, apiKey, baseUrl, scope, projectDir, harness, hooks, agentId } = parseArgs(process.argv);
+  const {
+    command: command2,
+    apiKey,
+    baseUrl,
+    scope,
+    projectDir,
+    harness,
+    hooks,
+    agentId,
+    positionals,
+    dir
+  } = parseArgs(process.argv);
   switch (command2) {
+    case "skills": {
+      if (!apiKey) {
+        console.error(
+          "API key required. Use --api-key or set MINDGRAPH_API_KEY."
+        );
+        process.exit(1);
+      }
+      const sub = positionals[0];
+      const api = httpSkillsApi(
+        baseUrl ?? "https://api.mindgraph.cloud",
+        apiKey,
+        agentId
+      );
+      if (sub === "pull") {
+        if (!agentId) {
+          console.error(
+            "note: no --agent-id/MINDGRAPH_AGENT_ID \u2014 pulling ALL published skills; bind an agent identity to scope the set by its grants."
+          );
+        }
+        const report = await skillsPull(api, dir ?? ".claude/skills", agentId);
+        for (const name of report.written) console.log(`  written    ${name}`);
+        for (const name of report.unchanged)
+          console.log(`  unchanged  ${name}`);
+        for (const name of report.locallyEdited)
+          console.log(`  local-edit ${name} \u2014 upstream unchanged; left alone`);
+        for (const name of report.conflicts)
+          console.log(
+            `  CONFLICT   ${name} \u2014 local edits kept; new upstream saved as SKILL.md.conflict`
+          );
+        for (const removal of report.removed)
+          console.log(
+            `  withdrawn  ${removal.name}${removal.kept ? " (local edits kept as SKILL.md.conflict)" : ""}${removal.statusReason ? ` \u2014 ${removal.statusReason}` : ""}`
+          );
+        for (const refusal of report.refused)
+          console.log(`  REFUSED    ${refusal.name} \u2014 ${refusal.reason}`);
+        const total = report.written.length + report.unchanged.length + report.locallyEdited.length + report.conflicts.length;
+        console.log(`
+${total} skill(s) synced.`);
+      } else if (sub === "push") {
+        const target = positionals[1];
+        if (!target) {
+          console.error("Usage: mindgraph-mcp skills push <path>");
+          process.exit(1);
+        }
+        const report = await skillsPush(api, target);
+        console.log(report.message);
+        if (report.existingUid) {
+          console.log(
+            `  existing skill: ${report.existingUid}${report.existingStatus ? ` (${report.existingStatus})` : ""}`
+          );
+        }
+        if (report.outcome === "error" || report.outcome === "conflict") {
+          process.exit(1);
+        }
+      } else {
+        console.error("Usage: mindgraph-mcp skills pull|push [...]");
+        process.exit(1);
+      }
+      break;
+    }
     case "help":
       printUsage();
       break;
@@ -7774,7 +9276,7 @@ async function main2() {
       if (hookHarness !== "claude-code" && hookHarness !== "codex") {
         throw new Error("--harness must be claude-code or codex");
       }
-      const runner = installHookRunner(__filename, void 0, "0.18.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(
@@ -7855,13 +9357,13 @@ async function main2() {
         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");
       }
@@ -7880,7 +9382,7 @@ async function main2() {
       process.exit(1);
   }
 }
-main2().catch((error) => {
-  console.error("Error:", error.message || error);
+main2().catch((error2) => {
+  console.error("Error:", error2.message || error2);
   process.exit(1);
 });