@structured-vibe-coding/core 0.14.3 → 0.16.0

package/defaults/mcp.yaml

@@ -0,0 +1,53 @@
+# External MCP *sources* that sdd will *call* (sdd = client).
+# Not the same as `sdd mcp serve` (that exposes sdd tools *to* agents).
+#
+# Use cases:
+#   - Org UI/UX / design-system MCP
+#   - Internal API catalog MCP
+#   - Third-party or custom AST / code-search MCP
+#
+# sdd matches sources by stage / workflow / keywords / intents, then invokes
+# the configured tool and can embed results in agent handoff.
+#
+# Add via CLI:
+#   sdd mcp sources add --id design-system --command npx --arg -y --arg @acme/ds-mcp \
+#     --stages design,implement --intents ui,design --tool search_components \
+#     --tool-arg query={{query}}
+#
+version: 1
+auto_fetch_on_handoff: true
+max_chars_per_source: 6000
+sources: []
+
+# Example (uncomment and edit):
+#
+# sources:
+#   - id: design-system
+#     description: Acme design system components and tokens
+#     command: npx
+#     args: ["-y", "@acme/design-system-mcp"]
+#     priority: 20
+#     when:
+#       stages: [design, implement, stories]
+#       workflows: [feature, enterprise-feature]
+#       intents: [ui, design, component]
+#       keywords: [button, token, theme, component]
+#     invoke:
+#       tool: search_components
+#       args:
+#         query: "{{query}}"
+#
+#   - id: code-ast
+#     description: AST / symbol search for this monorepo (external engine)
+#     command: npx
+#     args: ["-y", "@example/ast-search-mcp"]
+#     cwd: "{{projectRoot}}"
+#     priority: 30
+#     when:
+#       stages: [implement, code_research, local_verify]
+#       intents: [code, implement]
+#     invoke:
+#       tool: search
+#       args:
+#         query: "{{query}}"
+#         root: "{{projectRoot}}"

package/dist/{agents-WL3PNTJL.js → agents-7NS5LFEZ.js}

@@ -19,9 +19,9 @@ import {
   removeOtherAgentHosts,
   renderThinAgent,
   writeAgentHandoff
-} from "./chunk-S7SHVKG4.js";
+} from "./chunk-GR7KIAR2.js";
+import "./chunk-RRBKQ76B.js";
 import "./chunk-OJFMJHNL.js";
-import "./chunk-C725DWSB.js";
 import "./chunk-A752UVPF.js";
 import "./chunk-67AUAGNV.js";
 import "./chunk-7MJYPJMR.js";

package/dist/{chunk-HOH43IQ2.js → chunk-24EXBX7P.js}

@@ -245,7 +245,7 @@ async function createChange(input) {
   await materializeStageArtifacts(projectRoot, config, id, workflow, meta, firstStage);
   await setActiveChange(projectRoot, config, id);
   try {
-    const { refreshActiveAgentContext } = await import("./agents-WL3PNTJL.js");
+    const { refreshActiveAgentContext } = await import("./agents-7NS5LFEZ.js");
     await refreshActiveAgentContext(projectRoot);
   } catch {
   }
@@ -333,7 +333,7 @@ async function advanceStage(projectRoot, config, changeId, opts) {
         stage2
       );
       try {
-        const { refreshActiveAgentContext } = await import("./agents-WL3PNTJL.js");
+        const { refreshActiveAgentContext } = await import("./agents-7NS5LFEZ.js");
         await refreshActiveAgentContext(projectRoot);
       } catch {
       }
@@ -380,7 +380,7 @@ async function advanceStage(projectRoot, config, changeId, opts) {
     stage
   );
   try {
-    const { refreshActiveAgentContext } = await import("./agents-WL3PNTJL.js");
+    const { refreshActiveAgentContext } = await import("./agents-7NS5LFEZ.js");
     await refreshActiveAgentContext(projectRoot);
   } catch {
   }
@@ -484,7 +484,7 @@ async function completeChange(projectRoot, config, changeId) {
   let promoted;
   if (ctx.meta.workflow === "greenfield" || ctx.meta.flags?.greenfield === true) {
     try {
-      const { promoteGreenfieldToMemory: promoteGreenfieldToMemory2 } = await import("./greenfield-SY3SB5OT.js");
+      const { promoteGreenfieldToMemory: promoteGreenfieldToMemory2 } = await import("./greenfield-3ZH5OASX.js");
       promoted = await promoteGreenfieldToMemory2(projectRoot, config, changeId);
     } catch {
     }

package/dist/{chunk-S7SHVKG4.js → chunk-GR7KIAR2.js}

@@ -1,10 +1,10 @@
-import {
-  loadConfig
-} from "./chunk-OJFMJHNL.js";
 import {
   buildAgentPrompt,
   formatStatus
-} from "./chunk-C725DWSB.js";
+} from "./chunk-RRBKQ76B.js";
+import {
+  loadConfig
+} from "./chunk-OJFMJHNL.js";
 import {
   buildContext,
   getActiveChangeId

package/dist/chunk-KYWETNFU.js

@@ -0,0 +1,147 @@
+import {
+  sddRoot
+} from "./chunk-7MJYPJMR.js";
+import {
+  ensureDir,
+  pathExists,
+  readYaml,
+  writeYaml
+} from "./chunk-EPFURATC.js";
+
+// src/mcp/sources.ts
+import { join } from "pathe";
+
+// src/mcp/types.ts
+import { z } from "zod";
+var McpWhenSchema = z.object({
+  /** Empty = all stages */
+  stages: z.array(z.string()).default([]),
+  /** Empty = all workflows */
+  workflows: z.array(z.string()).default([]),
+  /** Match title/query (case-insensitive substring) */
+  keywords: z.array(z.string()).default([]),
+  /**
+   * High-level intent tags the operator or tool may pass:
+   * code | ui | design | api | docs | data
+   */
+  intents: z.array(z.string()).default([])
+});
+var McpInvokeSchema = z.object({
+  /** Tool name on the remote MCP server */
+  tool: z.string(),
+  /**
+   * Static args + templates:
+   * {{query}} {{title}} {{stage}} {{workflow}} {{projectRoot}}
+   */
+  args: z.record(z.unknown()).default({})
+});
+var McpSourceSchema = z.object({
+  id: z.string().min(1),
+  description: z.string().default(""),
+  /** stdio only in v1 */
+  transport: z.enum(["stdio"]).default("stdio"),
+  command: z.string().min(1),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string()).default({}),
+  /** Working directory (default: project root). Supports {{projectRoot}} */
+  cwd: z.string().optional(),
+  enabled: z.boolean().default(true),
+  /** Higher runs first when gathering */
+  priority: z.number().default(0),
+  when: McpWhenSchema.default({}),
+  /**
+   * How sdd calls this source when auto-gathering for a stage.
+   * If omitted, `sdd mcp fetch` still works with an explicit --tool.
+   */
+  invoke: McpInvokeSchema.optional(),
+  /** Optional allowlist of tool names (documentation / validation) */
+  tools: z.array(z.string()).optional()
+});
+var McpConfigSchema = z.object({
+  version: z.number().default(1),
+  /**
+   * When true, handoff generation calls matching sources with `invoke` and
+   * embeds results under "External MCP context".
+   */
+  auto_fetch_on_handoff: z.boolean().default(true),
+  /** Max chars of MCP output embedded into handoff per source */
+  max_chars_per_source: z.number().default(6e3),
+  sources: z.array(McpSourceSchema).default([])
+});
+
+// src/mcp/sources.ts
+function mcpConfigPath(projectRoot) {
+  return join(sddRoot(projectRoot), "mcp.yaml");
+}
+function defaultMcpConfig() {
+  return McpConfigSchema.parse({
+    version: 1,
+    auto_fetch_on_handoff: true,
+    max_chars_per_source: 6e3,
+    sources: []
+  });
+}
+async function loadMcpConfig(projectRoot) {
+  const path = mcpConfigPath(projectRoot);
+  if (!await pathExists(path)) {
+    return defaultMcpConfig();
+  }
+  const raw = await readYaml(path);
+  return McpConfigSchema.parse(raw ?? {});
+}
+async function saveMcpConfig(projectRoot, config) {
+  await ensureDir(sddRoot(projectRoot));
+  const path = mcpConfigPath(projectRoot);
+  await writeYaml(path, McpConfigSchema.parse(config));
+  return path;
+}
+async function ensureMcpConfig(projectRoot) {
+  const path = mcpConfigPath(projectRoot);
+  if (!await pathExists(path)) {
+    const cfg = defaultMcpConfig();
+    await saveMcpConfig(projectRoot, cfg);
+    return cfg;
+  }
+  return loadMcpConfig(projectRoot);
+}
+async function addMcpSource(projectRoot, source) {
+  const cfg = await ensureMcpConfig(projectRoot);
+  const parsed = McpSourceSchema.parse(source);
+  const rest = cfg.sources.filter((s) => s.id !== parsed.id);
+  cfg.sources = [...rest, parsed].sort((a, b) => b.priority - a.priority);
+  await saveMcpConfig(projectRoot, cfg);
+  return cfg;
+}
+async function removeMcpSource(projectRoot, id) {
+  const cfg = await ensureMcpConfig(projectRoot);
+  cfg.sources = cfg.sources.filter((s) => s.id !== id);
+  await saveMcpConfig(projectRoot, cfg);
+  return cfg;
+}
+function interpolate(value, vars) {
+  return value.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+}
+function interpolateArgs(args, vars) {
+  const out = {};
+  for (const [k, v] of Object.entries(args)) {
+    if (typeof v === "string") out[k] = interpolate(v, vars);
+    else out[k] = v;
+  }
+  return out;
+}
+
+export {
+  McpWhenSchema,
+  McpInvokeSchema,
+  McpSourceSchema,
+  McpConfigSchema,
+  mcpConfigPath,
+  defaultMcpConfig,
+  loadMcpConfig,
+  saveMcpConfig,
+  ensureMcpConfig,
+  addMcpSource,
+  removeMcpSource,
+  interpolate,
+  interpolateArgs
+};

package/dist/{chunk-C725DWSB.js → chunk-RRBKQ76B.js}

@@ -106,10 +106,41 @@ async function buildAgentPrompt(ctx, config, projectRoot) {
       `2. If present, read: \`changes/${ctx.id}/code-context.md\` (regenerate if stale)`
     );
     parts.push(
-      `Do not dump unbounded source into the prompt; prefer the sliced output.`
+      `3. Org libraries / remote AST: configure \`.sdd/mcp.yaml\` and \`sdd mcp fetch\` (see External MCP context below)`
+    );
+    parts.push(
+      `Do not dump unbounded source into the prompt; prefer sliced / MCP output.`
     );
     parts.push("");
   }
+  try {
+    const { loadMcpConfig } = await import("./sources-PF45EUH2.js");
+    const {
+      gatherMcpContextForChange,
+      formatMcpContextForHandoff
+    } = await import("./gather-74DQ35QX.js");
+    const mcpCfg = await loadMcpConfig(projectRoot);
+    if (mcpCfg.auto_fetch_on_handoff && mcpCfg.sources.length) {
+      const fetched = await gatherMcpContextForChange(projectRoot, ctx);
+      const block = formatMcpContextForHandoff(
+        fetched.filter((r) => r.ok || r.error)
+      );
+      if (block) {
+        parts.push(block);
+      }
+    } else if (mcpCfg.sources.length === 0) {
+      parts.push(`## External MCP sources`);
+      parts.push("");
+      parts.push(
+        `No sources in \`.sdd/mcp.yaml\` yet. To attach org libraries / AST engines:`
+      );
+      parts.push(
+        `\`sdd mcp sources add --help\` \xB7 docs: Configure MCP sources`
+      );
+      parts.push("");
+    }
+  } catch {
+  }
   parts.push(
     `When done with this stage, the human will run \`sdd next\` or \`sdd verify\` / \`sdd complete\`.`
   );

package/dist/chunk-VD3CPFAI.js

@@ -0,0 +1,236 @@
+import {
+  interpolate,
+  interpolateArgs,
+  loadMcpConfig
+} from "./chunk-KYWETNFU.js";
+
+// src/mcp/client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+function contentToText(result) {
+  const parts = result.content ?? [];
+  return parts.map((p) => p.type === "text" ? p.text ?? "" : JSON.stringify(p)).join("\n").trim();
+}
+async function withMcpSource(source, projectRoot, fn) {
+  const vars = { projectRoot };
+  const cwd = source.cwd ? interpolate(source.cwd, vars) : projectRoot;
+  const env = {
+    ...process.env,
+    ...source.env,
+    SDD_PROJECT_ROOT: projectRoot
+  };
+  const transport = new StdioClientTransport({
+    command: source.command,
+    args: source.args,
+    cwd,
+    env
+  });
+  const client = new Client({
+    name: "sdd-mcp-client",
+    version: "0.14.0"
+  });
+  await client.connect(transport);
+  try {
+    return await fn(client);
+  } finally {
+    try {
+      await client.close();
+    } catch {
+    }
+  }
+}
+async function listMcpSourceTools(source, projectRoot) {
+  return withMcpSource(source, projectRoot, async (client) => {
+    const listed = await client.listTools();
+    return listed.tools.map((t) => ({
+      name: t.name,
+      description: t.description
+    }));
+  });
+}
+async function callMcpSourceTool(source, projectRoot, tool, args) {
+  try {
+    if (source.tools?.length && !source.tools.includes(tool)) {
+      return {
+        ok: false,
+        text: "",
+        error: `Tool "${tool}" not in allowlist for source ${source.id}: ${source.tools.join(", ")}`
+      };
+    }
+    return await withMcpSource(source, projectRoot, async (client) => {
+      const result = await client.callTool({ name: tool, arguments: args });
+      const text = contentToText(result);
+      const isError = Boolean(result.isError);
+      return {
+        ok: !isError,
+        text: text || (isError ? "(empty error result)" : "(empty)"),
+        error: isError ? text || "tool returned isError" : void 0
+      };
+    });
+  } catch (err) {
+    return {
+      ok: false,
+      text: "",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/mcp/match.ts
+function includesCI(list, value) {
+  const v = value.toLowerCase();
+  return list.some((x) => x.toLowerCase() === v);
+}
+function matchMcpSources(sources, ctx) {
+  const stage = ctx.stage ?? "";
+  const workflow = ctx.workflow ?? "";
+  const query = (ctx.query ?? "").toLowerCase();
+  const intents = (ctx.intents ?? []).map((i) => i.toLowerCase());
+  const matched = sources.filter((s) => {
+    if (!s.enabled) return false;
+    const w = s.when;
+    if (w.stages.length && stage && !includesCI(w.stages, stage)) {
+      return false;
+    }
+    if (w.workflows.length && workflow && !includesCI(w.workflows, workflow)) {
+      return false;
+    }
+    if (w.intents.length && intents.length) {
+      const hit = w.intents.some((i) => intents.includes(i.toLowerCase()));
+      if (!hit) return false;
+    }
+    if (w.keywords.length && query) {
+      const hit = w.keywords.some((k) => query.includes(k.toLowerCase()));
+      if (!hit) return false;
+    }
+    return true;
+  });
+  return matched.sort((a, b) => b.priority - a.priority);
+}
+function explainMatch(source, ctx) {
+  const bits = [];
+  if (source.when.stages.length) {
+    bits.push(`stages=[${source.when.stages.join(",")}]`);
+  } else bits.push("stages=*");
+  if (source.when.workflows.length) {
+    bits.push(`workflows=[${source.when.workflows.join(",")}]`);
+  }
+  if (source.when.intents.length) {
+    bits.push(`intents=[${source.when.intents.join(",")}]`);
+  }
+  if (source.when.keywords.length) {
+    bits.push(`keywords=[${source.when.keywords.join(",")}]`);
+  }
+  const ok = matchMcpSources([source], ctx).length > 0;
+  return `${ok ? "MATCH" : "skip"} ${source.id} (${bits.join(" ")}) stage=${ctx.stage ?? "?"} workflow=${ctx.workflow ?? "?"}`;
+}
+
+// src/mcp/gather.ts
+async function gatherMcpContext(opts) {
+  const cfg = await loadMcpConfig(opts.projectRoot);
+  let sources = matchMcpSources(cfg.sources, opts.match);
+  if (opts.sourceIds?.length) {
+    const allow = new Set(opts.sourceIds);
+    sources = sources.filter((s) => allow.has(s.id));
+  }
+  const vars = {
+    projectRoot: opts.projectRoot,
+    query: opts.match.query ?? "",
+    title: opts.match.query ?? "",
+    stage: opts.match.stage ?? "",
+    workflow: opts.match.workflow ?? ""
+  };
+  const results = [];
+  for (const source of sources) {
+    const tool = opts.tool ?? source.invoke?.tool;
+    if (!tool) {
+      if (opts.requireInvoke !== false && !opts.tool) {
+        results.push({
+          sourceId: source.id,
+          tool: "(none)",
+          ok: false,
+          text: "",
+          error: "No invoke.tool configured. Set invoke in .sdd/mcp.yaml or pass --tool."
+        });
+      }
+      continue;
+    }
+    const baseArgs = opts.args ?? source.invoke?.args ?? {};
+    const args = interpolateArgs(
+      baseArgs,
+      vars
+    );
+    const called = await callMcpSourceTool(
+      source,
+      opts.projectRoot,
+      tool,
+      args
+    );
+    const max = cfg.max_chars_per_source ?? 6e3;
+    let text = called.text;
+    if (text.length > max) {
+      text = `${text.slice(0, max)}
+
+\u2026(truncated at max_chars_per_source=${max})`;
+    }
+    results.push({
+      sourceId: source.id,
+      tool,
+      ok: called.ok,
+      text,
+      error: called.error
+    });
+  }
+  return results;
+}
+async function gatherMcpContextForChange(projectRoot, ctx, extra) {
+  const cfg = await loadMcpConfig(projectRoot);
+  if (!cfg.auto_fetch_on_handoff && !extra?.query) {
+  }
+  return gatherMcpContext({
+    projectRoot,
+    match: {
+      stage: ctx.meta.stage,
+      workflow: ctx.meta.workflow,
+      query: extra?.query ?? ctx.meta.title,
+      intents: extra?.intents
+    },
+    requireInvoke: true
+  });
+}
+function formatMcpContextForHandoff(results) {
+  if (!results.length) return "";
+  const parts = [
+    "## External MCP context",
+    "",
+    "Pulled from project-configured MCP *sources* (`.sdd/mcp.yaml`).",
+    "Use this instead of guessing org libraries / design systems / remote AST indexes.",
+    ""
+  ];
+  for (const r of results) {
+    parts.push(`### Source \`${r.sourceId}\` (tool: \`${r.tool}\`)`);
+    parts.push("");
+    if (!r.ok) {
+      parts.push(`_Error: ${r.error ?? "failed"}_`);
+    } else {
+      parts.push(r.text || "_(empty)_");
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function listMatchingSourceIds(sources, match) {
+  return matchMcpSources(sources, match).map((s) => s.id);
+}
+
+export {
+  withMcpSource,
+  listMcpSourceTools,
+  callMcpSourceTool,
+  matchMcpSources,
+  explainMatch,
+  gatherMcpContext,
+  gatherMcpContextForChange,
+  formatMcpContextForHandoff,
+  listMatchingSourceIds
+};

package/dist/gather-74DQ35QX.js

@@ -0,0 +1,15 @@
+import {
+  formatMcpContextForHandoff,
+  gatherMcpContext,
+  gatherMcpContextForChange,
+  listMatchingSourceIds
+} from "./chunk-VD3CPFAI.js";
+import "./chunk-KYWETNFU.js";
+import "./chunk-7MJYPJMR.js";
+import "./chunk-EPFURATC.js";
+export {
+  formatMcpContextForHandoff,
+  gatherMcpContext,
+  gatherMcpContextForChange,
+  listMatchingSourceIds
+};

package/dist/{greenfield-SY3SB5OT.js → greenfield-3ZH5OASX.js}

@@ -6,8 +6,8 @@ import {
   startFeatureFromBacklog,
   startGreenfield,
   updateFeatureStatus
-} from "./chunk-HOH43IQ2.js";
-import "./chunk-C725DWSB.js";
+} from "./chunk-24EXBX7P.js";
+import "./chunk-RRBKQ76B.js";
 import "./chunk-A752UVPF.js";
 import "./chunk-67AUAGNV.js";
 import "./chunk-7MJYPJMR.js";

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 
 declare const GateSchema: z.ZodObject<{
     type: z.ZodDefault<z.ZodEnum<["none", "soft", "hard"]>>;
@@ -1410,6 +1411,7 @@ declare function defaultsRoot(): string;
 declare function defaultWorkflowsDir(): string;
 declare function defaultTemplatesDir(): string;
 declare function defaultMemoryDir(): string;
+declare function defaultMcpYamlPath(): string;
 
 declare function pathExists(path: string): Promise<boolean>;
 declare function ensureDir(path: string): Promise<void>;
@@ -1762,4 +1764,399 @@ declare function updateFeatureStatus(backlogPath: string, featureId: string, sta
  */
 declare function promoteGreenfieldToMemory(projectRoot: string, config: Config, changeId: string): Promise<string[]>;
 
-export { AGENT_INTEGRATIONS, AGENT_TARGET_OPTIONS, ALL_AGENT_TARGETS, type AdapterExtractResult, AdapterRegistry, type AdvanceResult, type AgentIntegration, type AgentTarget, type AgentTargetOption, type ArtifactDef, ArtifactDefSchema, type BuildRefinePlanOptions, type ChangeContext, type ChangeMeta, ChangeMetaSchema, type CodeContextCaps, type CodeContextGap, type CodeContextGapCode, type CodeContextRequest, type CodeContextResult, type CodeContextSummary, type CodeSlice, type Complexity, type Config, ConfigSchema, type CreateChangeInput, DEFAULT_CODE_CONTEXT_CAPS, DEFAULT_INIT_INTEGRATION, type FocusPlan, type Gate, GateSchema, type GenerateCodeContextDeps, type GreenfieldFeature, type InitOptions, type InitResult, type InstallAgentOptions, type InstallAgentResult, type InstallAgentsOptions, type InstallAgentsResult, type InstalledAgentSnapshot, type LanguageAdapter, PROTOCOL_MD, type RefineArtifactRef, type RefineMode, type RefinePlan, SDD_AGENT_ROLES, SDD_DIR, type SddAgentRole, type SddAgentRoleId, type Stage, StageSchema, type StartFeatureInput, type StartGreenfieldInput, type StartGreenfieldResult, type SymbolInfo, type SymbolKind, VerifyCommandSchema, type VerifyResult, type Workflow, WorkflowSchema, activePointerPath, activeStages, advanceStage, agentHostPaths, agentKickoffMessage, approveGate, archiveDir, buildAgentPrompt, buildContext, buildRefinePlan, canLeaveStage, changeDirName, changeMetaPath, changePath, changesDir, classifyPath, clearActiveIf, completeChange, configPath, copyDir, copyDirSkipExisting, createChange, defaultConfig, defaultMemoryDir, defaultTemplatesDir, defaultWorkflowsDir, defaultsRoot, domainsDir, ensureDir, fallbackAdapter, fallbackIncompleteStageId, findFeaturesBacklogPath, firstActiveStageId, formatJsonSummary, formatStatus, generateCodeContext, getActiveChangeId, getIntegration, getStage, incompletePriorStageErrors, inferComplexity, initProject, installAgentIntegration, installAgentIntegrations, integrationKeyFor, isIgnoredPath, isInitialized, isSecretPath, isStageSkipped, isSubstantiveArtifactContent, listBacklogFeatures, listChanges, listDirs, listFiles, listWorkflowNames, loadChangeMeta, loadConfig, loadInstalledAgent, loadWorkflow, memoryDir, mergeCaps, nextStageId, nowIso, optionForTarget, parseAgentTargets, parseFeaturesBacklog, parseIntegration, pathExists, promoteGreenfieldToMemory, readText, readYaml, recommendWorkflow, refreshActiveAgentContext, removeOtherAgentHosts, removePath, renderThinAgent, resolveChangeId, resolveFocus, resolveStages, runLocalVerify, saveChangeMeta, saveConfig, sddRoot, setActiveChange, shouldAutoSkip, skipStage, slugify, startFeatureFromBacklog, startGreenfield, switchWorkflow, templatesDir, todayIsoDate, tokenizeKeywords, typescriptAdapter, uniqueChangeDirName, updateFeatureStatus, workflowsDir, writeAgentHandoff, writeRefineBrief, writeText, writeTextIfMissing, writeYaml };
+/**
+ * External MCP *sources* that sdd consumes (sdd = MCP client).
+ * Distinct from `sdd mcp serve` (sdd as MCP server for agents).
+ */
+declare const McpWhenSchema: z.ZodObject<{
+    /** Empty = all stages */
+    stages: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Empty = all workflows */
+    workflows: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Match title/query (case-insensitive substring) */
+    keywords: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * High-level intent tags the operator or tool may pass:
+     * code | ui | design | api | docs | data
+     */
+    intents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    stages: string[];
+    keywords: string[];
+    workflows: string[];
+    intents: string[];
+}, {
+    stages?: string[] | undefined;
+    keywords?: string[] | undefined;
+    workflows?: string[] | undefined;
+    intents?: string[] | undefined;
+}>;
+declare const McpInvokeSchema: z.ZodObject<{
+    /** Tool name on the remote MCP server */
+    tool: z.ZodString;
+    /**
+     * Static args + templates:
+     * {{query}} {{title}} {{stage}} {{workflow}} {{projectRoot}}
+     */
+    args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    tool: string;
+    args: Record<string, unknown>;
+}, {
+    tool: string;
+    args?: Record<string, unknown> | undefined;
+}>;
+declare const McpSourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    /** stdio only in v1 */
+    transport: z.ZodDefault<z.ZodEnum<["stdio"]>>;
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /** Working directory (default: project root). Supports {{projectRoot}} */
+    cwd: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Higher runs first when gathering */
+    priority: z.ZodDefault<z.ZodNumber>;
+    when: z.ZodDefault<z.ZodObject<{
+        /** Empty = all stages */
+        stages: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Empty = all workflows */
+        workflows: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Match title/query (case-insensitive substring) */
+        keywords: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * High-level intent tags the operator or tool may pass:
+         * code | ui | design | api | docs | data
+         */
+        intents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        stages: string[];
+        keywords: string[];
+        workflows: string[];
+        intents: string[];
+    }, {
+        stages?: string[] | undefined;
+        keywords?: string[] | undefined;
+        workflows?: string[] | undefined;
+        intents?: string[] | undefined;
+    }>>;
+    /**
+     * How sdd calls this source when auto-gathering for a stage.
+     * If omitted, `sdd mcp fetch` still works with an explicit --tool.
+     */
+    invoke: z.ZodOptional<z.ZodObject<{
+        /** Tool name on the remote MCP server */
+        tool: z.ZodString;
+        /**
+         * Static args + templates:
+         * {{query}} {{title}} {{stage}} {{workflow}} {{projectRoot}}
+         */
+        args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        args: Record<string, unknown>;
+    }, {
+        tool: string;
+        args?: Record<string, unknown> | undefined;
+    }>>;
+    /** Optional allowlist of tool names (documentation / validation) */
+    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    when: {
+        stages: string[];
+        keywords: string[];
+        workflows: string[];
+        intents: string[];
+    };
+    priority: number;
+    args: string[];
+    transport: "stdio";
+    command: string;
+    env: Record<string, string>;
+    enabled: boolean;
+    cwd?: string | undefined;
+    invoke?: {
+        tool: string;
+        args: Record<string, unknown>;
+    } | undefined;
+    tools?: string[] | undefined;
+}, {
+    id: string;
+    command: string;
+    description?: string | undefined;
+    when?: {
+        stages?: string[] | undefined;
+        keywords?: string[] | undefined;
+        workflows?: string[] | undefined;
+        intents?: string[] | undefined;
+    } | undefined;
+    priority?: number | undefined;
+    args?: string[] | undefined;
+    transport?: "stdio" | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    enabled?: boolean | undefined;
+    invoke?: {
+        tool: string;
+        args?: Record<string, unknown> | undefined;
+    } | undefined;
+    tools?: string[] | undefined;
+}>;
+declare const McpConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodNumber>;
+    /**
+     * When true, handoff generation calls matching sources with `invoke` and
+     * embeds results under "External MCP context".
+     */
+    auto_fetch_on_handoff: z.ZodDefault<z.ZodBoolean>;
+    /** Max chars of MCP output embedded into handoff per source */
+    max_chars_per_source: z.ZodDefault<z.ZodNumber>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodDefault<z.ZodString>;
+        /** stdio only in v1 */
+        transport: z.ZodDefault<z.ZodEnum<["stdio"]>>;
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /** Working directory (default: project root). Supports {{projectRoot}} */
+        cwd: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Higher runs first when gathering */
+        priority: z.ZodDefault<z.ZodNumber>;
+        when: z.ZodDefault<z.ZodObject<{
+            /** Empty = all stages */
+            stages: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /** Empty = all workflows */
+            workflows: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /** Match title/query (case-insensitive substring) */
+            keywords: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * High-level intent tags the operator or tool may pass:
+             * code | ui | design | api | docs | data
+             */
+            intents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            stages: string[];
+            keywords: string[];
+            workflows: string[];
+            intents: string[];
+        }, {
+            stages?: string[] | undefined;
+            keywords?: string[] | undefined;
+            workflows?: string[] | undefined;
+            intents?: string[] | undefined;
+        }>>;
+        /**
+         * How sdd calls this source when auto-gathering for a stage.
+         * If omitted, `sdd mcp fetch` still works with an explicit --tool.
+         */
+        invoke: z.ZodOptional<z.ZodObject<{
+            /** Tool name on the remote MCP server */
+            tool: z.ZodString;
+            /**
+             * Static args + templates:
+             * {{query}} {{title}} {{stage}} {{workflow}} {{projectRoot}}
+             */
+            args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            tool: string;
+            args: Record<string, unknown>;
+        }, {
+            tool: string;
+            args?: Record<string, unknown> | undefined;
+        }>>;
+        /** Optional allowlist of tool names (documentation / validation) */
+        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        when: {
+            stages: string[];
+            keywords: string[];
+            workflows: string[];
+            intents: string[];
+        };
+        priority: number;
+        args: string[];
+        transport: "stdio";
+        command: string;
+        env: Record<string, string>;
+        enabled: boolean;
+        cwd?: string | undefined;
+        invoke?: {
+            tool: string;
+            args: Record<string, unknown>;
+        } | undefined;
+        tools?: string[] | undefined;
+    }, {
+        id: string;
+        command: string;
+        description?: string | undefined;
+        when?: {
+            stages?: string[] | undefined;
+            keywords?: string[] | undefined;
+            workflows?: string[] | undefined;
+            intents?: string[] | undefined;
+        } | undefined;
+        priority?: number | undefined;
+        args?: string[] | undefined;
+        transport?: "stdio" | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+        enabled?: boolean | undefined;
+        invoke?: {
+            tool: string;
+            args?: Record<string, unknown> | undefined;
+        } | undefined;
+        tools?: string[] | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    auto_fetch_on_handoff: boolean;
+    max_chars_per_source: number;
+    sources: {
+        id: string;
+        description: string;
+        when: {
+            stages: string[];
+            keywords: string[];
+            workflows: string[];
+            intents: string[];
+        };
+        priority: number;
+        args: string[];
+        transport: "stdio";
+        command: string;
+        env: Record<string, string>;
+        enabled: boolean;
+        cwd?: string | undefined;
+        invoke?: {
+            tool: string;
+            args: Record<string, unknown>;
+        } | undefined;
+        tools?: string[] | undefined;
+    }[];
+}, {
+    version?: number | undefined;
+    auto_fetch_on_handoff?: boolean | undefined;
+    max_chars_per_source?: number | undefined;
+    sources?: {
+        id: string;
+        command: string;
+        description?: string | undefined;
+        when?: {
+            stages?: string[] | undefined;
+            keywords?: string[] | undefined;
+            workflows?: string[] | undefined;
+            intents?: string[] | undefined;
+        } | undefined;
+        priority?: number | undefined;
+        args?: string[] | undefined;
+        transport?: "stdio" | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+        enabled?: boolean | undefined;
+        invoke?: {
+            tool: string;
+            args?: Record<string, unknown> | undefined;
+        } | undefined;
+        tools?: string[] | undefined;
+    }[] | undefined;
+}>;
+type McpWhen = z.infer<typeof McpWhenSchema>;
+type McpInvoke = z.infer<typeof McpInvokeSchema>;
+type McpSource = z.infer<typeof McpSourceSchema>;
+type McpConfig = z.infer<typeof McpConfigSchema>;
+interface McpMatchContext {
+    stage?: string;
+    workflow?: string;
+    /** Free text: change title, user query, task line */
+    query?: string;
+    /** Explicit intent tags from CLI/agent */
+    intents?: string[];
+}
+interface McpFetchResult {
+    sourceId: string;
+    tool: string;
+    ok: boolean;
+    text: string;
+    error?: string;
+}
+
+declare function mcpConfigPath(projectRoot: string): string;
+declare function defaultMcpConfig(): McpConfig;
+/**
+ * Example sources (commented in written file via description only —
+ * we write a real empty config + README-style top comment is hard in YAML;
+ * document examples in docs).
+ */
+declare function loadMcpConfig(projectRoot: string): Promise<McpConfig>;
+declare function saveMcpConfig(projectRoot: string, config: McpConfig): Promise<string>;
+declare function ensureMcpConfig(projectRoot: string): Promise<McpConfig>;
+declare function addMcpSource(projectRoot: string, source: McpSource): Promise<McpConfig>;
+declare function removeMcpSource(projectRoot: string, id: string): Promise<McpConfig>;
+declare function interpolate(value: string, vars: Record<string, string>): string;
+declare function interpolateArgs(args: Record<string, unknown>, vars: Record<string, string>): Record<string, unknown>;
+
+/**
+ * Decide which configured MCP sources apply for this stage / workflow / query.
+ *
+ * 1. enabled
+ * 2. when.stages → stage must match (if stage known)
+ * 3. when.workflows → workflow must match (if workflow known)
+ * 4. when.intents + caller passed intents → require intersection
+ * 5. when.keywords + query present → require a keyword substring hit
+ *
+ * So: stage routing always; intents/keywords refine when the caller provides signals.
+ */
+declare function matchMcpSources(sources: McpSource[], ctx: McpMatchContext): McpSource[];
+/** Human explanation of match for CLI */
+declare function explainMatch(source: McpSource, ctx: McpMatchContext): string;
+
+/**
+ * sdd as MCP *client* — connect to external stdio MCP servers and call tools.
+ */
+
+interface CallMcpToolResult {
+    ok: boolean;
+    text: string;
+    error?: string;
+}
+/**
+ * One-shot: spawn source, list tools or call tool, then close.
+ */
+declare function withMcpSource<T>(source: McpSource, projectRoot: string, fn: (client: Client) => Promise<T>): Promise<T>;
+declare function listMcpSourceTools(source: McpSource, projectRoot: string): Promise<{
+    name: string;
+    description?: string;
+}[]>;
+declare function callMcpSourceTool(source: McpSource, projectRoot: string, tool: string, args: Record<string, unknown>): Promise<CallMcpToolResult>;
+
+interface GatherMcpOptions {
+    projectRoot: string;
+    match: McpMatchContext;
+    /** Only these source ids (default: all matching) */
+    sourceIds?: string[];
+    /** Force tool/args instead of source.invoke */
+    tool?: string;
+    args?: Record<string, unknown>;
+    /** Skip sources without invoke unless tool override */
+    requireInvoke?: boolean;
+}
+/**
+ * Call matching external MCP sources and collect text for agents / handoff.
+ */
+declare function gatherMcpContext(opts: GatherMcpOptions): Promise<McpFetchResult[]>;
+declare function gatherMcpContextForChange(projectRoot: string, ctx: ChangeContext, extra?: {
+    query?: string;
+    intents?: string[];
+}): Promise<McpFetchResult[]>;
+declare function formatMcpContextForHandoff(results: McpFetchResult[]): string;
+declare function listMatchingSourceIds(sources: McpSource[], match: McpMatchContext): string[];
+
+export { AGENT_INTEGRATIONS, AGENT_TARGET_OPTIONS, ALL_AGENT_TARGETS, type AdapterExtractResult, AdapterRegistry, type AdvanceResult, type AgentIntegration, type AgentTarget, type AgentTargetOption, type ArtifactDef, ArtifactDefSchema, type BuildRefinePlanOptions, type CallMcpToolResult, type ChangeContext, type ChangeMeta, ChangeMetaSchema, type CodeContextCaps, type CodeContextGap, type CodeContextGapCode, type CodeContextRequest, type CodeContextResult, type CodeContextSummary, type CodeSlice, type Complexity, type Config, ConfigSchema, type CreateChangeInput, DEFAULT_CODE_CONTEXT_CAPS, DEFAULT_INIT_INTEGRATION, type FocusPlan, type Gate, GateSchema, type GatherMcpOptions, type GenerateCodeContextDeps, type GreenfieldFeature, type InitOptions, type InitResult, type InstallAgentOptions, type InstallAgentResult, type InstallAgentsOptions, type InstallAgentsResult, type InstalledAgentSnapshot, type LanguageAdapter, type McpConfig, McpConfigSchema, type McpFetchResult, type McpInvoke, McpInvokeSchema, type McpMatchContext, type McpSource, McpSourceSchema, type McpWhen, McpWhenSchema, PROTOCOL_MD, type RefineArtifactRef, type RefineMode, type RefinePlan, SDD_AGENT_ROLES, SDD_DIR, type SddAgentRole, type SddAgentRoleId, type Stage, StageSchema, type StartFeatureInput, type StartGreenfieldInput, type StartGreenfieldResult, type SymbolInfo, type SymbolKind, VerifyCommandSchema, type VerifyResult, type Workflow, WorkflowSchema, activePointerPath, activeStages, addMcpSource, advanceStage, agentHostPaths, agentKickoffMessage, approveGate, archiveDir, buildAgentPrompt, buildContext, buildRefinePlan, callMcpSourceTool, canLeaveStage, changeDirName, changeMetaPath, changePath, changesDir, classifyPath, clearActiveIf, completeChange, configPath, copyDir, copyDirSkipExisting, createChange, defaultConfig, defaultMcpConfig, defaultMcpYamlPath, defaultMemoryDir, defaultTemplatesDir, defaultWorkflowsDir, defaultsRoot, domainsDir, ensureDir, ensureMcpConfig, explainMatch, fallbackAdapter, fallbackIncompleteStageId, findFeaturesBacklogPath, firstActiveStageId, formatJsonSummary, formatMcpContextForHandoff, formatStatus, gatherMcpContext, gatherMcpContextForChange, generateCodeContext, getActiveChangeId, getIntegration, getStage, incompletePriorStageErrors, inferComplexity, initProject, installAgentIntegration, installAgentIntegrations, integrationKeyFor, interpolate, interpolateArgs, isIgnoredPath, isInitialized, isSecretPath, isStageSkipped, isSubstantiveArtifactContent, listBacklogFeatures, listChanges, listDirs, listFiles, listMatchingSourceIds, listMcpSourceTools, listWorkflowNames, loadChangeMeta, loadConfig, loadInstalledAgent, loadMcpConfig, loadWorkflow, matchMcpSources, mcpConfigPath, memoryDir, mergeCaps, nextStageId, nowIso, optionForTarget, parseAgentTargets, parseFeaturesBacklog, parseIntegration, pathExists, promoteGreenfieldToMemory, readText, readYaml, recommendWorkflow, refreshActiveAgentContext, removeMcpSource, removeOtherAgentHosts, removePath, renderThinAgent, resolveChangeId, resolveFocus, resolveStages, runLocalVerify, saveChangeMeta, saveConfig, saveMcpConfig, sddRoot, setActiveChange, shouldAutoSkip, skipStage, slugify, startFeatureFromBacklog, startGreenfield, switchWorkflow, templatesDir, todayIsoDate, tokenizeKeywords, typescriptAdapter, uniqueChangeDirName, updateFeatureStatus, withMcpSource, workflowsDir, writeAgentHandoff, writeRefineBrief, writeText, writeTextIfMissing, writeYaml };

package/dist/index.js

@@ -1,3 +1,48 @@
+import {
+  advanceStage,
+  approveGate,
+  canLeaveStage,
+  completeChange,
+  createChange,
+  fallbackIncompleteStageId,
+  findFeaturesBacklogPath,
+  incompletePriorStageErrors,
+  isSubstantiveArtifactContent,
+  listBacklogFeatures,
+  parseFeaturesBacklog,
+  promoteGreenfieldToMemory,
+  skipStage,
+  startFeatureFromBacklog,
+  startGreenfield,
+  switchWorkflow,
+  updateFeatureStatus
+} from "./chunk-24EXBX7P.js";
+import {
+  callMcpSourceTool,
+  explainMatch,
+  formatMcpContextForHandoff,
+  gatherMcpContext,
+  gatherMcpContextForChange,
+  listMatchingSourceIds,
+  listMcpSourceTools,
+  matchMcpSources,
+  withMcpSource
+} from "./chunk-VD3CPFAI.js";
+import {
+  McpConfigSchema,
+  McpInvokeSchema,
+  McpSourceSchema,
+  McpWhenSchema,
+  addMcpSource,
+  defaultMcpConfig,
+  ensureMcpConfig,
+  interpolate,
+  interpolateArgs,
+  loadMcpConfig,
+  mcpConfigPath,
+  removeMcpSource,
+  saveMcpConfig
+} from "./chunk-KYWETNFU.js";
 import {
   AGENT_INTEGRATIONS,
   AGENT_TARGET_OPTIONS,
@@ -19,36 +64,17 @@ import {
   removeOtherAgentHosts,
   renderThinAgent,
   writeAgentHandoff
-} from "./chunk-S7SHVKG4.js";
+} from "./chunk-GR7KIAR2.js";
+import {
+  buildAgentPrompt,
+  formatStatus
+} from "./chunk-RRBKQ76B.js";
 import {
   defaultConfig,
   isInitialized,
   loadConfig,
   saveConfig
 } from "./chunk-OJFMJHNL.js";
-import {
-  advanceStage,
-  approveGate,
-  canLeaveStage,
-  completeChange,
-  createChange,
-  fallbackIncompleteStageId,
-  findFeaturesBacklogPath,
-  incompletePriorStageErrors,
-  isSubstantiveArtifactContent,
-  listBacklogFeatures,
-  parseFeaturesBacklog,
-  promoteGreenfieldToMemory,
-  skipStage,
-  startFeatureFromBacklog,
-  startGreenfield,
-  switchWorkflow,
-  updateFeatureStatus
-} from "./chunk-HOH43IQ2.js";
-import {
-  buildAgentPrompt,
-  formatStatus
-} from "./chunk-C725DWSB.js";
 import {
   activeStages,
   buildContext,
@@ -144,6 +170,9 @@ function defaultTemplatesDir() {
 function defaultMemoryDir() {
   return join(defaultsRoot(), "memory");
 }
+function defaultMcpYamlPath() {
+  return join(defaultsRoot(), "mcp.yaml");
+}
 
 // src/init.ts
 async function initProject(opts) {
@@ -173,6 +202,12 @@ async function initProject(opts) {
     await copyDir(tSrc, tDest);
     created.push(tDest);
   }
+  const mcpSrc = defaultMcpYamlPath();
+  const mcpDest = mcpConfigPath(projectRoot);
+  if (await pathExists(mcpSrc)) {
+    const wrote = await writeTextIfMissing(mcpDest, await readText(mcpSrc));
+    if (wrote) created.push(mcpDest);
+  }
   const mDest = memoryDir(projectRoot, config);
   await ensureDir(mDest);
   const mSrc = defaultMemoryDir();
@@ -2098,6 +2133,10 @@ export {
   DEFAULT_CODE_CONTEXT_CAPS,
   DEFAULT_INIT_INTEGRATION,
   GateSchema,
+  McpConfigSchema,
+  McpInvokeSchema,
+  McpSourceSchema,
+  McpWhenSchema,
   PROTOCOL_MD,
   SDD_AGENT_ROLES,
   SDD_DIR,
@@ -2106,6 +2145,7 @@ export {
   WorkflowSchema,
   activePointerPath,
   activeStages,
+  addMcpSource,
   advanceStage,
   agentHostPaths,
   agentKickoffMessage,
@@ -2114,6 +2154,7 @@ export {
   buildAgentPrompt,
   buildContext,
   buildRefinePlan,
+  callMcpSourceTool,
   canLeaveStage,
   changeDirName,
   changeMetaPath,
@@ -2127,18 +2168,25 @@ export {
   copyDirSkipExisting,
   createChange,
   defaultConfig,
+  defaultMcpConfig,
+  defaultMcpYamlPath,
   defaultMemoryDir,
   defaultTemplatesDir,
   defaultWorkflowsDir,
   defaultsRoot,
   domainsDir,
   ensureDir,
+  ensureMcpConfig,
+  explainMatch,
   fallbackAdapter,
   fallbackIncompleteStageId,
   findFeaturesBacklogPath,
   firstActiveStageId,
   formatJsonSummary,
+  formatMcpContextForHandoff,
   formatStatus,
+  gatherMcpContext,
+  gatherMcpContextForChange,
   generateCodeContext,
   getActiveChangeId,
   getIntegration,
@@ -2149,6 +2197,8 @@ export {
   installAgentIntegration,
   installAgentIntegrations,
   integrationKeyFor,
+  interpolate,
+  interpolateArgs,
   isIgnoredPath,
   isInitialized,
   isSecretPath,
@@ -2158,11 +2208,16 @@ export {
   listChanges,
   listDirs,
   listFiles,
+  listMatchingSourceIds,
+  listMcpSourceTools,
   listWorkflowNames,
   loadChangeMeta,
   loadConfig,
   loadInstalledAgent,
+  loadMcpConfig,
   loadWorkflow,
+  matchMcpSources,
+  mcpConfigPath,
   memoryDir,
   mergeCaps,
   nextStageId,
@@ -2177,6 +2232,7 @@ export {
   readYaml,
   recommendWorkflow,
   refreshActiveAgentContext,
+  removeMcpSource,
   removeOtherAgentHosts,
   removePath,
   renderThinAgent,
@@ -2186,6 +2242,7 @@ export {
   runLocalVerify,
   saveChangeMeta,
   saveConfig,
+  saveMcpConfig,
   sddRoot,
   setActiveChange,
   shouldAutoSkip,
@@ -2200,6 +2257,7 @@ export {
   typescriptAdapter,
   uniqueChangeDirName,
   updateFeatureStatus,
+  withMcpSource,
   workflowsDir,
   writeAgentHandoff,
   writeRefineBrief,

package/dist/sources-PF45EUH2.js

@@ -0,0 +1,24 @@
+import {
+  addMcpSource,
+  defaultMcpConfig,
+  ensureMcpConfig,
+  interpolate,
+  interpolateArgs,
+  loadMcpConfig,
+  mcpConfigPath,
+  removeMcpSource,
+  saveMcpConfig
+} from "./chunk-KYWETNFU.js";
+import "./chunk-7MJYPJMR.js";
+import "./chunk-EPFURATC.js";
+export {
+  addMcpSource,
+  defaultMcpConfig,
+  ensureMcpConfig,
+  interpolate,
+  interpolateArgs,
+  loadMcpConfig,
+  mcpConfigPath,
+  removeMcpSource,
+  saveMcpConfig
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@structured-vibe-coding/core",
-  "version": "0.14.3",
+  "version": "0.16.0",
   "description": "Core engine for sdd — local Spec-Driven Development workflows, change packs, greenfield, and agent handoff",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,6 +17,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "pathe": "^2.0.3",
     "typescript": "^5.8.2",
     "yaml": "^2.7.0",