@hegemonart/get-design-done 1.31.0 → 1.32.0

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

@@ -0,0 +1,1966 @@
+#!/usr/bin/env -S node --experimental-strip-types
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// scripts/lib/snapshot-reader/index.cjs
+var require_snapshot_reader = __commonJS({
+  "scripts/lib/snapshot-reader/index.cjs"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var SnapshotNotFoundError = class extends Error {
+      constructor(dir) {
+        super("source directory not found: " + dir);
+        this.name = "SnapshotNotFoundError";
+        this.code = "directory_not_found";
+        this.dir = dir;
+      }
+    };
+    async function readLatestSnapshot2(rootDir) {
+      const dir = path.join(rootDir, ".design", "snapshots");
+      if (!fs.existsSync(dir)) {
+        throw new SnapshotNotFoundError(dir);
+      }
+      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);
+        try {
+          const stat = await fs.promises.stat(full);
+          candidates.push({ full, mtime: stat.mtimeMs });
+        } catch {
+        }
+      }
+      if (candidates.length === 0) return null;
+      candidates.sort((a, b) => b.mtime - a.mtime);
+      const winner = candidates[0];
+      const body = await fs.promises.readFile(winner.full, "utf8");
+      let snapshot;
+      try {
+        snapshot = JSON.parse(body);
+      } catch (err) {
+        throw new Error(
+          "snapshot parse failed: " + winner.full + ": " + (err && err.message ? err.message : String(err))
+        );
+      }
+      const since = typeof snapshot.timestamp === "string" && snapshot.timestamp.length > 0 ? snapshot.timestamp : new Date(winner.mtime).toISOString();
+      return { since, snapshot };
+    }
+    module2.exports = { readLatestSnapshot: readLatestSnapshot2, SnapshotNotFoundError };
+  }
+});
+
+// scripts/lib/issue-reporter/kill-switch.cjs
+var require_kill_switch = __commonJS({
+  "scripts/lib/issue-reporter/kill-switch.cjs"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var ENV_KEY = "GDD_DISABLE_ISSUE_REPORTER";
+    var CONFIG_RELATIVE_PATH = path.join(".design", "config.json");
+    var CONFIG_FLAG_KEY = "issue_reporter";
+    function readConfigFlag(cwd) {
+      const configPath = path.join(cwd, CONFIG_RELATIVE_PATH);
+      let raw;
+      try {
+        raw = fs.readFileSync(configPath, "utf8");
+      } catch {
+        return null;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return null;
+      }
+      if (parsed == null || typeof parsed !== "object") {
+        return null;
+      }
+      const value = parsed[CONFIG_FLAG_KEY];
+      if (typeof value === "boolean") {
+        return value;
+      }
+      return null;
+    }
+    function isDisabled(opts) {
+      const o = opts || {};
+      const cwd = o.cwd || process.cwd();
+      const env = o.env || process.env;
+      if (env[ENV_KEY] === "1") return true;
+      if (readConfigFlag(cwd) === false) return true;
+      return false;
+    }
+    function getDisableReason(opts) {
+      const o = opts || {};
+      const cwd = o.cwd || process.cwd();
+      const env = o.env || process.env;
+      if (env[ENV_KEY] === "1") return "env";
+      if (readConfigFlag(cwd) === false) return "config";
+      return null;
+    }
+    module2.exports = {
+      isDisabled,
+      getDisableReason
+    };
+  }
+});
+
+// scripts/lib/health-mirror/index.cjs
+var require_health_mirror = __commonJS({
+  "scripts/lib/health-mirror/index.cjs"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var { getDisableReason } = require_kill_switch();
+    function fileExists(p) {
+      try {
+        return fs.statSync(p).isFile();
+      } catch {
+        return false;
+      }
+    }
+    function dirExists(p) {
+      try {
+        return fs.statSync(p).isDirectory();
+      } catch {
+        return false;
+      }
+    }
+    async function getHealthChecks2(rootDir) {
+      const checks = [];
+      {
+        const p = path.join(rootDir, "CLAUDE.md");
+        const present = fileExists(p);
+        checks.push({
+          name: "claude_md",
+          status: present ? "ok" : "warn",
+          detail: present ? p : "CLAUDE.md not found at project root"
+        });
+      }
+      {
+        const p = path.join(rootDir, ".planning");
+        const present = dirExists(p);
+        checks.push({
+          name: "planning_dir",
+          status: present ? "ok" : "warn",
+          detail: present ? p : ".planning/ not found at project root"
+        });
+      }
+      {
+        const p = path.join(rootDir, ".design");
+        const present = dirExists(p);
+        checks.push({
+          name: "design_dir",
+          status: present ? "ok" : "warn",
+          detail: present ? p : ".design/ not found at project root"
+        });
+      }
+      {
+        const p = path.join(rootDir, "package.json");
+        if (!fileExists(p)) {
+          checks.push({
+            name: "package_json",
+            status: "warn",
+            detail: "package.json not found at project root"
+          });
+        } else {
+          try {
+            const body = await fs.promises.readFile(p, "utf8");
+            const parsed = JSON.parse(body);
+            const name13 = 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
+            });
+          } catch (err) {
+            checks.push({
+              name: "package_json",
+              status: "fail",
+              detail: "parse error: " + (err && err.message ? err.message : String(err))
+            });
+          }
+        }
+      }
+      {
+        let reason = null;
+        try {
+          reason = getDisableReason({ cwd: rootDir, env: process.env });
+        } catch {
+          reason = null;
+        }
+        let detail;
+        if (reason === "env") {
+          detail = "issue reporter: disabled by env (GDD_DISABLE_ISSUE_REPORTER=1)";
+        } else if (reason === "config") {
+          detail = "issue reporter: disabled by config (.design/config.json: issue_reporter=false)";
+        } else {
+          detail = "issue reporter: enabled";
+        }
+        checks.push({
+          name: "issue_reporter",
+          status: "ok",
+          detail
+        });
+      }
+      {
+        const tokenSet = !!(process.env.FIGMA_TOKEN || process.env.FIGMA_PERSONAL_ACCESS_TOKEN);
+        let detail;
+        let status;
+        if (!tokenSet) {
+          detail = "figma extract: token missing";
+          status = "warn";
+        } else if (figmaVariablesBlockedLocally(rootDir)) {
+          detail = "figma extract: plugin sync needed for variables (Free tier detected)";
+          status = "warn";
+        } else {
+          detail = "figma extract: ready (token set)";
+          status = "ok";
+        }
+        checks.push({ name: "figma_extract", status, detail });
+      }
+      {
+        const skillPresent = fileExists(
+          path.join(rootDir, "skills", "using-gdd", "SKILL.md")
+        );
+        const hookWired = skillPresent && sessionStartWiresInject(rootDir);
+        let detail;
+        let status;
+        if (!skillPresent) {
+          detail = "skill-discipline: missing using-gdd";
+          status = "warn";
+        } else if (!hookWired) {
+          detail = "skill-discipline: hook not wired";
+          status = "warn";
+        } else {
+          detail = "skill-discipline: ready";
+          status = "ok";
+        }
+        checks.push({ name: "skill_discipline", status, detail });
+      }
+      return { checks };
+    }
+    function sessionStartWiresInject(rootDir) {
+      try {
+        const p = path.join(rootDir, "hooks", "hooks.json");
+        let hooks;
+        try {
+          hooks = JSON.parse(fs.readFileSync(p, "utf8"));
+        } catch {
+          return false;
+        }
+        const sessionStart = hooks && hooks.hooks && Array.isArray(hooks.hooks.SessionStart) ? hooks.hooks.SessionStart : [];
+        for (const entry of sessionStart) {
+          const inner = entry && Array.isArray(entry.hooks) ? entry.hooks : [];
+          for (const h of inner) {
+            if (h && typeof h.command === "string" && /inject-using-gdd/.test(h.command)) {
+              return true;
+            }
+          }
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    }
+    function figmaVariablesBlockedLocally(rootDir) {
+      try {
+        const rawRoot = path.join(rootDir, ".figma-extract-cache", "raw");
+        let entries;
+        try {
+          entries = fs.readdirSync(rawRoot, { withFileTypes: true });
+        } catch {
+          return false;
+        }
+        for (const ent of entries) {
+          if (!ent.isDirectory()) continue;
+          const metaPath = path.join(rawRoot, ent.name, "_meta.json");
+          let meta;
+          try {
+            meta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
+          } catch {
+            continue;
+          }
+          const totals = meta && Array.isArray(meta.totals) ? meta.totals : [];
+          const blocked = totals.some(
+            (t) => t && t.name === "variables" && t.skipped === true && typeof t.reason === "string" && /403/.test(t.reason)
+          );
+          if (blocked) return true;
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    }
+    module2.exports = { getHealthChecks: getHealthChecks2 };
+  }
+});
+
+// scripts/lib/intel-store/index.cjs
+var require_intel_store = __commonJS({
+  "scripts/lib/intel-store/index.cjs"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var IntelNotFoundError = class extends Error {
+      constructor(dir) {
+        super("source directory not found: " + dir);
+        this.name = "IntelNotFoundError";
+        this.code = "directory_not_found";
+        this.dir = dir;
+      }
+    };
+    async function readSlice2(rootDir, sliceId) {
+      const dir = path.join(rootDir, ".design", "intel");
+      if (!fs.existsSync(dir)) {
+        throw new IntelNotFoundError(dir);
+      }
+      const file = path.join(dir, sliceId + ".json");
+      if (!fs.existsSync(file)) return null;
+      const body = await fs.promises.readFile(file, "utf8");
+      return JSON.parse(body);
+    }
+    function listSlices(rootDir) {
+      const dir = path.join(rootDir, ".design", "intel");
+      if (!fs.existsSync(dir)) {
+        throw new IntelNotFoundError(dir);
+      }
+      const entries = fs.readdirSync(dir);
+      const ids = [];
+      for (const name13 of entries) {
+        if (!name13.endsWith(".json")) continue;
+        ids.push(name13.slice(0, -".json".length));
+      }
+      return ids;
+    }
+    module2.exports = { readSlice: readSlice2, listSlices, IntelNotFoundError };
+  }
+});
+
+// scripts/lib/reflections-reader/index.cjs
+var require_reflections_reader = __commonJS({
+  "scripts/lib/reflections-reader/index.cjs"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    var DIGEST_CAP_BYTES = 5120;
+    var ReflectionsNotFoundError = class extends Error {
+      constructor(dir) {
+        super("source directory not found: " + dir);
+        this.name = "ReflectionsNotFoundError";
+        this.code = "directory_not_found";
+        this.dir = dir;
+      }
+    };
+    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);
+        try {
+          const stat = await fs.promises.stat(full);
+          candidates.push({ name: name13, 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);
+      if (m) return m[0];
+      return name13.replace(/\.md$/, "");
+    }
+    async function readLatestReflection2(rootDir) {
+      const dir = path.join(rootDir, ".design", "reflections");
+      if (!fs.existsSync(dir)) {
+        throw new ReflectionsNotFoundError(dir);
+      }
+      const files = await listReflectionFiles(dir);
+      if (files.length === 0) return null;
+      const f = files[0];
+      const content = await fs.promises.readFile(f.full, "utf8");
+      return { cycle: extractCycle(f.name), path: f.full, content };
+    }
+    async function readNReflections2(rootDir, n) {
+      const dir = path.join(rootDir, ".design", "reflections");
+      if (!fs.existsSync(dir)) {
+        throw new ReflectionsNotFoundError(dir);
+      }
+      const files = await listReflectionFiles(dir);
+      const take = Math.max(0, Math.min(n, files.length));
+      const out = [];
+      for (let i = 0; i < take; i++) {
+        const f = files[i];
+        const content = await fs.promises.readFile(f.full, "utf8");
+        out.push({ cycle: extractCycle(f.name), path: f.full, content });
+      }
+      return out;
+    }
+    function digestReflections2(reflections) {
+      const parts = [];
+      for (const r of reflections) {
+        let body = r.content;
+        if (body.startsWith("---")) {
+          const closing = body.indexOf("\n---", 3);
+          if (closing !== -1) body = body.slice(closing + 4).trim();
+        }
+        const excerpt = body.slice(0, 300).trim();
+        parts.push("[" + r.cycle + "] " + excerpt);
+      }
+      let joined = parts.join("\n---\n");
+      if (joined.length > DIGEST_CAP_BYTES) {
+        joined = joined.slice(0, DIGEST_CAP_BYTES);
+      }
+      return joined;
+    }
+    module2.exports = {
+      readLatestReflection: readLatestReflection2,
+      readNReflections: readNReflections2,
+      digestReflections: digestReflections2,
+      ReflectionsNotFoundError
+    };
+  }
+});
+
+// scripts/lib/roadmap-reader/index.cjs
+var require_roadmap_reader = __commonJS({
+  "scripts/lib/roadmap-reader/index.cjs"(exports2, module2) {
+    "use strict";
+    var fs = require("node:fs");
+    var path = require("node:path");
+    async function readRoadmapMd2(rootDir) {
+      const p = path.join(rootDir, ".planning", "ROADMAP.md");
+      return fs.promises.readFile(p, "utf8");
+    }
+    function parsePhases2(md) {
+      const statusMap = /* @__PURE__ */ new Map();
+      const overviewRe = /^-\s+\[([x\s])\]\s+\[Phase\s+(\S+?)\]/gm;
+      let mm;
+      while ((mm = overviewRe.exec(md)) !== null) {
+        const checked = mm[1] === "x";
+        statusMap.set(mm[2], checked ? "shipped" : "planned");
+      }
+      const headingRe = /^###\s+Phase\s+(\S+?):\s+([^\n]+?)$/gm;
+      const phases = [];
+      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 version = inlineVer ? inlineVer[1] : "";
+        if (inlineVer) {
+          name13 = name13.slice(0, inlineVer.index).trim();
+        }
+        if (version === "") {
+          const after = md.slice(h.index, h.index + 2e3);
+          const v = after.match(/\*\*Target version\*\*:\s*(v\d+\.\d+(?:\.\d+)?)/);
+          if (v) version = v[1];
+        }
+        phases.push({
+          number,
+          name: name13,
+          version,
+          checkbox_status: statusMap.get(number) ?? "unknown"
+        });
+      }
+      return phases;
+    }
+    module2.exports = { readRoadmapMd: readRoadmapMd2, parsePhases: parsePhases2 };
+  }
+});
+
+// sdk/mcp/gdd-mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  SERVER_NAME: () => SERVER_NAME,
+  SERVER_VERSION: () => SERVER_VERSION,
+  TOOL_DESCRIPTIONS: () => TOOL_DESCRIPTIONS,
+  TOOL_READONLY: () => TOOL_READONLY,
+  buildServer: () => buildServer,
+  runStdio: () => runStdio
+});
+module.exports = __toCommonJS(server_exports);
+var import_node_fs5 = require("node:fs");
+var import_node_path4 = require("node:path");
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_types6 = require("@modelcontextprotocol/sdk/types.js");
+
+// sdk/errors/index.ts
+var GDDError = class extends Error {
+  code;
+  context;
+  constructor(message, code, context = {}) {
+    super(message);
+    this.code = code;
+    this.context = Object.freeze({ ...context });
+    this.name = new.target.name;
+  }
+  /**
+   * Serialize to a plain object safe for JSON.stringify. Round-trips
+   * through JSON without loss of `name`, `kind`, `code`, `message`, or
+   * `context`. Does NOT include the stack trace — MCP tool handlers do
+   * not forward stacks to the model.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      kind: this.kind,
+      code: this.code,
+      message: this.message,
+      context: this.context
+    };
+  }
+};
+var ValidationError = class extends GDDError {
+  kind = "validation";
+  constructor(message, code = "VALIDATION", context) {
+    super(message, code, context);
+  }
+};
+var StateConflictError = class extends GDDError {
+  kind = "state_conflict";
+  constructor(message, code = "STATE_CONFLICT", context) {
+    super(message, code, context);
+  }
+};
+var OperationFailedError = class extends GDDError {
+  kind = "operation_failed";
+  constructor(message, code = "OPERATION_FAILED", context) {
+    super(message, code, context);
+  }
+};
+var ParseError = class extends ValidationError {
+  line;
+  constructor(message, line, context) {
+    super(
+      `STATE.md parse error at line ${line}: ${message}`,
+      "PARSE_ERROR",
+      { ...context, line }
+    );
+    this.line = line;
+  }
+};
+
+// sdk/errors/classification.ts
+function classify(err) {
+  if (err instanceof ValidationError) {
+    return {
+      kind: "validation",
+      shouldThrow: true,
+      retryable: false,
+      code: err.code,
+      message: err.message
+    };
+  }
+  if (err instanceof StateConflictError) {
+    return {
+      kind: "state_conflict",
+      shouldThrow: true,
+      retryable: true,
+      code: err.code,
+      message: err.message
+    };
+  }
+  if (err instanceof OperationFailedError) {
+    return {
+      kind: "operation_failed",
+      shouldThrow: false,
+      retryable: false,
+      code: err.code,
+      message: err.message
+    };
+  }
+  if (err instanceof Error) {
+    return {
+      kind: "unknown",
+      shouldThrow: true,
+      retryable: false,
+      code: "UNKNOWN",
+      message: err.message
+    };
+  }
+  return {
+    kind: "unknown",
+    shouldThrow: true,
+    retryable: false,
+    code: "UNKNOWN",
+    message: String(err)
+  };
+}
+function toToolError(err) {
+  const c = classify(err);
+  const out = {
+    error: {
+      code: c.code,
+      message: c.message,
+      kind: c.kind
+    }
+  };
+  if (err instanceof GDDError) {
+    out.error.context = err.context;
+  }
+  return out;
+}
+
+// sdk/mcp/gdd-mcp/tools/gdd_cycle_recap.ts
+var gdd_cycle_recap_exports = {};
+__export(gdd_cycle_recap_exports, {
+  handle: () => handle,
+  name: () => name,
+  schemaPath: () => schemaPath
+});
+
+// sdk/state/index.ts
+var import_node_fs = require("node:fs");
+
+// sdk/state/types.ts
+function isConnectionStatus(value) {
+  return value === "available" || value === "unavailable" || value === "not_configured";
+}
+function isDecisionStatus(value) {
+  return value === "locked" || value === "tentative";
+}
+function isMustHaveStatus(value) {
+  return value === "pending" || value === "pass" || value === "fail";
+}
+function isSpikeVerdict(value) {
+  return value === "yes" || value === "no" || value === "partial";
+}
+function isPrototypingEntryStatus(value) {
+  return value === "resolved";
+}
+function isQualityGateStatus(value) {
+  return value === "pass" || value === "fail" || value === "timeout" || value === "skipped";
+}
+
+// sdk/state/parser.ts
+var BLOCK_ORDER = [
+  "position",
+  "decisions",
+  "must_haves",
+  "prototyping",
+  "quality_gate",
+  "connections",
+  "blockers",
+  "parallelism_decision",
+  "todos",
+  "timestamps"
+];
+var EMPTY_RAW_BODIES = {
+  position: null,
+  decisions: null,
+  must_haves: null,
+  prototyping: null,
+  quality_gate: null,
+  connections: null,
+  blockers: null,
+  parallelism_decision: null,
+  todos: null,
+  timestamps: null
+};
+function parse(raw) {
+  const line_ending = raw.includes("\r\n") ? "\r\n" : "\n";
+  const normalized = line_ending === "\r\n" ? raw.replace(/\r\n/g, "\n") : raw;
+  const trailing_newline = normalized.endsWith("\n");
+  if (!normalized.startsWith("---\n")) {
+    throw new ParseError('file must begin with "---" frontmatter fence', 1);
+  }
+  const fmEnd = normalized.indexOf("\n---\n", 4);
+  if (fmEnd === -1) {
+    throw new ParseError('unterminated frontmatter (missing closing "---")', 1);
+  }
+  const fmText = normalized.slice(4, fmEnd);
+  const frontmatter = parseFrontmatter(fmText);
+  const afterFm = fmEnd + 5;
+  const body = normalized.slice(afterFm);
+  const lines = body.split("\n");
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  const blockOpen = /^<([a-z_]+)>\s*$/;
+  const blockClose = /^<\/([a-z_]+)>\s*$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const openMatch = line.match(blockOpen);
+    if (!openMatch) continue;
+    const name13 = openMatch[1];
+    if (!BLOCK_ORDER.includes(name13)) {
+      continue;
+    }
+    if (seen.has(name13)) {
+      throw new ParseError(`duplicate block <${name13}>`, 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) {
+        close = j;
+        break;
+      }
+    }
+    if (close === -1) {
+      throw new ParseError(
+        `unterminated block <${name13}> (no </${name13}>)`,
+        lineToFileLine(afterFm, normalized, i)
+      );
+    }
+    blocks.push({ name: name13, openLine: i, closeLine: close });
+    seen.add(name13);
+    i = close;
+  }
+  let body_preamble;
+  let body_trailer;
+  const block_gaps = {
+    position: "",
+    decisions: "",
+    must_haves: "",
+    prototyping: "",
+    quality_gate: "",
+    connections: "",
+    blockers: "",
+    parallelism_decision: "",
+    todos: "",
+    timestamps: ""
+  };
+  if (blocks.length === 0) {
+    body_preamble = body;
+    body_trailer = "";
+  } else {
+    const firstBlock = blocks[0];
+    const lastBlock = blocks[blocks.length - 1];
+    if (firstBlock === void 0 || lastBlock === void 0) {
+      throw new ParseError("internal: block index inconsistency", 1);
+    }
+    body_preamble = lines.slice(0, firstBlock.openLine).join("\n");
+    if (firstBlock.openLine > 0) body_preamble += "\n";
+    body_trailer = lines.slice(lastBlock.closeLine + 1).join("\n");
+    for (let bi = 0; bi < blocks.length; bi++) {
+      const cur = blocks[bi];
+      if (cur === void 0) continue;
+      if (bi === 0) {
+        block_gaps[cur.name] = body_preamble;
+      } else {
+        const prev = blocks[bi - 1];
+        if (prev === void 0) continue;
+        const gapLines = lines.slice(prev.closeLine + 1, cur.openLine);
+        let gap = gapLines.join("\n");
+        if (cur.openLine > prev.closeLine + 1) gap += "\n";
+        block_gaps[cur.name] = gap;
+      }
+    }
+  }
+  const raw_bodies = { ...EMPTY_RAW_BODIES };
+  let position = null;
+  let decisions = [];
+  let must_haves = [];
+  let connections = {};
+  let blockers = [];
+  let parallelism_decision = null;
+  let todos = null;
+  let prototyping = null;
+  let quality_gate = null;
+  let timestamps = {};
+  for (const blk of blocks) {
+    const rawBody = lines.slice(blk.openLine + 1, blk.closeLine).join("\n");
+    raw_bodies[blk.name] = rawBody;
+    const fileLineOfBody = lineToFileLine(afterFm, normalized, blk.openLine + 1);
+    switch (blk.name) {
+      case "position":
+        position = parsePositionBody(rawBody, fileLineOfBody);
+        break;
+      case "decisions":
+        decisions = parseDecisionsBody(rawBody, fileLineOfBody);
+        break;
+      case "must_haves":
+        must_haves = parseMustHavesBody(rawBody, fileLineOfBody);
+        break;
+      case "prototyping":
+        prototyping = parsePrototypingBody(rawBody, fileLineOfBody);
+        break;
+      case "quality_gate":
+        quality_gate = parseQualityGateBody(rawBody, fileLineOfBody);
+        break;
+      case "connections":
+        connections = parseConnectionsBody(rawBody, fileLineOfBody);
+        break;
+      case "blockers":
+        blockers = parseBlockersBody(rawBody, fileLineOfBody);
+        break;
+      case "parallelism_decision":
+        parallelism_decision = rawBody;
+        break;
+      case "todos":
+        todos = rawBody;
+        break;
+      case "timestamps":
+        timestamps = parseTimestampsBody(rawBody, fileLineOfBody);
+        break;
+      default: {
+        const _exhaustive = blk.name;
+        void _exhaustive;
+      }
+    }
+  }
+  if (position === null) {
+    throw new ParseError(
+      "missing required <position> block (run scan to initialize STATE.md)",
+      1
+    );
+  }
+  const state = {
+    frontmatter,
+    position,
+    decisions,
+    must_haves,
+    connections,
+    blockers,
+    parallelism_decision,
+    todos,
+    prototyping,
+    quality_gate,
+    timestamps,
+    body_preamble,
+    body_trailer
+  };
+  return {
+    state,
+    raw_bodies,
+    raw_frontmatter: fmText,
+    block_gaps,
+    line_ending,
+    trailing_newline
+  };
+}
+function lineToFileLine(bodyStartOffset, normalized, bodyLineIdx) {
+  const prefix = normalized.slice(0, bodyStartOffset);
+  const prefixLines = prefix.split("\n").length - 1;
+  return prefixLines + bodyLineIdx + 1;
+}
+function parseFrontmatter(raw) {
+  const out = {};
+  const lines = raw.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key === "wave") {
+      const n = Number(value);
+      out[key] = Number.isFinite(n) ? n : value;
+    } else {
+      out[key] = value;
+    }
+  }
+  const fm = {
+    pipeline_state_version: String(out["pipeline_state_version"] ?? "1.0"),
+    stage: String(out["stage"] ?? ""),
+    cycle: String(out["cycle"] ?? ""),
+    wave: typeof out["wave"] === "number" ? out["wave"] : 1,
+    started_at: String(out["started_at"] ?? ""),
+    last_checkpoint: String(out["last_checkpoint"] ?? "")
+  };
+  for (const [k, v] of Object.entries(out)) {
+    if (!(k in fm)) fm[k] = v;
+  }
+  return fm;
+}
+function parsePositionBody(body, startLine) {
+  const fields = {};
+  const lines = body.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("<!--")) continue;
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    let value = line.slice(idx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    fields[key] = value;
+  }
+  const stage = fields["stage"] ?? "";
+  const waveRaw = fields["wave"] ?? "1";
+  const waveNum = Number(waveRaw);
+  if (!Number.isFinite(waveNum)) {
+    throw new ParseError(`<position> wave not numeric: ${waveRaw}`, startLine);
+  }
+  return {
+    stage,
+    wave: waveNum,
+    task_progress: fields["task_progress"] ?? "0/0",
+    status: fields["status"] ?? "initialized",
+    handoff_source: fields["handoff_source"] ?? "",
+    handoff_path: fields["handoff_path"] ?? "",
+    skipped_stages: fields["skipped_stages"] ?? ""
+  };
+}
+function parseDecisionsBody(body, startLine) {
+  const out = [];
+  const lines = body.split("\n");
+  const re = /^(D-\d+):\s*(.*?)\s*\((locked|tentative)\)\s*$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] ?? "").trim();
+    if (line === "" || line.startsWith("<!--")) continue;
+    const m = line.match(re);
+    if (!m) {
+      continue;
+    }
+    const id = m[1] ?? "";
+    const text = m[2] ?? "";
+    const status = m[3];
+    if (!isDecisionStatus(status)) {
+      throw new ParseError(
+        `<decisions> invalid status for ${id}: ${status}`,
+        startLine + i
+      );
+    }
+    out.push({ id, text, status });
+  }
+  return out;
+}
+function parseMustHavesBody(body, startLine) {
+  const out = [];
+  const lines = body.split("\n");
+  const re = /^(M-\d+):\s*(.*?)\s*\|\s*status:\s*(pending|pass|fail)\s*$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] ?? "").trim();
+    if (line === "" || line.startsWith("<!--")) continue;
+    const m = line.match(re);
+    if (!m) continue;
+    const id = m[1] ?? "";
+    const text = m[2] ?? "";
+    const status = m[3];
+    if (!isMustHaveStatus(status)) {
+      throw new ParseError(
+        `<must_haves> invalid status for ${id}: ${status}`,
+        startLine + i
+      );
+    }
+    out.push({ id, text, status });
+  }
+  return out;
+}
+function parseConnectionsBody(body, startLine) {
+  const out = {};
+  const lines = body.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("<!--")) continue;
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (!isConnectionStatus(value)) {
+      throw new ParseError(
+        `<connections> invalid status for ${key}: ${value}`,
+        startLine + i
+      );
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function parseBlockersBody(body, startLine) {
+  const out = [];
+  const lines = body.split("\n");
+  const re = /^\[([^\]]+)\]\s*\[([^\]]+)\]:\s*(.*)$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] ?? "").trim();
+    if (line === "" || line.startsWith("<!--")) continue;
+    const m = line.match(re);
+    if (!m) {
+      throw new ParseError(
+        `<blockers> malformed line: "${line}"`,
+        startLine + i
+      );
+    }
+    out.push({ stage: m[1] ?? "", date: m[2] ?? "", text: m[3] ?? "" });
+  }
+  return out;
+}
+function parsePrototypingBody(body, startLine) {
+  const sketches = [];
+  const spikes = [];
+  const skipped = [];
+  const lines = body.split("\n");
+  const selfClose = /^<([a-z_]+)(\s+[^>]*?)?\s*\/>\s*$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] ?? "").trim();
+    if (line === "" || line.startsWith("<!--")) continue;
+    const m = line.match(selfClose);
+    if (!m) {
+      continue;
+    }
+    const tag = m[1] ?? "";
+    const attrs = parsePrototypingAttrs(m[2] ?? "");
+    const fileLine = startLine + i;
+    if (tag === "sketch") {
+      sketches.push(buildSketchEntry(attrs, fileLine));
+    } else if (tag === "spike") {
+      spikes.push(buildSpikeEntry(attrs, fileLine));
+    } else if (tag === "skipped") {
+      skipped.push(buildSkippedEntry(attrs, fileLine));
+    }
+  }
+  return { sketches, spikes, skipped };
+}
+function parsePrototypingAttrs(span) {
+  const out = {};
+  const re = /([a-zA-Z_][\w-]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s/>]+))/g;
+  let m;
+  while ((m = re.exec(span)) !== null) {
+    const key = m[1] ?? "";
+    const value = (m[2] !== void 0 ? m[2] : void 0) ?? (m[3] !== void 0 ? m[3] : void 0) ?? m[4] ?? "";
+    if (key !== "") out[key] = value;
+  }
+  return out;
+}
+function buildSketchEntry(attrs, fileLine) {
+  const slug = attrs["slug"];
+  const cycle = attrs["cycle"];
+  const decision = attrs["decision"];
+  const status = attrs["status"] ?? "resolved";
+  if (slug === void 0) {
+    throw new ParseError("<sketch/> missing required attribute slug", fileLine);
+  }
+  if (cycle === void 0) {
+    throw new ParseError("<sketch/> missing required attribute cycle", fileLine);
+  }
+  if (decision === void 0) {
+    throw new ParseError(
+      "<sketch/> missing required attribute decision",
+      fileLine
+    );
+  }
+  if (!isPrototypingEntryStatus(status)) {
+    throw new ParseError(
+      `<sketch/> invalid status: ${status}`,
+      fileLine
+    );
+  }
+  return {
+    slug,
+    cycle,
+    decision,
+    status,
+    extra_attrs: extractExtraAttrs(attrs, ["slug", "cycle", "decision", "status"])
+  };
+}
+function buildSpikeEntry(attrs, fileLine) {
+  const slug = attrs["slug"];
+  const cycle = attrs["cycle"];
+  const decision = attrs["decision"];
+  const verdict = attrs["verdict"];
+  const status = attrs["status"] ?? "resolved";
+  if (slug === void 0) {
+    throw new ParseError("<spike/> missing required attribute slug", fileLine);
+  }
+  if (cycle === void 0) {
+    throw new ParseError("<spike/> missing required attribute cycle", fileLine);
+  }
+  if (decision === void 0) {
+    throw new ParseError(
+      "<spike/> missing required attribute decision",
+      fileLine
+    );
+  }
+  if (verdict === void 0) {
+    throw new ParseError(
+      "<spike/> missing required attribute verdict",
+      fileLine
+    );
+  }
+  if (!isSpikeVerdict(verdict)) {
+    throw new ParseError(
+      `<spike/> invalid verdict: ${verdict}`,
+      fileLine
+    );
+  }
+  if (!isPrototypingEntryStatus(status)) {
+    throw new ParseError(
+      `<spike/> invalid status: ${status}`,
+      fileLine
+    );
+  }
+  return {
+    slug,
+    cycle,
+    decision,
+    verdict,
+    status,
+    extra_attrs: extractExtraAttrs(attrs, [
+      "slug",
+      "cycle",
+      "decision",
+      "verdict",
+      "status"
+    ])
+  };
+}
+function buildSkippedEntry(attrs, fileLine) {
+  const at = attrs["at"];
+  const cycle = attrs["cycle"];
+  const reason = attrs["reason"];
+  if (at === void 0) {
+    throw new ParseError("<skipped/> missing required attribute at", fileLine);
+  }
+  if (cycle === void 0) {
+    throw new ParseError(
+      "<skipped/> missing required attribute cycle",
+      fileLine
+    );
+  }
+  if (reason === void 0) {
+    throw new ParseError(
+      "<skipped/> missing required attribute reason",
+      fileLine
+    );
+  }
+  return {
+    at,
+    cycle,
+    reason,
+    extra_attrs: extractExtraAttrs(attrs, ["at", "cycle", "reason"])
+  };
+}
+function extractExtraAttrs(all, known) {
+  const out = {};
+  for (const [k, v] of Object.entries(all)) {
+    if (!known.includes(k)) out[k] = v;
+  }
+  return out;
+}
+function parseQualityGateBody(body, startLine) {
+  let run = null;
+  const lines = body.split("\n");
+  const selfClose = /^<([a-z_]+)(\s+[^>]*?)?\s*\/>\s*$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] ?? "").trim();
+    if (line === "" || line.startsWith("<!--")) continue;
+    const m = line.match(selfClose);
+    if (!m) {
+      continue;
+    }
+    const tag = m[1] ?? "";
+    if (tag !== "run") continue;
+    const attrs = parsePrototypingAttrs(m[2] ?? "");
+    run = buildQualityGateRun(attrs, startLine + i);
+  }
+  return { run };
+}
+function buildQualityGateRun(attrs, fileLine) {
+  const started_at = attrs["started_at"];
+  const completed_at = attrs["completed_at"];
+  const status = attrs["status"];
+  const iterationRaw = attrs["iteration"];
+  const commands_run = attrs["commands_run"];
+  if (started_at === void 0) {
+    throw new ParseError(
+      "<quality_gate> <run/> missing required attribute started_at",
+      fileLine
+    );
+  }
+  if (completed_at === void 0) {
+    throw new ParseError(
+      "<quality_gate> <run/> missing required attribute completed_at",
+      fileLine
+    );
+  }
+  if (status === void 0) {
+    throw new ParseError(
+      "<quality_gate> <run/> missing required attribute status",
+      fileLine
+    );
+  }
+  if (!isQualityGateStatus(status)) {
+    throw new ParseError(
+      `<quality_gate> <run/> invalid status: ${status}`,
+      fileLine
+    );
+  }
+  if (iterationRaw === void 0) {
+    throw new ParseError(
+      "<quality_gate> <run/> missing required attribute iteration",
+      fileLine
+    );
+  }
+  const iteration = Number(iterationRaw);
+  if (!Number.isFinite(iteration) || !Number.isInteger(iteration) || iteration < 0) {
+    throw new ParseError(
+      `<quality_gate> <run/> iteration not a non-negative integer: ${iterationRaw}`,
+      fileLine
+    );
+  }
+  if (commands_run === void 0) {
+    throw new ParseError(
+      "<quality_gate> <run/> missing required attribute commands_run",
+      fileLine
+    );
+  }
+  return {
+    started_at,
+    completed_at,
+    status,
+    iteration,
+    commands_run,
+    extra_attrs: extractExtraAttrs(attrs, [
+      "started_at",
+      "completed_at",
+      "status",
+      "iteration",
+      "commands_run"
+    ])
+  };
+}
+function parseTimestampsBody(body, _startLine) {
+  const out = {};
+  const lines = body.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("<!--")) continue;
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    out[key] = value;
+  }
+  return out;
+}
+
+// sdk/state/gates.ts
+var DESIGN_KEYWORDS = ["component", "token", "style", "copy", "layout"];
+function stageParity(state, expected) {
+  if (!state.position || typeof state.position.stage !== "string") {
+    return "position block missing or malformed";
+  }
+  if (!state.frontmatter || typeof state.frontmatter.stage !== "string") {
+    return "frontmatter stage missing or malformed";
+  }
+  if (state.position.stage !== expected) {
+    return `position.stage is "${state.position.stage}" \u2014 expected "${expected}"`;
+  }
+  if (state.frontmatter.stage !== expected) {
+    return `frontmatter.stage is "${state.frontmatter.stage}" \u2014 expected "${expected}"`;
+  }
+  return null;
+}
+var briefToExplore = (s) => {
+  const blockers = [];
+  const parity = stageParity(s, "brief");
+  if (parity) blockers.push(parity);
+  return { pass: blockers.length === 0, blockers };
+};
+var exploreToPlan = (s) => {
+  const blockers = [];
+  const parity = stageParity(s, "explore");
+  if (parity) blockers.push(parity);
+  const connKeys = Object.keys(s.connections ?? {});
+  if (connKeys.length === 0) {
+    blockers.push(
+      "connections map is empty \u2014 run the explore-stage probe before advancing"
+    );
+  }
+  return { pass: blockers.length === 0, blockers };
+};
+var planToDesign = (s) => {
+  const blockers = [];
+  const parity = stageParity(s, "plan");
+  if (parity) blockers.push(parity);
+  if ((s.must_haves ?? []).length === 0) {
+    blockers.push("must_haves is empty \u2014 discover stage must land at least M-01");
+  }
+  const hasLocked = (s.decisions ?? []).some((d) => d.status === "locked");
+  if (!hasLocked) {
+    blockers.push("no locked decision in <decisions> \u2014 at least one must be locked");
+  }
+  const failing = (s.must_haves ?? []).filter((m) => m.status === "fail");
+  for (const mh of failing) {
+    const reconciled = (s.decisions ?? []).some((d) => d.text.includes(mh.id));
+    if (!reconciled) {
+      blockers.push(`${mh.id} marked fail without a decision to reconcile`);
+    }
+  }
+  return { pass: blockers.length === 0, blockers };
+};
+var designToVerify = (s) => {
+  const blockers = [];
+  const parity = stageParity(s, "design");
+  if (parity) blockers.push(parity);
+  const pending = (s.must_haves ?? []).filter((m) => m.status === "pending");
+  for (const mh of pending) {
+    const lower = mh.text.toLowerCase();
+    const hit = DESIGN_KEYWORDS.find((kw) => lower.includes(kw));
+    if (hit) {
+      blockers.push(
+        `${mh.id} is pending and mentions "${hit}" \u2014 resolve in design before verify`
+      );
+    }
+  }
+  return { pass: blockers.length === 0, blockers };
+};
+var GATES = Object.freeze({
+  briefToExplore,
+  exploreToPlan,
+  planToDesign,
+  designToVerify
+});
+
+// sdk/state/index.ts
+async function read(path) {
+  const raw = (0, import_node_fs.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";
+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) {
+  try {
+    const snap = await (0, import_snapshot_reader.readLatestSnapshot)(resolveProjectRoot());
+    const state = await read(resolveStatePath());
+    if (snap === null) return okResponse({ since: null, diff: { state_sections: [], decisions_delta: 0, completed_plans_delta: 0 } });
+    const decisionsNow = (state.decisions ?? []).length;
+    const completedNow = (state.must_haves ?? []).filter((m) => m.status === "pass").length;
+    return okResponse({
+      since: snap.since,
+      diff: {
+        state_sections: Object.keys(state),
+        decisions_delta: decisionsNow - snapCount(snap.snapshot, "decisions_count", "last_n_decisions"),
+        completed_plans_delta: completedNow - snapCount(snap.snapshot, "completed_plans_count", "_unused")
+      }
+    });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+var name2 = "gdd_decisions_list";
+var schemaPath2 = "../schemas/gdd_decisions_list.schema.json";
+async function handle2(input) {
+  try {
+    const typed = input ?? {};
+    const state = await read(resolveStatePath());
+    let decisions = state.decisions ?? [];
+    if (typeof typed.status === "string" && typed.status.length > 0) {
+      decisions = decisions.filter((d) => d.status === typed.status);
+    }
+    return okResponse({ decisions });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+
+// sdk/event-stream/writer.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path2 = require("node:path");
+var import_node_module = require("node:module");
+function _findRepoRoot() {
+  let dir = process.cwd();
+  for (let i = 0; i < 8; i++) {
+    if ((0, import_node_fs3.existsSync)((0, import_node_path2.join)(dir, "package.json"))) return dir;
+    const parent = (0, import_node_path2.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+var _redact;
+try {
+  const _root = _findRepoRoot();
+  const _candidate = (0, import_node_path2.resolve)(_root, "scripts/lib/redact.cjs");
+  if ((0, import_node_fs3.existsSync)(_candidate)) {
+    const _redactRequire = (0, import_node_module.createRequire)((0, import_node_path2.join)(_root, "package.json"));
+    const _mod = _redactRequire(_candidate);
+    _redact = _mod.redact;
+  } else {
+    const _altRoot = (0, import_node_path2.resolve)(_root, "..", "..");
+    const _altCandidate = (0, import_node_path2.resolve)(_altRoot, "scripts/lib/redact.cjs");
+    if ((0, import_node_fs3.existsSync)(_altCandidate)) {
+      const _altRequire = (0, import_node_module.createRequire)((0, import_node_path2.join)(_altRoot, "package.json"));
+      const _altMod = _altRequire(_altCandidate);
+      _redact = _altMod.redact;
+    } else {
+      _redact = (v) => v;
+    }
+  }
+} catch {
+  _redact = (v) => v;
+}
+var DEFAULT_EVENTS_PATH = ".design/telemetry/events.jsonl";
+var DEFAULT_MAX_LINE_BYTES = 64 * 1024;
+
+// sdk/event-stream/reader.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_node_readline = require("node:readline");
+function resolveReadPath(opts) {
+  const raw = opts.path ?? DEFAULT_EVENTS_PATH;
+  if ((0, import_node_path3.isAbsolute)(raw)) return raw;
+  return (0, import_node_path3.resolve)(opts.baseDir ?? process.cwd(), raw);
+}
+async function* readEvents(opts = {}) {
+  const path = resolveReadPath(opts);
+  if (!(0, import_node_fs4.existsSync)(path)) return;
+  const stream = (0, import_node_fs4.createReadStream)(path, { encoding: "utf8" });
+  const rl = (0, import_node_readline.createInterface)({ input: stream, crlfDelay: Infinity });
+  const typeRe = opts.type instanceof RegExp ? opts.type : null;
+  const typeStr = typeof opts.type === "string" ? opts.type : null;
+  try {
+    for await (const line of rl) {
+      if (line.trim() === "") continue;
+      let ev;
+      try {
+        ev = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (typeStr !== null && ev.type !== typeStr) continue;
+      if (typeRe !== null && !typeRe.test(ev.type)) continue;
+      if (opts.predicate && !opts.predicate(ev)) continue;
+      if (opts.since !== void 0 && ev.timestamp < opts.since) continue;
+      if (opts.until !== void 0 && ev.timestamp > opts.until) continue;
+      yield ev;
+    }
+  } finally {
+    rl.close();
+    stream.close();
+  }
+}
+
+// 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) {
+  try {
+    const typed = input ?? {};
+    const limit = typeof typed.limit === "number" && typed.limit > 0 ? typed.limit : 50;
+    const ring = [];
+    const opts = { path: resolveTelemetryDir() + "/events.jsonl" };
+    if (typeof typed.type === "string" && typed.type.length > 0) opts.type = typed.type;
+    for await (const ev of readEvents(opts)) {
+      ring.push(ev);
+      if (ring.length > limit) ring.shift();
+    }
+    return okResponse({ events: ring });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// sdk/mcp/gdd-mcp/tools/gdd_health.ts
+var gdd_health_exports = {};
+__export(gdd_health_exports, {
+  handle: () => handle4,
+  name: () => name4,
+  schemaPath: () => schemaPath4
+});
+var import_health_mirror = __toESM(require_health_mirror());
+var name4 = "gdd_health";
+var schemaPath4 = "../schemas/gdd_health.schema.json";
+async function handle4(_input) {
+  try {
+    const result = await (0, import_health_mirror.getHealthChecks)(resolveProjectRoot());
+    return okResponse({ checks: result.checks });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+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) {
+  try {
+    const typed = input ?? {};
+    if (typeof typed.slice_id !== "string" || typed.slice_id.length === 0) {
+      return errorResponse(new Error("slice_id is required"));
+    }
+    const data = await (0, import_intel_store.readSlice)(resolveProjectRoot(), typed.slice_id);
+    if (data === null) return errorResponse(new Error("slice not found: " + typed.slice_id));
+    if (Array.isArray(typed.shape) && typed.shape.length > 0 && typeof data === "object" && data !== null) {
+      const projected = {};
+      for (const k of typed.shape) if (k in data) projected[k] = data[k];
+      return okResponse({ slice_id: typed.slice_id, data: projected });
+    }
+    return okResponse({ slice_id: typed.slice_id, data });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+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) {
+  try {
+    const typed = input ?? {};
+    const n = typeof typed.cycles === "number" && typed.cycles > 0 ? typed.cycles : 5;
+    const refls = await (0, import_reflections_reader.readNReflections)(resolveProjectRoot(), n);
+    return okResponse({ digest: (0, import_reflections_reader.digestReflections)(refls), cycles_included: refls.length });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+var name7 = "gdd_phase_current";
+var schemaPath7 = "../schemas/gdd_phase_current.schema.json";
+async function handle7(_input) {
+  try {
+    const state = await read(resolveStatePath());
+    const p = state.position;
+    return okResponse({
+      phase: state.frontmatter.cycle ?? null,
+      stage: p?.stage ?? null,
+      task_progress: p?.task_progress ?? null,
+      status: p?.status ?? null
+    });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+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) {
+  try {
+    const md = await (0, import_roadmap_reader.readRoadmapMd)(resolveProjectRoot());
+    return okResponse({ phases: (0, import_roadmap_reader.parsePhases)(md) });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+var name9 = "gdd_plans_list";
+var schemaPath9 = "../schemas/gdd_plans_list.schema.json";
+async function handle9(input) {
+  try {
+    const typed = input ?? {};
+    const state = await read(resolveStatePath());
+    const plans = (state.must_haves ?? []).map((m) => ({
+      id: m.id,
+      name: m.text,
+      status: m.status
+    }));
+    return okResponse({
+      phase: typed.phase ?? state.frontmatter.cycle ?? null,
+      plans
+    });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+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) {
+  try {
+    const r = await (0, import_reflections_reader2.readLatestReflection)(resolveProjectRoot());
+    if (r === null) return okResponse({ cycle: null, path: null, content_excerpt: "" });
+    return okResponse({
+      cycle: r.cycle,
+      path: r.path,
+      content_excerpt: r.content.slice(0, 4096)
+    });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// sdk/mcp/gdd-mcp/tools/gdd_status.ts
+var gdd_status_exports = {};
+__export(gdd_status_exports, {
+  handle: () => handle11,
+  name: () => name11,
+  schemaPath: () => schemaPath11
+});
+var name11 = "gdd_status";
+var schemaPath11 = "../schemas/gdd_status.schema.json";
+async function handle11(_input) {
+  try {
+    const state = await read(resolveStatePath());
+    const completed = (state.must_haves ?? []).filter((m) => m.status === "pass");
+    return okResponse({
+      phase: state.frontmatter.cycle ?? null,
+      branch: process.env["GIT_BRANCH"] ?? null,
+      last_decisions: (state.decisions ?? []).slice(-3),
+      last_completed_plans: completed.slice(-3),
+      blocker_count: (state.blockers ?? []).length
+    });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// 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
+});
+var name12 = "gdd_telemetry_query";
+var schemaPath12 = "../schemas/gdd_telemetry_query.schema.json";
+async function handle12(input) {
+  try {
+    const typed = input ?? {};
+    const limit = typeof typed.limit === "number" && typed.limit > 0 ? typed.limit : 100;
+    const events = [];
+    const opts = { path: resolveTelemetryDir() + "/events.jsonl" };
+    if (typeof typed.type === "string" && typed.type.length > 0) opts.type = typed.type;
+    if (typeof typed.since === "string" && typed.since.length > 0) opts.since = typed.since;
+    for await (const ev of readEvents(opts)) {
+      events.push(ev);
+      if (events.length >= limit) break;
+    }
+    return okResponse({ events });
+  } catch (err) {
+    return errorResponse(err);
+  }
+}
+
+// sdk/mcp/gdd-mcp/tools/index.ts
+var TOOL_MODULES = [
+  gdd_status_exports,
+  gdd_cycle_recap_exports,
+  gdd_decisions_list_exports,
+  gdd_events_tail_exports,
+  gdd_health_exports,
+  gdd_intel_get_exports,
+  gdd_learnings_digest_exports,
+  gdd_phase_current_exports,
+  gdd_phases_list_exports,
+  gdd_plans_list_exports,
+  gdd_reflections_latest_exports,
+  gdd_telemetry_query_exports
+];
+var TOOL_COUNT = TOOL_MODULES.length;
+if (TOOL_COUNT > 12) {
+  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.`
+  );
+}
+
+// sdk/mcp/gdd-mcp/server.ts
+var SERVER_NAME = "gdd-mcp";
+var SERVER_VERSION = "1.27.7";
+function here() {
+  const expectedRel = (0, import_node_path4.join)("sdk", "mcp", "gdd-mcp");
+  const entry = process.argv[1];
+  if (typeof entry === "string" && entry.length > 0) {
+    const entryDir = (0, import_node_path4.dirname)((0, import_node_path4.resolve)(entry));
+    if ((0, import_node_fs5.existsSync)((0, import_node_path4.join)(entryDir, "tools", "index.ts"))) {
+      return entryDir;
+    }
+  }
+  const candidate = (0, import_node_path4.resolve)(process.cwd(), expectedRel);
+  if ((0, import_node_fs5.existsSync)((0, import_node_path4.join)(candidate, "tools", "index.ts"))) {
+    return candidate;
+  }
+  return candidate;
+}
+function loadTools() {
+  const baseDir = here();
+  return TOOL_MODULES.map((m) => {
+    const absPath = (0, import_node_path4.join)(baseDir, "tools", m.schemaPath);
+    const raw = (0, import_node_fs5.readFileSync)(absPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const rawInput = parsed.properties?.input;
+    const inputSchema = rawInput !== void 0 && typeof rawInput === "object" ? rawInput : { type: "object" };
+    if (!("type" in inputSchema)) inputSchema["type"] = "object";
+    return { ...m, inputSchema };
+  });
+}
+var TOOL_DESCRIPTIONS = {
+  gdd_status: "gdd_status: current cycle phase, branch, last-3 decisions, last-3 completed plans, blocker count.",
+  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).",
+  gdd_decisions_list: "gdd_decisions_list: decisions from STATE.md (optionally filtered by input.status).",
+  gdd_intel_get: "gdd_intel_get: read a slice from .design/intel/ (input.slice_id required); directory_not_found if absent.",
+  gdd_telemetry_query: "gdd_telemetry_query: typed reader over .design/telemetry/*.jsonl with type/since/limit filters.",
+  gdd_cycle_recap: "gdd_cycle_recap: diff current STATE against latest .design/snapshots/ snapshot; directory_not_found if absent.",
+  gdd_reflections_latest: "gdd_reflections_latest: newest .design/reflections/ file (excerpt <= 4 KB); directory_not_found if absent.",
+  gdd_learnings_digest: "gdd_learnings_digest: aggregate last N reflections into a compact digest (<= 5 KB).",
+  gdd_events_tail: "gdd_events_tail: last-N events from .design/telemetry/events.jsonl with optional type filter.",
+  gdd_health: "gdd_health: read-only mirror of gdd-health SKILL \u2014 4 checks (CLAUDE.md, .planning/, .design/, package.json)."
+};
+var TOOL_READONLY = {
+  gdd_status: true,
+  gdd_phase_current: true,
+  gdd_phases_list: true,
+  gdd_plans_list: true,
+  gdd_decisions_list: true,
+  gdd_intel_get: true,
+  gdd_telemetry_query: true,
+  gdd_cycle_recap: true,
+  gdd_reflections_latest: true,
+  gdd_learnings_digest: true,
+  gdd_events_tail: true,
+  gdd_health: true
+};
+function buildServer() {
+  const tools = loadTools();
+  const byName = /* @__PURE__ */ new Map();
+  for (const t of tools) byName.set(t.name, t);
+  const server = new import_server.Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    {
+      capabilities: { tools: {} }
+    }
+  );
+  server.setRequestHandler(import_types6.ListToolsRequestSchema, async () => {
+    return {
+      tools: tools.map((t) => {
+        const description = TOOL_DESCRIPTIONS[t.name] ?? t.name;
+        const readOnly = TOOL_READONLY[t.name] ?? true;
+        return {
+          name: t.name,
+          description,
+          inputSchema: t.inputSchema,
+          annotations: {
+            readOnlyHint: readOnly,
+            destructiveHint: !readOnly,
+            idempotentHint: false
+          }
+        };
+      })
+    };
+  });
+  server.setRequestHandler(import_types6.CallToolRequestSchema, async (req) => {
+    const { name: toolName, arguments: args } = req.params;
+    const tool = byName.get(toolName);
+    if (tool === void 0) {
+      const payload = toToolError(
+        new Error(`unknown tool: ${toolName}`)
+      );
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: false, error: payload.error })
+          }
+        ],
+        structuredContent: { success: false, error: payload.error }
+      };
+    }
+    let response;
+    try {
+      response = await tool.handle(args ?? {});
+    } catch (err) {
+      const payload = toToolError(err);
+      response = { success: false, error: payload.error };
+    }
+    const text = JSON.stringify(response);
+    if (response.success === true) {
+      return {
+        content: [{ type: "text", text }],
+        structuredContent: response
+      };
+    }
+    return {
+      isError: true,
+      content: [{ type: "text", text }],
+      structuredContent: response
+    };
+  });
+  return server;
+}
+async function runStdio() {
+  const server = buildServer();
+  const transport = new import_stdio.StdioServerTransport();
+  const shutdown = async (signal) => {
+    if (SHUTTING_DOWN) return;
+    SHUTTING_DOWN = true;
+    try {
+      await server.close();
+    } catch {
+    }
+    process.exit(signal === "SIGTERM" ? 0 : 0);
+  };
+  process.on("SIGINT", () => {
+    void shutdown("SIGINT");
+  });
+  process.on("SIGTERM", () => {
+    void shutdown("SIGTERM");
+  });
+  await server.connect(transport);
+}
+var SHUTTING_DOWN = false;
+function isMain() {
+  const entry = process.argv[1];
+  if (typeof entry !== "string" || entry.length === 0) return false;
+  return /sdk\/mcp\/gdd-mcp\/server\.(ts|js|cjs|mjs)$/.test(
+    entry.replace(/\\/g, "/")
+  );
+}
+if (isMain()) {
+  runStdio().catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[gdd-mcp] fatal: ${msg}`);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SERVER_NAME,
+  SERVER_VERSION,
+  TOOL_DESCRIPTIONS,
+  TOOL_READONLY,
+  buildServer,
+  runStdio
+});