@versatly/workgraph 0.2.0 → 0.3.0

package/dist/cli.js

@@ -1,22 +1,27 @@
 import {
   bases_exports,
   board_exports,
+  clawdapus_exports,
   command_center_exports,
+  integration_exports,
+  onboard_exports,
+  search_qmd_adapter_exports,
+  skill_exports,
+  trigger_exports,
+  workspace_exports
+} from "./chunk-E3QU5Y53.js";
+import {
   dispatch_exports,
   graph_exports,
   ledger_exports,
-  onboard_exports,
+  mcp_server_exports,
   orientation_exports,
   policy_exports,
   query_exports,
   registry_exports,
-  search_qmd_adapter_exports,
-  skill_exports,
   store_exports,
-  thread_exports,
-  trigger_exports,
-  workspace_exports
-} from "./chunk-XUMA4O2Z.js";
+  thread_exports
+} from "./chunk-65ZMX2WM.js";
 
 // src/cli.ts
 import fs from "fs";
@@ -512,6 +517,40 @@ addWorkspaceOption(
     ]
   )
 );
+var integrationCmd = program.command("integration").description("Manage optional third-party integrations");
+addWorkspaceOption(
+  integrationCmd.command("list").description("List supported optional integrations").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => ({
+      integrations: integration_exports.listIntegrations()
+    }),
+    (result) => result.integrations.map((integration) => `${integration.id} (${integration.defaultTitle}) -> ${integration.defaultSourceUrl}`)
+  )
+);
+addWorkspaceOption(
+  integrationCmd.command("install <integrationName>").description("Install an optional integration into this workspace").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--owner <name>", "Skill owner override").option("--title <title>", "Skill title to store in workgraph").option("--source-url <url>", "Source URL override for integration content").option("--force", "Overwrite an existing imported integration skill").option("--json", "Emit structured JSON output")
+).action(
+  (integrationName, opts) => runCommand(
+    opts,
+    () => installNamedIntegration(resolveWorkspacePath(opts), integrationName, opts),
+    renderInstalledIntegrationResult
+  )
+);
+addWorkspaceOption(
+  integrationCmd.command("clawdapus").description("Import Clawdapus SKILL.md into this workspace").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--owner <name>", "Skill owner override").option("--title <title>", "Skill title to store in workgraph", "clawdapus").option(
+    "--source-url <url>",
+    "Source URL for Clawdapus SKILL.md",
+    clawdapus_exports.DEFAULT_CLAWDAPUS_SKILL_URL
+  ).option("--force", "Overwrite an existing imported Clawdapus skill").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => installNamedIntegration(resolveWorkspacePath(opts), "clawdapus", opts),
+    renderInstalledIntegrationResult
+  )
+);
 var ledgerCmd = program.command("ledger").description("Inspect the append-only workgraph ledger");
 addWorkspaceOption(
   ledgerCmd.command("show").description("Show recent ledger entries").option("-n, --count <n>", "Number of entries", "20").option("--actor <name>", "Filter by actor").option("--json", "Emit structured JSON output")
@@ -933,6 +972,39 @@ addWorkspaceOption(
     (result) => [`Run created: ${result.run.id} [${result.run.status}]`]
   )
 );
+addWorkspaceOption(
+  dispatchCmd.command("create-execute <objective>").description("Create and execute a run with autonomous multi-agent coordination").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--adapter <name>", "Adapter name", "cursor-cloud").option("--idempotency-key <key>", "Idempotency key").option("--agents <actors>", "Comma-separated agent identities for autonomous execution").option("--max-steps <n>", "Maximum scheduler steps", "200").option("--step-delay-ms <ms>", "Delay between scheduling steps", "25").option("--space <spaceRef>", "Restrict execution to one space").option("--no-checkpoint", "Skip automatic checkpoint generation after execution").option("--json", "Emit structured JSON output")
+).action(
+  (objective, opts) => runCommand(
+    opts,
+    async () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        run: await dispatch_exports.createAndExecuteRun(
+          workspacePath,
+          {
+            actor: opts.actor,
+            adapter: opts.adapter,
+            objective,
+            idempotencyKey: opts.idempotencyKey
+          },
+          {
+            agents: csv(opts.agents),
+            maxSteps: Number.parseInt(String(opts.maxSteps), 10),
+            stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
+            space: opts.space,
+            createCheckpoint: opts.checkpoint
+          }
+        )
+      };
+    },
+    (result) => [
+      `Run executed: ${result.run.id} [${result.run.status}]`,
+      ...result.run.output ? [`Output: ${result.run.output}`] : [],
+      ...result.run.error ? [`Error: ${result.run.error}`] : []
+    ]
+  )
+);
 addWorkspaceOption(
   dispatchCmd.command("list").description("List runs").option("--status <status>", "queued|running|succeeded|failed|cancelled").option("--limit <n>", "Result limit").option("--json", "Emit structured JSON output")
 ).action(
@@ -964,6 +1036,31 @@ addWorkspaceOption(
     (result) => [`${result.run.id} [${result.run.status}]`]
   )
 );
+addWorkspaceOption(
+  dispatchCmd.command("execute <runId>").description("Execute a queued/running run via adapter autonomous scheduling").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--agents <actors>", "Comma-separated agent identities").option("--max-steps <n>", "Maximum scheduler steps", "200").option("--step-delay-ms <ms>", "Delay between scheduling steps", "25").option("--space <spaceRef>", "Restrict execution to one space").option("--no-checkpoint", "Skip automatic checkpoint generation after execution").option("--json", "Emit structured JSON output")
+).action(
+  (runId, opts) => runCommand(
+    opts,
+    async () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        run: await dispatch_exports.executeRun(workspacePath, runId, {
+          actor: opts.actor,
+          agents: csv(opts.agents),
+          maxSteps: Number.parseInt(String(opts.maxSteps), 10),
+          stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
+          space: opts.space,
+          createCheckpoint: opts.checkpoint
+        })
+      };
+    },
+    (result) => [
+      `Run executed: ${result.run.id} [${result.run.status}]`,
+      ...result.run.output ? [`Output: ${result.run.output}`] : [],
+      ...result.run.error ? [`Error: ${result.run.error}`] : []
+    ]
+  )
+);
 addWorkspaceOption(
   dispatchCmd.command("followup <runId> <input>").description("Send follow-up input to a run").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--json", "Emit structured JSON output")
 ).action(
@@ -1107,7 +1204,19 @@ addWorkspaceOption(
     (result) => [`Updated onboarding: ${result.onboarding.path} [${String(result.onboarding.fields.status)}]`]
   )
 );
-program.parse();
+var mcpCmd = program.command("mcp").description("Run Workgraph MCP server");
+addWorkspaceOption(
+  mcpCmd.command("serve").description("Serve stdio MCP tools/resources for this workspace").option("-a, --actor <name>", "Default actor for MCP write tools", DEFAULT_ACTOR).option("--read-only", "Disable all MCP write tools")
+).action(async (opts) => {
+  const workspacePath = resolveWorkspacePath(opts);
+  console.error(`Starting MCP server for workspace: ${workspacePath}`);
+  await mcp_server_exports.startWorkgraphMcpServer({
+    workspacePath,
+    defaultActor: opts.actor,
+    readOnly: !!opts.readOnly
+  });
+});
+await program.parseAsync();
 function addWorkspaceOption(command) {
   return command.option("-w, --workspace <path>", "Workgraph workspace path").option("--vault <path>", "Alias for --workspace").option("--shared-vault <path>", "Shared vault path (e.g. mounted via Tailscale)");
 }
@@ -1134,6 +1243,22 @@ function csv(value) {
   if (!value) return void 0;
   return String(value).split(",").map((s) => s.trim()).filter(Boolean);
 }
+function installNamedIntegration(workspacePath, integrationName, opts) {
+  return integration_exports.installIntegration(workspacePath, integrationName, {
+    actor: opts.actor,
+    owner: opts.owner,
+    title: opts.title,
+    sourceUrl: opts.sourceUrl,
+    force: !!opts.force
+  });
+}
+function renderInstalledIntegrationResult(result) {
+  return [
+    `${result.replacedExisting ? "Updated" : "Installed"} ${result.provider} integration skill: ${result.skill.path}`,
+    `Source: ${result.sourceUrl}`,
+    `Status: ${String(result.skill.fields.status)}`
+  ];
+}
 function parseScalar(value) {
   if (value === "true") return true;
   if (value === "false") return false;
@@ -1173,9 +1298,9 @@ function wantsJson(opts) {
   if (process.env.WORKGRAPH_JSON === "1") return true;
   return false;
 }
-function runCommand(opts, action, renderText) {
+async function runCommand(opts, action, renderText) {
   try {
-    const result = action();
+    const result = await action();
     if (wantsJson(opts)) {
       console.log(JSON.stringify({ ok: true, data: result }, null, 2));
       return;

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+export { m as mcpServer } from './mcp-server-fU6U6ht8.js';
+import '@modelcontextprotocol/sdk/server/mcp.js';
+
 /**
  * Workgraph type definitions.
  */
@@ -693,7 +696,7 @@ declare namespace policy {
 }
 
 /**
- * Runtime dispatch contract (MVP local adapter).
+ * Runtime dispatch contract with adapter-backed execution.
  */
 
 interface DispatchCreateInput {
@@ -703,6 +706,14 @@ interface DispatchCreateInput {
     context?: Record<string, unknown>;
     idempotencyKey?: string;
 }
+interface DispatchExecuteInput {
+    actor: string;
+    agents?: string[];
+    maxSteps?: number;
+    stepDelayMs?: number;
+    space?: string;
+    createCheckpoint?: boolean;
+}
 declare function createRun(workspacePath: string, input: DispatchCreateInput): DispatchRun;
 declare function status(workspacePath: string, runId: string): DispatchRun;
 declare function followup(workspacePath: string, runId: string, actor: string, input: string): DispatchRun;
@@ -710,15 +721,21 @@ declare function stop(workspacePath: string, runId: string, actor: string): Disp
 declare function markRun(workspacePath: string, runId: string, actor: string, nextStatus: Exclude<RunStatus, 'queued'>, options?: {
     output?: string;
     error?: string;
+    contextPatch?: Record<string, unknown>;
 }): DispatchRun;
 declare function logs(workspacePath: string, runId: string): DispatchRun['logs'];
 declare function listRuns(workspacePath: string, options?: {
     status?: RunStatus;
     limit?: number;
 }): DispatchRun[];
+declare function executeRun(workspacePath: string, runId: string, input: DispatchExecuteInput): Promise<DispatchRun>;
+declare function createAndExecuteRun(workspacePath: string, createInput: DispatchCreateInput, executeInput?: Omit<DispatchExecuteInput, 'actor'>): Promise<DispatchRun>;
 
 type dispatch_DispatchCreateInput = DispatchCreateInput;
+type dispatch_DispatchExecuteInput = DispatchExecuteInput;
+declare const dispatch_createAndExecuteRun: typeof createAndExecuteRun;
 declare const dispatch_createRun: typeof createRun;
+declare const dispatch_executeRun: typeof executeRun;
 declare const dispatch_followup: typeof followup;
 declare const dispatch_listRuns: typeof listRuns;
 declare const dispatch_logs: typeof logs;
@@ -726,7 +743,7 @@ declare const dispatch_markRun: typeof markRun;
 declare const dispatch_status: typeof status;
 declare const dispatch_stop: typeof stop;
 declare namespace dispatch {
-  export { type dispatch_DispatchCreateInput as DispatchCreateInput, dispatch_createRun as createRun, dispatch_followup as followup, dispatch_listRuns as listRuns, dispatch_logs as logs, dispatch_markRun as markRun, dispatch_status as status, dispatch_stop as stop };
+  export { type dispatch_DispatchCreateInput as DispatchCreateInput, type dispatch_DispatchExecuteInput as DispatchExecuteInput, dispatch_createAndExecuteRun as createAndExecuteRun, dispatch_createRun as createRun, dispatch_executeRun as executeRun, dispatch_followup as followup, dispatch_listRuns as listRuns, dispatch_logs as logs, dispatch_markRun as markRun, dispatch_status as status, dispatch_stop as stop };
 }
 
 /**
@@ -811,4 +828,120 @@ declare namespace trigger {
   export { type trigger_FireTriggerOptions as FireTriggerOptions, type trigger_FireTriggerResult as FireTriggerResult, trigger_fireTrigger as fireTrigger };
 }
 
-export { type DispatchRun, type FieldDefinition, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PolicyParty, type PolicyRegistry, type PrimitiveInstance, type PrimitiveQueryFilters, type PrimitiveTypeDefinition, type Registry, type RunStatus, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphBrief, type WorkgraphStatusSnapshot, type WorkgraphWorkspaceConfig, bases, board, commandCenter, dispatch, graph, ledger, onboard, orientation, policy, query, registry, searchQmdAdapter, skill, store, thread, trigger, workspace };
+interface SkillIntegrationProvider {
+    id: string;
+    defaultTitle: string;
+    defaultSourceUrl: string;
+    distribution: string;
+    defaultTags: string[];
+    userAgent?: string;
+}
+interface InstallSkillIntegrationOptions {
+    actor: string;
+    owner?: string;
+    title?: string;
+    sourceUrl?: string;
+    force?: boolean;
+    status?: WriteSkillOptions['status'];
+    tags?: string[];
+    fetchSkillMarkdown?: (sourceUrl: string) => Promise<string>;
+}
+interface InstallSkillIntegrationResult {
+    provider: string;
+    skill: PrimitiveInstance;
+    sourceUrl: string;
+    importedAt: string;
+    replacedExisting: boolean;
+}
+declare function installSkillIntegration(workspacePath: string, provider: SkillIntegrationProvider, options: InstallSkillIntegrationOptions): Promise<InstallSkillIntegrationResult>;
+declare function fetchSkillMarkdownFromUrl(sourceUrl: string, userAgent?: string): Promise<string>;
+
+declare const DEFAULT_CLAWDAPUS_SKILL_URL = "https://raw.githubusercontent.com/mostlydev/clawdapus/master/skills/clawdapus/SKILL.md";
+declare const CLAWDAPUS_INTEGRATION_PROVIDER: SkillIntegrationProvider;
+type InstallClawdapusSkillOptions = InstallSkillIntegrationOptions;
+type InstallClawdapusSkillResult = InstallSkillIntegrationResult;
+declare function installClawdapusSkill(workspacePath: string, options: InstallClawdapusSkillOptions): Promise<InstallClawdapusSkillResult>;
+declare function fetchClawdapusSkillMarkdown(sourceUrl: string): Promise<string>;
+
+declare const clawdapus_CLAWDAPUS_INTEGRATION_PROVIDER: typeof CLAWDAPUS_INTEGRATION_PROVIDER;
+declare const clawdapus_DEFAULT_CLAWDAPUS_SKILL_URL: typeof DEFAULT_CLAWDAPUS_SKILL_URL;
+type clawdapus_InstallClawdapusSkillOptions = InstallClawdapusSkillOptions;
+type clawdapus_InstallClawdapusSkillResult = InstallClawdapusSkillResult;
+declare const clawdapus_fetchClawdapusSkillMarkdown: typeof fetchClawdapusSkillMarkdown;
+declare const clawdapus_installClawdapusSkill: typeof installClawdapusSkill;
+declare namespace clawdapus {
+  export { clawdapus_CLAWDAPUS_INTEGRATION_PROVIDER as CLAWDAPUS_INTEGRATION_PROVIDER, clawdapus_DEFAULT_CLAWDAPUS_SKILL_URL as DEFAULT_CLAWDAPUS_SKILL_URL, type clawdapus_InstallClawdapusSkillOptions as InstallClawdapusSkillOptions, type clawdapus_InstallClawdapusSkillResult as InstallClawdapusSkillResult, clawdapus_fetchClawdapusSkillMarkdown as fetchClawdapusSkillMarkdown, clawdapus_installClawdapusSkill as installClawdapusSkill };
+}
+
+interface IntegrationDescriptor {
+    id: string;
+    description: string;
+    defaultTitle: string;
+    defaultSourceUrl: string;
+}
+declare function listIntegrations(): IntegrationDescriptor[];
+declare function installIntegration(workspacePath: string, integrationId: string, options: InstallSkillIntegrationOptions): Promise<InstallSkillIntegrationResult>;
+
+type integration_IntegrationDescriptor = IntegrationDescriptor;
+declare const integration_installIntegration: typeof installIntegration;
+declare const integration_listIntegrations: typeof listIntegrations;
+declare namespace integration {
+  export { type integration_IntegrationDescriptor as IntegrationDescriptor, integration_installIntegration as installIntegration, integration_listIntegrations as listIntegrations };
+}
+
+interface DispatchAdapterCreateInput {
+    actor: string;
+    objective: string;
+    idempotencyKey?: string;
+    context?: Record<string, unknown>;
+}
+interface DispatchAdapterRunStatus {
+    runId: string;
+    status: RunStatus;
+}
+interface DispatchAdapterLogEntry {
+    ts: string;
+    level: 'info' | 'warn' | 'error';
+    message: string;
+}
+interface DispatchAdapterExecutionInput {
+    workspacePath: string;
+    runId: string;
+    actor: string;
+    objective: string;
+    context?: Record<string, unknown>;
+    agents?: string[];
+    maxSteps?: number;
+    stepDelayMs?: number;
+    space?: string;
+    createCheckpoint?: boolean;
+    isCancelled?: () => boolean;
+}
+interface DispatchAdapterExecutionResult {
+    status: RunStatus;
+    output?: string;
+    error?: string;
+    logs: DispatchAdapterLogEntry[];
+    metrics?: Record<string, unknown>;
+}
+interface DispatchAdapter {
+    name: string;
+    create(input: DispatchAdapterCreateInput): Promise<DispatchAdapterRunStatus>;
+    status(runId: string): Promise<DispatchAdapterRunStatus>;
+    followup(runId: string, actor: string, input: string): Promise<DispatchAdapterRunStatus>;
+    stop(runId: string, actor: string): Promise<DispatchAdapterRunStatus>;
+    logs(runId: string): Promise<DispatchAdapterLogEntry[]>;
+    execute?(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult>;
+}
+
+declare class CursorCloudAdapter implements DispatchAdapter {
+    name: string;
+    create(_input: DispatchAdapterCreateInput): Promise<DispatchAdapterRunStatus>;
+    status(runId: string): Promise<DispatchAdapterRunStatus>;
+    followup(runId: string, _actor: string, _input: string): Promise<DispatchAdapterRunStatus>;
+    stop(runId: string, _actor: string): Promise<DispatchAdapterRunStatus>;
+    logs(_runId: string): Promise<DispatchAdapterLogEntry[]>;
+    execute(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult>;
+}
+
+export { CursorCloudAdapter, type DispatchAdapter, type DispatchAdapterCreateInput, type DispatchAdapterExecutionInput, type DispatchAdapterExecutionResult, type DispatchAdapterLogEntry, type DispatchAdapterRunStatus, type DispatchRun, type FieldDefinition, type InstallSkillIntegrationOptions, type InstallSkillIntegrationResult, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PolicyParty, type PolicyRegistry, type PrimitiveInstance, type PrimitiveQueryFilters, type PrimitiveTypeDefinition, type Registry, type RunStatus, type SkillIntegrationProvider, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphBrief, type WorkgraphStatusSnapshot, type WorkgraphWorkspaceConfig, bases, board, clawdapus, commandCenter, dispatch, fetchSkillMarkdownFromUrl, graph, installSkillIntegration, integration, ledger, onboard, orientation, policy, query, registry, searchQmdAdapter, skill, store, thread, trigger, workspace };

package/dist/index.js

@@ -1,31 +1,45 @@
 import {
-  THREAD_STATUS_TRANSITIONS,
   bases_exports,
   board_exports,
+  clawdapus_exports,
   command_center_exports,
+  fetchSkillMarkdownFromUrl,
+  installSkillIntegration,
+  integration_exports,
+  onboard_exports,
+  search_qmd_adapter_exports,
+  skill_exports,
+  trigger_exports,
+  workspace_exports
+} from "./chunk-E3QU5Y53.js";
+import {
+  CursorCloudAdapter,
+  THREAD_STATUS_TRANSITIONS,
   dispatch_exports,
   graph_exports,
   ledger_exports,
-  onboard_exports,
+  mcp_server_exports,
   orientation_exports,
   policy_exports,
   query_exports,
   registry_exports,
-  search_qmd_adapter_exports,
-  skill_exports,
   store_exports,
-  thread_exports,
-  trigger_exports,
-  workspace_exports
-} from "./chunk-XUMA4O2Z.js";
+  thread_exports
+} from "./chunk-65ZMX2WM.js";
 export {
+  CursorCloudAdapter,
   THREAD_STATUS_TRANSITIONS,
   bases_exports as bases,
   board_exports as board,
+  clawdapus_exports as clawdapus,
   command_center_exports as commandCenter,
   dispatch_exports as dispatch,
+  fetchSkillMarkdownFromUrl,
   graph_exports as graph,
+  installSkillIntegration,
+  integration_exports as integration,
   ledger_exports as ledger,
+  mcp_server_exports as mcpServer,
   onboard_exports as onboard,
   orientation_exports as orientation,
   policy_exports as policy,

package/dist/mcp-server-fU6U6ht8.d.ts

@@ -0,0 +1,20 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+interface WorkgraphMcpServerOptions {
+    workspacePath: string;
+    defaultActor?: string;
+    readOnly?: boolean;
+    name?: string;
+    version?: string;
+}
+declare function createWorkgraphMcpServer(options: WorkgraphMcpServerOptions): McpServer;
+declare function startWorkgraphMcpServer(options: WorkgraphMcpServerOptions): Promise<McpServer>;
+
+type mcpServer_WorkgraphMcpServerOptions = WorkgraphMcpServerOptions;
+declare const mcpServer_createWorkgraphMcpServer: typeof createWorkgraphMcpServer;
+declare const mcpServer_startWorkgraphMcpServer: typeof startWorkgraphMcpServer;
+declare namespace mcpServer {
+  export { type mcpServer_WorkgraphMcpServerOptions as WorkgraphMcpServerOptions, mcpServer_createWorkgraphMcpServer as createWorkgraphMcpServer, mcpServer_startWorkgraphMcpServer as startWorkgraphMcpServer };
+}
+
+export { type WorkgraphMcpServerOptions as W, createWorkgraphMcpServer as c, mcpServer as m, startWorkgraphMcpServer as s };

package/dist/mcp-server.d.ts

@@ -0,0 +1,2 @@
+import '@modelcontextprotocol/sdk/server/mcp.js';
+export { W as WorkgraphMcpServerOptions, c as createWorkgraphMcpServer, s as startWorkgraphMcpServer } from './mcp-server-fU6U6ht8.js';

package/dist/mcp-server.js

@@ -0,0 +1,8 @@
+import {
+  createWorkgraphMcpServer,
+  startWorkgraphMcpServer
+} from "./chunk-65ZMX2WM.js";
+export {
+  createWorkgraphMcpServer,
+  startWorkgraphMcpServer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versatly/workgraph",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Agent-first workgraph workspace for multi-agent coordination with dynamic primitives, append-only ledger, and markdown-native storage.",
   "workspaces": [
     "packages/*"
@@ -14,6 +14,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./mcp-server": {
+      "types": "./dist/mcp-server.d.ts",
+      "import": "./dist/mcp-server.js"
+    },
     "./cli": {
       "types": "./dist/cli.d.ts",
       "import": "./dist/cli.js"
@@ -30,7 +34,7 @@
     "SKILL.md"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/cli.ts src/mcp-server.ts --format esm --dts --clean",
     "build:packages": "npm run build --workspaces --if-present",
     "typecheck": "tsc --noEmit",
     "typecheck:packages": "npm run typecheck --workspaces --if-present",
@@ -63,9 +67,11 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "commander": "^12.0.0",
     "gray-matter": "^4.0.3",
-    "yaml": "^2.8.1"
+    "yaml": "^2.8.1",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",