@hegemonart/get-design-done 1.30.6 → 1.31.5

package/scripts/lib/rate-guard.cjs

@@ -20,7 +20,7 @@
 // `resetAt` wins. This matches the D-01 rule in the plan.
 //
 // State-file writes are atomic (temp + rename) and coordinated by
-// scripts/lib/lockfile.cjs so two child processes hitting `ingestHeaders`
+// sdk/primitives/lockfile.cjs so two child processes hitting `ingestHeaders`
 // concurrently can never corrupt the file. The lock is scoped to the
 // state file, not to the provider directory, so different providers can
 // update in parallel.
@@ -30,7 +30,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { acquire, renameWithRetry } = require('./lockfile.cjs');
+const { acquire, renameWithRetry } = require('../../sdk/primitives/lockfile.cjs');
 
 const STATE_DIR_REL = path.join('.design', 'rate-limits');
 const LOCK_MAX_WAIT_MS = 3_000;

package/scripts/lib/recipe-loader.cjs

@@ -0,0 +1,142 @@
+/**
+ * recipe-loader.cjs — recipes/ scaffold loader (Plan 31-5-03, RECIPE-01 / SC#14).
+ *
+ * The top-level recipes/ directory ships EMPTY of recipes; it is populated
+ * downstream by Phase 32 (skill-trigger recipes), Phase 33.6 (per-provider),
+ * Phase 26 (per-runtime/per-model), and Phase 23.5 (bandit-arm shape). This
+ * module fixes the loading contract those phases build against so each does not
+ * reinvent it. Modelled on Storybloq's src/autonomous/recipes/ loader.ts.
+ *
+ * Contract:
+ *   loadRecipe(name, opts?) -> Recipe
+ *     name : recipe stem; resolves <repoRoot>/recipes/<name>.json
+ *     opts : { recipesDir, schemaPath, fs } — all injectable for tests
+ *     returns : the validated, parsed Recipe object
+ *     throws  : Error('recipe not found: <name>')              if the file is absent
+ *               Error('recipe <name> failed schema validation: …') if invalid
+ *
+ * Cache (SC#14 "caches by SHA"):
+ *   Keyed by name + ':' + sha256(fileBytes). Each call reads the file once to
+ *   compute the content hash; on a HIT (unchanged bytes) it returns the cached
+ *   object WITHOUT re-parsing / re-validating. On a MISS (changed bytes) it
+ *   parses + validates + stores. Keying by content SHA — not just name — means
+ *   an edited recipe is correctly re-validated.
+ *
+ * Empty-dir safety: this module requires cleanly when recipes/ is empty, and a
+ * directory listing of an empty (just-.gitkeep) dir does not throw. loadRecipe
+ * of a missing name throws the clear not-found error — distinct from "the empty
+ * dir is broken" (it is a valid scaffold state).
+ *
+ * Uses the repo's existing `ajv` dependency (package.json "ajv": "^8.18.0") —
+ * no new dependency. The schema is compiled once per schemaPath (singleton).
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const Ajv = require('ajv');
+
+// recipe-loader.cjs lives in scripts/lib/ → two levels up is the repo root.
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DEFAULT_RECIPES_DIR = path.join(REPO_ROOT, 'recipes');
+const DEFAULT_SCHEMA_PATH = path.join(REPO_ROOT, 'reference', 'schemas', 'recipe.schema.json');
+
+// Ajv 8 CJS: require('ajv') is (or wraps) the constructor.
+const AjvCtor = Ajv.default || Ajv;
+
+// SHA-keyed cache: `name + ':' + sha256(bytes)` → parsed Recipe object.
+const cache = new Map();
+
+// Compiled-validator singletons, keyed by resolved schemaPath. The schema is a
+// small trusted local file, so allErrors:true (full error list → clear message)
+// is safe here — unlike the untrusted-HTTP receiver which fails fast.
+const validators = new Map();
+
+// Test-observability counter: increments once per parse+validate (i.e. per
+// cache MISS). A cache HIT does not bump it. Tests assert on the delta to prove
+// SHA-keyed hit/miss semantics without depending on raw read counts (a hit must
+// still read the file once to hash it).
+let _validations = 0;
+
+/**
+ * Get (compiling once) the validator for a schema path.
+ * @param {string} schemaPath
+ * @param {typeof fs} fsImpl
+ * @returns {import('ajv').ValidateFunction}
+ */
+function getValidator(schemaPath, fsImpl) {
+  const resolved = path.resolve(schemaPath);
+  let validate = validators.get(resolved);
+  if (validate) return validate;
+
+  const schema = JSON.parse(fsImpl.readFileSync(resolved, 'utf8'));
+  const ajv = new AjvCtor({ allErrors: true, strict: false });
+  validate = ajv.compile(schema);
+  validators.set(resolved, validate);
+  return validate;
+}
+
+/**
+ * Load + validate a recipe by name.
+ * @param {string} name - recipe stem; resolves <recipesDir>/<name>.json
+ * @param {{ recipesDir?: string, schemaPath?: string, fs?: typeof fs }} [opts]
+ * @returns {Record<string, unknown>} the validated, parsed Recipe object
+ */
+function loadRecipe(name, opts = {}) {
+  if (typeof name !== 'string' || name.length === 0) {
+    throw new Error('recipe name must be a non-empty string');
+  }
+
+  const fsImpl = opts.fs || fs;
+  const dir = opts.recipesDir || DEFAULT_RECIPES_DIR;
+  const schemaPath = opts.schemaPath || DEFAULT_SCHEMA_PATH;
+  const file = path.join(dir, name + '.json');
+
+  if (!fsImpl.existsSync(file)) {
+    throw new Error('recipe not found: ' + name);
+  }
+
+  // Read once per call to compute the content hash (the cache key).
+  const bytes = fsImpl.readFileSync(file);
+  const sha = crypto.createHash('sha256').update(bytes).digest('hex');
+  const key = name + ':' + sha;
+
+  // Cache HIT: unchanged bytes → return cached object, skip parse + validate.
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+
+  // Cache MISS: parse + validate + store.
+  let parsed;
+  try {
+    parsed = JSON.parse(bytes.toString('utf8'));
+  } catch (err) {
+    throw new Error('recipe ' + name + ' is not valid JSON: ' + err.message);
+  }
+
+  const validate = getValidator(schemaPath, fsImpl);
+  _validations += 1;
+  const ok = validate(parsed) === true;
+  if (!ok) {
+    throw new Error(
+      'recipe ' + name + ' failed schema validation: ' + JSON.stringify(validate.errors || []),
+    );
+  }
+
+  cache.set(key, parsed);
+  return parsed;
+}
+
+/** Test hook: clear the SHA cache (does not drop compiled validators). */
+function _clearCache() {
+  cache.clear();
+}
+
+/** Test hook: introspect parse+validate counts (one per cache MISS). */
+function _stats() {
+  return { validations: _validations, cacheSize: cache.size };
+}
+
+module.exports = { loadRecipe, _clearCache, _stats };

package/scripts/lib/session-runner/errors.ts

@@ -38,7 +38,7 @@ import {
   OperationFailedError,
   StateConflictError,
   type GDDError,
-} from '../gdd-errors/index.ts';
+} from '../../../sdk/errors/index.ts';
 
 /**
  * Build an absolute path to a repo-root-relative file. We can't use
@@ -68,7 +68,7 @@ const REPO_ROOT = findRepoRoot();
  */
 const nodeRequire = createRequire(join(REPO_ROOT, 'package.json'));
 const transportClassifier = nodeRequire(
-  resolve(REPO_ROOT, 'scripts/lib/error-classifier.cjs'),
+  resolve(REPO_ROOT, 'sdk/primitives/error-classifier.cjs'),
 ) as {
   classify: (err: unknown) => {
     reason: string;
@@ -375,7 +375,7 @@ export function mapSdkError(err: unknown): MappedSdkError {
   }
 
   // 9. Transport-layer classification (ECONNRESET, ETIMEDOUT, etc.).
-  //    Delegate to scripts/lib/error-classifier.cjs which knows the errno
+  //    Delegate to sdk/primitives/error-classifier.cjs which knows the errno
   //    vocabulary. Only trust its `retryable` flag for transient network
   //    classes — other classes were already handled above.
   const classified = transportClassifier.classify(err);

package/scripts/lib/session-runner/index.ts

@@ -26,8 +26,8 @@
 //     (always; payload status mirrors SessionResult.status). Optional
 //     `session.budget_exceeded` emitted when the budget trips.
 
-import { appendEvent } from '../event-stream/index.ts';
-import type { BaseEvent } from '../event-stream/index.ts';
+import { appendEvent } from '../../../sdk/event-stream/index.ts';
+import type { BaseEvent } from '../../../sdk/event-stream/index.ts';
 import { sanitize as defaultSanitize } from '../prompt-sanitizer/index.ts';
 
 import { mapSdkError } from './errors.ts';
@@ -64,7 +64,7 @@ function _findRepoRoot(): string {
 const _REPO_ROOT = _findRepoRoot();
 const _nodeRequire = createRequire(_join(_REPO_ROOT, 'package.json'));
 const jitteredBackoff = _nodeRequire(
-  _resolve(_REPO_ROOT, 'scripts/lib/jittered-backoff.cjs'),
+  _resolve(_REPO_ROOT, 'sdk/primitives/jittered-backoff.cjs'),
 ) as {
   delayMs: (attempt: number, opts?: { baseMs?: number; maxMs?: number; factor?: number; jitter?: number }) => number;
 };

package/scripts/lib/session-runner/transcript.ts

@@ -2,7 +2,7 @@
 // transcript writer for Phase 21 headless Agent SDK sessions
 // (Plan 21-01 Task 4).
 //
-// Design mirrors scripts/lib/event-stream/writer.ts but is scoped to one
+// Design mirrors sdk/event-stream/writer.ts but is scoped to one
 // session per file rather than the global telemetry stream. Each session
 // owns a dedicated `.design/sessions/<ISO>-<stage>.jsonl` file; the
 // filename is stable for the full run and survives retries (retries

package/scripts/lib/tool-scoping/index.ts

@@ -21,7 +21,7 @@
 //   * Plan 21-01 `session-runner`  — computes `allowedTools` for each session.
 //   * Plan 21-05 `pipeline-runner` — picks the correct scope per stage.
 
-import { ValidationError } from '../gdd-errors/index.ts';
+import { ValidationError } from '../../../sdk/errors/index.ts';
 import type { Scope, ScopeInput, ScopeViolation, Stage } from './types.ts';
 import {
   NATIVE_TOOLS,

package/scripts/mcp-servers/gdd-mcp/server.ts

@@ -1,317 +1,35 @@
-#!/usr/bin/env -S node --experimental-strip-types
-// scripts/mcp-servers/gdd-mcp/server.ts
+// scripts/mcp-servers/gdd-mcp/server.ts — GDD-DEPRECATION-SHIM (Plan 31-5-06, SDK-05, D-02).
 //
-// MCP server `gdd-mcp` — read-mostly project-state surface (Phase 27.7).
-// Exposes STATE.md sections, phases, decisions, plans, telemetry, intel
-// slices, and the latest reflection as typed MCP tools backed by the
-// same `scripts/lib/*` modules the CLI uses.
+// Thin deprecation shim. The real MCP `gdd-mcp` server moved to
+// sdk/mcp/gdd-mcp/server.ts in Plan 31-5-05 (SDK consolidation, D-08). This
+// file is re-created at the OLD path so undocumented EXTERNAL importers /
+// invokers (anyone who reached into node_modules/@hegemonart/get-design-done/
+// scripts/mcp-servers/gdd-mcp/server.ts directly) keep working for one minor
+// grace window.
 //
-// Lifecycle (mirrors Phase 20 `gdd-state` server):
-//   1. Construct a low-level Server (we use the low-level surface so we
-//      can speak JSON Schema directly — the high-level McpServer wants
-//      Zod shapes, and our per-tool schemas are Draft-07 JSON.)
-//   2. Register `tools/list` — returns the registered tools with their
-//      input JSON Schemas loaded from disk. Scaffold ships with 0
-//      tools; Plan 27.7-02 populates `TOOL_MODULES` with 12 entries.
-//   3. Register `tools/call` — dispatches by name to the matching
-//      handler. Each handler returns a typed ToolResponse; the server
-//      wraps it into the MCP CallToolResult shape. Unknown tool names
-//      return `isError: true` with a structured payload.
-//   4. Attach StdioServerTransport; await connect. NO port allocation
-//      (D-05 stdio-only).
-//   5. On SIGINT / SIGTERM: close the transport, exit 0. Re-entrant
-//      shutdown is guarded with a module-level `SHUTTING_DOWN` flag.
+// REMOVED IN v1.33.0 (D-02). Grace window: 1.31.5 ships with shims →
+// 1.32.0 still has them → 1.33.0 removes them. The canonical invocation is
+// now the `bin/gdd-mcp` trampoline (Plan 31-5-05); internal callers already
+// use the sdk/ path. This shim is external-only; 31-5-10's
+// no-stale-internal-refs guard excludes files carrying the
+// GDD-DEPRECATION-SHIM marker above.
 //
-// Project-root discovery (D-05): `resolveProjectRoot()` lives in
-// `./tools/shared.ts` and walks up from `process.cwd()` looking for
-// `.design/` OR `.planning/` OR `.claude-plugin/plugin.json`. Server
-// infrastructure is allowed to import `node:fs`/`node:path` directly;
-// only individual TOOL files are bound by the thin-wrapper rule (D-06).
-//
-// Invariant: handler throws are contained. The dispatcher wraps every
-// call in a try/catch that funnels through `toToolError()` — the MCP
-// harness never sees an uncaught throw from our tools.
-
-import { readFileSync, existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-
-import { toToolError } from '../../lib/gdd-errors/classification.ts';
-import { TOOL_MODULES, type ToolModule } from './tools/index.ts';
-
-/** Server metadata advertised on initialize. */
-export const SERVER_NAME = 'gdd-mcp';
-export const SERVER_VERSION = '1.27.7';
-
-/**
- * Resolve this module's directory. We deliberately avoid `import.meta.url`
- * (not permitted by our tsconfig's Node16+CommonJS-compatible module
- * resolution) and `__dirname` (not portable under strip-types ESM).
- *
- * Strategy: when this module is invoked as a script, `process.argv[1]`
- * points at this file; resolve its dirname. When it is imported for
- * tests, we fall back to walking from `process.cwd()` — tests run
- * from the repo root by convention, so `scripts/mcp-servers/gdd-mcp`
- * resolves reliably. Both branches are canonicalized against the
- * on-disk tools directory.
- */
-function here(): string {
-  const expectedRel = join('scripts', 'mcp-servers', 'gdd-mcp');
-  // Script invocation: process.argv[1] === .../server.ts (or a shim).
-  const entry = process.argv[1];
-  if (typeof entry === 'string' && entry.length > 0) {
-    const entryDir = dirname(resolve(entry));
-    if (existsSync(join(entryDir, 'tools', 'index.ts'))) {
-      return entryDir;
-    }
-  }
-  // Library-import path (tests): walk cwd forward.
-  const candidate = resolve(process.cwd(), expectedRel);
-  if (existsSync(join(candidate, 'tools', 'index.ts'))) {
-    return candidate;
-  }
-  // Last-resort: return the expected path even if it does not exist —
-  // the subsequent readFileSync() call will produce a clear error.
-  return candidate;
-}
-
-/** Eager cache of input schemas keyed by tool name. We load them once at
- *  startup so a tool-call handler never hits the filesystem in the hot
- *  path; subsequent schema edits (JSON file on disk) require a server
- *  restart, which matches every other part of the pipeline.
- *
- *  Scaffold ships with 0 tools — loadTools() returns []. Plan 27.7-02
- *  adds 12 tool modules, each with its own `schemaPath` pointing into
- *  `scripts/mcp-servers/gdd-mcp/schemas/`. */
-interface LoadedTool extends ToolModule {
-  inputSchema: Record<string, unknown>;
-}
-
-function loadTools(): LoadedTool[] {
-  const baseDir = here();
-  return TOOL_MODULES.map((m) => {
-    const absPath = join(baseDir, 'tools', m.schemaPath);
-    const raw = readFileSync(absPath, 'utf8');
-    const parsed = JSON.parse(raw) as {
-      properties?: {
-        input?: { type?: string; properties?: Record<string, unknown> };
-      };
-    };
-    // The per-tool schema files are Draft-07 wrappers shaped as:
-    //   { type: "object", properties: { input: {...}, output: {...} } }
-    // MCP's tools/list advertises only the INPUT half. We project
-    // `properties.input` here; when the schema is malformed we fall
-    // back to an open object so the tool is still listable.
-    const rawInput = parsed.properties?.input;
-    const inputSchema: Record<string, unknown> =
-      rawInput !== undefined && typeof rawInput === 'object'
-        ? (rawInput as Record<string, unknown>)
-        : { type: 'object' };
-    if (!('type' in inputSchema)) inputSchema['type'] = 'object';
-    return { ...m, inputSchema };
-  });
-}
-
-/**
- * Tool descriptions — short, scannable, lifted from the plan. Skill
- * prose uses these verbatim when suggesting a tool to the model.
- *
- * Plan 27.7-02 populates 12 entries — one per tool name in the canonical
- * 12-tool list.
- */
-export const TOOL_DESCRIPTIONS: Record<string, string> = {
-  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 — 4 checks (CLAUDE.md, .planning/, .design/, package.json).',
-};
-
-/** Human-readable annotation hints (MCP clients use these to style the
- *  tool in UI). `readOnlyHint: true` — tells clients this tool does NOT
- *  modify disk. v1 is read-only (D-04) so every entry is `true`. */
-export const TOOL_READONLY: Record<string, boolean> = {
-  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,
-};
-
-/**
- * Build the MCP server. The tools list and call handlers are the only
- * two request handlers we register; everything else (initialize, ping,
- * cancellation, shutdown) is handled internally by the Protocol class.
- */
-export function buildServer(): Server {
-  const tools = loadTools();
-  const byName: Map<string, LoadedTool> = new Map();
-  for (const t of tools) byName.set(t.name, t);
-
-  const server = new Server(
-    { name: SERVER_NAME, version: SERVER_VERSION },
-    {
-      capabilities: { tools: {} },
-    },
+// Re-exporting the sdk/ server keeps the library surface (buildServer,
+// runStdio, SERVER_NAME, SERVER_VERSION, TOOL_DESCRIPTIONS, TOOL_READONLY)
+// reachable via the old path. The sdk/ server's own isMain() entry guard
+// keys off process.argv[1] ending with its own sdk/ path, so a re-export
+// does NOT auto-start the server — direct execution should go through the
+// bin trampoline. Runs under --experimental-strip-types.
+
+import { emitWarning } from 'node:process';
+
+let warned = false;
+if (!warned) {
+  warned = true;
+  emitWarning(
+    'scripts/mcp-servers/gdd-mcp/server.ts is deprecated; use the bin/gdd-mcp trampoline or import sdk/mcp/gdd-mcp instead. Removed in v1.33.0.',
+    'DeprecationWarning',
   );
-
-  server.setRequestHandler(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 as {
-            type: 'object';
-            properties?: Record<string, unknown>;
-            required?: string[];
-          },
-          annotations: {
-            readOnlyHint: readOnly,
-            destructiveHint: !readOnly,
-            idempotentHint: false,
-          },
-        };
-      }),
-    };
-  });
-
-  server.setRequestHandler(CallToolRequestSchema, async (req) => {
-    const { name: toolName, arguments: args } = req.params;
-    const tool = byName.get(toolName);
-    if (tool === undefined) {
-      // Unknown tool — return as CallToolResult isError=true so the
-      // client gets a structured error rather than a JSON-RPC error.
-      const payload = toToolError(
-        new Error(`unknown tool: ${toolName}`),
-      );
-      return {
-        isError: true,
-        content: [
-          {
-            type: 'text' as const,
-            text: JSON.stringify({ success: false, error: payload.error }),
-          },
-        ],
-        structuredContent: { success: false, error: payload.error },
-      };
-    }
-
-    let response;
-    try {
-      response = await tool.handle(args ?? {});
-    } catch (err) {
-      // Defensive catch — handlers shouldn't throw, but if one does
-      // we translate rather than crashing the server.
-      const payload = toToolError(err);
-      response = { success: false as const, error: payload.error };
-    }
-
-    const text = JSON.stringify(response);
-    if (response.success === true) {
-      return {
-        content: [{ type: 'text' as const, text }],
-        structuredContent: response as unknown as Record<string, unknown>,
-      };
-    }
-    return {
-      isError: true,
-      content: [{ type: 'text' as const, text }],
-      structuredContent: response as unknown as Record<string, unknown>,
-    };
-  });
-
-  return server;
-}
-
-/**
- * Run the server against stdio and block until the transport closes.
- * Called from CLI when this file is invoked as a script.
- */
-export async function runStdio(): Promise<void> {
-  const server = buildServer();
-  const transport = new StdioServerTransport();
-
-  const shutdown = async (signal: string): Promise<void> => {
-    // Re-entrant: signal handlers can fire more than once on flaky
-    // shells. Guard with a module-level flag.
-    if (SHUTTING_DOWN) return;
-    SHUTTING_DOWN = true;
-    try {
-      await server.close();
-    } catch {
-      // best-effort; we're exiting anyway.
-    }
-    // SIGTERM / SIGINT convention: exit(0) — orderly shutdown.
-    process.exit(signal === 'SIGTERM' ? 0 : 0);
-  };
-
-  process.on('SIGINT', () => {
-    void shutdown('SIGINT');
-  });
-  process.on('SIGTERM', () => {
-    void shutdown('SIGTERM');
-  });
-
-  await server.connect(transport);
 }
 
-/** Re-entrancy guard for `shutdown()`. */
-let SHUTTING_DOWN = false;
-
-/**
- * Are we being invoked as a script? We compare the argv[1] file path's
- * basename to `server.ts` — test imports never match this because
- * `node --test tests/*.ts` sets argv[1] to the test runner entry, not
- * our file. A direct `node scripts/mcp-servers/gdd-mcp/server.ts`
- * invocation DOES match. The Windows-safe path normalization uses
- * `.replace(/\\/g, '/')` before the endsWith check.
- */
-function isMain(): boolean {
-  const entry = process.argv[1];
-  if (typeof entry !== 'string' || entry.length === 0) return false;
-  return entry.replace(/\\/g, '/').endsWith('scripts/mcp-servers/gdd-mcp/server.ts');
-}
-
-if (isMain()) {
-  runStdio().catch((err) => {
-    const msg = err instanceof Error ? err.message : String(err);
-    // eslint-disable-next-line no-console
-    console.error(`[gdd-mcp] fatal: ${msg}`);
-    process.exit(1);
-  });
-}
+export * from '../../../sdk/mcp/gdd-mcp/server.ts';