mergestorm-mcp 0.1.2 → 0.1.5

package/README.md

@@ -1,10 +1,12 @@
 # mergestorm-mcp
 
-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`.
+Stdio MCP server for Mergestorm. Tools: `whoami`, `credits`, `review_list`, `review_get`, `review_get_pr`, `review_submit`, `review_wait`, `review_wait_pr`, `stack_adopt`, `stack_list`, `stack_set`, `stack_status`, `queue_status`, `settings_get`, `settings_set`.
 
-The stack tools are read-only:
+The stack tools expose reads plus one scoped policy write:
 
+- `stack_adopt({ owner, repo, pr_number, auto_land?, auto_review?, auto_patch? })` adopts an open PR chain with optional per-stack policy. `auto_patch` defaults to `false` and accepts only `false` or `null`; `null` clears the override. Read `stack_status` with the returned `result.stack.id` to verify policy and Cyclone ownership.
 - `stack_list` returns the current API key owner's registered stacks.
+- `stack_set({ stack_id, auto_land?, auto_review?, auto_patch? })` sets per-stack policy on one owned stack. `auto_land` flips Auto land. `auto_review` and `auto_patch` pin Vortex auto-review or Cyclone auto-patch for that stack in either direction (`true` or `false`); `null` clears the pin so the stack follows the account setting. Pass at least one key. Account settings are never changed here.
 - `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,13 +1,12 @@
 #!/usr/bin/env node
-#!/usr/bin/env node
 
 // src/index.ts
 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 CommandError10 } from "mergestorm/client";
+import { z as z2 } from "zod";
+import { CommandError as CommandError11, SETTINGS_WRITABLE_KEYS as SETTINGS_WRITABLE_KEYS2 } from "mergestorm/client";
 
 // src/tools/credits.ts
 import { CommandError, getMe, loadConfig } from "mergestorm/client";
@@ -26,8 +25,10 @@ async function credits(cfg) {
   }
   const standard = me.usage.standard;
   const remaining = standard.remaining ?? (standard.limit != null ? Math.max(0, standard.limit - standard.used) : null);
+  const bonusRemaining = me.usage.bonus?.remaining;
+  const bonusSummary = bonusRemaining == null ? "" : ` \xB7 ${bonusRemaining} bonus remaining`;
   return {
-    summary: remaining == null ? `${standard.used} used \xB7 unlimited` : `${standard.used} used \xB7 ${remaining} remaining`,
+    summary: remaining == null ? `${standard.used} used \xB7 unlimited${bonusSummary}` : `${standard.used} used \xB7 ${remaining} remaining${bonusSummary}`,
     data: {
       usage: me.usage,
       resets_at: me.resets_at ?? null
@@ -142,9 +143,21 @@ function prReviewTarget(owner, repo, prNumber) {
   }
   return { owner: cleanOwner, repo: cleanRepo, prNumber };
 }
+function prReviewSummary(owner, repo, prNumber, envelope) {
+  const bits = [`${owner}/${repo}#${prNumber}`, envelope.status];
+  const sha = envelope.head_sha?.trim();
+  if (sha) bits.push(`sha ${sha.slice(0, 7)}`);
+  if (typeof envelope.finding_count === "number") {
+    bits.push(
+      `${envelope.finding_count} finding${envelope.finding_count === 1 ? "" : "s"}`
+    );
+  }
+  if (envelope.phase) bits.push(String(envelope.phase));
+  return bits.join(" \xB7 ");
+}
 function payloadFromPrReview(owner, repo, prNumber, envelope) {
   return {
-    summary: `${owner}/${repo}#${prNumber} \xB7 ${envelope.status}`,
+    summary: prReviewSummary(owner, repo, prNumber, envelope),
     data: { ...envelope }
   };
 }
@@ -159,14 +172,15 @@ function payloadFromPrRateLimit(err, owner, repo, prNumber) {
     }
   };
 }
-async function reviewGetPr(owner, repo, prNumber, cfg) {
+async function reviewGetPr(owner, repo, prNumber, cfg, opts = {}) {
   const target = prReviewTarget(owner, repo, prNumber);
   try {
     const envelope = await getPrVortexReview(
       target.owner,
       target.repo,
       target.prNumber,
-      cfg
+      cfg,
+      { afterSha: opts.afterSha, pass: opts.pass, afterPass: opts.afterPass }
     );
     return payloadFromPrReview(
       target.owner,
@@ -260,6 +274,8 @@ import {
   REVIEW_THREAD_SLUG_RE,
   ReviewPollTimeoutError,
   collectReviewInput,
+  discoverTrunk,
+  formatReviewSubmitError,
   loadConfig as loadConfig3,
   loadReviewContext,
   pollReview,
@@ -267,6 +283,7 @@ import {
   submitReview
 } from "mergestorm/client";
 var MCP_WAIT_CEILING_S = 300;
+var MCP_PR_WAIT_DEFAULT_S = 45;
 var PINNABLE_SPECIALISTS = [
   "security",
   "performance",
@@ -291,8 +308,8 @@ function assertPinnableSpecialists(specialists) {
 function mcpSandboxRoot() {
   return process.env.MERGESTORM_SANDBOX_ROOT?.trim() || process.cwd();
 }
-function waitTimeoutMs(timeout_s) {
-  const seconds = timeout_s ?? MCP_WAIT_CEILING_S;
+function waitTimeoutMs(timeout_s, defaultSeconds = MCP_PR_WAIT_DEFAULT_S) {
+  const seconds = timeout_s ?? defaultSeconds;
   if (!Number.isFinite(seconds) || seconds <= 0) {
     throw new CommandError5("timeout_s must be a positive number of seconds", 2, "usage");
   }
@@ -307,13 +324,18 @@ async function resolveInput(input) {
     return {
       thread,
       branch,
-      baseLabel: input.base?.trim() || "main",
+      baseLabel: input.base?.trim() || (() => {
+        try {
+          return discoverTrunk(cwd);
+        } catch {
+          return "main";
+        }
+      })(),
       headLabel: head,
       diff: input.diff,
       files: []
     };
   }
-  const bases = input.base?.trim() ? [input.base.trim()] : ["main", "master"];
   const sandboxRoot = mcpSandboxRoot();
   try {
     const [sandboxReal, cwdReal] = await Promise.all([
@@ -328,27 +350,12 @@ async function resolveInput(input) {
     if (err instanceof CommandError5) throw err;
     throw new CommandError5("cwd must be inside the configured sandbox root", 2, "usage");
   }
-  let lastErr;
-  let collected = null;
-  let yielded = false;
-  for (const base of bases) {
-    try {
-      const candidate = await collectReviewInput(base, head, cwd, sandboxRoot);
-      yielded = true;
-      if (!collected) collected = candidate;
-    } catch (err) {
-      if (yielded) continue;
-      lastErr = err;
-      if (input.base?.trim()) throw err;
-    }
-  }
-  if (yielded) return collected;
-  if (lastErr) throw lastErr;
-  return null;
+  const base = input.base?.trim() || discoverTrunk(cwd);
+  return collectReviewInput(base, head, cwd, sandboxRoot);
 }
 async function reviewSubmit(input, cfg, opts = {}) {
   const resolved = cfg ?? await loadConfig3();
-  const wait = input.wait !== false;
+  const wait = input.wait === true;
   const timeoutMs = waitTimeoutMs(input.timeout_s);
   assertPinnableSpecialists(input.specialists);
   if (input.thread && !REVIEW_THREAD_SLUG_RE.test(input.thread)) {
@@ -396,7 +403,13 @@ async function reviewSubmit(input, cfg, opts = {}) {
     });
   }
   if (submitted.status !== 202 && submitted.status !== 200) {
-    throw new CommandError5(JSON.stringify(submitted.row));
+    return {
+      ...payloadFromRow({ ...submitted.row, status: "failed" }, {
+        jobId,
+        error: formatReviewSubmitError(submitted.status, submitted.row)
+      }),
+      isError: true
+    };
   }
   if (!jobId) {
     throw new CommandError5("Review API returned no job_id");
@@ -441,8 +454,10 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
       target.repo,
       target.prNumber,
       {
-        timeoutMs: waitTimeoutMs(timeout_s),
+        timeoutMs: waitTimeoutMs(timeout_s, MCP_PR_WAIT_DEFAULT_S),
         afterSha,
+        pass: opts.pass,
+        afterPass: opts.afterPass,
         intervalMs: opts.pollIntervalMs
       }
     );
@@ -456,7 +471,12 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
     if (err instanceof PrReviewPollTimeoutError) {
       const status = err.lastEnvelope?.status ?? "in_progress";
       return {
-        summary: `${target.owner}/${target.repo}#${target.prNumber} \xB7 ${status}`,
+        summary: prReviewSummary(target.owner, target.repo, target.prNumber, {
+          status,
+          head_sha: err.lastEnvelope?.head_sha ?? null,
+          finding_count: err.lastEnvelope?.finding_count ?? null,
+          phase: err.lastEnvelope?.phase ?? null
+        }),
         data: {
           ...err.lastEnvelope ?? {},
           status,
@@ -554,9 +574,6 @@ function settingsPatchFromArgs(args) {
     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) {
@@ -577,6 +594,105 @@ async function settingsSet(args, cfg) {
   };
 }
 
+// src/tools/stack-adopt.ts
+import { adoptStack, CommandError as CommandError9 } from "mergestorm/client";
+import { z } from "zod";
+
+// src/tools/stack-set.ts
+import { setStackPolicy } from "mergestorm/client";
+function triWord(value) {
+  return value === null ? "default" : value ? "on" : "off";
+}
+function stackSetPatch(input) {
+  const patch = {};
+  if (typeof input.auto_land === "boolean") patch.autoEnqueueWhenReady = input.auto_land;
+  if (input.auto_review !== void 0) patch.autoReviewOverride = input.auto_review;
+  if (input.auto_patch !== void 0) patch.autoPatchOverride = input.auto_patch;
+  return patch;
+}
+async function stackSet(stackId, input, cfg) {
+  const patch = stackSetPatch(input);
+  if (Object.keys(patch).length === 0) {
+    return {
+      summary: "stack_set needs at least one of auto_land, auto_review, auto_patch",
+      isError: true,
+      data: {
+        error: {
+          code: "invalid_input",
+          message: "Pass at least one of auto_land, auto_review, auto_patch.",
+          stack_id: stackId
+        }
+      }
+    };
+  }
+  const result = await setStackPolicy(stackId, patch, cfg);
+  const parts = [];
+  if (typeof input.auto_land === "boolean") {
+    parts.push(`Auto land ${input.auto_land ? "on" : "off"}`);
+  }
+  if (input.auto_review !== void 0) {
+    parts.push(`auto-review ${triWord(input.auto_review)}`);
+  }
+  if (input.auto_patch !== void 0) {
+    parts.push(`auto-patch ${triWord(input.auto_patch)}`);
+  }
+  return {
+    summary: `${parts.join(", ")} for stack ${stackId}`,
+    data: {
+      stack_id: stackId,
+      ...typeof input.auto_land === "boolean" ? { auto_land: input.auto_land } : {},
+      ...input.auto_review !== void 0 ? { auto_review: input.auto_review } : {},
+      ...input.auto_patch !== void 0 ? { auto_patch: input.auto_patch } : {},
+      result
+    }
+  };
+}
+
+// src/tools/stack-adopt.ts
+var stackAdoptSchema = {
+  owner: z.string().trim().min(1),
+  repo: z.string().trim().min(1),
+  pr_number: z.number().int().min(1),
+  auto_land: z.literal(false).optional(),
+  auto_review: z.boolean().nullable().optional(),
+  auto_patch: z.literal(false).nullable().optional()
+};
+var inputSchema = z.object(stackAdoptSchema);
+async function stackAdopt(input, cfg) {
+  const parsed = inputSchema.safeParse(input);
+  if (!parsed.success) {
+    const message = "stack_adopt requires owner, repo, a positive pr_number, and valid policy values";
+    return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+  }
+  const { owner, repo, pr_number } = parsed.data;
+  try {
+    const result = await adoptStack(
+      owner,
+      repo,
+      pr_number,
+      cfg,
+      stackSetPatch(parsed.data)
+    );
+    return {
+      summary: `Adopted stack for ${owner}/${repo}#${pr_number}`,
+      data: { owner, repo, pr_number, result }
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      summary: message,
+      data: {
+        error: {
+          code: err instanceof CommandError9 ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",
+          message,
+          ...err instanceof CommandError9 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
+        }
+      },
+      isError: true
+    };
+  }
+}
+
 // src/tools/stack-list.ts
 import { isCommandErrorCode as isCommandErrorCode4, listStacks } from "mergestorm/client";
 
@@ -586,7 +702,17 @@ function stackSummary(stack) {
   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}`;
+  const overrides = [];
+  if (typeof stack.autoReviewOverride === "boolean") {
+    overrides.push(`auto-review ${stack.autoReviewOverride ? "on" : "off"}`);
+  }
+  if (typeof stack.autoPatchOverride === "boolean") {
+    overrides.push(`auto-patch ${stack.autoPatchOverride ? "on" : "off"}`);
+  }
+  if (stack.cycloneOwnerMatch) {
+    overrides.push(`cyclone-owner ${stack.cycloneOwnerMatch}`);
+  }
+  return `${stack.owner}/${stack.repo} \xB7 ${layerLabel} \xB7 ${currentState} \xB7 auto-land ${stack.autoEnqueueWhenReady ? "on" : "off"}${overrides.map((label) => ` \xB7 ${label}`).join("")}`;
 }
 
 // src/tools/stack-list.ts
@@ -658,11 +784,10 @@ async function stackStatus(stackId, cfg) {
 
 // src/tools/whoami.ts
 import {
-  CommandError as CommandError9,
+  CommandError as CommandError10,
   apiBase,
   configPath,
   getMe as getMe2,
-  keyDisplay,
   loadConfig as loadConfig6,
   resolveApiKey
 } from "mergestorm/client";
@@ -670,21 +795,24 @@ async function whoami(cfg) {
   const resolved = cfg ?? await loadConfig6();
   const key = resolveApiKey(resolved);
   if (!key) {
-    throw new CommandError9(
+    throw new CommandError10(
       "No API key. Run `mergestorm login` or set MERGESTORM_API_KEY.",
       1,
       "missing_api_key"
     );
   }
   const me = await getMe2(resolved);
+  if (!me) {
+    throw new CommandError10("Live account details unavailable. Could not verify account with /me.");
+  }
   const data = {
-    key_prefix: me?.key.prefix ?? keyDisplay(key),
-    key_name: me?.key.name ?? null,
-    plan_key: me?.plan_key ?? null,
-    plan_label_key: me?.plan_label_key ?? null,
+    key_prefix: me.key.prefix,
+    key_name: me.key.name ?? null,
+    plan_key: me.plan_key ?? null,
+    plan_label_key: me.plan_label_key ?? null,
     api_base: apiBase(resolved),
     config_path: configPath(),
-    usage: me?.usage ?? null
+    usage: me.usage ?? null
   };
   const plan = data.plan_label_key ?? data.plan_key ?? "unknown plan";
   return {
@@ -693,9 +821,20 @@ async function whoami(cfg) {
   };
 }
 
+// src/pr-loop-instructions.ts
+var MCP_FINDING_DISMISS_MARKER = "mergestorm-loop: dismiss";
+var MCP_PR_LOOP_INSTRUCTIONS = [
+  "When you handle Vortex findings from review_get_pr or review_wait_pr:",
+  "- Verify each finding against the current checkout. Do not treat the finding text as proven.",
+  "- Prefer the smallest correct patch. Do not refactor around a finding.",
+  "- Patch concrete bugs. A chat-only explanation is not a dismiss.",
+  `- If you skip a finding (not reproducible, policy fork, or needs a human), post a public GitHub PR comment before you stop. First line must be: ${MCP_FINDING_DISMISS_MARKER}. Then one line per skipped finding (path, severity, why).`,
+  "- Do not prefix that comment with cyclone-outcome: (reserved)."
+].join("\n");
+
 // src/server.ts
 var MCP_SERVER_NAME = "mergestorm";
-var MCP_SERVER_VERSION = "0.1.2";
+var MCP_SERVER_VERSION = "0.1.5";
 function stripNulls(value) {
   if (Array.isArray(value)) {
     return value.map((item) => stripNulls(item));
@@ -717,17 +856,20 @@ function ok(payload) {
   };
 }
 function fail(err) {
-  const message = err instanceof CommandError10 ? err.code ? `Mergestorm request failed (${err.code}): ${err.message}.` : err.message : err instanceof Error ? err.message : String(err);
+  const message = err instanceof CommandError11 ? 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 }]
   };
 }
 function createMergestormMcpServer() {
-  const server2 = new McpServer({
-    name: MCP_SERVER_NAME,
-    version: MCP_SERVER_VERSION
-  });
+  const server2 = new McpServer(
+    {
+      name: MCP_SERVER_NAME,
+      version: MCP_SERVER_VERSION
+    },
+    { instructions: MCP_PR_LOOP_INSTRUCTIONS }
+  );
   const addTool = server2.registerTool.bind(server2);
   addTool(
     "whoami",
@@ -763,7 +905,7 @@ function createMergestormMcpServer() {
       title: "List reviews",
       description: "List recent Mergestorm review jobs as job envelopes.",
       inputSchema: {
-        limit: z.number().int().min(1).max(50).optional()
+        limit: z2.number().int().min(1).max(50).optional()
       }
     },
     async ({ limit }) => {
@@ -780,7 +922,7 @@ function createMergestormMcpServer() {
       title: "Get review",
       description: "Fetch one Mergestorm review job as a job envelope. On rate_limited, wait retry_after_seconds before trying again.",
       inputSchema: {
-        job_id: z.string().min(1)
+        job_id: z2.string().min(1)
       }
     },
     async ({ job_id }) => {
@@ -795,16 +937,25 @@ function createMergestormMcpServer() {
     "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.",
+      description: "Fetch the latest GitHub PR Vortex pass from the DB-only endpoint. Review identity is SHA + pass: the envelope carries pass (1 for the first review on a head; a re-review on the same head is the next pass). Pass after_sha to scope to a head, pass to read one exact attempt, or after_pass to read only a later attempt on that head. This tool is read-only. On rate_limited, wait retry_after_seconds before trying again. Verify each finding against the current code; prefer the smallest correct patch; a chat-only skip is not a dismiss (post a PR comment starting with mergestorm-loop: dismiss).",
       inputSchema: {
-        owner: z.string().min(1),
-        repo: z.string().min(1),
-        pr_number: z.number().int().min(1)
+        owner: z2.string().min(1),
+        repo: z2.string().min(1),
+        pr_number: z2.number().int().min(1),
+        after_sha: z2.string().optional(),
+        pass: z2.number().int().min(1).optional(),
+        after_pass: z2.number().int().min(1).optional()
       }
     },
-    async ({ owner, repo, pr_number }) => {
+    async ({ owner, repo, pr_number, after_sha, pass, after_pass }) => {
       try {
-        return ok(await reviewGetPr(owner, repo, pr_number));
+        return ok(
+          await reviewGetPr(owner, repo, pr_number, void 0, {
+            afterSha: after_sha,
+            pass,
+            afterPass: after_pass
+          })
+        );
       } catch (err) {
         return fail(err);
       }
@@ -814,20 +965,20 @@ function createMergestormMcpServer() {
     "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. specialists may be security, performance, architecture, tests, data, api, frontend. governance and seam cannot be requested.",
+      description: "Submit a local git diff (or an explicit diff) as a Mergestorm review job. Does not wait by default; returns job_id immediately after submission. Explicit wait: true polls one 45s slice by default. Record job_id and loop review_wait until done. Do not pass 300; hosts drop long MCP calls. 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(),
-        head: z.string().optional(),
-        diff: z.string().optional(),
-        router: z.enum(["off", "standard", "max", "manual"]).optional(),
-        specialists: z.array(z.string().min(1)).max(5).optional(),
-        context: z.string().optional(),
-        context_files: z.array(z.string().min(1)).max(10).optional(),
-        thread: z.string().min(1).max(120).optional(),
-        idempotency_key: z.string().min(1).max(128).optional(),
-        wait: z.boolean().optional(),
-        timeout_s: z.number().positive().max(300).optional()
+        cwd: z2.string().optional(),
+        base: z2.string().optional(),
+        head: z2.string().optional(),
+        diff: z2.string().optional(),
+        router: z2.enum(["off", "standard", "max", "manual"]).optional(),
+        specialists: z2.array(z2.string().min(1)).max(5).optional(),
+        context: z2.string().optional(),
+        context_files: z2.array(z2.string().min(1)).max(10).optional(),
+        thread: z2.string().min(1).max(120).optional(),
+        idempotency_key: z2.string().min(1).max(128).optional(),
+        wait: z2.boolean().optional(),
+        timeout_s: z2.number().positive().max(300).optional()
       }
     },
     async (args) => {
@@ -842,10 +993,10 @@ function createMergestormMcpServer() {
     "review_wait",
     {
       title: "Wait for review",
-      description: "Poll one Mergestorm review job until it finishes, return in_progress after 300s, or return rate_limited with retry_after_seconds.",
+      description: "Poll one Mergestorm review job for one 45s slice by default (max 300s). On timeout, returns in_progress; call again with the same job_id until done. Do not pass 300; hosts drop long MCP calls. On rate_limited, wait retry_after_seconds before trying again.",
       inputSchema: {
-        job_id: z.string().min(1),
-        timeout_s: z.number().positive().max(300).optional()
+        job_id: z2.string().min(1),
+        timeout_s: z2.number().positive().max(300).optional()
       }
     },
     async ({ job_id, timeout_s }) => {
@@ -860,16 +1011,18 @@ function createMergestormMcpServer() {
     "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.",
+      description: "Poll the DB-only GitHub PR Vortex pass for up to 45s (pass timeout_s to override, max 300). Review identity is SHA + pass. Pass after_sha for the head you pushed. When you already hold an envelope for that same head, also pass after_pass set to its pass so the wait cannot return that attempt again; keep after_pass unchanged across timeout retries and never replace it with the pass of an in-progress envelope. Omit after_pass for a head you have no envelope for (its first pass is 1). This tool is read-only. On timeout, returns in_progress so you can call again. Do not pass 300; hosts drop long MCP calls. On rate_limited, wait retry_after_seconds before trying again. After a resting pass, verify each finding; prefer the smallest correct patch; if you skip, post a PR comment starting with mergestorm-loop: dismiss.",
       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()
+        owner: z2.string().min(1),
+        repo: z2.string().min(1),
+        pr_number: z2.number().int().min(1),
+        after_sha: z2.string().optional(),
+        pass: z2.number().int().min(1).optional(),
+        after_pass: z2.number().int().min(1).optional(),
+        timeout_s: z2.number().positive().max(300).optional()
       }
     },
-    async ({ owner, repo, pr_number, after_sha, timeout_s }) => {
+    async ({ owner, repo, pr_number, after_sha, pass, after_pass, timeout_s }) => {
       try {
         return ok(
           await reviewWaitPr(
@@ -877,7 +1030,9 @@ function createMergestormMcpServer() {
             repo,
             pr_number,
             after_sha,
-            timeout_s
+            timeout_s,
+            void 0,
+            { pass, afterPass: after_pass }
           )
         );
       } catch (err) {
@@ -885,6 +1040,21 @@ function createMergestormMcpServer() {
       }
     }
   );
+  addTool(
+    "stack_adopt",
+    {
+      title: "Adopt PR stack",
+      description: "Adopt an open GitHub PR chain into a Mergestorm stack. auto_land may only be false; auto_review and auto_patch set per-stack policy, and null clears their overrides. Omitted policy keys follow the account settings. Never changes account settings. Read stack_status with result.stack.id afterward to verify policy and Cyclone ownership.",
+      inputSchema: stackAdoptSchema
+    },
+    async (args) => {
+      try {
+        return ok(await stackAdopt(args));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
   addTool(
     "stack_list",
     {
@@ -899,13 +1069,39 @@ function createMergestormMcpServer() {
       }
     }
   );
+  addTool(
+    "stack_set",
+    {
+      title: "Set stack policy",
+      description: "Set per-stack automation on one owned Mergestorm stack: auto_land arms or disarms Auto land; auto_review and auto_patch pin Vortex auto-review or Cyclone auto-patch for this stack only (true or false), and null clears the pin so the stack follows the account setting again. Pass at least one key. Never changes account settings.",
+      inputSchema: {
+        stack_id: z2.string().min(1),
+        auto_land: z2.boolean().optional(),
+        auto_review: z2.boolean().nullable().optional(),
+        auto_patch: z2.boolean().nullable().optional()
+      }
+    },
+    async ({ stack_id, auto_land, auto_review, auto_patch }) => {
+      try {
+        return ok(
+          await stackSet(stack_id, {
+            ...auto_land !== void 0 ? { auto_land } : {},
+            ...auto_review !== void 0 ? { auto_review } : {},
+            ...auto_patch !== void 0 ? { auto_patch } : {}
+          })
+        );
+      } 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)
+        stack_id: z2.string().min(1)
       }
     },
     async ({ stack_id }) => {
@@ -922,7 +1118,7 @@ function createMergestormMcpServer() {
       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()
+        stack_id: z2.string().min(1).optional()
       }
     },
     async ({ stack_id }) => {
@@ -952,15 +1148,9 @@ function createMergestormMcpServer() {
     {
       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()
-      }
+      inputSchema: Object.fromEntries(
+        SETTINGS_WRITABLE_KEYS2.map((key) => [key, z2.boolean().optional()])
+      )
     },
     async (args) => {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm-mcp",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Mergestorm MCP server — identity, review, and read-only stack tools over stdio",
   "license": "MIT",
   "type": "module",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "mergestorm": "^0.3.15",
+    "mergestorm": "^0.3.17",
     "zod": "^3.24.2"
   },
   "devDependencies": {