mergestorm-mcp 0.2.20 → 0.2.22

package/README.md

@@ -1,6 +1,6 @@
 # mergestorm-mcp
 
-Stdio MCP server for Mergestorm. Tools: `whoami`, `credits`, `review_list`, `review_submit`, `review_wait`, `review_wait_pr`, `review_dismiss`, `stack_adopt`, `stack_list`, `stack_set`, `stack_status`, `stack_wait`, `queue_status`, `settings_get`, `settings_set`.
+Stdio MCP server for Mergestorm. Tools: `whoami`, `credits`, `review_list`, `review_submit`, `review_wait`, `review_wait_pr`, `review_dismiss`, `issue_create`, `stack_adopt`, `stack_list`, `stack_publish`, `stack_publish_status`, `stack_set`, `stack_status`, `stack_wait`, `queue_status`, `settings_get`, `settings_set`, `repo_settings_get`, `repo_settings_set`.
 
 Every tool declares MCP `annotations` for read-only access, destructive changes, idempotence, and external systems. Reads are read-only; submission, adoption, dismissal, and policy changes are writes. Tools that can change existing policy, topology, or review gates are marked potentially destructive even when some inputs only preview or read. Annotations describe effects; the client still controls approval and authorization.
 
@@ -16,10 +16,14 @@ Every tool declares MCP `annotations` for read-only access, destructive changes,
 - **Gates.** `gate.seam.cleared` is true only when every finding of that integration review is dismissed and it is still the member's current seam verdict. `gate.vortex.cleared` is true once every Vortex Blocker (error finding) at the live head is dismissed (every Core review merged into that head) and no Vortex review of the head is running or incomplete; with a warning still open the head reads `comment`, which Auto land accepts; otherwise `gate.vortex.reason` and `message` say what still holds it: that head's Vortex verdict becomes approve for Auto land, the stack watch, the dashboard and Cyclone. A partial dismissal clears nothing. CI and Auto land policy are unchanged (`gate.other_gates: "unchanged"`). For a stack PR the result carries `watch` with the next `stack_wait` call.
 - **No resurfacing.** Vortex does not raise a dismissed finding again on the same diff: the same head, or a restack whose diff is unchanged.
 
-The stack tools expose reads plus one scoped policy write:
+`issue_create({ title, body?, labels?, owner?, repo?, cwd? })` opens a GitHub issue through Mergestorm with no GitHub credentials: the Surge App creates it and names the caller in the body. It defaults to the origin repository of `cwd`. Labels must already exist on the repository. The same title again returns the open issue it already made (`created: false`), so a retry does not duplicate it. Put `Fixes #<number>` in the commit or pull request body.
+
+The stack tools expose reads, one scoped policy write, and publication of your own branch:
 
 - `stack_adopt({ owner, repo, pr_number, auto_land?, auto_review?, auto_patch?, auto_resolve_conflicts?, auto_fix_ci? })` adopts an open PR chain with optional per-stack policy. Omitted policy does not force Cyclone off. `auto_review`, `auto_patch`, `auto_resolve_conflicts`, and `auto_fix_ci` accept `true`, `false`, or `null`; `null` clears the override. Read `stack_status` with the returned `result.stack.id` to verify policy and Cyclone ownership. Adoption needs the Mergestorm Surge GitHub App on the repository (Cyclone is the auto-patch App). A refusal keeps the code `cyclone_not_connected` or `cyclone_not_installed`; its message, and `error.reason` starting with `surge_` when Surge is the one to install, say which App is missing.
 - `stack_list` returns the current API key owner's registered stacks.
+- `stack_publish({ cwd?, owner?, repo?, branch?, base?, title?, body?, replace_head?, auto_land? })` publishes a local branch with no GitHub credentials. It reads the branch's commits from the repository at `cwd` and sends them to Mergestorm, which writes them and the branch on GitHub as the Surge App, opens a ready pull request, and registers the stack with Auto patch pinned off, Auto land on for a new stack, and Auto review left to the account. It never runs `gh`, `git push` or `git fetch`. Call it again for every later commit to that branch, and after a lost response: it resumes and does not duplicate the branch, commits, pull request or stack. It refuses with `head_changed` when the branch on GitHub holds work the local branch does not; `replace_head` names the exact GitHub head to replace. Limits: 20 commits, 500 changed paths, 2 MiB a file, 8 MiB in total; no submodules or merge commits. The result carries the verified head commit and tree, the pull request, the stack and its `watch`.
+- `stack_publish_status({ cwd?, owner?, repo?, branch? })` reads how far a publication got (`absent`, `pushed`, `opened`, `registered`) with the head on GitHub, the pull request and the stack's Auto patch and Auto land state. It changes nothing.
 - `stack_set({ stack_id, auto_land?, auto_review?, auto_patch?, auto_resolve_conflicts?, auto_fix_ci? })` sets per-stack policy on one owned stack. `auto_land` flips Auto land. `auto_review`, `auto_patch`, `auto_resolve_conflicts`, and `auto_fix_ci` pin Vortex auto-review, Cyclone auto-patch, Auto-resolve merge conflicts, or Auto-fix failing CI 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, plus `attention`, `issues`, and `currentCandidate` from the same blocker rules as `stack_wait`, read against that stack's own merge queue. It returns a structured `stack_not_found` or `rate_limited` error.
 - `stack_wait({ stack_id, timeout_s?, enrolled_head_sha?, after_finished_at?, bounce_id? })` waits for a stack or queue state change and returns the latest snapshots. `timeout_s: 0` returns one snapshot; a positive timeout after a snapshot with no attention returns the current `waiting` or `in_progress` status with selectors to use for the next call. An unread deadline returns `failed`. While Cyclone or Vortex is still working on the blocked PR, `stack_wait` and `stack_status` return `in_progress` instead of `attention`, with `busy[]` naming the PR, blocker, and agent, and `agents` carrying that PR's `vortexStatus`, `cycloneStatus`, `vortexReview`, and busy flags. A nonempty `busy[]` means wait. A queued Vortex run holds for at most 15 minutes, `seam_pending` alone does not hold, and reviewing or patching holds until the run finishes or its lease or check run is cleared. A blocker no agent run clears (a merge conflict vs the live parent, a restack `Conflict` or `Restack failed`, a Draft PR, a seam review pending with no review running, "Seam review stuck in reviewing, no review running", "Seam re-review pending, no review running", "Seam verdict is for an older head, no review running", or a review skipped for review quota) is still named during that `in_progress`, in `blocker`, `prNumber`, `headSha`, and `issues[]`, with `actAfter: "agents_idle"` and `waitingOn` listing the busy agents; act when a snapshot after the agents finish returns `attention`, re-reading the blocker then. For the three stuck-seam blockers, `repair` has kind `seam_review_stuck`: do not patch or push; tell the human to click Continue, which re-queues the seam review at the live head. `repair` is included when another concrete repair hint is available. Blockers the agents can change keep `blocker` and `actAfter` null. If a hold looks stuck, refresh `stack_status` and tell the human.

package/dist/index.js

@@ -5,8 +5,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z3 } from "zod";
-import { CommandError as CommandError11, BEARER_SETTINGS as BEARER_SETTINGS2 } from "mergestorm/client";
+import { z as z5 } from "zod";
+import { CommandError as CommandError14, BEARER_SETTINGS as BEARER_SETTINGS2 } from "mergestorm/client";
 
 // src/brand-icons.ts
 var MARK_RECTS = [
@@ -75,10 +75,59 @@ async function credits(cfg) {
   };
 }
 
+// src/tools/issue-create.ts
+import { CommandError as CommandError2, openStackIssue, parseGithubOriginRepo } from "mergestorm/client";
+import { z } from "zod";
+var issueCreateSchema = {
+  title: z.string().trim().min(1).max(256),
+  body: z.string().max(6e4).optional(),
+  labels: z.array(z.string().trim().min(1).max(50)).max(10).optional(),
+  owner: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/).optional(),
+  repo: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/).optional(),
+  cwd: z.string().trim().min(1).optional()
+};
+var inputSchema = z.object(issueCreateSchema);
+async function issueCreate(input, cfg, deps = {}) {
+  const parsed = inputSchema.safeParse(input);
+  if (!parsed.success || Boolean(parsed.data.owner) !== Boolean(parsed.data.repo)) {
+    const message = "issue_create needs a one-line title of at most 256 characters, and owner and repo together";
+    return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+  }
+  const { title, body, labels, owner, repo, cwd } = parsed.data;
+  try {
+    const target2 = owner && repo ? { owner, repo } : (deps.parseGithubOriginRepo ?? parseGithubOriginRepo)(cwd);
+    if (!target2) {
+      const message = "Could not read a GitHub owner/repo from origin. Pass owner and repo.";
+      return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+    }
+    const issue = await (deps.openStackIssue ?? openStackIssue)(
+      { owner: target2.owner, repo: target2.repo, title, body: body ?? "", labels: labels ?? [] },
+      cfg
+    );
+    return {
+      summary: `${issue.created ? "Opened" : "Already open:"} ${target2.owner}/${target2.repo}#${issue.number} ${issue.url}. Put "Fixes #${issue.number}" in the commit or pull request body.`,
+      data: { owner: target2.owner, repo: target2.repo, ...issue }
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      summary: message,
+      data: {
+        error: {
+          code: err instanceof CommandError2 ? err.code ?? "issue_create_failed" : "issue_create_failed",
+          message,
+          ...err instanceof CommandError2 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
+        }
+      },
+      isError: true
+    };
+  }
+}
+
 // src/tools/queue-status.ts
 import {
   apiFetch,
-  CommandError as CommandError2,
+  CommandError as CommandError3,
   isCommandErrorCode,
   loadConfig as loadConfig2,
   rateLimitedMessage,
@@ -106,12 +155,12 @@ async function queueStatus(stackId, cfg) {
       id ? `/api/v1/stacks/queue?stackId=${encodeURIComponent(id)}` : "/api/v1/stacks/queue"
     );
     if (status === 404) {
-      throw new CommandError2(
+      throw new CommandError3(
         "Merge queue route returned 404. Deploy the API."
       );
     }
     if (status === 429) {
-      throw new CommandError2(
+      throw new CommandError3(
         rateLimitedMessage(retryAfterSeconds),
         REVIEW_EXIT.rate_limited,
         "rate_limited",
@@ -119,13 +168,13 @@ async function queueStatus(stackId, cfg) {
       );
     }
     if (status !== 200) {
-      throw new CommandError2(
+      throw new CommandError3(
         `Failed to get queue status (HTTP ${status}): ${JSON.stringify(body)}`
       );
     }
     const entries = body.entries;
     if (!Array.isArray(entries)) {
-      throw new CommandError2(
+      throw new CommandError3(
         `Failed to get queue status (HTTP 200): ${JSON.stringify(body)}`
       );
     }
@@ -190,13 +239,13 @@ import {
   stackWatchBackgroundCommand,
   stackWatchObligation
 } from "mergestorm/client";
-import { z } from "zod";
+import { z as z2 } from "zod";
 var stackWaitSchema = {
-  stack_id: z.string().trim().min(1),
-  timeout_s: z.number().finite().min(0).max(45).default(45),
-  enrolled_head_sha: z.string().nullable().optional(),
-  after_finished_at: z.string().nullable().optional(),
-  bounce_id: z.string().nullable().optional()
+  stack_id: z2.string().trim().min(1),
+  timeout_s: z2.number().finite().min(0).max(45).default(45),
+  enrolled_head_sha: z2.string().nullable().optional(),
+  after_finished_at: z2.string().nullable().optional(),
+  bounce_id: z2.string().nullable().optional()
 };
 function repairSummary(repair) {
   if (!repair) return "";
@@ -233,7 +282,7 @@ function stackWaitStatusLine(envelope) {
   return `${base} \xB7 watch not finished: only with a confirmed host notification that resumes this task, run ${stackWatchBackgroundCommand(envelope.stackId)} as a background command and end your turn; otherwise call stack_wait again with timeout_s 45 and the same cursor: ${selectors.join(", ")}`;
 }
 async function stackWait(input, cfg, deps = {}) {
-  const args = z.object(stackWaitSchema).parse(input);
+  const args = z2.object(stackWaitSchema).parse(input);
   const cursor = args.enrolled_head_sha !== void 0 || args.after_finished_at !== void 0 || args.bounce_id !== void 0 ? {
     stackId: args.stack_id,
     enrolledHeadSha: args.enrolled_head_sha ?? null,
@@ -346,7 +395,7 @@ import { createHash } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { relative, resolve, sep } from "node:path";
 import {
-  CommandError as CommandError3,
+  CommandError as CommandError4,
   REVIEW_THREAD_SLUG_RE,
   ReviewPollTimeoutError,
   collectReviewInput,
@@ -401,7 +450,7 @@ function assertPinnableSpecialists(specialists) {
     (id) => !PINNABLE_SPECIALISTS.includes(id)
   );
   if (unknown.length === 0) return;
-  throw new CommandError3(
+  throw new CommandError4(
     `Unknown specialist: ${unknown.join(", ")}. Valid lanes: ${PINNABLE_SPECIALISTS.join(", ")}. governance and seam cannot be requested.`,
     2,
     "usage"
@@ -413,7 +462,7 @@ function mcpSandboxRoot() {
 function waitTimeoutMs(timeout_s, defaultSeconds = MCP_PR_WAIT_DEFAULT_S) {
   const seconds = timeout_s ?? defaultSeconds;
   if (!Number.isFinite(seconds) || seconds <= 0) {
-    throw new CommandError3("timeout_s must be a positive number of seconds", 2, "usage");
+    throw new CommandError4("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));
 }
@@ -446,11 +495,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 CommandError4("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 CommandError4) throw err;
+    throw new CommandError4("cwd must be inside the configured sandbox root", 2, "usage");
   }
   const base = input.base?.trim() || discoverTrunk(cwd);
   return collectReviewInput(base, head, cwd, sandboxRoot);
@@ -461,10 +510,10 @@ async function reviewSubmit(input, cfg, opts = {}) {
   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 CommandError4("thread must be 1\u2013120 chars [A-Za-z0-9._/-]", 2, "usage");
   }
   if (input.context === "-") {
-    throw new CommandError3(
+    throw new CommandError4(
       'context "-" (stdin) is not available over MCP; pass the text directly',
       2,
       "usage"
@@ -514,7 +563,7 @@ async function reviewSubmit(input, cfg, opts = {}) {
     };
   }
   if (!jobId) {
-    throw new CommandError3("Review API returned no job_id");
+    throw new CommandError4("Review API returned no job_id");
   }
   if (!wait) {
     return payloadFromRow(submitted.row, { jobId, status: submitted.row.status ?? "queued" });
@@ -550,7 +599,7 @@ import {
 
 // src/tools/review-get-pr.ts
 import {
-  CommandError as CommandError4,
+  CommandError as CommandError5,
   getPrVortexReview,
   isCommandErrorCode as isCommandErrorCode3
 } from "mergestorm/client";
@@ -558,7 +607,7 @@ function prReviewTarget(owner, repo, prNumber) {
   const cleanOwner = owner.trim();
   const cleanRepo = repo.trim();
   if (!cleanOwner || !cleanRepo || !Number.isInteger(prNumber) || prNumber <= 0) {
-    throw new CommandError4(
+    throw new CommandError5(
       "owner, repo, and a positive pr_number are required",
       2,
       "usage"
@@ -596,27 +645,27 @@ function payloadFromPrRateLimit(err, owner, repo, prNumber) {
   };
 }
 async function reviewGetPr(owner, repo, prNumber, cfg, opts = {}) {
-  const target = prReviewTarget(owner, repo, prNumber);
+  const target2 = prReviewTarget(owner, repo, prNumber);
   try {
     const envelope = await getPrVortexReview(
-      target.owner,
-      target.repo,
-      target.prNumber,
+      target2.owner,
+      target2.repo,
+      target2.prNumber,
       cfg,
       { afterSha: opts.afterSha, pass: opts.pass, afterPass: opts.afterPass }
     );
     return payloadFromPrReview(
-      target.owner,
-      target.repo,
-      target.prNumber,
+      target2.owner,
+      target2.repo,
+      target2.prNumber,
       envelope
     );
   } catch (err) {
     const rateLimited = payloadFromPrRateLimit(
       err,
-      target.owner,
-      target.repo,
-      target.prNumber
+      target2.owner,
+      target2.repo,
+      target2.prNumber
     );
     if (rateLimited) return rateLimited;
     throw err;
@@ -625,10 +674,10 @@ async function reviewGetPr(owner, repo, prNumber, cfg, opts = {}) {
 
 // src/tools/review-wait-pr.ts
 async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opts = {}) {
-  const target = prReviewTarget(owner, repo, prNumber);
+  const target2 = prReviewTarget(owner, repo, prNumber);
   const resolved = cfg ?? await loadConfig5();
   if (timeout_s === 0) {
-    return reviewGetPr(target.owner, target.repo, target.prNumber, resolved, {
+    return reviewGetPr(target2.owner, target2.repo, target2.prNumber, resolved, {
       afterSha,
       pass: opts.pass,
       afterPass: opts.afterPass
@@ -637,9 +686,9 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
   try {
     const envelope = await pollPrVortexReview(
       resolved,
-      target.owner,
-      target.repo,
-      target.prNumber,
+      target2.owner,
+      target2.repo,
+      target2.prNumber,
       {
         timeoutMs: waitTimeoutMs(timeout_s, MCP_PR_WAIT_DEFAULT_S),
         afterSha,
@@ -649,9 +698,9 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
       }
     );
     return payloadFromPrReview(
-      target.owner,
-      target.repo,
-      target.prNumber,
+      target2.owner,
+      target2.repo,
+      target2.prNumber,
       envelope
     );
   } catch (err) {
@@ -663,14 +712,14 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
         observedSha && expectedSha.length >= 7 && (observedSha.startsWith(expectedSha) || expectedSha.startsWith(observedSha))
       );
       const findingCount = headShaMatches ? err.lastEnvelope?.finding_count ?? null : null;
-      const summary = prReviewSummary(target.owner, target.repo, target.prNumber, {
+      const summary = prReviewSummary(target2.owner, target2.repo, target2.prNumber, {
         status,
         head_sha: err.lastEnvelope?.head_sha ?? null,
         finding_count: findingCount,
         phase: err.lastEnvelope?.phase ?? null
       });
       return {
-        summary: err.reviewSeen ? summary : `${summary} \xB7 ${noPrReviewYetMessage(target.owner, target.repo, target.prNumber, { afterSha, pass: opts.pass, afterPass: opts.afterPass })}`,
+        summary: err.reviewSeen ? summary : `${summary} \xB7 ${noPrReviewYetMessage(target2.owner, target2.repo, target2.prNumber, { afterSha, pass: opts.pass, afterPass: opts.afterPass })}`,
         data: {
           status,
           head_sha: err.lastEnvelope?.head_sha ?? null,
@@ -683,9 +732,9 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
     }
     const rateLimited = payloadFromPrRateLimit(
       err,
-      target.owner,
-      target.repo,
-      target.prNumber
+      target2.owner,
+      target2.repo,
+      target2.prNumber
     );
     if (rateLimited) return rateLimited;
     throw err;
@@ -694,7 +743,7 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
 
 // src/tools/review-wait.ts
 import {
-  CommandError as CommandError6,
+  CommandError as CommandError7,
   ReviewPollTimeoutError as ReviewPollTimeoutError2,
   loadConfig as loadConfig6,
   pollReview as pollReview2
@@ -702,7 +751,7 @@ import {
 
 // src/tools/review-get.ts
 import {
-  CommandError as CommandError5,
+  CommandError as CommandError6,
   getReview,
   toReviewJobEnvelope as toReviewJobEnvelope3
 } from "mergestorm/client";
@@ -716,7 +765,7 @@ async function reviewGet(jobId, cfg) {
     throw err;
   }
   if (!row || typeof row !== "object" || typeof row.status !== "string") {
-    throw new CommandError5(`Unexpected response for review ${jobId}.`);
+    throw new CommandError6(`Unexpected response for review ${jobId}.`);
   }
   const envelope = toReviewJobEnvelope3(row, { jobId });
   const bits = [envelope.status];
@@ -732,7 +781,7 @@ async function reviewWait(jobId, timeout_s, cfg, opts = {}) {
   const resolved = cfg ?? await loadConfig6();
   const id = jobId.trim();
   if (!id) {
-    throw new CommandError6("job_id is required", 2, "usage");
+    throw new CommandError7("job_id is required", 2, "usage");
   }
   if (timeout_s === 0) return reviewGet(id, resolved);
   try {
@@ -757,7 +806,7 @@ async function reviewWait(jobId, timeout_s, cfg, opts = {}) {
 
 // src/tools/settings-get.ts
 import {
-  CommandError as CommandError7,
+  CommandError as CommandError8,
   getSettings
 } from "mergestorm/client";
 function settingsSummary(settings) {
@@ -775,7 +824,7 @@ function settingsSummary(settings) {
 async function settingsGet(cfg) {
   const settings = await getSettings(cfg);
   if (!settings) {
-    throw new CommandError7(
+    throw new CommandError8(
       "Settings are not available (offline or API too old). Try again or open https://mergestorm.ai/settings"
     );
   }
@@ -787,7 +836,7 @@ async function settingsGet(cfg) {
 
 // src/tools/settings-set.ts
 import {
-  CommandError as CommandError8,
+  CommandError as CommandError9,
   BEARER_SETTINGS,
   SETTINGS_WRITABLE_KEYS,
   patchSettings
@@ -799,7 +848,7 @@ var SETTINGS_READ_ONLY_KEYS = [
 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");
+      throw new CommandError9(`${key} is read-only and cannot be set.`, 2, "usage");
     }
   }
   const patch = {};
@@ -810,7 +859,7 @@ function settingsPatchFromArgs(args) {
     if ("kind" in row && (row.kind === "seconds" || row.kind === "count")) {
       if (typeof value !== "number" || !Number.isInteger(value) || value < row.min || value > row.max) {
         const unit = row.kind === "seconds" ? " of seconds" : "";
-        throw new CommandError8(
+        throw new CommandError9(
           `${key} takes a whole number${unit} from ${row.min} through ${row.max}.`,
           2,
           "usage"
@@ -821,17 +870,17 @@ function settingsPatchFromArgs(args) {
     }
     if ("kind" in row) {
       const valid = row.kind === "logins" ? Array.isArray(value) && value.every((login) => typeof login === "string") : typeof value === "string" && row.values.includes(value);
-      if (!valid) throw new CommandError8(`Invalid value for ${key}.`, 2, "usage");
+      if (!valid) throw new CommandError9(`Invalid value for ${key}.`, 2, "usage");
       Object.assign(patch, { [key]: value });
       continue;
     }
     if (typeof value !== "boolean") {
-      throw new CommandError8(`${key} takes a boolean.`, 2, "usage");
+      throw new CommandError9(`${key} takes a boolean.`, 2, "usage");
     }
     Object.assign(patch, { [key]: value });
   }
   if (Object.keys(patch).length === 0) {
-    throw new CommandError8(
+    throw new CommandError9(
       `At least one settings key is required: ${SETTINGS_WRITABLE_KEYS.join(", ")}.`,
       2,
       "usage"
@@ -848,9 +897,71 @@ async function settingsSet(args, cfg) {
   };
 }
 
+// src/tools/repo-settings.ts
+import {
+  CommandError as CommandError10,
+  REPO_SETTINGS_KEYS,
+  listRepoSettings,
+  patchRepoSettings
+} from "mergestorm/client";
+var ARG_BY_KEY = {
+  auto_patch_enabled: "auto_patch",
+  auto_review_enabled: "auto_review",
+  auto_land_default: "auto_land"
+};
+function parseRepo(raw) {
+  const match = typeof raw === "string" ? /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(raw.trim()) : null;
+  if (!match) throw new CommandError10("repo takes <owner>/<repo>.", 2, "usage");
+  return { owner: match[1], repo: match[2] };
+}
+function words(value) {
+  return value === null ? "inherit" : value ? "on" : "off";
+}
+function repoSettingsSummary(entry) {
+  return `${entry.owner}/${entry.repo}: ${REPO_SETTINGS_KEYS.map((key) => `${ARG_BY_KEY[key]} ${words(entry[key])}`).join(" \xB7 ")}`;
+}
+function repoSettingsPatchFromArgs(args) {
+  const patch = {};
+  for (const key of REPO_SETTINGS_KEYS) {
+    const value = args[ARG_BY_KEY[key]];
+    if (value === void 0) continue;
+    if (value !== null && typeof value !== "boolean") {
+      throw new CommandError10(`${ARG_BY_KEY[key]} takes true, false, or null.`, 2, "usage");
+    }
+    patch[key] = value;
+  }
+  if (Object.keys(patch).length === 0) {
+    throw new CommandError10(
+      `At least one of ${Object.values(ARG_BY_KEY).join(", ")} is required.`,
+      2,
+      "usage"
+    );
+  }
+  return patch;
+}
+async function repoSettingsGet(args, cfg) {
+  const wanted = args.repo === void 0 ? null : parseRepo(args.repo);
+  const all = await listRepoSettings(cfg);
+  if (!wanted) {
+    return {
+      summary: all.length === 0 ? "No repositories are connected to this account." : all.map(repoSettingsSummary).join("\n"),
+      data: { repos: all }
+    };
+  }
+  const slug = `${wanted.owner}/${wanted.repo}`.toLowerCase();
+  const entry = all.find((candidate) => `${candidate.owner}/${candidate.repo}`.toLowerCase() === slug);
+  if (!entry) throw new CommandError10(`${wanted.owner}/${wanted.repo} is not connected to this account.`);
+  return { summary: repoSettingsSummary(entry), data: { ...entry } };
+}
+async function repoSettingsSet(args, cfg) {
+  const { owner, repo } = parseRepo(args.repo);
+  const entry = await patchRepoSettings(owner, repo, repoSettingsPatchFromArgs(args), cfg);
+  return { summary: repoSettingsSummary(entry), data: { ...entry } };
+}
+
 // src/tools/stack-adopt.ts
-import { adoptStack, CommandError as CommandError9, stackWatchObligation as stackWatchObligation4 } from "mergestorm/client";
-import { z as z2 } from "zod";
+import { adoptStack, CommandError as CommandError11, stackWatchObligation as stackWatchObligation4 } from "mergestorm/client";
+import { z as z3 } from "zod";
 
 // src/tools/stack-set.ts
 import { setStackPolicy, stackWatchObligation as stackWatchObligation3 } from "mergestorm/client";
@@ -918,18 +1029,18 @@ async function stackSet(stackId, input, cfg) {
 
 // src/tools/stack-adopt.ts
 var stackAdoptSchema = {
-  owner: z2.string().trim().min(1),
-  repo: z2.string().trim().min(1),
-  pr_number: z2.number().int().min(1),
-  auto_land: z2.boolean().optional(),
-  auto_review: z2.boolean().nullable().optional(),
-  auto_patch: z2.boolean().nullable().optional(),
-  auto_resolve_conflicts: z2.boolean().nullable().optional(),
-  auto_fix_ci: z2.boolean().nullable().optional()
+  owner: z3.string().trim().min(1),
+  repo: z3.string().trim().min(1),
+  pr_number: z3.number().int().min(1),
+  auto_land: z3.boolean().optional(),
+  auto_review: z3.boolean().nullable().optional(),
+  auto_patch: z3.boolean().nullable().optional(),
+  auto_resolve_conflicts: z3.boolean().nullable().optional(),
+  auto_fix_ci: z3.boolean().nullable().optional()
 };
-var inputSchema = z2.object(stackAdoptSchema);
+var inputSchema2 = z3.object(stackAdoptSchema);
 async function stackAdopt(input, cfg) {
-  const parsed = inputSchema.safeParse(input);
+  const parsed = inputSchema2.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 };
@@ -959,11 +1070,11 @@ async function stackAdopt(input, cfg) {
       summary: message,
       data: {
         error: {
-          code: err instanceof CommandError9 ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",
+          code: err instanceof CommandError11 ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",
           message,
-          ...err instanceof CommandError9 ? { exit_code: err.exitCode } : {},
-          ...err instanceof CommandError9 && err.reason !== void 0 ? { reason: err.reason } : {},
-          ...err instanceof CommandError9 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
+          ...err instanceof CommandError11 ? { exit_code: err.exitCode } : {},
+          ...err instanceof CommandError11 && err.reason !== void 0 ? { reason: err.reason } : {},
+          ...err instanceof CommandError11 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
         }
       },
       isError: true
@@ -1032,6 +1143,102 @@ async function stackList(cfg) {
   }
 }
 
+// src/tools/stack-publish.ts
+import {
+  CommandError as CommandError12,
+  publishWorkingBranch,
+  stackWatchObligation as stackWatchObligation5,
+  workingBranchPublication
+} from "mergestorm/client";
+import { z as z4 } from "zod";
+var target = {
+  cwd: z4.string().trim().min(1).optional(),
+  owner: z4.string().trim().min(1).optional(),
+  repo: z4.string().trim().min(1).optional(),
+  branch: z4.string().trim().min(1).optional()
+};
+var stackPublishSchema = {
+  ...target,
+  base: z4.string().trim().min(1).optional(),
+  title: z4.string().trim().min(1).max(256).optional(),
+  body: z4.string().max(6e4).optional(),
+  replace_head: z4.string().regex(/^[0-9a-f]{40}$/).optional(),
+  auto_land: z4.boolean().optional()
+};
+var stackPublishStatusSchema = target;
+var publishInput = z4.object(stackPublishSchema);
+var statusInput = z4.object(stackPublishStatusSchema);
+function failure(err, fallback) {
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    summary: message,
+    data: {
+      error: {
+        code: err instanceof CommandError12 ? err.code ?? fallback : fallback,
+        message,
+        ...err instanceof CommandError12 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
+      }
+    },
+    isError: true
+  };
+}
+function targetOf(input, cfg) {
+  return {
+    ...input.cwd ? { cwd: input.cwd } : {},
+    ...input.owner ? { owner: input.owner } : {},
+    ...input.repo ? { repo: input.repo } : {},
+    ...input.branch ? { branch: input.branch } : {},
+    ...cfg ? { cfg } : {}
+  };
+}
+async function stackPublish(input, cfg, deps) {
+  const parsed = publishInput.safeParse(input);
+  if (!parsed.success || Boolean(parsed.data.owner) !== Boolean(parsed.data.repo)) {
+    const message = "stack_publish takes owner and repo together, and replace_head as a full 40-character commit SHA";
+    return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+  }
+  try {
+    const result = await publishWorkingBranch(
+      {
+        ...targetOf(parsed.data, cfg),
+        ...parsed.data.base ? { base: parsed.data.base } : {},
+        ...parsed.data.title ? { title: parsed.data.title } : {},
+        ...parsed.data.body !== void 0 ? { body: parsed.data.body } : {},
+        ...parsed.data.replace_head ? { replaceHead: parsed.data.replace_head } : {},
+        ...typeof parsed.data.auto_land === "boolean" ? { autoLand: parsed.data.auto_land } : {}
+      },
+      deps
+    );
+    const watch = stackWatchObligation5({ stackId: result.stack.id, terminal: null, unread: true, freshCursor: true });
+    const moved = result.branchCreated ? "created" : result.branchUpdated ? "updated" : "already current";
+    return {
+      summary: withWatchText(
+        watch,
+        `Published ${result.owner}/${result.repo} ${result.branch} (${moved}) at ${result.head.sha}, PR #${result.pr.number}, stack ${result.stack.id} with Auto patch off`
+      ),
+      data: { result, watch }
+    };
+  } catch (err) {
+    return failure(err, "stack_publish_failed");
+  }
+}
+async function stackPublishStatus(input, cfg, deps) {
+  const parsed = statusInput.safeParse(input);
+  if (!parsed.success || Boolean(parsed.data.owner) !== Boolean(parsed.data.repo)) {
+    const message = "stack_publish_status takes owner and repo together";
+    return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+  }
+  try {
+    const status = await workingBranchPublication(targetOf(parsed.data, cfg), deps);
+    return {
+      summary: `${status.owner}/${status.repo} ${status.branch}: ${status.state}${status.head ? ` at ${status.head.sha}` : ""}${status.pr ? `, PR #${status.pr.number}` : ""}${status.stack ? `, stack ${status.stack.id}` : ""}`,
+      data: { status }
+    };
+  } catch (err) {
+    return failure(err, "stack_publish_status_failed");
+  }
+}
+
 // src/tools/stack-status.ts
 import {
   getEnrichedStack,
@@ -1039,14 +1246,14 @@ import {
   isCommandErrorCode as isCommandErrorCode5,
   stackBlockers as stackBlockers2,
   stackTerminalReason,
-  stackWatchObligation as stackWatchObligation5
+  stackWatchObligation as stackWatchObligation6
 } 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}`;
-      const watch2 = stackWatchObligation5({ stackId, terminal: "not_found" });
+      const watch2 = stackWatchObligation6({ stackId, terminal: "not_found" });
       return {
         summary: withWatchText(watch2, message),
         data: {
@@ -1062,7 +1269,7 @@ async function stackStatus(stackId, cfg) {
     }
     const entries = await listMergeQueueEntries2(cfg, { stackId: stack.id });
     const { attention, held, issues, currentCandidate, busy, agents, repair, landGatePending, queueWait } = stackBlockers2(stack, entries);
-    const watch = stackWatchObligation5({
+    const watch = stackWatchObligation6({
       stackId: stack.id,
       terminal: stackTerminalReason(stack),
       cursor: { enrolledHeadSha: currentCandidate?.headSha ?? null },
@@ -1075,7 +1282,7 @@ async function stackStatus(stackId, cfg) {
     };
   } catch (err) {
     if (isCommandErrorCode5(err, "rate_limited")) {
-      const watch = stackWatchObligation5({
+      const watch = stackWatchObligation6({
         stackId,
         terminal: null,
         status: "rate_limited",
@@ -1101,7 +1308,7 @@ async function stackStatus(stackId, cfg) {
 
 // src/tools/whoami.ts
 import {
-  CommandError as CommandError10,
+  CommandError as CommandError13,
   apiBase,
   configPath,
   getMe as getMe2,
@@ -1112,7 +1319,7 @@ async function whoami(cfg, serverVersion) {
   const resolved = cfg ?? await loadConfig7();
   const key = resolveApiKey(resolved);
   if (!key) {
-    throw new CommandError10(
+    throw new CommandError13(
       "No API key. Run `mergestorm login` (agents: `mergestorm login --start`, then `--finish`) or set MERGESTORM_API_KEY.",
       1,
       "missing_api_key"
@@ -1120,7 +1327,7 @@ async function whoami(cfg, serverVersion) {
   }
   const me = await getMe2(resolved);
   if (!me) {
-    throw new CommandError10("Live account details unavailable. Could not verify account with /me.");
+    throw new CommandError13("Live account details unavailable. Could not verify account with /me.");
   }
   const data = {
     key_prefix: me.key.prefix,
@@ -1195,7 +1402,7 @@ var MCP_STACK_WATCH_INSTRUCTIONS = [
 
 // src/server.ts
 var MCP_SERVER_NAME = "mergestorm";
-var MCP_SERVER_VERSION = "0.2.20";
+var MCP_SERVER_VERSION = "0.2.22";
 var MCP_SERVER_INSTRUCTIONS = [
   MCP_STACK_DONE_INSTRUCTIONS,
   MCP_PR_LOOP_INSTRUCTIONS,
@@ -1214,14 +1421,14 @@ function ok(payload) {
   };
 }
 function fail(err) {
-  const message = err instanceof CommandError11 ? err.code ? `Mergestorm request failed (${err.code}${err.reason ? `, reason ${err.reason}` : ""}): ${err.message}.` : err.message : err instanceof Error ? err.message : String(err);
+  const message = err instanceof CommandError14 ? err.code ? `Mergestorm request failed (${err.code}${err.reason ? `, reason ${err.reason}` : ""}): ${err.message}.` : err.message : err instanceof Error ? err.message : String(err);
   return ok({
     isError: true,
     summary: message,
     data: {
       error: {
         message: err instanceof Error ? err.message : String(err),
-        ...err instanceof CommandError11 ? {
+        ...err instanceof CommandError14 ? {
           exit_code: err.exitCode,
           ...err.code !== void 0 ? { code: err.code } : {},
           ...err.reason !== void 0 ? { reason: err.reason } : {},
@@ -1279,7 +1486,7 @@ function createMergestormMcpServer() {
       title: "List reviews",
       description: "List recent Mergestorm review jobs as job envelopes.",
       inputSchema: {
-        limit: z3.number().int().min(1).max(50).optional()
+        limit: z5.number().int().min(1).max(50).optional()
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
@@ -1297,18 +1504,18 @@ function createMergestormMcpServer() {
       title: "Submit review",
       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: z3.string().optional(),
-        base: z3.string().optional(),
-        head: z3.string().optional(),
-        diff: z3.string().optional(),
-        router: z3.enum(["off", "standard", "max", "manual"]).optional(),
-        specialists: z3.array(z3.string().min(1)).max(5).optional(),
-        context: z3.string().optional(),
-        context_files: z3.array(z3.string().min(1)).max(10).optional(),
-        thread: z3.string().min(1).max(120).optional(),
-        idempotency_key: z3.string().min(1).max(128).optional(),
-        wait: z3.boolean().optional(),
-        timeout_s: z3.number().positive().max(300).optional()
+        cwd: z5.string().optional(),
+        base: z5.string().optional(),
+        head: z5.string().optional(),
+        diff: z5.string().optional(),
+        router: z5.enum(["off", "standard", "max", "manual"]).optional(),
+        specialists: z5.array(z5.string().min(1)).max(5).optional(),
+        context: z5.string().optional(),
+        context_files: z5.array(z5.string().min(1)).max(10).optional(),
+        thread: z5.string().min(1).max(120).optional(),
+        idempotency_key: z5.string().min(1).max(128).optional(),
+        wait: z5.boolean().optional(),
+        timeout_s: z5.number().positive().max(300).optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
     },
@@ -1326,8 +1533,8 @@ function createMergestormMcpServer() {
       title: "Wait for review",
       description: "Read one local Mergestorm review job by the job_id that review_submit returned, as a job envelope. timeout_s: 0 reads it once without polling; otherwise it polls 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: z3.string().min(1),
-        timeout_s: z3.number().min(0).max(300).optional()
+        job_id: z5.string().min(1),
+        timeout_s: z5.number().min(0).max(300).optional()
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
@@ -1345,13 +1552,13 @@ function createMergestormMcpServer() {
       title: "Wait for GitHub PR Vortex review",
       description: "Read the Vortex pass on a GitHub PR from the DB-only endpoint; review identity is head SHA + pass. timeout_s: 0 reads it once without polling; otherwise it polls for one 45s slice by default (max 300) and returns in_progress on timeout so you can call again, or none when no review exists for that PR and head yet (call once more; if it is none again, Vortex is not reviewing that head: comment @mergestorm-vortex review on the PR, run mg review, or push a new commit). Pass after_sha for the head you pushed and pass to read one exact attempt; when you already hold a resting envelope for that head, also pass after_pass set to its pass and keep it unchanged across retries; never replace it with the pass of an in-progress envelope, and omit after_pass for a head you hold no envelope for. With timeout_s: 0, a pass that does not exist yet returns not_found, so after a push use a positive timeout. 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: z3.string().min(1),
-        repo: z3.string().min(1),
-        pr_number: z3.number().int().min(1),
-        after_sha: z3.string().optional(),
-        pass: z3.number().int().min(1).optional(),
-        after_pass: z3.number().int().min(1).optional(),
-        timeout_s: z3.number().min(0).max(300).optional()
+        owner: z5.string().min(1),
+        repo: z5.string().min(1),
+        pr_number: z5.number().int().min(1),
+        after_sha: z5.string().optional(),
+        pass: z5.number().int().min(1).optional(),
+        after_pass: z5.number().int().min(1).optional(),
+        timeout_s: z5.number().min(0).max(300).optional()
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
@@ -1379,16 +1586,16 @@ function createMergestormMcpServer() {
       title: "Dismiss Vortex findings",
       description: `Record an audited dismissal of Vortex findings you verified are wrong or not actionable on a GitHub PR. Identity is exact: head_sha must be the PR's live head, review_id a Vortex review (Core or seam) made at that head, and finding_ids the GitHub review comment ids of that review (offdiff-<n> for a body-only finding), or scope "review" with no finding_ids to dismiss every finding of that review. reason must say why (at least 20 characters); evidence_url is optional. Call with preview: true first to list the review's finding ids and the seam gate without writing. The caller's linked GitHub account needs write access to the repository. A moved head, another review, an unknown id or a missing permission is refused and nothing is written. Retries are idempotent. The seam gate clears only when every finding of that integration review is dismissed; the Vortex gate at the head clears only once every Vortex Blocker (error finding) at that head is dismissed and no Vortex review of it is running (gate.vortex.cleared, else gate.vortex.message); CI and Auto land policy are unchanged. Vortex does not raise a dismissed finding again on the same diff. Never dismiss a finding you did not check.` + STACK_WATCH_RESULT_NOTE,
       inputSchema: {
-        owner: z3.string().min(1),
-        repo: z3.string().min(1),
-        pr_number: z3.number().int().min(1),
-        head_sha: z3.string().regex(/^[0-9a-fA-F]{40}$/),
-        review_id: z3.number().int().min(1),
-        finding_ids: z3.array(z3.string().min(1)).max(50).optional(),
-        scope: z3.enum(["findings", "review"]).optional(),
-        reason: z3.string().optional(),
-        evidence_url: z3.string().url().optional(),
-        preview: z3.boolean().optional()
+        owner: z5.string().min(1),
+        repo: z5.string().min(1),
+        pr_number: z5.number().int().min(1),
+        head_sha: z5.string().regex(/^[0-9a-fA-F]{40}$/),
+        review_id: z5.number().int().min(1),
+        finding_ids: z5.array(z5.string().min(1)).max(50).optional(),
+        scope: z5.enum(["findings", "review"]).optional(),
+        reason: z5.string().optional(),
+        evidence_url: z5.string().url().optional(),
+        preview: z5.boolean().optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
     },
@@ -1400,6 +1607,22 @@ function createMergestormMcpServer() {
       }
     }
   );
+  addTool(
+    "issue_create",
+    {
+      title: "Open GitHub issue",
+      description: "Open a GitHub issue through Mergestorm with no GitHub credentials: the Surge App creates it and names you in the body. Use it for the issue a pull request must have before it is opened, then put Fixes #<number> in the commit or pull request body. Defaults to the origin repository of cwd; pass owner and repo together to name another. labels must already exist on the repository; an unknown one is refused with unknown_label and nothing is created. Calling it again with the same title returns the open issue it already made (created: false) when that issue is among the newest 100 open issues of the repository; an older one, or two calls at the same time, can still create a duplicate, so check the returned number before retrying after a lost response. Needs write access to the repository through your linked GitHub account and Surge installed on it.",
+      inputSchema: issueCreateSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await issueCreate(args));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
   addTool(
     "stack_adopt",
     {
@@ -1431,18 +1654,50 @@ function createMergestormMcpServer() {
       }
     }
   );
+  addTool(
+    "stack_publish",
+    {
+      title: "Publish branch through Mergestorm",
+      description: "Publish a local branch without any GitHub credentials. Reads the branch's commits from the local repository at cwd (never runs gh, git push or git fetch) and sends them to Mergestorm, which writes the exact commits and the branch on GitHub as the Surge App, opens a ready pull request when the branch has none, and registers the stack with Auto patch pinned off, Auto land on for a new stack, and Auto review left to the account. These are your own changes; Cyclone does not write or patch them. Use it for the first publication and for every later commit to that branch. Defaults: owner and repo from origin, the checked-out branch, the repository's trunk as base, title and body from the tip commit. Mergestorm verifies each commit's Git tree before it moves the branch and returns the verified head and tree. It refuses with head_changed when the branch on GitHub holds work your local branch does not, base_changed when the base commit left the base branch, protected_branch for trunk and Mergestorm-owned branches, and payload_too_large beyond 20 commits, 500 changed paths, 2 MiB a file or 8 MiB in total; submodules and merge commits are not carried. replace_head replaces that exact GitHub head with the local branch and discards its commits. Safe to call again after a lost response or a failure: it resumes and never duplicates the branch, commits, pull request or stack." + STACK_WATCH_RESULT_NOTE,
+      inputSchema: stackPublishSchema,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await stackPublish(args));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "stack_publish_status",
+    {
+      title: "Read branch publication",
+      description: "Read how far a branch published with stack_publish got: absent, pushed (branch on GitHub, no pull request), opened (pull request open, stack not registered) or registered, with the head commit and tree on GitHub, the pull request and the stack's Auto patch and Auto land state. Changes nothing. Call it after a lost stack_publish response, then call stack_publish again to resume.",
+      inputSchema: stackPublishStatusSchema,
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await stackPublishStatus(args));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
   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, auto_patch, auto_resolve_conflicts, and auto_fix_ci pin Vortex auto-review, Cyclone auto-patch, Auto-resolve merge conflicts, or Auto-fix failing CI 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." + STACK_WATCH_RESULT_NOTE,
       inputSchema: {
-        stack_id: z3.string().min(1),
-        auto_land: z3.boolean().optional(),
-        auto_review: z3.boolean().nullable().optional(),
-        auto_patch: z3.boolean().nullable().optional(),
-        auto_resolve_conflicts: z3.boolean().nullable().optional(),
-        auto_fix_ci: z3.boolean().nullable().optional()
+        stack_id: z5.string().min(1),
+        auto_land: z5.boolean().optional(),
+        auto_review: z5.boolean().nullable().optional(),
+        auto_patch: z5.boolean().nullable().optional(),
+        auto_resolve_conflicts: z5.boolean().nullable().optional(),
+        auto_fix_ci: z5.boolean().nullable().optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
     },
@@ -1468,7 +1723,7 @@ function createMergestormMcpServer() {
       title: "Get stack status",
       description: `Fetch one owned Mergestorm stack with enriched checks and agent state, plus attention, issues, and currentCandidate from the same blocker rules as stack_wait, read against that stack's own merge queue. trunkBranch is mg-stack-<n> for an adopted 2+ PR stack and matches the bottom open PR's GitHub base; an mg-park-* parentBranch is a freeze. Neither is drift to fix. repair names the concrete fix for attention; landGatePending is a wait, not attention. held names a blocker no agent run clears while Vortex or Cyclone is still busy on that PR (actAfter agents_idle, waitingOn); repair then describes the fix to plan, not to apply yet. Auto land off after a merge_failed, gh_error, or ci_timeout bounce (the stack's autoLandOff reads reason bounced) returns attention with the blocker "Auto land off after <kind> bounce", the bounce in issues[], and a repair of kind auto_land_off: fix the cause, then turn Auto land back on or enqueue. A Vortex request_changes handoff at the live head returns attention with blocker "Vortex findings need a person" and repair kind vortex_findings; verify its findings against the live head.` + STACK_WATCH_RESULT_NOTE,
       inputSchema: {
-        stack_id: z3.string().min(1)
+        stack_id: z5.string().min(1)
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
@@ -1503,7 +1758,7 @@ function createMergestormMcpServer() {
       title: "Get merge queue status",
       description: "List live merge queue entries (position >= 1) plus the newest bounced entries (position 0) with bounceDetail for the current user, optionally filtered by stack.",
       inputSchema: {
-        stack_id: z3.string().min(1).optional()
+        stack_id: z5.string().min(1).optional()
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
@@ -1515,6 +1770,43 @@ function createMergestormMcpServer() {
       }
     }
   );
+  addTool(
+    "repo_settings_get",
+    {
+      title: "Get repository settings",
+      description: "Read the repository-level Auto patch, Auto review and Auto land values for the repositories connected to this account. Each value is true, false, or null; null means not set, so the account setting applies. Auto patch and Auto review precedence is the stack override (stack_set), then the repository value, then the account setting (settings_get). The Auto land repository value only seeds new stacks at adoption; it does not override an existing stack. Pass repo as owner/repo for one repository, or omit it for all.",
+      inputSchema: { repo: z5.string().min(3).optional() },
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await repoSettingsGet(args ?? {}));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "repo_settings_set",
+    {
+      title: "Update repository settings",
+      description: "Set Auto patch (Cyclone), Auto review (Vortex) or the Auto land default for every stack and pull request in one repository connected to this account, and return the stored result. true or false sets the repository value; null clears it so the account setting applies again. A stack override (stack_set) still wins for that stack. auto_patch and auto_review apply to open stacks without an override from their next decision; nothing is cancelled or re-queued. auto_land only seeds new stacks. Only the account that connected the repository can change it. Never changes account settings.",
+      inputSchema: {
+        repo: z5.string().min(3),
+        auto_patch: z5.boolean().nullable().optional(),
+        auto_review: z5.boolean().nullable().optional(),
+        auto_land: z5.boolean().nullable().optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await repoSettingsSet(args ?? {}));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
   addTool(
     "settings_get",
     {
@@ -1539,12 +1831,12 @@ function createMergestormMcpServer() {
         ...Object.fromEntries(
           BEARER_SETTINGS2.map((row) => [
             row.key,
-            ("kind" in row ? row.kind === "logins" ? z3.array(z3.string()) : row.kind === "seconds" || row.kind === "count" ? z3.number().int().min(row.min).max(row.max) : z3.enum(row.values) : z3.boolean()).optional()
+            ("kind" in row ? row.kind === "logins" ? z5.array(z5.string()) : row.kind === "seconds" || row.kind === "count" ? z5.number().int().min(row.min).max(row.max) : z5.enum(row.values) : z5.boolean()).optional()
           ])
         ),
         // Preserve these args so the handler rejects them even alongside a writable key.
-        cyclone_connected: z3.unknown().optional(),
-        github_connected: z3.unknown().optional()
+        cyclone_connected: z5.unknown().optional(),
+        github_connected: z5.unknown().optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm-mcp",
-  "version": "0.2.20",
+  "version": "0.2.22",
   "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.52",
+    "mergestorm": "0.3.56",
     "zod": "^3.24.2"
   },
   "devDependencies": {