@hegemonart/get-design-done 1.51.0 → 1.53.0

package/sdk/mcp/gdd-mcp/server.js

@@ -10,8 +10,8 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
-  for (var name13 in all)
-    __defProp(target, name13, { get: all[name13], enumerable: true });
+  for (var name14 in all)
+    __defProp(target, name14, { get: all[name14], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -31,6 +31,282 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// scripts/lib/design-context-query.cjs
+var require_design_context_query = __commonJS({
+  "scripts/lib/design-context-query.cjs"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var EXPECTED_NODE_TYPES = [
+      "token",
+      "component",
+      "variant",
+      "state",
+      "motion-fragment",
+      "a11y-pattern",
+      "screen",
+      "layer",
+      "pattern",
+      "anti-pattern"
+    ];
+    function load2(graphPath) {
+      const raw = fs.readFileSync(graphPath, "utf8");
+      return JSON.parse(raw);
+    }
+    function _nodes(graph) {
+      return Array.isArray(graph && graph.nodes) ? graph.nodes : [];
+    }
+    function _edges(graph) {
+      return Array.isArray(graph && graph.edges) ? graph.edges : [];
+    }
+    function nodes2(graph, opts = {}) {
+      const { type, tag } = opts;
+      return _nodes(graph).filter((n) => {
+        if (type !== void 0 && n.type !== type) return false;
+        if (tag !== void 0 && !(Array.isArray(n.tags) && n.tags.includes(tag))) return false;
+        return true;
+      });
+    }
+    function edges2(graph, opts = {}) {
+      const { type } = opts;
+      return _edges(graph).filter((e) => type === void 0 ? true : e.type === type);
+    }
+    function _adjacency(graph) {
+      const adj = /* @__PURE__ */ new Map();
+      const ensure = (id) => {
+        if (!adj.has(id)) adj.set(id, /* @__PURE__ */ new Set());
+        return adj.get(id);
+      };
+      for (const n of _nodes(graph)) {
+        if (n && typeof n.id === "string") ensure(n.id);
+      }
+      for (const e of _edges(graph)) {
+        if (!e || typeof e.source !== "string" || typeof e.target !== "string") continue;
+        const dir = e.direction;
+        if (dir === "forward" || dir === "bidirectional") ensure(e.source).add(e.target);
+        if (dir === "backward" || dir === "bidirectional") ensure(e.target).add(e.source);
+      }
+      return adj;
+    }
+    function pathBetween(graph, from, to) {
+      const adj = _adjacency(graph);
+      if (!adj.has(from) || !adj.has(to)) return null;
+      if (from === to) return [from];
+      const prev = /* @__PURE__ */ new Map([[from, null]]);
+      const queue = [from];
+      while (queue.length) {
+        const cur = queue.shift();
+        for (const next of adj.get(cur) || []) {
+          if (prev.has(next)) continue;
+          prev.set(next, cur);
+          if (next === to) {
+            const out = [];
+            for (let at = to; at !== null; at = prev.get(at)) out.unshift(at);
+            return out;
+          }
+          queue.push(next);
+        }
+      }
+      return null;
+    }
+    function consumersOf2(graph, id) {
+      const nodeById = new Map(_nodes(graph).filter((n) => n && typeof n.id === "string").map((n) => [n.id, n]));
+      const consumerIds = /* @__PURE__ */ new Set();
+      for (const e of _edges(graph)) {
+        if (!e || typeof e.source !== "string" || typeof e.target !== "string") continue;
+        const dir = e.direction;
+        if ((dir === "forward" || dir === "bidirectional") && e.target === id) consumerIds.add(e.source);
+        if ((dir === "backward" || dir === "bidirectional") && e.source === id) consumerIds.add(e.target);
+      }
+      consumerIds.delete(id);
+      return [...consumerIds].map((cid) => nodeById.get(cid)).filter(Boolean);
+    }
+    function unreachable2(graph) {
+      const incident = /* @__PURE__ */ new Set();
+      for (const e of _edges(graph)) {
+        if (!e) continue;
+        if (typeof e.source === "string") incident.add(e.source);
+        if (typeof e.target === "string") incident.add(e.target);
+      }
+      return _nodes(graph).filter((n) => n && typeof n.id === "string" && !incident.has(n.id)).map((n) => n.id);
+    }
+    function cycles2(graph) {
+      const adj = _adjacency(graph);
+      const WHITE = 0;
+      const GRAY = 1;
+      const BLACK = 2;
+      const color = new Map([...adj.keys()].map((id) => [id, WHITE]));
+      const stack = [];
+      const found = [];
+      const seen = /* @__PURE__ */ new Set();
+      const canonical = (cyc) => {
+        let min = 0;
+        for (let i = 1; i < cyc.length; i++) if (cyc[i] < cyc[min]) min = i;
+        return cyc.slice(min).concat(cyc.slice(0, min)).join("\0");
+      };
+      const visit = (node) => {
+        color.set(node, GRAY);
+        stack.push(node);
+        for (const next of adj.get(node) || []) {
+          if (color.get(next) === GRAY) {
+            const idx = stack.indexOf(next);
+            const cyc = stack.slice(idx);
+            const key = canonical(cyc);
+            if (!seen.has(key)) {
+              seen.add(key);
+              found.push(cyc.slice());
+            }
+          } else if (color.get(next) === WHITE) {
+            visit(next);
+          }
+        }
+        stack.pop();
+        color.set(node, BLACK);
+      };
+      for (const id of adj.keys()) if (color.get(id) === WHITE) visit(id);
+      return found;
+    }
+    function coverage2(graph) {
+      const present = new Set(_nodes(graph).map((n) => n && n.type).filter(Boolean));
+      const present_types = EXPECTED_NODE_TYPES.filter((t) => present.has(t));
+      const missing_types = EXPECTED_NODE_TYPES.filter((t) => !present.has(t));
+      const pct = Math.round(present_types.length / EXPECTED_NODE_TYPES.length * 100);
+      return { present_types, missing_types, pct };
+    }
+    function _parseFlags(argv) {
+      const flags = { json: false, file: null };
+      const rest = [];
+      for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--json") flags.json = true;
+        else if (a === "--file") flags.file = argv[++i];
+        else if (a.startsWith("--file=")) flags.file = a.slice("--file=".length);
+        else rest.push(a);
+      }
+      return { flags, rest };
+    }
+    function _printNodes(list, json, out) {
+      if (json) {
+        out.write(JSON.stringify(list, null, 2) + "\n");
+        return;
+      }
+      if (!list.length) {
+        out.write("(no matching nodes)\n");
+        return;
+      }
+      for (const n of list) out.write(`${n.id}	${n.type}	${n.name}
+`);
+    }
+    function main(argv, io = {}) {
+      const out = io.stdout || process.stdout;
+      const err = io.stderr || process.stderr;
+      const { flags, rest } = _parseFlags(argv);
+      const cmd = rest[0];
+      const usage = "usage: design-context-query <nodes|edges|path|consumers-of|unreachable|cycles|coverage> [args] [--file PATH] [--json]";
+      if (!cmd) {
+        err.write(usage + "\n");
+        return 1;
+      }
+      const file = flags.file || path.join(process.cwd(), ".design", "context-graph.json");
+      let graph;
+      try {
+        graph = load2(file);
+      } catch (e) {
+        err.write(`design-context-query: cannot load ${file}: ${e.message}
+`);
+        return 1;
+      }
+      switch (cmd) {
+        case "nodes": {
+          const typeIdx = rest.indexOf("--type");
+          const tagIdx = rest.indexOf("--tag");
+          const opts = {};
+          if (typeIdx !== -1) opts.type = rest[typeIdx + 1];
+          if (tagIdx !== -1) opts.tag = rest[tagIdx + 1];
+          _printNodes(nodes2(graph, opts), flags.json, out);
+          return 0;
+        }
+        case "edges": {
+          const typeIdx = rest.indexOf("--type");
+          const opts = {};
+          if (typeIdx !== -1) opts.type = rest[typeIdx + 1];
+          const list = edges2(graph, opts);
+          if (flags.json) out.write(JSON.stringify(list, null, 2) + "\n");
+          else if (!list.length) out.write("(no matching edges)\n");
+          else for (const e of list) out.write(`${e.source}	${e.type}	${e.target}	${e.direction}	${e.weight}
+`);
+          return 0;
+        }
+        case "path": {
+          const [, from, to] = rest;
+          if (!from || !to) {
+            err.write("usage: path <from-id> <to-id>\n");
+            return 1;
+          }
+          const p = pathBetween(graph, from, to);
+          if (flags.json) out.write(JSON.stringify({ from, to, path: p }, null, 2) + "\n");
+          else out.write(p ? p.join(" -> ") + "\n" : `(no path from ${from} to ${to})
+`);
+          return 0;
+        }
+        case "consumers-of": {
+          const [, id] = rest;
+          if (!id) {
+            err.write("usage: consumers-of <node-id>\n");
+            return 1;
+          }
+          _printNodes(consumersOf2(graph, id), flags.json, out);
+          return 0;
+        }
+        case "unreachable": {
+          const list = unreachable2(graph);
+          if (flags.json) out.write(JSON.stringify(list, null, 2) + "\n");
+          else out.write(list.length ? list.join("\n") + "\n" : "(no orphan nodes)\n");
+          return 0;
+        }
+        case "cycles": {
+          const list = cycles2(graph);
+          if (flags.json) out.write(JSON.stringify(list, null, 2) + "\n");
+          else if (!list.length) out.write("(no cycles)\n");
+          else for (const c of list) out.write(c.join(" -> ") + " -> " + c[0] + "\n");
+          return 0;
+        }
+        case "coverage": {
+          const c = coverage2(graph);
+          if (flags.json) out.write(JSON.stringify(c, null, 2) + "\n");
+          else {
+            out.write(`coverage: ${c.pct}% (${c.present_types.length}/${EXPECTED_NODE_TYPES.length} node types)
+`);
+            out.write(`present: ${c.present_types.join(", ") || "(none)"}
+`);
+            out.write(`missing: ${c.missing_types.join(", ") || "(none)"}
+`);
+          }
+          return 0;
+        }
+        default:
+          err.write(`design-context-query: unknown command "${cmd}"
+${usage}
+`);
+          return 1;
+      }
+    }
+    if (require.main === module2) process.exit(main(process.argv.slice(2)));
+    module2.exports = {
+      load: load2,
+      nodes: nodes2,
+      edges: edges2,
+      path: pathBetween,
+      consumersOf: consumersOf2,
+      unreachable: unreachable2,
+      cycles: cycles2,
+      coverage: coverage2,
+      main,
+      EXPECTED_NODE_TYPES
+    };
+  }
+});
+
 // scripts/lib/snapshot-reader/index.cjs
 var require_snapshot_reader = __commonJS({
   "scripts/lib/snapshot-reader/index.cjs"(exports2, module2) {
@@ -52,10 +328,10 @@ var require_snapshot_reader = __commonJS({
       }
       const entries = await fs.promises.readdir(dir);
       const candidates = [];
-      for (const name13 of entries) {
-        if (!name13.endsWith(".json")) continue;
-        if (name13 === "last-recap.json") continue;
-        const full = path.join(dir, name13);
+      for (const name14 of entries) {
+        if (!name14.endsWith(".json")) continue;
+        if (name14 === "last-recap.json") continue;
+        const full = path.join(dir, name14);
         try {
           const stat = await fs.promises.stat(full);
           candidates.push({ full, mtime: stat.mtimeMs });
@@ -147,16 +423,16 @@ var require_loader = __commonJS({
     function reset() {
       _cache.clear();
     }
-    function load(name13, opts) {
+    function load2(name14, opts) {
       const o = opts || {};
       const dir = o.dir || MANIFEST_DIR;
       const fallback = Object.prototype.hasOwnProperty.call(o, "fallback") ? o.fallback : {};
-      const abs = path.join(dir, `${name13}.json`);
+      const abs = path.join(dir, `${name14}.json`);
       let stat;
       try {
         stat = fs.statSync(abs);
       } catch {
-        if (!o.quiet) process.stderr.write(`manifest: ${name13}.json not found \u2014 using empty fallback (a consumer phase may not have shipped its data yet)
+        if (!o.quiet) process.stderr.write(`manifest: ${name14}.json not found \u2014 using empty fallback (a consumer phase may not have shipped its data yet)
 `);
         return fallback;
       }
@@ -167,12 +443,12 @@ var require_loader = __commonJS({
         _cache.set(abs, { mtimeMs: stat.mtimeMs, data });
         return data;
       } catch (e) {
-        if (!o.quiet) process.stderr.write(`manifest: ${name13}.json parse error (${e.message}) \u2014 using empty fallback
+        if (!o.quiet) process.stderr.write(`manifest: ${name14}.json parse error (${e.message}) \u2014 using empty fallback
 `);
         return fallback;
       }
     }
-    module2.exports = { load, reset, MANIFEST_DIR };
+    module2.exports = { load: load2, reset, MANIFEST_DIR };
   }
 });
 
@@ -300,12 +576,12 @@ var require_health_mirror = __commonJS({
           try {
             const body = await fs.promises.readFile(p, "utf8");
             const parsed = JSON.parse(body);
-            const name13 = typeof parsed.name === "string" ? parsed.name : "(unknown)";
+            const name14 = typeof parsed.name === "string" ? parsed.name : "(unknown)";
             const version = typeof parsed.version === "string" ? parsed.version : "0.0.0";
             checks.push({
               name: "package_json",
               status: "ok",
-              detail: name13 + "@" + version
+              detail: name14 + "@" + version
             });
           } catch (err) {
             checks.push({
@@ -484,9 +760,9 @@ var require_intel_store = __commonJS({
       }
       const entries = fs.readdirSync(dir);
       const ids = [];
-      for (const name13 of entries) {
-        if (!name13.endsWith(".json")) continue;
-        ids.push(name13.slice(0, -".json".length));
+      for (const name14 of entries) {
+        if (!name14.endsWith(".json")) continue;
+        ids.push(name14.slice(0, -".json".length));
       }
       return ids;
     }
@@ -512,22 +788,22 @@ var require_reflections_reader = __commonJS({
     async function listReflectionFiles(dir) {
       const entries = await fs.promises.readdir(dir);
       const candidates = [];
-      for (const name13 of entries) {
-        if (!name13.endsWith(".md")) continue;
-        const full = path.join(dir, name13);
+      for (const name14 of entries) {
+        if (!name14.endsWith(".md")) continue;
+        const full = path.join(dir, name14);
         try {
           const stat = await fs.promises.stat(full);
-          candidates.push({ name: name13, full, mtime: stat.mtimeMs });
+          candidates.push({ name: name14, full, mtime: stat.mtimeMs });
         } catch {
         }
       }
       candidates.sort((a, b) => b.mtime - a.mtime);
       return candidates;
     }
-    function extractCycle(name13) {
-      const m = name13.match(/cycle[-_]?[\w.]+/i);
+    function extractCycle(name14) {
+      const m = name14.match(/cycle[-_]?[\w.]+/i);
       if (m) return m[0];
-      return name13.replace(/\.md$/, "");
+      return name14.replace(/\.md$/, "");
     }
     async function readLatestReflection2(rootDir) {
       const dir = path.join(rootDir, ".design", "reflections");
@@ -604,12 +880,12 @@ var require_roadmap_reader = __commonJS({
       let h;
       while ((h = headingRe.exec(md)) !== null) {
         const number = h[1];
-        let name13 = h[2].trim();
-        name13 = name13.replace(/\s+\([^)]*\)\s*$/g, "").trim();
-        const inlineVer = name13.match(/\s+—\s+(v\d+\.\d+(?:\.\d+)?)/);
+        let name14 = h[2].trim();
+        name14 = name14.replace(/\s+\([^)]*\)\s*$/g, "").trim();
+        const inlineVer = name14.match(/\s+—\s+(v\d+\.\d+(?:\.\d+)?)/);
         let version = inlineVer ? inlineVer[1] : "";
         if (inlineVer) {
-          name13 = name13.slice(0, inlineVer.index).trim();
+          name14 = name14.slice(0, inlineVer.index).trim();
         }
         if (version === "") {
           const after = md.slice(h.index, h.index + 2e3);
@@ -618,7 +894,7 @@ var require_roadmap_reader = __commonJS({
         }
         phases.push({
           number,
-          name: name13,
+          name: name14,
           version,
           checkbox_status: statusMap.get(number) ?? "unknown"
         });
@@ -763,16 +1039,99 @@ function toToolError(err) {
   return out;
 }
 
-// sdk/mcp/gdd-mcp/tools/gdd_cycle_recap.ts
-var gdd_cycle_recap_exports = {};
-__export(gdd_cycle_recap_exports, {
+// sdk/mcp/gdd-mcp/tools/gdd_context_query.ts
+var gdd_context_query_exports = {};
+__export(gdd_context_query_exports, {
   handle: () => handle,
   name: () => name,
   schemaPath: () => schemaPath
 });
+var import_design_context_query = __toESM(require_design_context_query());
 
-// sdk/state/index.ts
+// sdk/mcp/gdd-mcp/tools/shared.ts
 var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+function okResponse(data) {
+  return { success: true, data };
+}
+function errorResponse(err) {
+  const payload = toToolError(err);
+  if (typeof err === "object" && err !== null && "code" in err && err.code === "directory_not_found") {
+    const error = { ...payload.error, mcp_code: "directory_not_found" };
+    return { success: false, error };
+  }
+  return { success: false, error: payload.error };
+}
+function resolveStatePath() {
+  const override = process.env["GDD_STATE_PATH"];
+  if (typeof override === "string" && override.length > 0) {
+    return override;
+  }
+  return (0, import_node_path.join)(resolveProjectRoot(), ".design", "STATE.md");
+}
+function resolveTelemetryDir() {
+  return (0, import_node_path.join)(resolveProjectRoot(), ".design", "telemetry");
+}
+function resolveProjectRoot(startCwd = process.cwd()) {
+  const override = process.env["GDD_PROJECT_ROOT"];
+  if (typeof override === "string" && override.length > 0) {
+    return (0, import_node_path.resolve)(override);
+  }
+  let dir = (0, import_node_path.resolve)(startCwd);
+  while (true) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, ".design")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, ".planning")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, ".claude-plugin", "plugin.json"))) {
+      return dir;
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) {
+      throw new Error(
+        `gdd project root not found: walked up to ${dir} from ${startCwd}`
+      );
+    }
+    dir = parent;
+  }
+}
+
+// sdk/mcp/gdd-mcp/tools/gdd_context_query.ts
+var name = "gdd_context_query";
+var schemaPath = "../schemas/gdd_context_query.schema.json";
+async function handle(input) {
+  try {
+    const t = input ?? {};
+    let graph = null;
+    const ops = {
+      nodes: () => (0, import_design_context_query.nodes)(graph, { type: t.type, tag: t.tag }),
+      edges: () => (0, import_design_context_query.edges)(graph, { type: t.type }),
+      path: () => (0, import_design_context_query.path)(graph, t.from, t.to),
+      "consumers-of": () => (0, import_design_context_query.consumersOf)(graph, t.id),
+      unreachable: () => (0, import_design_context_query.unreachable)(graph),
+      cycles: () => (0, import_design_context_query.cycles)(graph),
+      coverage: () => (0, import_design_context_query.coverage)(graph)
+    };
+    const fn = t.op ? ops[t.op] : void 0;
+    if (!fn) return errorResponse(new Error("op is required \u2014 one of: " + Object.keys(ops).join(", ")));
+    try {
+      graph = (0, import_design_context_query.load)(resolveProjectRoot() + "/.design/context-graph.json");
+    } catch {
+      graph = null;
+    }
+    if (!graph) return okResponse({ op: t.op, graph_present: false, result: null });
+    return okResponse({ op: t.op, graph_present: true, result: fn() });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// sdk/mcp/gdd-mcp/tools/gdd_cycle_recap.ts
+var gdd_cycle_recap_exports = {};
+__export(gdd_cycle_recap_exports, {
+  handle: () => handle2,
+  name: () => name2,
+  schemaPath: () => schemaPath2
+});
+
+// sdk/state/index.ts
+var import_node_fs2 = require("node:fs");
 
 // sdk/state/types.ts
 function isConnectionStatus(value) {
@@ -843,29 +1202,29 @@ function parse(raw) {
     const line = lines[i] ?? "";
     const openMatch = line.match(blockOpen);
     if (!openMatch) continue;
-    const name13 = openMatch[1];
-    if (!BLOCK_ORDER.includes(name13)) {
+    const name14 = openMatch[1];
+    if (!BLOCK_ORDER.includes(name14)) {
       continue;
     }
-    if (seen.has(name13)) {
-      throw new ParseError(`duplicate block <${name13}>`, lineToFileLine(afterFm, normalized, i));
+    if (seen.has(name14)) {
+      throw new ParseError(`duplicate block <${name14}>`, lineToFileLine(afterFm, normalized, i));
     }
     let close = -1;
     for (let j = i + 1; j < lines.length; j++) {
       const cm = (lines[j] ?? "").match(blockClose);
-      if (cm && cm[1] === name13) {
+      if (cm && cm[1] === name14) {
         close = j;
         break;
       }
     }
     if (close === -1) {
       throw new ParseError(
-        `unterminated block <${name13}> (no </${name13}>)`,
+        `unterminated block <${name14}> (no </${name14}>)`,
         lineToFileLine(afterFm, normalized, i)
       );
     }
-    blocks.push({ name: name13, openLine: i, closeLine: close });
-    seen.add(name13);
+    blocks.push({ name: name14, openLine: i, closeLine: close });
+    seen.add(name14);
     i = close;
   }
   let body_preamble;
@@ -1475,66 +1834,20 @@ var GATES = Object.freeze({
 
 // sdk/state/index.ts
 async function read(path) {
-  const raw = (0, import_node_fs.readFileSync)(path, "utf8");
+  const raw = (0, import_node_fs2.readFileSync)(path, "utf8");
   return parse(raw).state;
 }
 
 // sdk/mcp/gdd-mcp/tools/gdd_cycle_recap.ts
 var import_snapshot_reader = __toESM(require_snapshot_reader());
-
-// sdk/mcp/gdd-mcp/tools/shared.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path = require("node:path");
-function okResponse(data) {
-  return { success: true, data };
-}
-function errorResponse(err) {
-  const payload = toToolError(err);
-  if (typeof err === "object" && err !== null && "code" in err && err.code === "directory_not_found") {
-    const error = { ...payload.error, mcp_code: "directory_not_found" };
-    return { success: false, error };
-  }
-  return { success: false, error: payload.error };
-}
-function resolveStatePath() {
-  const override = process.env["GDD_STATE_PATH"];
-  if (typeof override === "string" && override.length > 0) {
-    return override;
-  }
-  return (0, import_node_path.join)(resolveProjectRoot(), ".design", "STATE.md");
-}
-function resolveTelemetryDir() {
-  return (0, import_node_path.join)(resolveProjectRoot(), ".design", "telemetry");
-}
-function resolveProjectRoot(startCwd = process.cwd()) {
-  const override = process.env["GDD_PROJECT_ROOT"];
-  if (typeof override === "string" && override.length > 0) {
-    return (0, import_node_path.resolve)(override);
-  }
-  let dir = (0, import_node_path.resolve)(startCwd);
-  while (true) {
-    if ((0, import_node_fs2.existsSync)((0, import_node_path.join)(dir, ".design")) || (0, import_node_fs2.existsSync)((0, import_node_path.join)(dir, ".planning")) || (0, import_node_fs2.existsSync)((0, import_node_path.join)(dir, ".claude-plugin", "plugin.json"))) {
-      return dir;
-    }
-    const parent = (0, import_node_path.dirname)(dir);
-    if (parent === dir) {
-      throw new Error(
-        `gdd project root not found: walked up to ${dir} from ${startCwd}`
-      );
-    }
-    dir = parent;
-  }
-}
-
-// sdk/mcp/gdd-mcp/tools/gdd_cycle_recap.ts
-var name = "gdd_cycle_recap";
-var schemaPath = "../schemas/gdd_cycle_recap.schema.json";
+var name2 = "gdd_cycle_recap";
+var schemaPath2 = "../schemas/gdd_cycle_recap.schema.json";
 function snapCount(snap, key, fallback) {
   if (typeof snap[key] === "number") return snap[key];
   const arr = snap[fallback];
   return Array.isArray(arr) ? arr.length : 0;
 }
-async function handle(_input) {
+async function handle2(_input) {
   try {
     const snap = await (0, import_snapshot_reader.readLatestSnapshot)(resolveProjectRoot());
     const state = await read(resolveStatePath());
@@ -1557,13 +1870,13 @@ async function handle(_input) {
 // sdk/mcp/gdd-mcp/tools/gdd_decisions_list.ts
 var gdd_decisions_list_exports = {};
 __export(gdd_decisions_list_exports, {
-  handle: () => handle2,
-  name: () => name2,
-  schemaPath: () => schemaPath2
+  handle: () => handle3,
+  name: () => name3,
+  schemaPath: () => schemaPath3
 });
-var name2 = "gdd_decisions_list";
-var schemaPath2 = "../schemas/gdd_decisions_list.schema.json";
-async function handle2(input) {
+var name3 = "gdd_decisions_list";
+var schemaPath3 = "../schemas/gdd_decisions_list.schema.json";
+async function handle3(input) {
   try {
     const typed = input ?? {};
     const state = await read(resolveStatePath());
@@ -1580,9 +1893,9 @@ async function handle2(input) {
 // sdk/mcp/gdd-mcp/tools/gdd_events_tail.ts
 var gdd_events_tail_exports = {};
 __export(gdd_events_tail_exports, {
-  handle: () => handle3,
-  name: () => name3,
-  schemaPath: () => schemaPath3
+  handle: () => handle4,
+  name: () => name4,
+  schemaPath: () => schemaPath4
 });
 
 // sdk/event-stream/writer.ts
@@ -1663,9 +1976,9 @@ async function* readEvents(opts = {}) {
 }
 
 // sdk/mcp/gdd-mcp/tools/gdd_events_tail.ts
-var name3 = "gdd_events_tail";
-var schemaPath3 = "../schemas/gdd_events_tail.schema.json";
-async function handle3(input) {
+var name4 = "gdd_events_tail";
+var schemaPath4 = "../schemas/gdd_events_tail.schema.json";
+async function handle4(input) {
   try {
     const typed = input ?? {};
     const limit = typeof typed.limit === "number" && typed.limit > 0 ? typed.limit : 50;
@@ -1685,14 +1998,14 @@ async function handle3(input) {
 // sdk/mcp/gdd-mcp/tools/gdd_health.ts
 var gdd_health_exports = {};
 __export(gdd_health_exports, {
-  handle: () => handle4,
-  name: () => name4,
-  schemaPath: () => schemaPath4
+  handle: () => handle5,
+  name: () => name5,
+  schemaPath: () => schemaPath5
 });
 var import_health_mirror = __toESM(require_health_mirror());
-var name4 = "gdd_health";
-var schemaPath4 = "../schemas/gdd_health.schema.json";
-async function handle4(_input) {
+var name5 = "gdd_health";
+var schemaPath5 = "../schemas/gdd_health.schema.json";
+async function handle5(_input) {
   try {
     const result = await (0, import_health_mirror.getHealthChecks)(resolveProjectRoot());
     return okResponse({ checks: result.checks });
@@ -1704,14 +2017,14 @@ async function handle4(_input) {
 // sdk/mcp/gdd-mcp/tools/gdd_intel_get.ts
 var gdd_intel_get_exports = {};
 __export(gdd_intel_get_exports, {
-  handle: () => handle5,
-  name: () => name5,
-  schemaPath: () => schemaPath5
+  handle: () => handle6,
+  name: () => name6,
+  schemaPath: () => schemaPath6
 });
 var import_intel_store = __toESM(require_intel_store());
-var name5 = "gdd_intel_get";
-var schemaPath5 = "../schemas/gdd_intel_get.schema.json";
-async function handle5(input) {
+var name6 = "gdd_intel_get";
+var schemaPath6 = "../schemas/gdd_intel_get.schema.json";
+async function handle6(input) {
   try {
     const typed = input ?? {};
     if (typeof typed.slice_id !== "string" || typed.slice_id.length === 0) {
@@ -1733,14 +2046,14 @@ async function handle5(input) {
 // sdk/mcp/gdd-mcp/tools/gdd_learnings_digest.ts
 var gdd_learnings_digest_exports = {};
 __export(gdd_learnings_digest_exports, {
-  handle: () => handle6,
-  name: () => name6,
-  schemaPath: () => schemaPath6
+  handle: () => handle7,
+  name: () => name7,
+  schemaPath: () => schemaPath7
 });
 var import_reflections_reader = __toESM(require_reflections_reader());
-var name6 = "gdd_learnings_digest";
-var schemaPath6 = "../schemas/gdd_learnings_digest.schema.json";
-async function handle6(input) {
+var name7 = "gdd_learnings_digest";
+var schemaPath7 = "../schemas/gdd_learnings_digest.schema.json";
+async function handle7(input) {
   try {
     const typed = input ?? {};
     const n = typeof typed.cycles === "number" && typed.cycles > 0 ? typed.cycles : 5;
@@ -1754,13 +2067,13 @@ async function handle6(input) {
 // sdk/mcp/gdd-mcp/tools/gdd_phase_current.ts
 var gdd_phase_current_exports = {};
 __export(gdd_phase_current_exports, {
-  handle: () => handle7,
-  name: () => name7,
-  schemaPath: () => schemaPath7
+  handle: () => handle8,
+  name: () => name8,
+  schemaPath: () => schemaPath8
 });
-var name7 = "gdd_phase_current";
-var schemaPath7 = "../schemas/gdd_phase_current.schema.json";
-async function handle7(_input) {
+var name8 = "gdd_phase_current";
+var schemaPath8 = "../schemas/gdd_phase_current.schema.json";
+async function handle8(_input) {
   try {
     const state = await read(resolveStatePath());
     const p = state.position;
@@ -1778,14 +2091,14 @@ async function handle7(_input) {
 // sdk/mcp/gdd-mcp/tools/gdd_phases_list.ts
 var gdd_phases_list_exports = {};
 __export(gdd_phases_list_exports, {
-  handle: () => handle8,
-  name: () => name8,
-  schemaPath: () => schemaPath8
+  handle: () => handle9,
+  name: () => name9,
+  schemaPath: () => schemaPath9
 });
 var import_roadmap_reader = __toESM(require_roadmap_reader());
-var name8 = "gdd_phases_list";
-var schemaPath8 = "../schemas/gdd_phases_list.schema.json";
-async function handle8(_input) {
+var name9 = "gdd_phases_list";
+var schemaPath9 = "../schemas/gdd_phases_list.schema.json";
+async function handle9(_input) {
   try {
     const md = await (0, import_roadmap_reader.readRoadmapMd)(resolveProjectRoot());
     return okResponse({ phases: (0, import_roadmap_reader.parsePhases)(md) });
@@ -1797,13 +2110,13 @@ async function handle8(_input) {
 // sdk/mcp/gdd-mcp/tools/gdd_plans_list.ts
 var gdd_plans_list_exports = {};
 __export(gdd_plans_list_exports, {
-  handle: () => handle9,
-  name: () => name9,
-  schemaPath: () => schemaPath9
+  handle: () => handle10,
+  name: () => name10,
+  schemaPath: () => schemaPath10
 });
-var name9 = "gdd_plans_list";
-var schemaPath9 = "../schemas/gdd_plans_list.schema.json";
-async function handle9(input) {
+var name10 = "gdd_plans_list";
+var schemaPath10 = "../schemas/gdd_plans_list.schema.json";
+async function handle10(input) {
   try {
     const typed = input ?? {};
     const state = await read(resolveStatePath());
@@ -1824,14 +2137,14 @@ async function handle9(input) {
 // sdk/mcp/gdd-mcp/tools/gdd_reflections_latest.ts
 var gdd_reflections_latest_exports = {};
 __export(gdd_reflections_latest_exports, {
-  handle: () => handle10,
-  name: () => name10,
-  schemaPath: () => schemaPath10
+  handle: () => handle11,
+  name: () => name11,
+  schemaPath: () => schemaPath11
 });
 var import_reflections_reader2 = __toESM(require_reflections_reader());
-var name10 = "gdd_reflections_latest";
-var schemaPath10 = "../schemas/gdd_reflections_latest.schema.json";
-async function handle10(_input) {
+var name11 = "gdd_reflections_latest";
+var schemaPath11 = "../schemas/gdd_reflections_latest.schema.json";
+async function handle11(_input) {
   try {
     const r = await (0, import_reflections_reader2.readLatestReflection)(resolveProjectRoot());
     if (r === null) return okResponse({ cycle: null, path: null, content_excerpt: "" });
@@ -1848,13 +2161,13 @@ async function handle10(_input) {
 // sdk/mcp/gdd-mcp/tools/gdd_status.ts
 var gdd_status_exports = {};
 __export(gdd_status_exports, {
-  handle: () => handle11,
-  name: () => name11,
-  schemaPath: () => schemaPath11
+  handle: () => handle12,
+  name: () => name12,
+  schemaPath: () => schemaPath12
 });
-var name11 = "gdd_status";
-var schemaPath11 = "../schemas/gdd_status.schema.json";
-async function handle11(_input) {
+var name12 = "gdd_status";
+var schemaPath12 = "../schemas/gdd_status.schema.json";
+async function handle12(_input) {
   try {
     const state = await read(resolveStatePath());
     const completed = (state.must_haves ?? []).filter((m) => m.status === "pass");
@@ -1873,13 +2186,13 @@ async function handle11(_input) {
 // sdk/mcp/gdd-mcp/tools/gdd_telemetry_query.ts
 var gdd_telemetry_query_exports = {};
 __export(gdd_telemetry_query_exports, {
-  handle: () => handle12,
-  name: () => name12,
-  schemaPath: () => schemaPath12
+  handle: () => handle13,
+  name: () => name13,
+  schemaPath: () => schemaPath13
 });
-var name12 = "gdd_telemetry_query";
-var schemaPath12 = "../schemas/gdd_telemetry_query.schema.json";
-async function handle12(input) {
+var name13 = "gdd_telemetry_query";
+var schemaPath13 = "../schemas/gdd_telemetry_query.schema.json";
+async function handle13(input) {
   try {
     const typed = input ?? {};
     const limit = typeof typed.limit === "number" && typed.limit > 0 ? typed.limit : 100;
@@ -1900,6 +2213,7 @@ async function handle12(input) {
 // sdk/mcp/gdd-mcp/tools/index.ts
 var TOOL_MODULES = [
   gdd_status_exports,
+  gdd_context_query_exports,
   gdd_cycle_recap_exports,
   gdd_decisions_list_exports,
   gdd_events_tail_exports,
@@ -1913,9 +2227,9 @@ var TOOL_MODULES = [
   gdd_telemetry_query_exports
 ];
 var TOOL_COUNT = TOOL_MODULES.length;
-if (TOOL_COUNT > 12) {
+if (TOOL_COUNT > 13) {
   throw new Error(
-    `gdd-mcp: TOOL_COUNT=${TOOL_COUNT} exceeds the 12-tool cap (D-03). Add tool past 12 requires re-scoping in a new plan.`
+    `gdd-mcp: TOOL_COUNT=${TOOL_COUNT} exceeds the 13-tool cap (D-03, raised from 12 in Phase 52). Adding a tool past 13 requires re-scoping in a new plan.`
   );
 }
 
@@ -1951,6 +2265,7 @@ function loadTools() {
 }
 var TOOL_DESCRIPTIONS = {
   gdd_status: "gdd_status: current cycle phase, branch, last-3 decisions, last-3 completed plans, blocker count.",
+  gdd_context_query: "gdd_context_query: read-only query over the DesignContext graph (.design/context-graph.json) \u2014 op one of nodes/edges/path/consumers-of/unreachable/cycles/coverage; structured no-graph result when absent.",
   gdd_phase_current: "gdd_phase_current: STATE.md <position> block (phase, stage, task_progress, status).",
   gdd_phases_list: "gdd_phases_list: parsed ROADMAP.md overview (phase number, name, target version, shipped/planned).",
   gdd_plans_list: "gdd_plans_list: plans tracked in STATE.md must_haves (optionally filtered by input.phase).",
@@ -1965,6 +2280,7 @@ var TOOL_DESCRIPTIONS = {
 };
 var TOOL_READONLY = {
   gdd_status: true,
+  gdd_context_query: true,
   gdd_phase_current: true,
   gdd_phases_list: true,
   gdd_plans_list: true,