mergestorm-mcp 0.1.0 → 0.1.3

package/README.md

@@ -1,6 +1,11 @@
 # mergestorm-mcp
 
-Stdio MCP server for Mergestorm. Tools: `whoami`, `credits`, `review_list`, `review_get`, `review_submit`, `review_wait`.
+Stdio MCP server for Mergestorm. Tools: `whoami`, `credits`, `review_list`, `review_get`, `review_get_pr`, `review_submit`, `review_wait`, `review_wait_pr`, `stack_list`, `stack_status`, `queue_status`, `settings_get`, `settings_set`.
+
+The stack tools are read-only:
+
+- `stack_list` returns the current API key owner's registered stacks.
+- `stack_status({ stack_id })` returns one owned stack with enriched checks and agent state, or a structured `stack_not_found` error.
 
 Auth is `MERGESTORM_API_KEY`, then `~/.mergestorm/config.json` (same as `mg`).
 

package/dist/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-#!/usr/bin/env node
 
 // src/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -7,7 +6,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { CommandError as CommandError6 } from "mergestorm/client";
+import { CommandError as CommandError10 } from "mergestorm/client";
 
 // src/tools/credits.ts
 import { CommandError, getMe, loadConfig } from "mergestorm/client";
@@ -35,16 +34,167 @@ async function credits(cfg) {
   };
 }
 
-// src/tools/review-get.ts
+// src/tools/queue-status.ts
 import {
+  apiFetch,
   CommandError as CommandError2,
+  isCommandErrorCode,
+  loadConfig as loadConfig2,
+  rateLimitedMessage,
+  REVIEW_EXIT
+} from "mergestorm/client";
+function entrySummary(entry) {
+  const repo = entry.owner && entry.repo ? `${entry.owner}/${entry.repo}` : "unknown repo";
+  const position = entry.position === void 0 ? "queue" : `#${entry.position}`;
+  return `${position} \xB7 ${repo} \xB7 stack ${entry.stackId ?? "unknown"} \xB7 ${entry.state ?? "unknown"}`;
+}
+async function queueStatus(stackId, cfg) {
+  try {
+    const resolved = cfg ?? await loadConfig2();
+    const { status, body, retryAfterSeconds } = await apiFetch(
+      resolved,
+      "/api/v1/stacks/queue"
+    );
+    if (status === 404) {
+      throw new CommandError2(
+        "Merge queue API is not available on this server yet. Deploy the API update or use the dashboard."
+      );
+    }
+    if (status === 429) {
+      throw new CommandError2(
+        rateLimitedMessage(retryAfterSeconds),
+        REVIEW_EXIT.rate_limited,
+        "rate_limited",
+        { retryAfterSeconds }
+      );
+    }
+    if (status !== 200) {
+      throw new CommandError2(
+        `Failed to get queue status (HTTP ${status}): ${JSON.stringify(body)}`
+      );
+    }
+    const entries = body.entries;
+    if (!Array.isArray(entries)) {
+      throw new CommandError2(
+        `Failed to get queue status (HTTP 200): ${JSON.stringify(body)}`
+      );
+    }
+    const id = stackId?.trim();
+    if (id) {
+      const entry = entries.find((candidate) => candidate?.stackId === id);
+      if (!entry) {
+        const message = `Live queue entry not found for stack: ${id}`;
+        return {
+          summary: message,
+          data: {
+            error: {
+              code: "queue_entry_not_found",
+              message,
+              stack_id: id
+            }
+          },
+          isError: true
+        };
+      }
+      return {
+        summary: entrySummary(entry),
+        data: { entry }
+      };
+    }
+    return {
+      summary: entries.length === 0 ? "No live merge queue entries" : entries.map(entrySummary).join("\n"),
+      data: { entries }
+    };
+  } catch (err) {
+    if (isCommandErrorCode(err, "rate_limited")) {
+      return {
+        summary: err.message,
+        data: {
+          error: {
+            code: "rate_limited",
+            message: err.message,
+            retry_after_seconds: err.retryAfterSeconds
+          }
+        },
+        isError: true
+      };
+    }
+    throw err;
+  }
+}
+
+// src/tools/review-get-pr.ts
+import {
+  CommandError as CommandError3,
+  getPrVortexReview,
+  isCommandErrorCode as isCommandErrorCode2
+} from "mergestorm/client";
+function prReviewTarget(owner, repo, prNumber) {
+  const cleanOwner = owner.trim();
+  const cleanRepo = repo.trim();
+  if (!cleanOwner || !cleanRepo || !Number.isInteger(prNumber) || prNumber <= 0) {
+    throw new CommandError3(
+      "owner, repo, and a positive pr_number are required",
+      2,
+      "usage"
+    );
+  }
+  return { owner: cleanOwner, repo: cleanRepo, prNumber };
+}
+function payloadFromPrReview(owner, repo, prNumber, envelope) {
+  return {
+    summary: `${owner}/${repo}#${prNumber} \xB7 ${envelope.status}`,
+    data: { ...envelope }
+  };
+}
+function payloadFromPrRateLimit(err, owner, repo, prNumber) {
+  if (!isCommandErrorCode2(err, "rate_limited")) return null;
+  return {
+    summary: `${owner}/${repo}#${prNumber} \xB7 rate_limited`,
+    data: {
+      status: "rate_limited",
+      error: err.message,
+      retry_after_seconds: err.retryAfterSeconds
+    }
+  };
+}
+async function reviewGetPr(owner, repo, prNumber, cfg) {
+  const target = prReviewTarget(owner, repo, prNumber);
+  try {
+    const envelope = await getPrVortexReview(
+      target.owner,
+      target.repo,
+      target.prNumber,
+      cfg
+    );
+    return payloadFromPrReview(
+      target.owner,
+      target.repo,
+      target.prNumber,
+      envelope
+    );
+  } catch (err) {
+    const rateLimited = payloadFromPrRateLimit(
+      err,
+      target.owner,
+      target.repo,
+      target.prNumber
+    );
+    if (rateLimited) return rateLimited;
+    throw err;
+  }
+}
+
+// src/tools/review-get.ts
+import {
+  CommandError as CommandError4,
   getReview,
   toReviewJobEnvelope as toReviewJobEnvelope2
 } from "mergestorm/client";
 
 // src/tools/envelope.ts
 import {
-  isCommandErrorCode,
+  isCommandErrorCode as isCommandErrorCode3,
   toReviewJobEnvelope
 } from "mergestorm/client";
 function payloadFromRow(row, fallback = {}) {
@@ -57,7 +207,7 @@ function payloadFromRow(row, fallback = {}) {
   };
 }
 function payloadFromRateLimit(err, jobId) {
-  if (!isCommandErrorCode(err, "rate_limited")) return null;
+  if (!isCommandErrorCode3(err, "rate_limited")) return null;
   return payloadFromRow(null, {
     jobId,
     status: "rate_limited",
@@ -77,7 +227,7 @@ async function reviewGet(jobId, cfg) {
     throw err;
   }
   if (!row || typeof row !== "object" || typeof row.status !== "string") {
-    throw new CommandError2(`Unexpected response for review ${jobId}.`);
+    throw new CommandError4(`Unexpected response for review ${jobId}.`);
   }
   const envelope = toReviewJobEnvelope2(row, { jobId });
   const bits = [envelope.status];
@@ -105,24 +255,45 @@ import { createHash } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { relative, resolve, sep } from "node:path";
 import {
-  CommandError as CommandError3,
+  CommandError as CommandError5,
   REVIEW_THREAD_SLUG_RE,
   ReviewPollTimeoutError,
   collectReviewInput,
-  loadConfig as loadConfig2,
+  loadConfig as loadConfig3,
   loadReviewContext,
   pollReview,
-  rateLimitedMessage,
+  rateLimitedMessage as rateLimitedMessage2,
   submitReview
 } from "mergestorm/client";
 var MCP_WAIT_CEILING_S = 300;
+var PINNABLE_SPECIALISTS = [
+  "security",
+  "performance",
+  "architecture",
+  "tests",
+  "data",
+  "api",
+  "frontend"
+];
+function assertPinnableSpecialists(specialists) {
+  if (!specialists?.length) return;
+  const unknown = specialists.filter(
+    (id) => !PINNABLE_SPECIALISTS.includes(id)
+  );
+  if (unknown.length === 0) return;
+  throw new CommandError5(
+    `Unknown specialist: ${unknown.join(", ")}. Valid lanes: ${PINNABLE_SPECIALISTS.join(", ")}. governance and seam cannot be requested.`,
+    2,
+    "usage"
+  );
+}
 function mcpSandboxRoot() {
   return process.env.MERGESTORM_SANDBOX_ROOT?.trim() || process.cwd();
 }
 function waitTimeoutMs(timeout_s) {
   const seconds = timeout_s ?? MCP_WAIT_CEILING_S;
   if (!Number.isFinite(seconds) || seconds <= 0) {
-    throw new CommandError3("timeout_s must be a positive number of seconds", 2, "usage");
+    throw new CommandError5("timeout_s must be a positive number of seconds", 2, "usage");
   }
   return Math.max(1, Math.round(Math.min(seconds, MCP_WAIT_CEILING_S) * 1e3));
 }
@@ -150,11 +321,11 @@ async function resolveInput(input) {
     ]);
     const relToSandbox = relative(sandboxReal, cwdReal);
     if (relToSandbox === ".." || relToSandbox.startsWith(`..${sep}`)) {
-      throw new CommandError3("cwd must be inside the configured sandbox root", 2, "usage");
+      throw new CommandError5("cwd must be inside the configured sandbox root", 2, "usage");
     }
   } catch (err) {
-    if (err instanceof CommandError3) throw err;
-    throw new CommandError3("cwd must be inside the configured sandbox root", 2, "usage");
+    if (err instanceof CommandError5) throw err;
+    throw new CommandError5("cwd must be inside the configured sandbox root", 2, "usage");
   }
   let lastErr;
   let collected = null;
@@ -175,14 +346,15 @@ async function resolveInput(input) {
   return null;
 }
 async function reviewSubmit(input, cfg, opts = {}) {
-  const resolved = cfg ?? await loadConfig2();
+  const resolved = cfg ?? await loadConfig3();
   const wait = input.wait !== false;
   const timeoutMs = waitTimeoutMs(input.timeout_s);
+  assertPinnableSpecialists(input.specialists);
   if (input.thread && !REVIEW_THREAD_SLUG_RE.test(input.thread)) {
-    throw new CommandError3("thread must be 1\u2013120 chars [A-Za-z0-9._/-]", 2, "usage");
+    throw new CommandError5("thread must be 1\u2013120 chars [A-Za-z0-9._/-]", 2, "usage");
   }
   if (input.context === "-") {
-    throw new CommandError3(
+    throw new CommandError5(
       'context "-" (stdin) is not available over MCP; pass the text directly',
       2,
       "usage"
@@ -218,15 +390,15 @@ async function reviewSubmit(input, cfg, opts = {}) {
     return payloadFromRow(submitted.row, {
       jobId,
       status: "rate_limited",
-      error: rateLimitedMessage(submitted.retryAfterSeconds),
+      error: rateLimitedMessage2(submitted.retryAfterSeconds),
       retryAfterSeconds: submitted.retryAfterSeconds
     });
   }
   if (submitted.status !== 202 && submitted.status !== 200) {
-    throw new CommandError3(JSON.stringify(submitted.row));
+    throw new CommandError5(JSON.stringify(submitted.row));
   }
   if (!jobId) {
-    throw new CommandError3("Review API returned no job_id");
+    throw new CommandError5("Review API returned no job_id");
   }
   if (!wait) {
     return payloadFromRow(submitted.row, { jobId, status: submitted.row.status ?? "queued" });
@@ -252,18 +424,68 @@ async function reviewSubmit(input, cfg, opts = {}) {
   return payloadFromRow(row, { jobId });
 }
 
+// src/tools/review-wait-pr.ts
+import {
+  PrReviewPollTimeoutError,
+  loadConfig as loadConfig4,
+  pollPrVortexReview
+} from "mergestorm/client";
+async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opts = {}) {
+  const target = prReviewTarget(owner, repo, prNumber);
+  const resolved = cfg ?? await loadConfig4();
+  try {
+    const envelope = await pollPrVortexReview(
+      resolved,
+      target.owner,
+      target.repo,
+      target.prNumber,
+      {
+        timeoutMs: waitTimeoutMs(timeout_s),
+        afterSha,
+        intervalMs: opts.pollIntervalMs
+      }
+    );
+    return payloadFromPrReview(
+      target.owner,
+      target.repo,
+      target.prNumber,
+      envelope
+    );
+  } catch (err) {
+    if (err instanceof PrReviewPollTimeoutError) {
+      const status = err.lastEnvelope?.status ?? "in_progress";
+      return {
+        summary: `${target.owner}/${target.repo}#${target.prNumber} \xB7 ${status}`,
+        data: {
+          ...err.lastEnvelope ?? {},
+          status,
+          error: err.message
+        }
+      };
+    }
+    const rateLimited = payloadFromPrRateLimit(
+      err,
+      target.owner,
+      target.repo,
+      target.prNumber
+    );
+    if (rateLimited) return rateLimited;
+    throw err;
+  }
+}
+
 // src/tools/review-wait.ts
 import {
-  CommandError as CommandError4,
+  CommandError as CommandError6,
   ReviewPollTimeoutError as ReviewPollTimeoutError2,
-  loadConfig as loadConfig3,
+  loadConfig as loadConfig5,
   pollReview as pollReview2
 } from "mergestorm/client";
 async function reviewWait(jobId, timeout_s, cfg, opts = {}) {
-  const resolved = cfg ?? await loadConfig3();
+  const resolved = cfg ?? await loadConfig5();
   const id = jobId.trim();
   if (!id) {
-    throw new CommandError4("job_id is required", 2, "usage");
+    throw new CommandError6("job_id is required", 2, "usage");
   }
   try {
     const row = await pollReview2(resolved, id, {
@@ -285,21 +507,169 @@ async function reviewWait(jobId, timeout_s, cfg, opts = {}) {
   }
 }
 
+// src/tools/settings-get.ts
+import {
+  CommandError as CommandError7,
+  getSettings
+} from "mergestorm/client";
+function settingsSummary(settings) {
+  const autoPatch = settings.auto_patch_enabled ? "on" : "off";
+  const cyclone = settings.cyclone_connected ? "Cyclone connected" : "Cyclone not connected";
+  return `auto_patch ${autoPatch} \xB7 ${cyclone}`;
+}
+async function settingsGet(cfg) {
+  const settings = await getSettings(cfg);
+  if (!settings) {
+    throw new CommandError7(
+      "Settings are not available (offline or API too old). Try again or open https://mergestorm.ai/settings"
+    );
+  }
+  return {
+    summary: settingsSummary(settings),
+    data: { ...settings }
+  };
+}
+
+// src/tools/settings-set.ts
+import {
+  CommandError as CommandError8,
+  SETTINGS_WRITABLE_KEYS,
+  patchSettings
+} from "mergestorm/client";
+var SETTINGS_READ_ONLY_KEYS = [
+  "cyclone_connected",
+  "github_connected"
+];
+function settingsPatchFromArgs(args) {
+  for (const key of SETTINGS_READ_ONLY_KEYS) {
+    if (args[key] !== void 0) {
+      throw new CommandError8(`${key} is read-only and cannot be set.`, 2, "usage");
+    }
+  }
+  const patch = {};
+  for (const key of SETTINGS_WRITABLE_KEYS) {
+    const value = args[key];
+    if (value === void 0) continue;
+    if (typeof value !== "boolean") {
+      throw new CommandError8(`${key} takes a boolean.`, 2, "usage");
+    }
+    if (key === "auto_patch_enabled" && value === true) {
+      throw new CommandError8("auto_patch_enabled cannot be enabled by this tool.", 2, "usage");
+    }
+    patch[key] = value;
+  }
+  if (Object.keys(patch).length === 0) {
+    throw new CommandError8(
+      `At least one settings key is required: ${SETTINGS_WRITABLE_KEYS.join(", ")}.`,
+      2,
+      "usage"
+    );
+  }
+  return patch;
+}
+async function settingsSet(args, cfg) {
+  const patch = settingsPatchFromArgs(args);
+  const settings = await patchSettings(patch, cfg);
+  return {
+    summary: settingsSummary(settings),
+    data: { ...settings }
+  };
+}
+
+// src/tools/stack-list.ts
+import { isCommandErrorCode as isCommandErrorCode4, listStacks } from "mergestorm/client";
+
+// src/tools/stack-summary.ts
+function stackSummary(stack) {
+  const count = stack.layers.length;
+  const layerLabel = `${count} layer${count === 1 ? "" : "s"}`;
+  const states = [...new Set(stack.layers.map((layer) => layer.state))];
+  const currentState = states.length > 0 ? `layers: ${states.join(", ")}` : stack.unit ? `unit: ${stack.unit.state}` : "no open layers";
+  return `${stack.owner}/${stack.repo} \xB7 ${layerLabel} \xB7 ${currentState}`;
+}
+
+// src/tools/stack-list.ts
+async function stackList(cfg) {
+  try {
+    const stacks = await listStacks(cfg);
+    return {
+      summary: stacks.length === 0 ? "No stacks" : stacks.map((stack) => stackSummary(stack)).join("\n"),
+      data: { stacks }
+    };
+  } catch (err) {
+    if (isCommandErrorCode4(err, "rate_limited")) {
+      return {
+        summary: err.message,
+        data: {
+          error: {
+            code: "rate_limited",
+            message: err.message,
+            retry_after_seconds: err.retryAfterSeconds
+          }
+        },
+        isError: true
+      };
+    }
+    throw err;
+  }
+}
+
+// src/tools/stack-status.ts
+import { getEnrichedStack, isCommandErrorCode as isCommandErrorCode5 } from "mergestorm/client";
+async function stackStatus(stackId, cfg) {
+  try {
+    const stack = await getEnrichedStack(stackId, cfg);
+    if (!stack) {
+      const message = `Stack not found or not owned by the current user: ${stackId}`;
+      return {
+        summary: message,
+        data: {
+          error: {
+            code: "stack_not_found",
+            message,
+            stack_id: stackId
+          }
+        },
+        isError: true
+      };
+    }
+    return {
+      summary: stackSummary(stack),
+      data: { stack }
+    };
+  } catch (err) {
+    if (isCommandErrorCode5(err, "rate_limited")) {
+      return {
+        summary: err.message,
+        data: {
+          error: {
+            code: "rate_limited",
+            message: err.message,
+            retry_after_seconds: err.retryAfterSeconds
+          }
+        },
+        isError: true
+      };
+    }
+    throw err;
+  }
+}
+
 // src/tools/whoami.ts
 import {
-  CommandError as CommandError5,
+  CommandError as CommandError9,
   apiBase,
   configPath,
   getMe as getMe2,
   keyDisplay,
-  loadConfig as loadConfig4,
+  loadConfig as loadConfig6,
   resolveApiKey
 } from "mergestorm/client";
 async function whoami(cfg) {
-  const resolved = cfg ?? await loadConfig4();
+  const resolved = cfg ?? await loadConfig6();
   const key = resolveApiKey(resolved);
   if (!key) {
-    throw new CommandError5(
+    throw new CommandError9(
       "No API key. Run `mergestorm login` or set MERGESTORM_API_KEY.",
       1,
       "missing_api_key"
@@ -324,7 +694,7 @@ async function whoami(cfg) {
 
 // src/server.ts
 var MCP_SERVER_NAME = "mergestorm";
-var MCP_SERVER_VERSION = "0.1.0";
+var MCP_SERVER_VERSION = "0.1.3";
 function stripNulls(value) {
   if (Array.isArray(value)) {
     return value.map((item) => stripNulls(item));
@@ -340,12 +710,13 @@ function stripNulls(value) {
 }
 function ok(payload) {
   return {
+    ...payload.isError ? { isError: true } : {},
     content: [{ type: "text", text: payload.summary }],
     structuredContent: stripNulls(payload.data)
   };
 }
 function fail(err) {
-  const message = err instanceof CommandError6 ? err.code ? `Mergestorm request failed (${err.code}): ${err.message}.` : err.message : err instanceof Error ? err.message : String(err);
+  const message = err instanceof CommandError10 ? err.code ? `Mergestorm request failed (${err.code}): ${err.message}.` : err.message : err instanceof Error ? err.message : String(err);
   return {
     isError: true,
     content: [{ type: "text", text: message }]
@@ -419,11 +790,30 @@ function createMergestormMcpServer() {
       }
     }
   );
+  addTool(
+    "review_get_pr",
+    {
+      title: "Get GitHub PR Vortex review",
+      description: "Fetch the latest GitHub PR Vortex pass from the DB-only endpoint. This tool is read-only. On rate_limited, wait retry_after_seconds before trying again.",
+      inputSchema: {
+        owner: z.string().min(1),
+        repo: z.string().min(1),
+        pr_number: z.number().int().min(1)
+      }
+    },
+    async ({ owner, repo, pr_number }) => {
+      try {
+        return ok(await reviewGetPr(owner, repo, pr_number));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
   addTool(
     "review_submit",
     {
       title: "Submit review",
-      description: "Submit a local git diff (or an explicit diff) as a Mergestorm review job. Default waits up to 300s. On rate_limited, wait retry_after_seconds and inspect or wait for an in-flight review before resubmitting.",
+      description: "Submit a local git diff (or an explicit diff) as a Mergestorm review job. Default waits up to 300s. On rate_limited, wait retry_after_seconds and inspect or wait for an in-flight review before resubmitting. specialists may be security, performance, architecture, tests, data, api, frontend. governance and seam cannot be requested.",
       inputSchema: {
         cwd: z.string().optional(),
         base: z.string().optional(),
@@ -465,6 +855,120 @@ function createMergestormMcpServer() {
       }
     }
   );
+  addTool(
+    "review_wait_pr",
+    {
+      title: "Wait for GitHub PR Vortex review",
+      description: "Poll the DB-only GitHub PR Vortex pass until it rests. This tool is read-only. On timeout, returns in_progress. On rate_limited, wait retry_after_seconds before trying again.",
+      inputSchema: {
+        owner: z.string().min(1),
+        repo: z.string().min(1),
+        pr_number: z.number().int().min(1),
+        after_sha: z.string().optional(),
+        timeout_s: z.number().positive().max(300).optional()
+      }
+    },
+    async ({ owner, repo, pr_number, after_sha, timeout_s }) => {
+      try {
+        return ok(
+          await reviewWaitPr(
+            owner,
+            repo,
+            pr_number,
+            after_sha,
+            timeout_s
+          )
+        );
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "stack_list",
+    {
+      title: "List stacks",
+      description: "List the current user's Mergestorm stacks. This tool is read-only."
+    },
+    async () => {
+      try {
+        return ok(await stackList());
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "stack_status",
+    {
+      title: "Get stack status",
+      description: "Fetch one owned Mergestorm stack with enriched checks and agent state. This tool is read-only.",
+      inputSchema: {
+        stack_id: z.string().min(1)
+      }
+    },
+    async ({ stack_id }) => {
+      try {
+        return ok(await stackStatus(stack_id));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "queue_status",
+    {
+      title: "Get merge queue status",
+      description: "List live merge queue entries for the current user, optionally filtered by stack. This tool is read-only.",
+      inputSchema: {
+        stack_id: z.string().min(1).optional()
+      }
+    },
+    async ({ stack_id }) => {
+      try {
+        return ok(await queueStatus(stack_id));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "settings_get",
+    {
+      title: "Get settings",
+      description: "Read the Bearer /api/v1/settings toggles, including auto_patch_enabled and cyclone_connected. This tool is read-only."
+    },
+    async () => {
+      try {
+        return ok(await settingsGet());
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "settings_set",
+    {
+      title: "Update settings",
+      description: "Update writable Bearer /api/v1/settings toggles and return the stored result. At least one key is required. cyclone_connected and github_connected are read-only and cannot be set.",
+      inputSchema: {
+        auto_review_enabled: z.boolean().optional(),
+        auto_patch_enabled: z.boolean().optional(),
+        vortex_show_thinking_traces: z.boolean().optional(),
+        repo_overview_enabled: z.boolean().optional(),
+        review_unit_land_prs_enabled: z.boolean().optional(),
+        cyclone_review_unit_land_prs_enabled: z.boolean().optional(),
+        vortex_seam_specialist_enabled: z.boolean().optional()
+      }
+    },
+    async (args) => {
+      try {
+        return ok(await settingsSet(args ?? {}));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
   return server2;
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mergestorm-mcp",
-  "version": "0.1.0",
-  "description": "Mergestorm MCP server — whoami, credits, and review read tools over stdio",
+  "version": "0.1.3",
+  "description": "Mergestorm MCP server — identity, review, and read-only stack tools over stdio",
   "license": "MIT",
   "type": "module",
   "author": "Margin Systems <hello@mergestorm.ai>",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "mergestorm": "^0.3.13",
+    "mergestorm": "^0.3.15",
     "zod": "^3.24.2"
   },
   "devDependencies": {