mindgraph-mcp 0.24.0 → 0.26.0

package/dist/server.mjs

@@ -1,15 +1,10 @@
 // src/server.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 import {
-  CallToolRequestSchema,
-  GetPromptRequestSchema,
-  ListPromptsRequestSchema,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
-  ListToolsRequestSchema,
-  ReadResourceRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
+  createMcpHandler,
+  isLegacyRequest,
+  Server,
+  WebStandardStreamableHTTPServerTransport
+} from "@modelcontextprotocol/server";
 
 // src/error-detail.ts
 import { MindGraphError } from "mindgraph";
@@ -117,12 +112,21 @@ function unwrapSearchResult(value) {
   }
   return void 0;
 }
+function supersededBy(node) {
+  const marker = node.superseded;
+  if (!marker) return void 0;
+  const head = obj(marker);
+  if (!head) return str(node.superseded_by) ?? "";
+  const label = (str(head.head_label) ?? str(head.head_uid) ?? "").replace(/\s+/g, " ").trim();
+  const short = label.length <= 80 ? label : `${label.slice(0, 79)}\u2026`;
+  const date = str(head.head_stated_at);
+  return short && date ? `${short} (${date.slice(0, 10)})` : short;
+}
 function statusTag(node) {
   const tags = [];
-  if (node.superseded === true) {
-    tags.push(
-      node.superseded_by ? `SUPERSEDED by ${str(node.superseded_by)}` : "SUPERSEDED"
-    );
+  const replacement = supersededBy(node);
+  if (replacement !== void 0) {
+    tags.push(replacement ? `SUPERSEDED by ${replacement}` : "SUPERSEDED");
   }
   const truth = str(node.truth_status) ?? str(obj(node.props)?.truth_status);
   if (truth && truth !== "accepted") tags.push(`truth: ${truth}`);
@@ -392,13 +396,13 @@ 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) {
+function renderResumeContext(response, maxChars, repositoryNames = {}) {
   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 scopedOut = typeof payload.scoped_out_tasks === "number" ? payload.scoped_out_tasks : 0;
     const note = scopedOut > 0 ? ` ${scopedOut} task(s) exist outside the requested scope.` : "";
     return assemble(
       "# Resume context",
@@ -412,6 +416,17 @@ function renderResumeContext(response, maxChars) {
     if (section) sections.push(section);
   };
   push(resumeSection("## Current task", [payload.task], state, "Task"));
+  const other = otherEligibleWork(payload, repositoryNames);
+  if (other.shown > 0) {
+    sections.push({
+      heading: `## Other eligible work (${other.shown} shown${other.more > 0 ? `, ${other.more} more not listed` : ""})`,
+      items: other.groups.flatMap(
+        (group) => group.tasks.map(
+          (task) => `- ${group.repository}: ${task.label} [${task.uid}]${task.detail ? ` \u2014 ${task.detail}` : ""}`
+        )
+      )
+    });
+  }
   push(
     resumeSection(
       "## Goal and project",
@@ -483,6 +498,37 @@ function renderResumeContext(response, maxChars) {
   if (sections.length === 0) return void 0;
   return assemble("# Resume context", sections, state, maxChars);
 }
+function otherEligibleWork(brief, names = {}) {
+  const listed = Array.isArray(brief?.other_eligible) ? brief.other_eligible : [];
+  const groups = [];
+  let shown = 0;
+  for (const entry of listed) {
+    const task = obj(entry);
+    const uid = typeof task?.uid === "string" ? task.uid : void 0;
+    if (!task || !uid) continue;
+    const scopes = Array.isArray(task.scope_uids) ? task.scope_uids.map(String) : [];
+    const named = scopes.find((scope) => names[scope]);
+    const repository = named ? names[named] : "Other scopes";
+    let group = groups.find((candidate) => candidate.repository === repository);
+    if (!group) {
+      group = { repository, tasks: [] };
+      groups.push(group);
+    }
+    const label = typeof task.label === "string" && task.label ? task.label : "(unlabeled)";
+    const detail = [
+      typeof task.status === "string" ? task.status : void 0,
+      typeof task.priority === "string" && task.priority ? `priority ${task.priority}` : void 0
+    ].filter(Boolean).join(", ");
+    group.tasks.push({
+      uid,
+      label: label.length > 160 ? `${label.slice(0, 159)}\u2026` : label,
+      detail
+    });
+    shown += 1;
+  }
+  const total = typeof brief?.eligible_total === "number" ? brief.eligible_total : 0;
+  return { groups, shown, more: Math.max(0, total - 1 - shown) };
+}
 function renderNodeList(response, title, limit, maxChars) {
   let candidates = [];
   if (Array.isArray(response)) {
@@ -533,15 +579,15 @@ function renderTraversal(response, maxChars) {
   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((path2) => Boolean(path2)).map((path2, index) => {
-      const uids = Array.isArray(path2.node_uids) ? path2.node_uids.map(String) : [];
-      const labels = Array.isArray(path2.labels) ? path2.labels.map(String) : Array.isArray(path2.nodes) ? path2.nodes.map((hop) => {
+    const items = paths.map((raw) => obj(raw)).filter((path3) => Boolean(path3)).map((path3, index) => {
+      const uids = Array.isArray(path3.node_uids) ? path3.node_uids.map(String) : [];
+      const labels = Array.isArray(path3.labels) ? path3.labels.map(String) : Array.isArray(path3.nodes) ? path3.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(path2.cost) ?? num(path2.path_cost);
-      const confidence = num(path2.path_confidence);
+      const cost = num(path3.cost) ?? num(path3.path_cost);
+      const confidence = num(path3.path_confidence);
       const meta = [
         cost !== void 0 ? `cost ${cost}` : void 0,
         confidence !== void 0 ? `confidence ${confidence}` : void 0
@@ -1557,764 +1603,156 @@ ${conversation}`
 
 // src/memory-tool.ts
 import { createHash } from "crypto";
-var RESULT_SCHEMA_VERSION = "mindgraph.memory.result.v1";
-var DEFAULT_OUTPUT_CHARS = 8e3;
-var MIN_OUTPUT_CHARS = 512;
-var MAX_OUTPUT_CHARS = 24e3;
-var HIDDEN_CONTEXT_NODE_TYPES = /* @__PURE__ */ new Set(["Chunk", "Document", "Article"]);
-var HIDDEN_CONTEXT_EDGE_TYPES = /* @__PURE__ */ new Set(["POSSIBLE_DUPLICATE", "PossibleDuplicate"]);
-var 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/workspace-scope.ts
+import fs from "fs";
+import path from "path";
+
+// src/codegraph.ts
+import { spawn } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { realpath } from "fs/promises";
+import { homedir } from "os";
+import {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  relative,
+  resolve,
+  sep
+} from "path";
+import { randomUUID } from "crypto";
+var UnknownRepositoryError = class extends Error {
+  constructor(repo) {
+    super(
+      `unknown repository "${repo}": not declared in .mindgraph/workspace.json, not the current repository, and no such path exists`
+    );
+    this.repo = repo;
+    this.name = "UnknownRepositoryError";
   }
+  repo;
 };
-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 invocationCwd(args) {
+  const context = args.invocation_context;
+  if (context && typeof context === "object" && !Array.isArray(context)) {
+    const cwd = context.cwd;
+    if (typeof cwd === "string" && cwd) return cwd;
+  }
+  return process.cwd();
 }
-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(",")}}`;
+function unavailabilityCaveats(reason, message) {
+  const caveats = [message || "codegraph status failed"];
+  if (reason === "absent") {
+    caveats.push(
+      "Optional: install codegraph (https://github.com/colbymchenry/codegraph) and run `codegraph init` in this repository to enable code anchoring and structural recall. Memory and work tools are unaffected."
+    );
   }
-  return JSON.stringify(value);
+  return caveats;
 }
-function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_STATUS_TTL_MS = 6e4;
+var MAX_OUTPUT_BYTES = 5 * 1024 * 1024;
+function normalizePath(path3) {
+  return path3.replaceAll("\\", "/").replace(/^\.\//, "");
 }
-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 normalizeSignature(signature) {
+  return signature.replace(/\s+/g, " ").trim();
 }
-function defined(values) {
-  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
+function languageFromPath(path3) {
+  const extension = extname(path3).toLowerCase();
+  return {
+    ".c": "c",
+    ".cc": "cpp",
+    ".cpp": "cpp",
+    ".go": "go",
+    ".java": "java",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".kt": "kotlin",
+    ".py": "python",
+    ".rb": "ruby",
+    ".rs": "rust",
+    ".swift": "swift",
+    ".ts": "typescript",
+    ".tsx": "typescript"
+  }[extension] ?? "unknown";
 }
-function memoryStatus(config = {}) {
+function asNode(hit) {
+  return hit.node ?? hit;
+}
+function toCandidate(node) {
+  if (!node.filePath || !node.kind || !(node.qualifiedName || node.name)) return null;
   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."
-      }
-    ]
+    path: normalizePath(node.filePath),
+    language: node.language ?? languageFromPath(node.filePath),
+    kind: node.kind,
+    qualifiedName: node.qualifiedName ?? node.name ?? "",
+    signature: node.signature ?? null,
+    startLine: node.startLine ?? 1,
+    endLine: node.endLine ?? node.startLine ?? 1
   };
 }
-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);
-    }
+function normalizeRemote(remote) {
+  const trimmed = remote.trim();
+  if (!trimmed) return null;
+  const scp = /^(?:[^@]+@)?([^:]+):(.+)$/.exec(trimmed);
+  if (scp && !trimmed.includes("://")) {
+    return `${scp[1].toLowerCase()}/${scp[2].replace(/\.git$/, "")}`;
   }
-  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);
-    }
+  try {
+    const url = new URL(trimmed);
+    const pathname = url.pathname.replace(/\/$/, "").replace(/\.git$/, "");
+    return `${url.host.toLowerCase()}${pathname}`;
+  } catch {
+    return null;
   }
-  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 pathContains(root, candidate) {
+  const child = relative(root, candidate);
+  return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
 }
-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;
+function nearestExistingDirectory(candidate) {
+  let current = resolve(candidate);
+  for (; ; ) {
+    if (existsSync(current)) {
+      try {
+        return statSync(current).isDirectory() ? current : dirname(current);
+      } catch {
       }
-      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." });
     }
+    const parent = dirname(current);
+    if (parent === current) return current;
+    current = parent;
   }
-  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(client, 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'");
+var MAX_CHILD_DIRECTORIES = 200;
+function findChildWorkspaceFiles(start) {
+  let entries;
+  try {
+    entries = readdirSync(start, { withFileTypes: true });
+  } catch {
+    return [];
   }
-  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 client.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 client.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 = sha256(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_${sha256(
-    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
-  };
-}
-
-// src/resources.ts
-var 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",
-    description: "Current knowledge graph statistics: node counts, edge counts, and layer distribution",
-    mimeType: "application/json"
-  },
-  {
-    uri: "mindgraph://goals",
-    name: "Active Goals",
-    description: "All active goals in the knowledge graph",
-    mimeType: "application/json"
-  },
-  {
-    uri: "mindgraph://questions",
-    name: "Open Questions",
-    description: "All open questions in the knowledge graph",
-    mimeType: "application/json"
-  },
-  {
-    uri: "mindgraph://contradictions",
-    name: "Contradictions",
-    description: "Contradictory claims in the knowledge graph",
-    mimeType: "application/json"
-  },
-  {
-    uri: "mindgraph://decisions",
-    name: "Open Decisions",
-    description: "Unresolved decisions awaiting resolution",
-    mimeType: "application/json"
-  }
-];
-var RESOURCE_TEMPLATES = [
-  {
-    uriTemplate: "mindgraph://node/{uid}",
-    name: "Graph Node",
-    description: "Retrieve a specific node by its UID, including all properties, edges, and version history",
-    mimeType: "application/json"
-  },
-  {
-    uriTemplate: "mindgraph://search/{query}",
-    name: "Search Results",
-    description: "BM25 keyword search across all nodes \u2014 pass 1\u20133 discriminating terms (e.g. 'Kissinger NATO'), not natural language sentences",
-    mimeType: "application/json"
-  },
-  {
-    uriTemplate: "mindgraph://layer/{layer}",
-    name: "Layer Nodes",
-    description: "List all nodes in a specific cognitive layer (reality, epistemic, intent, action, memory, agent)",
-    mimeType: "application/json"
-  }
-];
-var RESOURCE_GOVERNANCE_TOOL = "mindgraph_retrieve";
-function json(uri, data) {
-  return {
-    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(data) }]
-  };
-}
-async function readResource(client, uri, memoryConfig = {}) {
-  switch (uri) {
-    case "mindgraph://memory/status":
-      return json(uri, memoryStatus(memoryConfig));
-    case "mindgraph://stats":
-      return json(uri, await client.stats());
-    case "mindgraph://goals":
-      return json(uri, await client.getGoals());
-    case "mindgraph://questions":
-      return json(uri, await client.getOpenQuestions());
-    case "mindgraph://contradictions":
-      return json(uri, await client.getContradictions());
-    case "mindgraph://decisions":
-      return json(uri, await client.getOpenDecisions());
-  }
-  const nodeMatch = uri.match(/^mindgraph:\/\/node\/(.+)$/);
-  if (nodeMatch) {
-    const uid = decodeURIComponent(nodeMatch[1]);
-    const node = await client.getNode(uid);
-    const edges = await client.getEdges({ from_uid: uid });
-    const inEdges = await client.getEdges({ to_uid: uid });
-    return json(uri, { node, outgoing_edges: edges, incoming_edges: inEdges });
-  }
-  const searchMatch = uri.match(/^mindgraph:\/\/search\/(.+)$/);
-  if (searchMatch) {
-    const query = decodeURIComponent(searchMatch[1]);
-    return json(uri, await client.search(query, { limit: 20 }));
-  }
-  const layerMatch = uri.match(/^mindgraph:\/\/layer\/(.+)$/);
-  if (layerMatch) {
-    const layer = decodeURIComponent(layerMatch[1]);
-    return json(uri, await client.getNodes({ layer, limit: 50 }));
-  }
-  throw new Error(`Unknown resource: ${uri}`);
-}
-async function readGovernedResource(client, 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(
-    toolName,
-    toolArgs,
-    { ...governanceConfig, context: { resource_uri: uri } }
-  );
-  if (!governance.allowed) {
-    throw new Error(governance.message);
-  }
-  return readResource(client, uri, memoryConfig);
-}
-
-// src/tools.ts
-import { createHash as createHash2 } from "crypto";
-
-// src/codegraph.ts
-import { spawn } from "child_process";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  statSync,
-  writeFileSync
-} from "fs";
-import { realpath } from "fs/promises";
-import { homedir } from "os";
-import {
-  basename,
-  dirname,
-  extname,
-  isAbsolute,
-  join,
-  relative,
-  resolve,
-  sep
-} from "path";
-import { randomUUID } from "crypto";
-var UnknownRepositoryError = class extends Error {
-  constructor(repo) {
-    super(
-      `unknown repository "${repo}": not declared in .mindgraph/workspace.json, not the current repository, and no such path exists`
-    );
-    this.repo = repo;
-    this.name = "UnknownRepositoryError";
-  }
-  repo;
-};
-function invocationCwd(args) {
-  const context = args.invocation_context;
-  if (context && typeof context === "object" && !Array.isArray(context)) {
-    const cwd = context.cwd;
-    if (typeof cwd === "string" && cwd) return cwd;
-  }
-  return process.cwd();
-}
-function unavailabilityCaveats(reason, message) {
-  const caveats = [message || "codegraph status failed"];
-  if (reason === "absent") {
-    caveats.push(
-      "Optional: install codegraph (https://github.com/colbymchenry/codegraph) and run `codegraph init` in this repository to enable code anchoring and structural recall. Memory and work tools are unaffected."
-    );
-  }
-  return caveats;
-}
-var DEFAULT_TIMEOUT_MS = 5e3;
-var DEFAULT_STATUS_TTL_MS = 6e4;
-var MAX_OUTPUT_BYTES = 5 * 1024 * 1024;
-function normalizePath(path2) {
-  return path2.replaceAll("\\", "/").replace(/^\.\//, "");
-}
-function normalizeSignature(signature) {
-  return signature.replace(/\s+/g, " ").trim();
-}
-function languageFromPath(path2) {
-  const extension = extname(path2).toLowerCase();
-  return {
-    ".c": "c",
-    ".cc": "cpp",
-    ".cpp": "cpp",
-    ".go": "go",
-    ".java": "java",
-    ".js": "javascript",
-    ".jsx": "javascript",
-    ".kt": "kotlin",
-    ".py": "python",
-    ".rb": "ruby",
-    ".rs": "rust",
-    ".swift": "swift",
-    ".ts": "typescript",
-    ".tsx": "typescript"
-  }[extension] ?? "unknown";
-}
-function asNode(hit) {
-  return hit.node ?? hit;
-}
-function toCandidate(node) {
-  if (!node.filePath || !node.kind || !(node.qualifiedName || node.name)) return null;
-  return {
-    path: normalizePath(node.filePath),
-    language: node.language ?? languageFromPath(node.filePath),
-    kind: node.kind,
-    qualifiedName: node.qualifiedName ?? node.name ?? "",
-    signature: node.signature ?? null,
-    startLine: node.startLine ?? 1,
-    endLine: node.endLine ?? node.startLine ?? 1
-  };
-}
-function normalizeRemote(remote) {
-  const trimmed = remote.trim();
-  if (!trimmed) return null;
-  const scp = /^(?:[^@]+@)?([^:]+):(.+)$/.exec(trimmed);
-  if (scp && !trimmed.includes("://")) {
-    return `${scp[1].toLowerCase()}/${scp[2].replace(/\.git$/, "")}`;
-  }
-  try {
-    const url = new URL(trimmed);
-    const pathname = url.pathname.replace(/\/$/, "").replace(/\.git$/, "");
-    return `${url.host.toLowerCase()}${pathname}`;
-  } catch {
-    return null;
-  }
-}
-function pathContains(root, candidate) {
-  const child = relative(root, candidate);
-  return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
-}
-function nearestExistingDirectory(candidate) {
-  let current = resolve(candidate);
-  for (; ; ) {
-    if (existsSync(current)) {
-      try {
-        return statSync(current).isDirectory() ? current : dirname(current);
-      } catch {
-      }
-    }
-    const parent = dirname(current);
-    if (parent === current) return current;
-    current = parent;
-  }
-}
-function findWorkspaceFile(start, explicit) {
-  if (explicit) return resolve(start, explicit);
-  let current = resolve(start);
-  for (; ; ) {
-    const candidate = join(current, ".mindgraph", "workspace.json");
-    if (existsSync(candidate)) return candidate;
-    const parent = dirname(current);
-    if (parent === current) return void 0;
-    current = parent;
+  return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).slice(0, MAX_CHILD_DIRECTORIES).map((entry) => join(start, entry.name, ".mindgraph", "workspace.json")).filter((candidate) => existsSync(candidate)).sort();
+}
+function findWorkspaceFile(start, explicit) {
+  if (explicit) return resolve(start, explicit);
+  let current = resolve(start);
+  for (; ; ) {
+    const candidate = join(current, ".mindgraph", "workspace.json");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
   }
 }
 async function runProcess(executable, args, timeoutMs, env, cwd) {
@@ -2382,6 +1820,7 @@ var CodegraphAdapter = class {
   env;
   cwd;
   workspaceFile;
+  childWorkspaceFiles;
   now;
   identityCache = /* @__PURE__ */ new Map();
   statusCache = /* @__PURE__ */ new Map();
@@ -2394,6 +1833,7 @@ var CodegraphAdapter = class {
       this.cwd,
       options.workspaceFile ?? this.env.MINDGRAPH_WORKSPACE_FILE
     );
+    this.childWorkspaceFiles = !this.workspaceFile && options.childWorkspaces ? findChildWorkspaceFiles(this.cwd) : [];
     this.now = options.now ?? Date.now;
   }
   async resolveRepository(repo, fallbackSpaceUid) {
@@ -2560,925 +2000,1593 @@ var CodegraphAdapter = class {
         if ((status.index?.pendingRefs ?? 0) > 0) {
           caveats.push(`${status.index?.pendingRefs} references remain pending`);
         }
-        if (status.index?.reindexRecommended) caveats.push("codegraph recommends reindexing");
-        availability = {
-          available: true,
-          stale: caveats.length > 0,
-          caveats,
-          lastIndexed: status.lastIndexed
+        if (status.index?.reindexRecommended) caveats.push("codegraph recommends reindexing");
+        availability = {
+          available: true,
+          stale: caveats.length > 0,
+          caveats,
+          lastIndexed: status.lastIndexed
+        };
+      }
+      this.statusCache.set(repository.repoRoot, {
+        status,
+        availability,
+        expiresAt: this.now() + this.statusTtlMs
+      });
+      return availability;
+    } catch (cause) {
+      const failure = cause;
+      const reason = failure.kind ?? "command_failed";
+      return {
+        available: false,
+        reason,
+        stale: false,
+        caveats: unavailabilityCaveats(reason, failure.message)
+      };
+    }
+  }
+  async resolveRefs(refs, options = {}) {
+    const normalized = refs.map(
+      (ref) => typeof ref === "string" ? { symbol: ref } : ref
+    );
+    const results = await Promise.all(
+      normalized.map(async (ref) => {
+        const repository2 = await this.repositoryForRef(
+          ref,
+          options.repo,
+          options.fallbackSpaceUid
+        );
+        const availability2 = await this.availability(repository2);
+        if (!availability2.available) {
+          return {
+            ref,
+            repository: repository2,
+            availability: availability2,
+            candidates: [],
+            error: availability2.reason
+          };
+        }
+        return {
+          ...await this.resolveOne(ref, repository2),
+          repository: repository2,
+          availability: availability2
+        };
+      })
+    );
+    const repositories = [
+      ...new Map(
+        results.flatMap(
+          (result) => result.repository ? [[result.repository.repoRoot, result.repository]] : []
+        )
+      ).values()
+    ];
+    const repository = repositories[0] ?? await this.resolveRepository(options.repo, options.fallbackSpaceUid);
+    if (repositories.length === 0) repositories.push(repository);
+    const availabilities = results.flatMap(
+      (result) => result.availability ? [result.availability] : []
+    );
+    const availability = availabilities.length === 0 ? await this.availability(repository) : {
+      available: availabilities.every((item) => item.available),
+      reason: availabilities.find((item) => !item.available)?.reason,
+      stale: availabilities.some((item) => item.stale),
+      caveats: [
+        ...new Set(availabilities.flatMap((item) => item.caveats))
+      ]
+    };
+    return { repository, repositories, availability, results };
+  }
+  async repositoryForRef(ref, defaultRepo, fallbackSpaceUid) {
+    if (ref.repo || defaultRepo) {
+      return this.resolveRepository(ref.repo || defaultRepo, fallbackSpaceUid);
+    }
+    if (ref.path) {
+      const requested = isAbsolute(ref.path) ? resolve(ref.path) : resolve(this.cwd, ref.path);
+      const absolute = await realpath(requested).catch(() => requested);
+      const configured = await this.resolveRepositories(fallbackSpaceUid);
+      const defining = [...configured].sort((a, b) => b.repoRoot.length - a.repoRoot.length).find((candidate) => pathContains(candidate.repoRoot, absolute));
+      if (defining) {
+        return this.env.MINDGRAPH_REPO_ID && pathContains(defining.repoRoot, this.cwd) ? this.resolveRepositoryIdentity(
+          defining.repoRoot,
+          this.env.MINDGRAPH_REPO_ID,
+          defining.spaceUid
+        ) : defining;
+      }
+      const gitRoot = await this.gitRoot(absolute);
+      if (gitRoot) {
+        return this.resolveRepositoryIdentity(
+          gitRoot,
+          this.env.MINDGRAPH_REPO_ID,
+          this.env.MINDGRAPH_CODE_SPACE_UID || fallbackSpaceUid
+        );
+      }
+    }
+    return this.resolveRepository(void 0, fallbackSpaceUid);
+  }
+  async expand(resolved, limit = 20) {
+    const repository = {
+      repoId: resolved.repoId,
+      repoRoot: resolved.repoRoot
+    };
+    const availability = await this.availability(repository);
+    if (!availability.available) {
+      return { availability, callers: [], callees: [], truncated: false };
+    }
+    const cap = Math.min(Math.max(limit, 1), 20);
+    const [callers, callees] = await Promise.all([
+      this.related("callers", resolved, cap + 1),
+      this.related("callees", resolved, cap + 1)
+    ]);
+    return {
+      availability,
+      callers: callers.slice(0, cap),
+      callees: callees.slice(0, cap),
+      truncated: callers.length > cap || callees.length > cap
+    };
+  }
+  async affected(resolved, limit = 50) {
+    const repository = {
+      repoId: resolved.repoId,
+      repoRoot: resolved.repoRoot
+    };
+    const availability = await this.availability(repository);
+    if (!availability.available) {
+      return { availability, affected: [], truncated: false };
+    }
+    const cap = Math.min(Math.max(limit, 1), 50);
+    const raw = await this.runJson([
+      "impact",
+      "-p",
+      resolved.repoRoot,
+      "-j",
+      "-d",
+      "2",
+      resolved.qualifiedName
+    ]);
+    const refs = (raw.affected ?? []).map((node) => ({
+      path: node.filePath,
+      line: node.startLine,
+      symbol: node.qualifiedName ?? node.name,
+      kind: node.kind
+    }));
+    const resolvedRefs = await this.resolveRelatedRefs(refs.slice(0, cap + 1), repository);
+    return {
+      availability,
+      affected: resolvedRefs.slice(0, cap),
+      truncated: refs.length > cap
+    };
+  }
+  configuredRepositories() {
+    const configured = [];
+    const workspaceFiles = this.workspaceFile ? [this.workspaceFile] : this.childWorkspaceFiles;
+    for (const workspaceFile of workspaceFiles) {
+      if (!existsSync(workspaceFile)) continue;
+      try {
+        const parsed = JSON.parse(
+          readFileSync(workspaceFile, "utf8")
+        );
+        if (parsed.v === 1 && Array.isArray(parsed.repositories)) {
+          const configDirectory = dirname(workspaceFile);
+          const base = basename(configDirectory) === ".mindgraph" ? dirname(configDirectory) : configDirectory;
+          for (const repository of parsed.repositories) {
+            if (!repository || typeof repository.root !== "string") continue;
+            configured.push({
+              repoId: typeof repository.repo_id === "string" ? repository.repo_id : void 0,
+              repoRoot: resolve(base, repository.root),
+              spaceUid: typeof repository.space_uid === "string" ? repository.space_uid : void 0
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    const raw = this.env.MINDGRAPH_CODE_REPOS;
+    if (raw) {
+      try {
+        const parsed = JSON.parse(raw);
+        for (const [repoId, config] of Object.entries(parsed)) {
+          configured.push({
+            repoId,
+            repoRoot: resolve(
+              this.cwd,
+              typeof config === "string" ? config : config.root
+            ),
+            spaceUid: typeof config === "string" ? void 0 : config.space_uid
+          });
+        }
+      } catch {
+      }
+    }
+    return [
+      ...new Map(
+        configured.map((repository) => [repository.repoRoot, repository])
+      ).values()
+    ];
+  }
+  async resolveOne(ref, repository) {
+    const search = ref.symbol || ref.path;
+    if (!search || ref.line !== void 0 && (!Number.isInteger(ref.line) || ref.line < 1)) {
+      return { ref, candidates: [], error: "invalid_ref" };
+    }
+    try {
+      const args = ["query", "-p", repository.repoRoot, "-j", "-l", "50"];
+      if (ref.kind) args.push("-k", ref.kind);
+      args.push(search);
+      const hits = await this.runJson(args);
+      let candidates = hits.map(asNode).map(toCandidate).filter((item) => item !== null);
+      if (ref.path) {
+        const absolutePath = isAbsolute(ref.path) ? await realpath(ref.path).catch(() => ref.path) : void 0;
+        const wanted = normalizePath(
+          absolutePath ? relative(repository.repoRoot, absolutePath) : ref.path
+        );
+        candidates = candidates.filter((candidate) => candidate.path === wanted);
+      }
+      if (ref.language) {
+        candidates = candidates.filter(
+          (candidate) => candidate.language.toLowerCase() === ref.language?.toLowerCase()
+        );
+      }
+      if (ref.kind) {
+        candidates = candidates.filter(
+          (candidate) => candidate.kind.toLowerCase() === ref.kind?.toLowerCase()
+        );
+      }
+      if (ref.symbol) {
+        const exact = candidates.filter((candidate) => {
+          const tail = candidate.qualifiedName.split(/::|\.|#/).at(-1);
+          return candidate.qualifiedName === ref.symbol || tail === ref.symbol;
+        });
+        if (exact.length > 0) candidates = exact;
+      }
+      if (ref.signature) {
+        const signature = normalizeSignature(ref.signature);
+        candidates = candidates.filter(
+          (candidate) => candidate.signature !== null && normalizeSignature(candidate.signature) === signature
+        );
+      }
+      if (ref.line !== void 0) {
+        candidates = candidates.filter(
+          (candidate) => candidate.startLine <= ref.line && candidate.endLine >= ref.line
+        );
+        if (candidates.length > 1) {
+          const narrowest = Math.min(
+            ...candidates.map((candidate) => candidate.endLine - candidate.startLine)
+          );
+          const narrowed = candidates.filter(
+            (candidate) => candidate.endLine - candidate.startLine === narrowest
+          );
+          if (narrowed.length === 1) candidates = narrowed;
+        }
+      }
+      if (candidates.length !== 1) {
+        return {
+          ref,
+          candidates,
+          error: candidates.length === 0 ? "not_found" : "ambiguous"
         };
       }
-      this.statusCache.set(repository.repoRoot, {
-        status,
-        availability,
-        expiresAt: this.now() + this.statusTtlMs
-      });
-      return availability;
+      return {
+        ref,
+        candidates,
+        resolved: {
+          repoId: repository.repoId,
+          repoRoot: repository.repoRoot,
+          ...candidates[0]
+        }
+      };
     } catch (cause) {
       const failure = cause;
-      const reason = failure.kind ?? "command_failed";
       return {
-        available: false,
-        reason,
-        stale: false,
-        caveats: unavailabilityCaveats(reason, failure.message)
+        ref,
+        candidates: [],
+        error: failure.kind ?? "command_failed"
       };
     }
   }
-  async resolveRefs(refs, options = {}) {
-    const normalized = refs.map(
-      (ref) => typeof ref === "string" ? { symbol: ref } : ref
-    );
-    const results = await Promise.all(
-      normalized.map(async (ref) => {
-        const repository2 = await this.repositoryForRef(
-          ref,
-          options.repo,
-          options.fallbackSpaceUid
+  async related(action, resolved, limit) {
+    const raw = await this.runJson([
+      action,
+      "-p",
+      resolved.repoRoot,
+      "-j",
+      "-l",
+      String(limit),
+      resolved.qualifiedName
+    ]);
+    const refs = (raw[action] ?? []).map((node) => ({
+      path: node.filePath,
+      line: node.startLine,
+      symbol: node.qualifiedName ?? node.name,
+      kind: node.kind
+    }));
+    return this.resolveRelatedRefs(refs, {
+      repoId: resolved.repoId,
+      repoRoot: resolved.repoRoot
+    });
+  }
+  async resolveRelatedRefs(refs, repository) {
+    const results = await Promise.all(refs.map((ref) => this.resolveOne(ref, repository)));
+    const seen = /* @__PURE__ */ new Set();
+    return results.flatMap((result) => result.resolved ? [result.resolved] : []).filter((result) => {
+      const key = `${result.path}:${result.qualifiedName}:${result.startLine}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+  async runJson(args) {
+    const candidates = [
+      this.env.MINDGRAPH_CODEGRAPH_BIN,
+      "codegraph",
+      resolve(homedir(), ".local", "bin", "codegraph")
+    ].filter((candidate, index, all) => {
+      return Boolean(candidate) && all.indexOf(candidate) === index;
+    });
+    let lastFailure;
+    for (const executable of candidates) {
+      try {
+        const stdout = await runProcess(
+          executable,
+          args,
+          this.timeoutMs,
+          this.env,
+          this.cwd
         );
-        const availability2 = await this.availability(repository2);
-        if (!availability2.available) {
-          return {
+        return JSON.parse(stdout);
+      } catch (cause) {
+        const failure = cause;
+        lastFailure = failure;
+        if (failure.kind !== "absent") throw failure;
+      }
+    }
+    throw lastFailure ?? Object.assign(new Error("codegraph executable not found"), {
+      kind: "absent"
+    });
+  }
+};
+function repositoryIdentityKey(repository) {
+  return { v: 1, kind: "repository", repo_id: repository.repoId };
+}
+function codeRefIdentityKey(ref) {
+  if (ref.kind === "file") {
+    return {
+      v: 1,
+      kind: "file",
+      repo_id: ref.repoId,
+      path: ref.path
+    };
+  }
+  return {
+    v: 1,
+    kind: "symbol",
+    repo_id: ref.repoId,
+    language: ref.language,
+    symbol_kind: ref.kind,
+    qualified_name: ref.qualifiedName,
+    disambiguator: {
+      signature: ref.signature ?? "",
+      path: ref.path
+    }
+  };
+}
+
+// src/code-tool.ts
+var ok2 = (data) => ({
+  content: [{ type: "text", text: JSON.stringify(data) }]
+});
+var err3 = (code, message, details) => ({
+  content: [
+    {
+      type: "text",
+      text: JSON.stringify({ error: message, code, details })
+    }
+  ],
+  isError: true
+});
+var CODE_TOOL = {
+  name: "mindgraph_code",
+  description: "Resolve typed code references through the local codegraph index and join them to persistent MindGraph memory/work. anchor creates exact repository/code anchors; recall reads attached graph context; expand reads callers/callees; affected reads impact for a code ref or Task/Execution. Ambiguous refs return candidates without writing. Refs with a path route to the repository defining that file (nearest declared root in .mindgraph/workspace.json); bare symbols resolve against the current repository only \u2014 pass path or repo to target a sibling.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["anchor", "recall", "expand", "affected"]
+      },
+      code_refs: {
+        type: "array",
+        maxItems: 50,
+        items: {
+          oneOf: [
+            { type: "string" },
+            {
+              type: "object",
+              properties: {
+                repo: { type: "string" },
+                path: { type: "string" },
+                line: { type: "integer", minimum: 1 },
+                symbol: { type: "string" },
+                kind: { type: "string" },
+                language: { type: "string" },
+                signature: { type: "string" }
+              },
+              additionalProperties: false
+            }
+          ]
+        }
+      },
+      anchor_uids: {
+        type: "array",
+        maxItems: 50,
+        items: { type: "string" },
+        description: "Already-materialized code anchor UIDs (codegraph is not required for recall)"
+      },
+      repo: {
+        type: "string",
+        description: "Configured repository id or repository root"
+      },
+      repo_space_uid: {
+        type: "string",
+        description: "Writable shared Project/repository Space for new anchors (anchor requires this, a workspace space_uid, or MINDGRAPH_CODE_SPACE_UID)"
+      },
+      task_uid: { type: "string" },
+      execution_uid: { type: "string" },
+      limit: { type: "integer", minimum: 1, maximum: 50 },
+      agent_id: { type: "string" }
+    },
+    required: ["action"]
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  }
+};
+async function handleCodeTool(client, args, adapter = new CodegraphAdapter({ cwd: invocationCwd(args) })) {
+  const codeClient = client;
+  const action = args.action;
+  const refs = Array.isArray(args.code_refs) ? args.code_refs : [];
+  const anchorUids = Array.isArray(args.anchor_uids) ? args.anchor_uids : [];
+  const agentId = typeof args.agent_id === "string" ? args.agent_id : "mcp";
+  const fallbackSpaceUid = typeof args.repo_space_uid === "string" ? args.repo_space_uid : void 0;
+  const options = {
+    repo: typeof args.repo === "string" ? args.repo : void 0,
+    fallbackSpaceUid
+  };
+  const limit = typeof args.limit === "number" ? args.limit : void 0;
+  try {
+    switch (action) {
+      case "anchor": {
+        if (refs.length === 0) return err3("missing_code_refs", "code_refs is required for anchor");
+        const resolution = await adapter.resolveRefs(refs, options);
+        const resolved = resolution.results.flatMap(
+          (result) => result.resolved && result.repository ? [{ ref: result.resolved, repository: result.repository }] : []
+        );
+        const unresolved = resolution.results.filter((result) => !result.resolved);
+        if (resolved.length === 0) {
+          return ok2({ ...resolution, anchors: [], wrote: false });
+        }
+        const missingSpace = resolved.find(
+          ({ repository }) => typeof args.repo_space_uid !== "string" && !repository.spaceUid
+        );
+        if (missingSpace) {
+          return err3(
+            "missing_repository_space",
+            `repo_space_uid, a workspace space_uid, or MINDGRAPH_CODE_SPACE_UID is required for ${missingSpace.repository.repoId}`
+          );
+        }
+        const repositoryAnchors = /* @__PURE__ */ new Map();
+        for (const { repository } of resolved) {
+          if (repositoryAnchors.has(repository.repoRoot)) continue;
+          const spaceUid = typeof args.repo_space_uid === "string" ? args.repo_space_uid : repository.spaceUid;
+          const anchored = await anchorRepository(
+            codeClient,
+            repository,
+            spaceUid,
+            agentId
+          );
+          repositoryAnchors.set(repository.repoRoot, {
+            ...anchored,
+            repository
+          });
+        }
+        const anchors = [];
+        for (const { ref, repository } of resolved) {
+          const repositoryAnchor = repositoryAnchors.get(repository.repoRoot);
+          if (!repositoryAnchor.uid) continue;
+          const spaceUid = typeof args.repo_space_uid === "string" ? args.repo_space_uid : repository.spaceUid;
+          const anchor = await anchorCodeRef(
+            codeClient,
             ref,
-            repository: repository2,
-            availability: availability2,
-            candidates: [],
-            error: availability2.reason
-          };
+            repositoryAnchor.uid,
+            spaceUid,
+            agentId
+          );
+          anchors.push(anchor);
         }
-        return {
-          ...await this.resolveOne(ref, repository2),
-          repository: repository2,
-          availability: availability2
-        };
-      })
-    );
-    const repositories = [
-      ...new Map(
-        results.flatMap(
-          (result) => result.repository ? [[result.repository.repoRoot, result.repository]] : []
-        )
-      ).values()
-    ];
-    const repository = repositories[0] ?? await this.resolveRepository(options.repo, options.fallbackSpaceUid);
-    if (repositories.length === 0) repositories.push(repository);
-    const availabilities = results.flatMap(
-      (result) => result.availability ? [result.availability] : []
-    );
-    const availability = availabilities.length === 0 ? await this.availability(repository) : {
-      available: availabilities.every((item) => item.available),
-      reason: availabilities.find((item) => !item.available)?.reason,
-      stale: availabilities.some((item) => item.stale),
-      caveats: [
-        ...new Set(availabilities.flatMap((item) => item.caveats))
-      ]
-    };
-    return { repository, repositories, availability, results };
-  }
-  async repositoryForRef(ref, defaultRepo, fallbackSpaceUid) {
-    if (ref.repo || defaultRepo) {
-      return this.resolveRepository(ref.repo || defaultRepo, fallbackSpaceUid);
-    }
-    if (ref.path) {
-      const requested = isAbsolute(ref.path) ? resolve(ref.path) : resolve(this.cwd, ref.path);
-      const absolute = await realpath(requested).catch(() => requested);
-      const configured = await this.resolveRepositories(fallbackSpaceUid);
-      const defining = [...configured].sort((a, b) => b.repoRoot.length - a.repoRoot.length).find((candidate) => pathContains(candidate.repoRoot, absolute));
-      if (defining) {
-        return this.env.MINDGRAPH_REPO_ID && pathContains(defining.repoRoot, this.cwd) ? this.resolveRepositoryIdentity(
-          defining.repoRoot,
-          this.env.MINDGRAPH_REPO_ID,
-          defining.spaceUid
-        ) : defining;
+        return ok2({
+          availability: resolution.availability,
+          repository: repositoryAnchors.values().next().value,
+          repositories: [...repositoryAnchors.values()],
+          anchors,
+          unresolved,
+          wrote: anchors.some((anchor) => anchor.created)
+        });
       }
-      const gitRoot = await this.gitRoot(absolute);
-      if (gitRoot) {
-        return this.resolveRepositoryIdentity(
-          gitRoot,
-          this.env.MINDGRAPH_REPO_ID,
-          this.env.MINDGRAPH_CODE_SPACE_UID || fallbackSpaceUid
+      case "recall": {
+        const materialized = new Set(anchorUids);
+        let resolution;
+        if (refs.length > 0) {
+          resolution = await adapter.resolveRefs(refs, options);
+          for (const result of resolution.results) {
+            if (!result.resolved) continue;
+            const uid = await resolveMaterializedUid(codeClient, result.resolved, agentId);
+            if (uid) materialized.add(uid);
+          }
+        }
+        if (materialized.size === 0) {
+          return ok2({
+            availability: resolution?.availability,
+            anchors: [],
+            context: [],
+            unresolved: resolution?.results.filter((result) => !result.resolved) ?? []
+          });
+        }
+        const context = await Promise.all(
+          [...materialized].map(async (uid) => ({
+            anchor_uid: uid,
+            graph: await codeClient.traverse({
+              action: "neighborhood",
+              start_uid: uid,
+              depth: 2,
+              max_nodes: Math.min(limit ?? 20, 20)
+            })
+          }))
         );
+        return ok2({
+          availability: resolution?.availability,
+          anchors: [...materialized],
+          context,
+          unresolved: resolution?.results.filter((result) => !result.resolved) ?? []
+        });
       }
-    }
-    return this.resolveRepository(void 0, fallbackSpaceUid);
-  }
-  async expand(resolved, limit = 20) {
-    const repository = {
-      repoId: resolved.repoId,
-      repoRoot: resolved.repoRoot
-    };
-    const availability = await this.availability(repository);
-    if (!availability.available) {
-      return { availability, callers: [], callees: [], truncated: false };
-    }
-    const cap = Math.min(Math.max(limit, 1), 20);
-    const [callers, callees] = await Promise.all([
-      this.related("callers", resolved, cap + 1),
-      this.related("callees", resolved, cap + 1)
-    ]);
-    return {
-      availability,
-      callers: callers.slice(0, cap),
-      callees: callees.slice(0, cap),
-      truncated: callers.length > cap || callees.length > cap
-    };
-  }
-  async affected(resolved, limit = 50) {
-    const repository = {
-      repoId: resolved.repoId,
-      repoRoot: resolved.repoRoot
-    };
-    const availability = await this.availability(repository);
-    if (!availability.available) {
-      return { availability, affected: [], truncated: false };
-    }
-    const cap = Math.min(Math.max(limit, 1), 50);
-    const raw = await this.runJson([
-      "impact",
-      "-p",
-      resolved.repoRoot,
-      "-j",
-      "-d",
-      "2",
-      resolved.qualifiedName
-    ]);
-    const refs = (raw.affected ?? []).map((node) => ({
-      path: node.filePath,
-      line: node.startLine,
-      symbol: node.qualifiedName ?? node.name,
-      kind: node.kind
-    }));
-    const resolvedRefs = await this.resolveRelatedRefs(refs.slice(0, cap + 1), repository);
-    return {
-      availability,
-      affected: resolvedRefs.slice(0, cap),
-      truncated: refs.length > cap
-    };
-  }
-  configuredRepositories() {
-    const configured = [];
-    if (this.workspaceFile && existsSync(this.workspaceFile)) {
-      try {
-        const parsed = JSON.parse(
-          readFileSync(this.workspaceFile, "utf8")
+      case "expand": {
+        const target = await resolveSingleTarget(
+          codeClient,
+          adapter,
+          refs,
+          anchorUids,
+          options
         );
-        if (parsed.v === 1 && Array.isArray(parsed.repositories)) {
-          const configDirectory = dirname(this.workspaceFile);
-          const base = basename(configDirectory) === ".mindgraph" ? dirname(configDirectory) : configDirectory;
-          for (const repository of parsed.repositories) {
-            if (!repository || typeof repository.root !== "string") continue;
-            configured.push({
-              repoId: typeof repository.repo_id === "string" ? repository.repo_id : void 0,
-              repoRoot: resolve(base, repository.root),
-              spaceUid: typeof repository.space_uid === "string" ? repository.space_uid : void 0
-            });
-          }
-        }
-      } catch {
+        if ("error" in target) return target.error;
+        const expanded = await adapter.expand(target.ref, limit);
+        const joined = await joinMaterialized(
+          codeClient,
+          [...expanded.callers, ...expanded.callees],
+          agentId,
+          Math.min(limit ?? 20, 20)
+        );
+        return ok2({ anchor: target.ref, ...expanded, materialized: joined });
       }
-    }
-    const raw = this.env.MINDGRAPH_CODE_REPOS;
-    if (raw) {
-      try {
-        const parsed = JSON.parse(raw);
-        for (const [repoId, config] of Object.entries(parsed)) {
-          configured.push({
-            repoId,
-            repoRoot: resolve(
-              this.cwd,
-              typeof config === "string" ? config : config.root
-            ),
-            spaceUid: typeof config === "string" ? void 0 : config.space_uid
+      case "affected": {
+        const targetUid = typeof args.task_uid === "string" ? args.task_uid : typeof args.execution_uid === "string" ? args.execution_uid : void 0;
+        let graphContext;
+        const graphRefs = [];
+        let unavailableRepositories = [];
+        if (targetUid) {
+          graphContext = await codeClient.traverse({
+            action: "neighborhood",
+            start_uid: targetUid,
+            depth: 2,
+            max_nodes: 50
+          });
+          const fromGraph = await codeRefsFromGraphContext(
+            codeClient,
+            adapter,
+            graphContext
+          );
+          graphRefs.push(...fromGraph.refs);
+          unavailableRepositories = fromGraph.unavailable;
+        }
+        if (refs.length > 0 || anchorUids.length > 0) {
+          const target = await resolveSingleTarget(
+            codeClient,
+            adapter,
+            refs,
+            anchorUids,
+            options
+          );
+          if ("error" in target) return target.error;
+          graphRefs.unshift(target.ref);
+        }
+        const unique = uniqueRefs(graphRefs);
+        if (unique.length === 0) {
+          return ok2({
+            target_uid: targetUid,
+            graph_context: graphContext,
+            affected: [],
+            degradation: unavailableRepositories.length > 0 ? `attached code anchors reference repositories unavailable here: ${unavailableRepositories.join(", ")}` : "no materialized code anchors were attached",
+            ...unavailableRepositories.length > 0 ? { unavailable_repositories: unavailableRepositories } : {}
           });
         }
-      } catch {
-      }
-    }
-    return [
-      ...new Map(
-        configured.map((repository) => [repository.repoRoot, repository])
-      ).values()
-    ];
-  }
-  async resolveOne(ref, repository) {
-    const search = ref.symbol || ref.path;
-    if (!search || ref.line !== void 0 && (!Number.isInteger(ref.line) || ref.line < 1)) {
-      return { ref, candidates: [], error: "invalid_ref" };
-    }
-    try {
-      const args = ["query", "-p", repository.repoRoot, "-j", "-l", "50"];
-      if (ref.kind) args.push("-k", ref.kind);
-      args.push(search);
-      const hits = await this.runJson(args);
-      let candidates = hits.map(asNode).map(toCandidate).filter((item) => item !== null);
-      if (ref.path) {
-        const absolutePath = isAbsolute(ref.path) ? await realpath(ref.path).catch(() => ref.path) : void 0;
-        const wanted = normalizePath(
-          absolutePath ? relative(repository.repoRoot, absolutePath) : ref.path
-        );
-        candidates = candidates.filter((candidate) => candidate.path === wanted);
-      }
-      if (ref.language) {
-        candidates = candidates.filter(
-          (candidate) => candidate.language.toLowerCase() === ref.language?.toLowerCase()
+        const impacts = await Promise.all(
+          unique.map(async (ref) => ({ anchor: ref, ...await adapter.affected(ref, limit) }))
         );
-      }
-      if (ref.kind) {
-        candidates = candidates.filter(
-          (candidate) => candidate.kind.toLowerCase() === ref.kind?.toLowerCase()
+        const structural = uniqueRefs(impacts.flatMap((impact) => impact.affected));
+        const joined = await joinMaterialized(
+          codeClient,
+          structural,
+          agentId,
+          Math.min(limit ?? 50, 50)
         );
-      }
-      if (ref.symbol) {
-        const exact = candidates.filter((candidate) => {
-          const tail = candidate.qualifiedName.split(/::|\.|#/).at(-1);
-          return candidate.qualifiedName === ref.symbol || tail === ref.symbol;
+        return ok2({
+          target_uid: targetUid,
+          graph_context: graphContext,
+          impacts,
+          materialized: joined,
+          ...unavailableRepositories.length > 0 ? { unavailable_repositories: unavailableRepositories } : {}
         });
-        if (exact.length > 0) candidates = exact;
       }
-      if (ref.signature) {
-        const signature = normalizeSignature(ref.signature);
-        candidates = candidates.filter(
-          (candidate) => candidate.signature !== null && normalizeSignature(candidate.signature) === signature
-        );
+      default:
+        return err3("unknown_action", `unknown mindgraph_code action: ${action}`);
+    }
+  } catch (cause) {
+    if (cause instanceof UnknownRepositoryError) {
+      return err3("unknown_repository", cause.message);
+    }
+    return toolError(cause, "code_tool_failed");
+  }
+}
+async function attachCodeRefsToToolResult(client, result, args, adapter) {
+  if (result.isError || !Array.isArray(args.code_refs) || args.code_refs.length === 0) {
+    return result;
+  }
+  const original = JSON.parse(result.content[0]?.text ?? "null");
+  const targetUids = primaryUids(original);
+  if (targetUids.length === 0) {
+    return ok2({
+      result: original,
+      code_anchors: {
+        wrote: false,
+        caveat: "the write response exposed no primary UID to attach"
       }
-      if (ref.line !== void 0) {
-        candidates = candidates.filter(
-          (candidate) => candidate.startLine <= ref.line && candidate.endLine >= ref.line
-        );
-        if (candidates.length > 1) {
-          const narrowest = Math.min(
-            ...candidates.map((candidate) => candidate.endLine - candidate.startLine)
-          );
-          const narrowed = candidates.filter(
-            (candidate) => candidate.endLine - candidate.startLine === narrowest
+    });
+  }
+  const anchorResult = await handleCodeTool(
+    client,
+    {
+      action: "anchor",
+      code_refs: args.code_refs,
+      repo: args.repo,
+      repo_space_uid: args.repo_space_uid,
+      agent_id: args.agent_id,
+      // Keeps the default adapter anchored to the live session directory
+      // rather than wherever the MCP server process was launched.
+      invocation_context: args.invocation_context
+    },
+    adapter
+  );
+  const anchors = JSON.parse(anchorResult.content[0]?.text ?? "null");
+  if (!anchorResult.isError) {
+    const codeClient = client;
+    const anchorUids = (anchors.anchors ?? []).flatMap(
+      (anchor) => anchor.uid ? [anchor.uid] : []
+    );
+    const relateFailures = [];
+    for (const targetUid of targetUids) {
+      for (const anchorUid of anchorUids) {
+        try {
+          await codeClient.entity({
+            action: "relate",
+            source_uid: targetUid,
+            target_uid: anchorUid,
+            edge_type: args.action === "lesson" ? "ABOUT" : "RELEVANT_TO",
+            agent_id: args.agent_id
+          });
+        } catch (cause) {
+          relateFailures.push(
+            `${targetUid} -> ${anchorUid}: ${errorDetail(cause)}`
           );
-          if (narrowed.length === 1) candidates = narrowed;
         }
       }
-      if (candidates.length !== 1) {
-        return {
-          ref,
-          candidates,
-          error: candidates.length === 0 ? "not_found" : "ambiguous"
-        };
-      }
-      return {
-        ref,
-        candidates,
-        resolved: {
-          repoId: repository.repoId,
-          repoRoot: repository.repoRoot,
-          ...candidates[0]
+    }
+    if (relateFailures.length > 0) {
+      return ok2({
+        result: original,
+        code_anchors: {
+          ...anchors,
+          caveat: `anchors written, but ${relateFailures.length} relate edge(s) failed: ${relateFailures.join("; ")}`
         }
-      };
-    } catch (cause) {
-      const failure = cause;
+      });
+    }
+  }
+  return ok2({ result: original, code_anchors: anchors });
+}
+async function anchorRepository(client, repository, spaceUid, agentId) {
+  return client.entity({
+    action: "create",
+    label: repository.repoId,
+    props: {
+      entity_type: "repository",
+      canonical_name: repository.repoId,
+      identifiers: { repo_id: repository.repoId }
+    },
+    identity: {
+      namespace: "external.code",
+      key_version: 1,
+      key: repositoryIdentityKey(repository)
+    },
+    identity_space_uid: spaceUid,
+    agent_id: agentId
+  });
+}
+async function anchorCodeRef(client, ref, repositoryUid, spaceUid, agentId) {
+  const response = await client.entity({
+    action: "create",
+    label: ref.qualifiedName,
+    props: {
+      entity_type: ref.kind === "file" ? "code_file" : "code_symbol",
+      canonical_name: ref.qualifiedName,
+      identifiers: {
+        repo_id: ref.repoId,
+        path: ref.path,
+        qualified_name: ref.qualifiedName
+      },
+      attributes: { code_ref: storedCodeRef(ref) }
+    },
+    identity: {
+      namespace: "external.code",
+      key_version: 1,
+      key: codeRefIdentityKey(ref)
+    },
+    identity_space_uid: spaceUid,
+    agent_id: agentId
+  });
+  if (response.uid && response.created !== false && response.status !== "existing") {
+    await client.entity({
+      action: "relate",
+      source_uid: response.uid,
+      target_uid: repositoryUid,
+      edge_type: "PART_OF",
+      agent_id: agentId
+    });
+  }
+  return { ...response, ref };
+}
+async function resolveMaterializedUid(client, ref, agentId) {
+  const response = await client.entity({
+    action: "resolve_identity",
+    identity: {
+      namespace: "external.code",
+      key_version: 1,
+      key: codeRefIdentityKey(ref)
+    },
+    agent_id: agentId
+  });
+  return response.status === "existing" ? response.uid : void 0;
+}
+async function codeRefFromAnchor(client, adapter, uid) {
+  const node = await client.getNode(uid);
+  const attributes = node.props?.attributes;
+  if (!attributes || typeof attributes !== "object") return void 0;
+  const codeRef = attributes.code_ref;
+  if (!isStoredCodeRef(codeRef)) return void 0;
+  try {
+    const repository = await adapter.resolveRepository(codeRef.repoId);
+    return { ref: { ...codeRef, repoRoot: repository.repoRoot } };
+  } catch (cause) {
+    if (cause instanceof UnknownRepositoryError) {
+      return { missingRepo: codeRef.repoId };
+    }
+    throw cause;
+  }
+}
+async function resolveSingleTarget(client, adapter, refs, anchorUids, options) {
+  if (refs.length > 1 || anchorUids.length > 1) {
+    return { error: err3("ambiguous_target", "expand/affected accepts exactly one code target") };
+  }
+  if (anchorUids.length === 1) {
+    const outcome = await codeRefFromAnchor(client, adapter, anchorUids[0]);
+    if (!outcome) {
+      return { error: err3("invalid_anchor", "anchor UID does not contain a typed code_ref") };
+    }
+    if ("missingRepo" in outcome) {
       return {
-        ref,
-        candidates: [],
-        error: failure.kind ?? "command_failed"
+        error: err3(
+          "repository_unavailable",
+          `repository ${outcome.missingRepo} is not checked out here or declared in .mindgraph/workspace.json; expand/affected need its local index`
+        )
       };
     }
+    return { ref: outcome.ref };
   }
-  async related(action, resolved, limit) {
-    const raw = await this.runJson([
-      action,
-      "-p",
-      resolved.repoRoot,
-      "-j",
-      "-l",
-      String(limit),
-      resolved.qualifiedName
-    ]);
-    const refs = (raw[action] ?? []).map((node) => ({
-      path: node.filePath,
-      line: node.startLine,
-      symbol: node.qualifiedName ?? node.name,
-      kind: node.kind
-    }));
-    return this.resolveRelatedRefs(refs, {
-      repoId: resolved.repoId,
-      repoRoot: resolved.repoRoot
-    });
+  if (refs.length !== 1) {
+    return { error: err3("missing_code_ref", "one code_ref or anchor_uid is required") };
   }
-  async resolveRelatedRefs(refs, repository) {
-    const results = await Promise.all(refs.map((ref) => this.resolveOne(ref, repository)));
-    const seen = /* @__PURE__ */ new Set();
-    return results.flatMap((result) => result.resolved ? [result.resolved] : []).filter((result) => {
-      const key = `${result.path}:${result.qualifiedName}:${result.startLine}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
+  const resolution = await adapter.resolveRefs(refs, options);
+  const result = resolution.results[0];
+  if (!result.resolved) {
+    return {
+      error: ok2({
+        availability: resolution.availability,
+        result,
+        wrote: false
+      })
+    };
   }
-  async runJson(args) {
-    const candidates = [
-      this.env.MINDGRAPH_CODEGRAPH_BIN,
-      "codegraph",
-      resolve(homedir(), ".local", "bin", "codegraph")
-    ].filter((candidate, index, all) => {
-      return Boolean(candidate) && all.indexOf(candidate) === index;
+  return { ref: result.resolved };
+}
+async function joinMaterialized(client, refs, agentId, limit) {
+  const joined = [];
+  for (const ref of uniqueRefs(refs).slice(0, limit)) {
+    const uid = await resolveMaterializedUid(client, ref, agentId);
+    if (!uid) continue;
+    joined.push({
+      ref,
+      anchor_uid: uid,
+      graph: await client.traverse({
+        action: "neighborhood",
+        start_uid: uid,
+        depth: 2,
+        max_nodes: 20
+      })
     });
-    let lastFailure;
-    for (const executable of candidates) {
-      try {
-        const stdout = await runProcess(
-          executable,
-          args,
-          this.timeoutMs,
-          this.env,
-          this.cwd
-        );
-        return JSON.parse(stdout);
-      } catch (cause) {
-        const failure = cause;
-        lastFailure = failure;
-        if (failure.kind !== "absent") throw failure;
+  }
+  return joined;
+}
+async function codeRefsFromGraphContext(client, adapter, context) {
+  const uids = /* @__PURE__ */ new Set();
+  collectUids(context, uids);
+  if (uids.size === 0) return { refs: [], unavailable: [] };
+  const nodes = client.getNodesBatch ? await client.getNodesBatch([...uids]) : await Promise.all([...uids].map((uid) => client.getNode(uid).catch(() => void 0)));
+  const stored = nodes.flatMap((node) => {
+    if (!node) return [];
+    const attributes = node.props?.attributes;
+    if (!attributes || typeof attributes !== "object") return [];
+    const codeRef = attributes.code_ref;
+    return isStoredCodeRef(codeRef) ? [codeRef] : [];
+  });
+  const refs = [];
+  const unavailable = /* @__PURE__ */ new Set();
+  for (const ref of stored) {
+    try {
+      const repository = await adapter.resolveRepository(ref.repoId);
+      refs.push({ ...ref, repoRoot: repository.repoRoot });
+    } catch (cause) {
+      if (cause instanceof UnknownRepositoryError) {
+        unavailable.add(ref.repoId);
+      } else {
+        throw cause;
       }
     }
-    throw lastFailure ?? Object.assign(new Error("codegraph executable not found"), {
-      kind: "absent"
-    });
   }
-};
-function repositoryIdentityKey(repository) {
-  return { v: 1, kind: "repository", repo_id: repository.repoId };
+  return { refs, unavailable: [...unavailable].sort() };
 }
-function codeRefIdentityKey(ref) {
-  if (ref.kind === "file") {
-    return {
-      v: 1,
-      kind: "file",
-      repo_id: ref.repoId,
-      path: ref.path
-    };
+function collectUids(value, uids) {
+  if (Array.isArray(value)) {
+    value.forEach((item) => collectUids(item, uids));
+    return;
   }
-  return {
-    v: 1,
-    kind: "symbol",
-    repo_id: ref.repoId,
-    language: ref.language,
-    symbol_kind: ref.kind,
-    qualified_name: ref.qualifiedName,
-    disambiguator: {
-      signature: ref.signature ?? "",
-      path: ref.path
+  if (!value || typeof value !== "object") return;
+  for (const [key, child] of Object.entries(value)) {
+    if (typeof child === "string" && ["uid", "node_uid", "neighbor_uid", "from_uid", "to_uid"].includes(key)) {
+      uids.add(child);
+    } else {
+      collectUids(child, uids);
     }
-  };
+  }
+}
+function isStoredCodeRef(value) {
+  if (!value || typeof value !== "object") return false;
+  const ref = value;
+  return typeof ref.repoId === "string" && typeof ref.path === "string" && typeof ref.language === "string" && typeof ref.kind === "string" && typeof ref.qualifiedName === "string" && (typeof ref.signature === "string" || ref.signature === null) && typeof ref.startLine === "number" && typeof ref.endLine === "number";
+}
+function storedCodeRef(ref) {
+  const { repoRoot: _localOnly, ...stored } = ref;
+  return stored;
+}
+function uniqueRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((ref) => {
+    const key = `${ref.repoId}:${ref.path}:${ref.qualifiedName}:${ref.signature ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function primaryUids(value) {
+  if (!value || typeof value !== "object") return [];
+  const object = value;
+  const keys = [
+    "uid",
+    "claim_uid",
+    "goal_uid",
+    "project_uid",
+    "milestone_uid",
+    "decision_uid",
+    "task_uid",
+    "plan_uid",
+    "step_uid",
+    "execution_uid",
+    "lesson_uid"
+  ];
+  return [
+    ...new Set(
+      keys.flatMap((key) => typeof object[key] === "string" ? [object[key]] : [])
+    )
+  ];
 }
 
-// src/code-tool.ts
-var ok2 = (data) => ({
-  content: [{ type: "text", text: JSON.stringify(data) }]
-});
-var err3 = (code, message, details) => ({
-  content: [
-    {
-      type: "text",
-      text: JSON.stringify({ error: message, code, details })
-    }
-  ],
-  isError: true
-});
-var CODE_TOOL = {
-  name: "mindgraph_code",
-  description: "Resolve typed code references through the local codegraph index and join them to persistent MindGraph memory/work. anchor creates exact repository/code anchors; recall reads attached graph context; expand reads callers/callees; affected reads impact for a code ref or Task/Execution. Ambiguous refs return candidates without writing. Refs with a path route to the repository defining that file (nearest declared root in .mindgraph/workspace.json); bare symbols resolve against the current repository only \u2014 pass path or repo to target a sibling.",
+// src/workspace-scope.ts
+var WORKSPACE_RESUME_LIMIT = 9;
+var SCOPE_CACHE_TTL_MS = 12 * 60 * 60 * 1e3;
+
+// src/memory-tool.ts
+var RESULT_SCHEMA_VERSION = "mindgraph.memory.result.v1";
+var DEFAULT_OUTPUT_CHARS = 8e3;
+var MIN_OUTPUT_CHARS = 512;
+var MAX_OUTPUT_CHARS = 24e3;
+var HIDDEN_CONTEXT_NODE_TYPES = /* @__PURE__ */ new Set(["Chunk", "Document", "Article"]);
+var HIDDEN_CONTEXT_EDGE_TYPES = /* @__PURE__ */ new Set(["POSSIBLE_DUPLICATE", "PossibleDuplicate"]);
+var 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: ["anchor", "recall", "expand", "affected"]
+        enum: ["status", "context"],
+        description: "Read integration status or bounded memory context"
       },
-      code_refs: {
+      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",
-        maxItems: 50,
-        items: {
-          oneOf: [
-            { type: "string" },
-            {
-              type: "object",
-              properties: {
-                repo: { type: "string" },
-                path: { type: "string" },
-                line: { type: "integer", minimum: 1 },
-                symbol: { type: "string" },
-                kind: { type: "string" },
-                language: { type: "string" },
-                signature: { type: "string" }
-              },
-              additionalProperties: false
-            }
-          ]
-        }
+        items: { type: "string" },
+        description: "Optional explicit graph scopes for continuity/resume"
+      },
+      scope: {
+        type: "string",
+        enum: ["workspace"],
+        description: "For continuity/resume on a local server: select work across every repository the working directory's .mindgraph/workspace.json declares, and list the other eligible tasks grouped by repository"
       },
-      anchor_uids: {
+      node_types: {
         type: "array",
-        maxItems: 50,
         items: { type: "string" },
-        description: "Already-materialized code anchor UIDs (codegraph is not required for recall)"
+        description: "Optional node-type filter for topic context"
       },
-      repo: {
+      layer: {
         type: "string",
-        description: "Configured repository id or repository root"
+        enum: ["reality", "epistemic", "intent", "action", "memory", "agent"],
+        description: "Optional cognitive-layer filter for topic context"
       },
-      repo_space_uid: {
+      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: "Writable shared Project/repository Space for new anchors (anchor requires this, a workspace space_uid, or MINDGRAPH_CODE_SPACE_UID)"
+        description: "Optional ISO timestamp for time-aware topic retrieval"
       },
-      task_uid: { type: "string" },
-      execution_uid: { type: "string" },
-      limit: { type: "integer", minimum: 1, maximum: 50 },
-      agent_id: { type: "string" }
+      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"]
   },
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true
-  }
-};
-async function handleCodeTool(client, args, adapter = new CodegraphAdapter({ cwd: invocationCwd(args) })) {
-  const codeClient = client;
-  const action = args.action;
-  const refs = Array.isArray(args.code_refs) ? args.code_refs : [];
-  const anchorUids = Array.isArray(args.anchor_uids) ? args.anchor_uids : [];
-  const agentId = typeof args.agent_id === "string" ? args.agent_id : "mcp";
-  const fallbackSpaceUid = typeof args.repo_space_uid === "string" ? args.repo_space_uid : void 0;
-  const options = {
-    repo: typeof args.repo === "string" ? args.repo : void 0,
-    fallbackSpaceUid
-  };
-  const limit = typeof args.limit === "number" ? args.limit : void 0;
-  try {
-    switch (action) {
-      case "anchor": {
-        if (refs.length === 0) return err3("missing_code_refs", "code_refs is required for anchor");
-        const resolution = await adapter.resolveRefs(refs, options);
-        const resolved = resolution.results.flatMap(
-          (result) => result.resolved && result.repository ? [{ ref: result.resolved, repository: result.repository }] : []
-        );
-        const unresolved = resolution.results.filter((result) => !result.resolved);
-        if (resolved.length === 0) {
-          return ok2({ ...resolution, anchors: [], wrote: false });
-        }
-        const missingSpace = resolved.find(
-          ({ repository }) => typeof args.repo_space_uid !== "string" && !repository.spaceUid
-        );
-        if (missingSpace) {
-          return err3(
-            "missing_repository_space",
-            `repo_space_uid, a workspace space_uid, or MINDGRAPH_CODE_SPACE_UID is required for ${missingSpace.repository.repoId}`
-          );
-        }
-        const repositoryAnchors = /* @__PURE__ */ new Map();
-        for (const { repository } of resolved) {
-          if (repositoryAnchors.has(repository.repoRoot)) continue;
-          const spaceUid = typeof args.repo_space_uid === "string" ? args.repo_space_uid : repository.spaceUid;
-          const anchored = await anchorRepository(
-            codeClient,
-            repository,
-            spaceUid,
-            agentId
-          );
-          repositoryAnchors.set(repository.repoRoot, {
-            ...anchored,
-            repository
-          });
-        }
-        const anchors = [];
-        for (const { ref, repository } of resolved) {
-          const repositoryAnchor = repositoryAnchors.get(repository.repoRoot);
-          if (!repositoryAnchor.uid) continue;
-          const spaceUid = typeof args.repo_space_uid === "string" ? args.repo_space_uid : repository.spaceUid;
-          const anchor = await anchorCodeRef(
-            codeClient,
-            ref,
-            repositoryAnchor.uid,
-            spaceUid,
-            agentId
-          );
-          anchors.push(anchor);
-        }
-        return ok2({
-          availability: resolution.availability,
-          repository: repositoryAnchors.values().next().value,
-          repositories: [...repositoryAnchors.values()],
-          anchors,
-          unresolved,
-          wrote: anchors.some((anchor) => anchor.created)
-        });
-      }
-      case "recall": {
-        const materialized = new Set(anchorUids);
-        let resolution;
-        if (refs.length > 0) {
-          resolution = await adapter.resolveRefs(refs, options);
-          for (const result of resolution.results) {
-            if (!result.resolved) continue;
-            const uid = await resolveMaterializedUid(codeClient, result.resolved, agentId);
-            if (uid) materialized.add(uid);
-          }
-        }
-        if (materialized.size === 0) {
-          return ok2({
-            availability: resolution?.availability,
-            anchors: [],
-            context: [],
-            unresolved: resolution?.results.filter((result) => !result.resolved) ?? []
-          });
-        }
-        const context = await Promise.all(
-          [...materialized].map(async (uid) => ({
-            anchor_uid: uid,
-            graph: await codeClient.traverse({
-              action: "neighborhood",
-              start_uid: uid,
-              depth: 2,
-              max_nodes: Math.min(limit ?? 20, 20)
-            })
-          }))
-        );
-        return ok2({
-          availability: resolution?.availability,
-          anchors: [...materialized],
-          context,
-          unresolved: resolution?.results.filter((result) => !result.resolved) ?? []
-        });
-      }
-      case "expand": {
-        const target = await resolveSingleTarget(
-          codeClient,
-          adapter,
-          refs,
-          anchorUids,
-          options
-        );
-        if ("error" in target) return target.error;
-        const expanded = await adapter.expand(target.ref, limit);
-        const joined = await joinMaterialized(
-          codeClient,
-          [...expanded.callers, ...expanded.callees],
-          agentId,
-          Math.min(limit ?? 20, 20)
-        );
-        return ok2({ anchor: target.ref, ...expanded, materialized: joined });
-      }
-      case "affected": {
-        const targetUid = typeof args.task_uid === "string" ? args.task_uid : typeof args.execution_uid === "string" ? args.execution_uid : void 0;
-        let graphContext;
-        const graphRefs = [];
-        let unavailableRepositories = [];
-        if (targetUid) {
-          graphContext = await codeClient.traverse({
-            action: "neighborhood",
-            start_uid: targetUid,
-            depth: 2,
-            max_nodes: 50
-          });
-          const fromGraph = await codeRefsFromGraphContext(
-            codeClient,
-            adapter,
-            graphContext
-          );
-          graphRefs.push(...fromGraph.refs);
-          unavailableRepositories = fromGraph.unavailable;
-        }
-        if (refs.length > 0 || anchorUids.length > 0) {
-          const target = await resolveSingleTarget(
-            codeClient,
-            adapter,
-            refs,
-            anchorUids,
-            options
-          );
-          if ("error" in target) return target.error;
-          graphRefs.unshift(target.ref);
-        }
-        const unique = uniqueRefs(graphRefs);
-        if (unique.length === 0) {
-          return ok2({
-            target_uid: targetUid,
-            graph_context: graphContext,
-            affected: [],
-            degradation: unavailableRepositories.length > 0 ? `attached code anchors reference repositories unavailable here: ${unavailableRepositories.join(", ")}` : "no materialized code anchors were attached",
-            ...unavailableRepositories.length > 0 ? { unavailable_repositories: unavailableRepositories } : {}
-          });
-        }
-        const impacts = await Promise.all(
-          unique.map(async (ref) => ({ anchor: ref, ...await adapter.affected(ref, limit) }))
-        );
-        const structural = uniqueRefs(impacts.flatMap((impact) => impact.affected));
-        const joined = await joinMaterialized(
-          codeClient,
-          structural,
-          agentId,
-          Math.min(limit ?? 50, 50)
-        );
-        return ok2({
-          target_uid: targetUid,
-          graph_context: graphContext,
-          impacts,
-          materialized: joined,
-          ...unavailableRepositories.length > 0 ? { unavailable_repositories: unavailableRepositories } : {}
-        });
+  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"
+        ]
       }
-      default:
-        return err3("unknown_action", `unknown mindgraph_code action: ${action}`);
-    }
-  } catch (cause) {
-    if (cause instanceof UnknownRepositoryError) {
-      return err3("unknown_repository", cause.message);
-    }
-    return toolError(cause, "code_tool_failed");
+    ]
+  },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
   }
+};
+function obj2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-async function attachCodeRefsToToolResult(client, result, args, adapter) {
-  if (result.isError || !Array.isArray(args.code_refs) || args.code_refs.length === 0) {
-    return result;
+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(",")}}`;
   }
-  const original = JSON.parse(result.content[0]?.text ?? "null");
-  const targetUids = primaryUids(original);
-  if (targetUids.length === 0) {
-    return ok2({
-      result: original,
-      code_anchors: {
-        wrote: false,
-        caveat: "the write response exposed no primary UID to attach"
+  return JSON.stringify(value);
+}
+function sha256(value) {
+  return 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),
+    // `true` from /retrieve, an object naming the replacement from /retrieve/context.
+    superseded: value.superseded ? 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 anchorResult = await handleCodeTool(
-    client,
-    {
-      action: "anchor",
-      code_refs: args.code_refs,
-      repo: args.repo,
-      repo_space_uid: args.repo_space_uid,
-      agent_id: args.agent_id,
-      // Keeps the default adapter anchored to the live session directory
-      // rather than wherever the MCP server process was launched.
-      invocation_context: args.invocation_context
-    },
-    adapter
-  );
-  const anchors = JSON.parse(anchorResult.content[0]?.text ?? "null");
-  if (!anchorResult.isError) {
-    const codeClient = client;
-    const anchorUids = (anchors.anchors ?? []).flatMap(
-      (anchor) => anchor.uid ? [anchor.uid] : []
+  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)
+      })
     );
-    const relateFailures = [];
-    for (const targetUid of targetUids) {
-      for (const anchorUid of anchorUids) {
-        try {
-          await codeClient.entity({
-            action: "relate",
-            source_uid: targetUid,
-            target_uid: anchorUid,
-            edge_type: args.action === "lesson" ? "ABOUT" : "RELEVANT_TO",
-            agent_id: args.agent_id
-          });
-        } catch (cause) {
-          relateFailures.push(
-            `${targetUid} -> ${anchorUid}: ${errorDetail(cause)}`
-          );
-        }
-      }
+  }
+  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 value of Array.isArray(payload.other_eligible) ? payload.other_eligible : []) {
+    const item = compactItem(value, "Task");
+    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);
     }
-    if (relateFailures.length > 0) {
-      return ok2({
-        result: original,
-        code_anchors: {
-          ...anchors,
-          caveat: `anchors written, but ${relateFailures.length} relate edge(s) failed: ${relateFailures.join("; ")}`
-        }
-      });
+  }
+  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 ok2({ result: original, code_anchors: anchors });
+  return items;
 }
-async function anchorRepository(client, repository, spaceUid, agentId) {
-  return client.entity({
-    action: "create",
-    label: repository.repoId,
-    props: {
-      entity_type: "repository",
-      canonical_name: repository.repoId,
-      identifiers: { repo_id: repository.repoId }
-    },
-    identity: {
-      namespace: "external.code",
-      key_version: 1,
-      key: repositoryIdentityKey(repository)
-    },
-    identity_space_uid: spaceUid,
-    agent_id: agentId
+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;
   });
 }
-async function anchorCodeRef(client, ref, repositoryUid, spaceUid, agentId) {
-  const response = await client.entity({
-    action: "create",
-    label: ref.qualifiedName,
-    props: {
-      entity_type: ref.kind === "file" ? "code_file" : "code_symbol",
-      canonical_name: ref.qualifiedName,
-      identifiers: {
-        repo_id: ref.repoId,
-        path: ref.path,
-        qualified_name: ref.qualifiedName
-      },
-      attributes: { code_ref: storedCodeRef(ref) }
-    },
-    identity: {
-      namespace: "external.code",
-      key_version: 1,
-      key: codeRefIdentityKey(ref)
-    },
-    identity_space_uid: spaceUid,
-    agent_id: agentId
-  });
-  if (response.uid && response.created !== false && response.status !== "existing") {
-    await client.entity({
-      action: "relate",
-      source_uid: response.uid,
-      target_uid: repositoryUid,
-      edge_type: "PART_OF",
-      agent_id: agentId
+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.`
     });
   }
-  return { ...response, ref };
+  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;
 }
-async function resolveMaterializedUid(client, ref, agentId) {
-  const response = await client.entity({
-    action: "resolve_identity",
-    identity: {
-      namespace: "external.code",
-      key_version: 1,
-      key: codeRefIdentityKey(ref)
-    },
-    agent_id: agentId
-  });
-  return response.status === "existing" ? response.uid : void 0;
+function error(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
 }
-async function codeRefFromAnchor(client, adapter, uid) {
-  const node = await client.getNode(uid);
-  const attributes = node.props?.attributes;
-  if (!attributes || typeof attributes !== "object") return void 0;
-  const codeRef = attributes.code_ref;
-  if (!isStoredCodeRef(codeRef)) return void 0;
-  try {
-    const repository = await adapter.resolveRepository(codeRef.repoId);
-    return { ref: { ...codeRef, repoRoot: repository.repoRoot } };
-  } catch (cause) {
-    if (cause instanceof UnknownRepositoryError) {
-      return { missingRepo: codeRef.repoId };
+async function handleMemoryTool(client, 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;
+  let workspace;
+  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 client.retrieveContext(request);
+    rendered2 = renderContext(raw, budget) ?? "No results found for this search.";
+    strategy = "retrieve_context";
+    candidates = topicCandidates(raw);
+  } else {
+    if (args.scope !== void 0 && args.scope !== "workspace") {
+      return error("scope must be 'workspace' when given");
     }
-    throw cause;
+    if (args.scope === "workspace") {
+      if (!config.resolveWorkspaceScope) {
+        return error(
+          "scope='workspace' needs the local MindGraph MCP server, which reads .mindgraph/workspace.json beside the checkout; this server has no working directory. Pass scope_uids instead."
+        );
+      }
+      workspace = await config.resolveWorkspaceScope(agentId ?? "mcp");
+      if (workspace.uids.length === 0) {
+        return error(
+          `scope='workspace' resolved no repositories${workspace.failures.length > 0 ? ` (${workspace.failures.join("; ")})` : ""}`
+        );
+      }
+    }
+    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)] : [],
+        ...workspace?.uids ?? []
+      ])
+    );
+    raw = await client.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: workspace ? WORKSPACE_RESUME_LIMIT : 1,
+        agent_id: agentId
+      })
+    );
+    rendered2 = renderResumeContext(raw, budget, workspace?.names) ?? "No eligible work was found in the requested scope.";
+    strategy = "resume_work";
+    candidates = resumeCandidates(raw);
   }
+  const items = visibleItems(candidates, rendered2);
+  const renderedHash = sha256(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,
+    workspace_repositories: workspace ? Object.values(workspace.names).sort() : void 0
+  });
+  const contextId = `ctx_${sha256(
+    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),
+      ...workspace && workspace.failures.length > 0 ? [
+        {
+          code: "workspace_scope_partial",
+          message: `${workspace.failures.length} declared repositories did not resolve and were left out: ${workspace.failures.join("; ")}`
+        }
+      ] : []
+    ]
+  };
+  return {
+    content: [{ type: "text", text: rendered2 }],
+    structuredContent: result
+  };
 }
-async function resolveSingleTarget(client, adapter, refs, anchorUids, options) {
-  if (refs.length > 1 || anchorUids.length > 1) {
-    return { error: err3("ambiguous_target", "expand/affected accepts exactly one code target") };
-  }
-  if (anchorUids.length === 1) {
-    const outcome = await codeRefFromAnchor(client, adapter, anchorUids[0]);
-    if (!outcome) {
-      return { error: err3("invalid_anchor", "anchor UID does not contain a typed code_ref") };
-    }
-    if ("missingRepo" in outcome) {
-      return {
-        error: err3(
-          "repository_unavailable",
-          `repository ${outcome.missingRepo} is not checked out here or declared in .mindgraph/workspace.json; expand/affected need its local index`
-        )
-      };
-    }
-    return { ref: outcome.ref };
-  }
-  if (refs.length !== 1) {
-    return { error: err3("missing_code_ref", "one code_ref or anchor_uid is required") };
+
+// src/resources.ts
+var 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",
+    description: "Current knowledge graph statistics: node counts, edge counts, and layer distribution",
+    mimeType: "application/json"
+  },
+  {
+    uri: "mindgraph://goals",
+    name: "Active Goals",
+    description: "All active goals in the knowledge graph",
+    mimeType: "application/json"
+  },
+  {
+    uri: "mindgraph://questions",
+    name: "Open Questions",
+    description: "All open questions in the knowledge graph",
+    mimeType: "application/json"
+  },
+  {
+    uri: "mindgraph://contradictions",
+    name: "Contradictions",
+    description: "Contradictory claims in the knowledge graph",
+    mimeType: "application/json"
+  },
+  {
+    uri: "mindgraph://decisions",
+    name: "Open Decisions",
+    description: "Unresolved decisions awaiting resolution",
+    mimeType: "application/json"
   }
-  const resolution = await adapter.resolveRefs(refs, options);
-  const result = resolution.results[0];
-  if (!result.resolved) {
-    return {
-      error: ok2({
-        availability: resolution.availability,
-        result,
-        wrote: false
-      })
-    };
+];
+var RESOURCE_TEMPLATES = [
+  {
+    uriTemplate: "mindgraph://node/{uid}",
+    name: "Graph Node",
+    description: "Retrieve a specific node by its UID, including all properties, edges, and version history",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "mindgraph://search/{query}",
+    name: "Search Results",
+    description: "BM25 keyword search across all nodes \u2014 pass 1\u20133 discriminating terms (e.g. 'Kissinger NATO'), not natural language sentences",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "mindgraph://layer/{layer}",
+    name: "Layer Nodes",
+    description: "List all nodes in a specific cognitive layer (reality, epistemic, intent, action, memory, agent)",
+    mimeType: "application/json"
   }
-  return { ref: result.resolved };
+];
+var RESOURCE_GOVERNANCE_TOOL = "mindgraph_retrieve";
+function json(uri, data) {
+  return {
+    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(data) }]
+  };
 }
-async function joinMaterialized(client, refs, agentId, limit) {
-  const joined = [];
-  for (const ref of uniqueRefs(refs).slice(0, limit)) {
-    const uid = await resolveMaterializedUid(client, ref, agentId);
-    if (!uid) continue;
-    joined.push({
-      ref,
-      anchor_uid: uid,
-      graph: await client.traverse({
-        action: "neighborhood",
-        start_uid: uid,
-        depth: 2,
-        max_nodes: 20
-      })
-    });
+async function readResource(client, uri, memoryConfig = {}) {
+  switch (uri) {
+    case "mindgraph://memory/status":
+      return json(uri, memoryStatus(memoryConfig));
+    case "mindgraph://stats":
+      return json(uri, await client.stats());
+    case "mindgraph://goals":
+      return json(uri, await client.getGoals());
+    case "mindgraph://questions":
+      return json(uri, await client.getOpenQuestions());
+    case "mindgraph://contradictions":
+      return json(uri, await client.getContradictions());
+    case "mindgraph://decisions":
+      return json(uri, await client.getOpenDecisions());
   }
-  return joined;
-}
-async function codeRefsFromGraphContext(client, adapter, context) {
-  const uids = /* @__PURE__ */ new Set();
-  collectUids(context, uids);
-  if (uids.size === 0) return { refs: [], unavailable: [] };
-  const nodes = client.getNodesBatch ? await client.getNodesBatch([...uids]) : await Promise.all([...uids].map((uid) => client.getNode(uid).catch(() => void 0)));
-  const stored = nodes.flatMap((node) => {
-    if (!node) return [];
-    const attributes = node.props?.attributes;
-    if (!attributes || typeof attributes !== "object") return [];
-    const codeRef = attributes.code_ref;
-    return isStoredCodeRef(codeRef) ? [codeRef] : [];
-  });
-  const refs = [];
-  const unavailable = /* @__PURE__ */ new Set();
-  for (const ref of stored) {
-    try {
-      const repository = await adapter.resolveRepository(ref.repoId);
-      refs.push({ ...ref, repoRoot: repository.repoRoot });
-    } catch (cause) {
-      if (cause instanceof UnknownRepositoryError) {
-        unavailable.add(ref.repoId);
-      } else {
-        throw cause;
-      }
-    }
+  const nodeMatch = uri.match(/^mindgraph:\/\/node\/(.+)$/);
+  if (nodeMatch) {
+    const uid = decodeURIComponent(nodeMatch[1]);
+    const node = await client.getNode(uid);
+    const edges = await client.getEdges({ from_uid: uid });
+    const inEdges = await client.getEdges({ to_uid: uid });
+    return json(uri, { node, outgoing_edges: edges, incoming_edges: inEdges });
   }
-  return { refs, unavailable: [...unavailable].sort() };
-}
-function collectUids(value, uids) {
-  if (Array.isArray(value)) {
-    value.forEach((item) => collectUids(item, uids));
-    return;
+  const searchMatch = uri.match(/^mindgraph:\/\/search\/(.+)$/);
+  if (searchMatch) {
+    const query = decodeURIComponent(searchMatch[1]);
+    return json(uri, await client.search(query, { limit: 20 }));
   }
-  if (!value || typeof value !== "object") return;
-  for (const [key, child] of Object.entries(value)) {
-    if (typeof child === "string" && ["uid", "node_uid", "neighbor_uid", "from_uid", "to_uid"].includes(key)) {
-      uids.add(child);
-    } else {
-      collectUids(child, uids);
-    }
+  const layerMatch = uri.match(/^mindgraph:\/\/layer\/(.+)$/);
+  if (layerMatch) {
+    const layer = decodeURIComponent(layerMatch[1]);
+    return json(uri, await client.getNodes({ layer, limit: 50 }));
   }
+  throw new Error(`Unknown resource: ${uri}`);
 }
-function isStoredCodeRef(value) {
-  if (!value || typeof value !== "object") return false;
-  const ref = value;
-  return typeof ref.repoId === "string" && typeof ref.path === "string" && typeof ref.language === "string" && typeof ref.kind === "string" && typeof ref.qualifiedName === "string" && (typeof ref.signature === "string" || ref.signature === null) && typeof ref.startLine === "number" && typeof ref.endLine === "number";
-}
-function storedCodeRef(ref) {
-  const { repoRoot: _localOnly, ...stored } = ref;
-  return stored;
-}
-function uniqueRefs(refs) {
-  const seen = /* @__PURE__ */ new Set();
-  return refs.filter((ref) => {
-    const key = `${ref.repoId}:${ref.path}:${ref.qualifiedName}:${ref.signature ?? ""}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-function primaryUids(value) {
-  if (!value || typeof value !== "object") return [];
-  const object = value;
-  const keys = [
-    "uid",
-    "claim_uid",
-    "goal_uid",
-    "project_uid",
-    "milestone_uid",
-    "decision_uid",
-    "task_uid",
-    "plan_uid",
-    "step_uid",
-    "execution_uid",
-    "lesson_uid"
-  ];
-  return [
-    ...new Set(
-      keys.flatMap((key) => typeof object[key] === "string" ? [object[key]] : [])
-    )
-  ];
+async function readGovernedResource(client, 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(
+    toolName,
+    toolArgs,
+    { ...governanceConfig, context: { resource_uri: uri } }
+  );
+  if (!governance.allowed) {
+    throw new Error(governance.message);
+  }
+  return readResource(client, uri, memoryConfig);
 }
 
+// src/tools.ts
+import { createHash as createHash2 } from "crypto";
+
 // src/sync-tool.ts
 import crypto from "crypto";
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 var ok3 = (data) => ({
   content: [{ type: "text", text: JSON.stringify(data) }]
 });
@@ -3555,12 +3663,12 @@ var SYNC_TOOL = {
   }
 };
 function safePath(root, candidate) {
-  const absolute = path.resolve(root, candidate);
-  const relative2 = path.relative(root, absolute);
-  if (relative2.startsWith("..") || path.isAbsolute(relative2)) {
+  const absolute = path2.resolve(root, candidate);
+  const relative2 = path2.relative(root, absolute);
+  if (relative2.startsWith("..") || path2.isAbsolute(relative2)) {
     throw new Error(`path escapes repository root: ${candidate}`);
   }
-  if (fs.existsSync(absolute)) {
+  if (fs2.existsSync(absolute)) {
     if (!pathContains(realPathOf(root), realPathOf(absolute))) {
       throw new Error(`path escapes repository root via symlink: ${candidate}`);
     }
@@ -3569,25 +3677,25 @@ function safePath(root, candidate) {
 }
 function realPathOf(target) {
   try {
-    return fs.realpathSync(target);
+    return fs2.realpathSync(target);
   } catch {
-    return path.resolve(target);
+    return path2.resolve(target);
   }
 }
 function markdownFiles(target, realRoot, visited = /* @__PURE__ */ new Set()) {
-  if (!fs.existsSync(target)) return [];
+  if (!fs2.existsSync(target)) return [];
   const real = realPathOf(target);
   if (!pathContains(realRoot, real)) return [];
-  const stat = fs.statSync(target);
+  const stat = fs2.statSync(target);
   if (stat.isFile()) return target.endsWith(".md") ? [target] : [];
   if (!stat.isDirectory() || visited.has(real)) return [];
   visited.add(real);
-  return fs.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(path.join(target, entry.name), realRoot, visited));
+  return fs2.readdirSync(target, { withFileTypes: true }).flatMap((entry) => markdownFiles(path2.join(target, entry.name), realRoot, visited));
 }
 function fileDescriptor(root, absolute) {
-  const content = fs.readFileSync(absolute, "utf8");
+  const content = fs2.readFileSync(absolute, "utf8");
   return {
-    logical_path: path.relative(root, absolute).split(path.sep).join("/"),
+    logical_path: path2.relative(root, absolute).split(path2.sep).join("/"),
     content_hash: crypto.createHash("sha256").update(content).digest("hex"),
     bytes: Buffer.byteLength(content),
     content
@@ -3657,7 +3765,7 @@ async function handleSyncTool(client, args) {
     }
     if (action === "status" && request.logical_path && request.file_present !== false) {
       const absolute = safePath(root, String(request.logical_path));
-      request.file_present = fs.existsSync(absolute);
+      request.file_present = fs2.existsSync(absolute);
       if (request.file_present && !request.content_hash) {
         request.content_hash = fileDescriptor(root, absolute).content_hash;
       }
@@ -6196,7 +6304,7 @@ function buildMindGraphServer(wiring) {
       instructions: wiring.instructions
     }
   );
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
+  server.setRequestHandler("tools/list", async () => {
     const generated = await getGeneratedTools(client, wiring.generatedTools);
     const tools = [...toolsForProfile(wiring.profile), ...generated.tools];
     if (!hosted) return { tools };
@@ -6207,7 +6315,7 @@ function buildMindGraphServer(wiring) {
       ]
     };
   });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler("tools/call", async (request) => {
     const { name, arguments: args } = request.params;
     const rawArgs = {
       ...args || {},
@@ -6254,20 +6362,20 @@ function buildMindGraphServer(wiring) {
     }
     return handleTool(client, name, toolArgs, wiring.memory);
   });
-  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  server.setRequestHandler("prompts/list", async () => {
     return { prompts: PROMPTS };
   });
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  server.setRequestHandler("prompts/get", async (request) => {
     const { name, arguments: args } = request.params;
     return getPrompt(name, args);
   });
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  server.setRequestHandler("resources/list", async () => {
     return { resources: RESOURCES };
   });
-  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+  server.setRequestHandler("resources/templates/list", async () => {
     return { resourceTemplates: RESOURCE_TEMPLATES };
   });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  server.setRequestHandler("resources/read", async (request) => {
     return readGovernedResource(
       client,
       request.params.uri,
@@ -6333,6 +6441,19 @@ async function handleHostedRequest(request, opts) {
   if (Array.isArray(parsedBody)) {
     return jsonRpcError(400, -32600, "JSON-RPC batches are not accepted");
   }
+  if (!await isLegacyRequest(request, parsedBody)) {
+    const modern = createMcpHandler(() => createMindGraphServer(opts), {
+      legacy: "reject"
+      // Default response mode: one JSON body unless a handler emits a message
+      // before its result. No tool does today; a tool that starts emitting
+      // progress must also stop this function closing the handler on return.
+    });
+    try {
+      return await modern.fetch(request, { parsedBody });
+    } finally {
+      await modern.close();
+    }
+  }
   const server = createMindGraphServer(opts);
   const transport = new WebStandardStreamableHTTPServerTransport({
     sessionIdGenerator: void 0,