mergestorm-mcp 0.2.26 → 0.2.27

package/dist/index.js

@@ -3,10 +3,33 @@
 // src/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/tools/chat-wake.ts
+import { apiFetch } from "mergestorm/client";
+var CHAT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function breezeChatId(value) {
+  const trimmed = value?.trim() ?? "";
+  return CHAT_ID.test(trimmed) ? trimmed.toLowerCase() : null;
+}
+var CHAT_WAKE_REVIEW_NOTE = "Keep waiting: call review_wait_pr again until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
+var REVIEW_START_WAIT_NOTE = "Wait for it now: call review_wait_pr for this pull request until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
+var CHAT_WAKE_STACK_NOTE = "If your reply ends before the stack is done, this chat is woken when the stack lands, is bounced out of the merge queue, or is archived.";
+async function registerChatWake(cfg, chatId, target2, signal) {
+  const json = target2.kind === "vortex" ? { chat_id: chatId, kind: "vortex", owner: target2.owner, repo: target2.repo, pr_number: target2.prNumber, head_sha: target2.headSha, min_pass: target2.headSha ? target2.minPass : null } : { chat_id: chatId, kind: "stack", stack_id: target2.stackId };
+  try {
+    const response = await apiFetch(cfg, "/api/v1/stacks/chat-waits", { method: "POST", json, signal, timeoutMs: 1e4 });
+    const body = response.body;
+    if (response.status !== 200 || !body || typeof body.id !== "string") return null;
+    if (body.result !== "waiting" && body.result !== "existing" && body.result !== "finished") return null;
+    return { id: body.id, result: body.result };
+  } catch {
+    return null;
+  }
+}
+
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z5 } from "zod";
-import { CommandError as CommandError14, BEARER_SETTINGS as BEARER_SETTINGS2 } from "mergestorm/client";
+import { CommandError as CommandError15, BEARER_SETTINGS as BEARER_SETTINGS2 } from "mergestorm/client";
 
 // src/brand-icons.ts
 var MARK_RECTS = [
@@ -86,6 +109,13 @@ var issueCreateSchema = {
   repo: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/).optional(),
   cwd: z.string().trim().min(1).optional()
 };
+var hostedIssueCreateSchema = {
+  title: issueCreateSchema.title,
+  body: issueCreateSchema.body,
+  labels: issueCreateSchema.labels,
+  owner: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/),
+  repo: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/)
+};
 var inputSchema = z.object(issueCreateSchema);
 async function issueCreate(input, cfg, deps = {}) {
   const parsed = inputSchema.safeParse(input);
@@ -126,7 +156,7 @@ async function issueCreate(input, cfg, deps = {}) {
 
 // src/tools/queue-status.ts
 import {
-  apiFetch,
+  apiFetch as apiFetch2,
   CommandError as CommandError3,
   isCommandErrorCode,
   loadConfig as loadConfig2,
@@ -150,7 +180,7 @@ async function queueStatus(stackId, cfg) {
   try {
     const resolved = cfg ?? await loadConfig2();
     const id = stackId?.trim();
-    const { status, body, retryAfterSeconds } = await apiFetch(
+    const { status, body, retryAfterSeconds } = await apiFetch2(
       resolved,
       id ? `/api/v1/stacks/queue?stackId=${encodeURIComponent(id)}` : "/api/v1/stacks/queue"
     );
@@ -226,6 +256,7 @@ async function queueStatus(stackId, cfg) {
 // src/tools/review-dismiss.ts
 import {
   dismissPrFindings,
+  dismissThreadsLine,
   stackWatchObligation as stackWatchObligation2
 } from "mergestorm/client";
 
@@ -283,6 +314,7 @@ function stackWaitStatusLine(envelope) {
 }
 async function stackWait(input, cfg, deps = {}) {
   const args = z2.object(stackWaitSchema).parse(input);
+  const config = cfg ?? await loadConfig3();
   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,
@@ -291,7 +323,7 @@ async function stackWait(input, cfg, deps = {}) {
   } : void 0;
   let envelope;
   try {
-    envelope = await (deps.pollStackWatch ?? pollStackWatch)(cfg ?? await loadConfig3(), args.stack_id, {
+    envelope = await (deps.pollStackWatch ?? pollStackWatch)(config, args.stack_id, {
       timeoutMs: args.timeout_s * 1e3,
       cursor,
       signal: deps.signal
@@ -312,9 +344,12 @@ async function stackWait(input, cfg, deps = {}) {
     envelope = err.lastEnvelope;
   }
   const sealed = { ...envelope, watch: envelopeWatch(envelope) };
+  const wake = deps.chatId && !sealed.watch.done ? await registerChatWake(config, deps.chatId, { kind: "stack", stackId: sealed.stackId }, deps.signal) : null;
   return {
-    summary: stackWaitSummary(sealed),
-    data: sealed
+    summary: wake ? `${stackWaitSummary(sealed)}
+
+${CHAT_WAKE_STACK_NOTE}` : stackWaitSummary(sealed),
+    data: wake ? { ...sealed, chat_wake: wake } : sealed
   };
 }
 
@@ -335,6 +370,8 @@ function reviewDismissSummary(result) {
       `${pr} ${head}: dismissed ${result.dismissed.length}, already dismissed ${result.already_dismissed.length}, still open ${result.remaining.length}.`
     );
     for (const finding of result.remaining) lines.push(`- open: ${findingText(finding)}`);
+    const threads = dismissThreadsLine(result);
+    if (threads) lines.push(threads);
   }
   const seam = result.gate.seam;
   if (seam) {
@@ -378,6 +415,144 @@ async function reviewDismiss(input, cfg) {
   return { summary: withWatchText(watch, summary), data: { ...result, watch } };
 }
 
+// src/tools/agent-request.ts
+import { apiFetch as apiFetch3, CommandError as CommandError4, loadConfig as loadConfig4 } from "mergestorm/client";
+async function agentRequest(route, init, cfg) {
+  const resolved = cfg ?? await loadConfig4();
+  const { status, body, retryAfterSeconds } = await apiFetch3(resolved, route, { method: init.method, ...init.json ? { json: init.json } : {} });
+  const data = body && typeof body === "object" && !Array.isArray(body) ? body : { body };
+  if (status === 404 && data.error === void 0) {
+    throw new CommandError4("This Mergestorm server does not offer that action yet.", 1, "not_found");
+  }
+  const message = typeof data.message === "string" ? data.message : `Mergestorm answered ${status}.`;
+  if (status >= 400) {
+    return {
+      summary: message,
+      isError: true,
+      data: {
+        ...data,
+        error: {
+          code: typeof data.error === "string" ? data.error : `http_${status}`,
+          message,
+          ...retryAfterSeconds !== void 0 ? { retry_after_seconds: retryAfterSeconds } : {}
+        }
+      }
+    };
+  }
+  return { summary: message, data };
+}
+
+// src/tools/review-start.ts
+async function reviewStartPr(input, cfg, chatId) {
+  const payload = await agentRequest("/api/v1/agents/vortex/review", {
+    method: "POST",
+    json: {
+      owner: input.owner,
+      repo: input.repo,
+      pr_number: input.pr_number,
+      ...input.head_sha ? { head_sha: input.head_sha } : {},
+      ...chatId ? { chat_id: chatId } : {}
+    }
+  }, cfg);
+  return payload.data.chat_wake ? { ...payload, summary: `${payload.summary} ${REVIEW_START_WAIT_NOTE}` } : payload;
+}
+async function reviewStopPr(input, cfg) {
+  return agentRequest("/api/v1/agents/vortex/stop", {
+    method: "POST",
+    json: { owner: input.owner, repo: input.repo, pr_number: input.pr_number }
+  }, cfg);
+}
+
+// src/tools/cyclone-job.ts
+var CYCLONE_TASKS = ["fix_findings", "fix_ci", "resolve_conflicts", "build"];
+var CYCLONE_JOB_WAIT_DEFAULT_S = 45;
+var CYCLONE_JOB_WAIT_MAX_S = 100;
+var CYCLONE_JOB_POLL_MS = 5e3;
+var CYCLONE_JOB_TERMINAL_STATES = ["pushed", "completed", "failed"];
+var CYCLONE_START_WAIT_NOTE = `Wait for it now: call cyclone_job with this dispatch_id and timeout_s ${CYCLONE_JOB_WAIT_DEFAULT_S}, again while it is queued or running, then tell the user what Cyclone pushed or why it failed.`;
+var CHAT_WAKE_CYCLONE_NOTE = "If your reply ends before Cyclone finishes, this chat is woken with the job's result.";
+var CYCLONE_JOB_STILL_RUNNING_NOTE = `Cyclone is not done. Call cyclone_job again with this dispatch_id and timeout_s ${CYCLONE_JOB_WAIT_DEFAULT_S}, and report the result once it is pushed, completed or failed.`;
+async function cycloneStart(input, cfg, chatId) {
+  const payload = await agentRequest("/api/v1/agents/cyclone/jobs", {
+    method: "POST",
+    json: {
+      task: input.task,
+      owner: input.owner,
+      repo: input.repo,
+      ...input.pr_number !== void 0 ? { pr_number: input.pr_number } : {},
+      ...input.failing_check ? { failing_check: input.failing_check } : {},
+      ...input.brief ? { brief: input.brief } : {},
+      ...chatId ? { chat_id: chatId } : {}
+    }
+  }, cfg);
+  if (payload.isError || typeof payload.data.dispatch_id !== "string" || isCycloneJobTerminal(payload.data)) return payload;
+  return { ...payload, summary: [payload.summary, CYCLONE_START_WAIT_NOTE, ...payload.data.chat_wake ? [CHAT_WAKE_CYCLONE_NOTE] : []].join(" ") };
+}
+function isCycloneJobTerminal(job) {
+  return CYCLONE_JOB_TERMINAL_STATES.includes(job.state);
+}
+function cycloneJobSummary(job) {
+  const target2 = job.pr_number ? `${job.owner}/${job.repo}#${job.pr_number}` : `${job.owner}/${job.repo}`;
+  const parts = [`Cyclone ${job.task ?? "job"} on ${target2}: ${job.state}`];
+  if (typeof job.outcome === "string" && job.outcome) parts[0] += ` (${job.outcome})`;
+  if (typeof job.result_sha === "string" && job.result_sha) parts.push(`pushed ${job.result_sha.slice(0, 10)}`);
+  if (typeof job.detail === "string" && job.detail) parts.push(job.detail);
+  return parts.join(". ");
+}
+function sleepFor(ms, signal) {
+  return new Promise((resolve2) => {
+    if (signal?.aborted) return resolve2();
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve2();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+async function cycloneJob(dispatchId, cfg, timeoutS = 0, deps = {}) {
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? sleepFor;
+  const deadline = now() + Math.min(Math.max(timeoutS, 0), CYCLONE_JOB_WAIT_MAX_S) * 1e3;
+  const route = `/api/v1/agents/cyclone/jobs/${encodeURIComponent(dispatchId)}`;
+  for (; ; ) {
+    const payload = await agentRequest(route, { method: "GET" }, cfg);
+    if (payload.isError) return payload;
+    if (isCycloneJobTerminal(payload.data)) return { ...payload, summary: cycloneJobSummary(payload.data) };
+    const left = deadline - now();
+    if (left <= 0 || deps.signal?.aborted) return { ...payload, summary: `${cycloneJobSummary(payload.data)}. ${CYCLONE_JOB_STILL_RUNNING_NOTE}` };
+    await sleep(Math.min(deps.pollMs ?? CYCLONE_JOB_POLL_MS, left), deps.signal);
+  }
+}
+
+// src/tools/stack-actions.ts
+import { enqueueStack, loadConfig as loadConfig5, restackStack, stackWatchObligation as stackWatchObligation3 } from "mergestorm/client";
+async function stackRestack(stackId, cfg) {
+  const result = await restackStack(stackId, cfg);
+  const watch = stackWatchObligation3({ stackId, terminal: null, unread: true, freshCursor: true });
+  return {
+    summary: withWatchText(watch, `Restacked stack ${stackId}: its layer branches were rebased onto their parents and pushed`),
+    data: { stack_id: stackId, result, watch }
+  };
+}
+async function stackEnqueue(stackId, cfg, chatId) {
+  const resolved = cfg ?? await loadConfig5();
+  const result = await enqueueStack(stackId, resolved);
+  const watch = stackWatchObligation3({ stackId, terminal: null, unread: true, freshCursor: true });
+  const wake = chatId ? await registerChatWake(resolved, chatId, { kind: "stack", stackId }) : null;
+  const summary = withWatchText(watch, `Sent stack ${stackId} to the Mergestorm merge queue`);
+  return {
+    summary: wake ? `${summary} ${CHAT_WAKE_STACK_NOTE}` : summary,
+    data: { stack_id: stackId, result, watch, ...wake ? { chat_wake: wake } : {} }
+  };
+}
+
+// src/tools/surge-setup.ts
+async function surgeSetup(input, cfg) {
+  return agentRequest("/api/v1/agents/surge/setup", { method: "POST", json: { owner: input.owner, repo: input.repo } }, cfg);
+}
+
 // src/tools/review-list.ts
 import { listJobs, toReviewJobEnvelope } from "mergestorm/client";
 async function reviewList(limit = 10, cfg) {
@@ -395,13 +570,13 @@ import { createHash } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { relative, resolve, sep } from "node:path";
 import {
-  CommandError as CommandError4,
+  CommandError as CommandError5,
   REVIEW_THREAD_SLUG_RE,
   ReviewPollTimeoutError,
   collectReviewInput,
   discoverTrunk,
   formatReviewSubmitError,
-  loadConfig as loadConfig4,
+  loadConfig as loadConfig6,
   loadReviewContext,
   pollReview,
   rateLimitedMessage as rateLimitedMessage2,
@@ -450,7 +625,7 @@ function assertPinnableSpecialists(specialists) {
     (id) => !PINNABLE_SPECIALISTS.includes(id)
   );
   if (unknown.length === 0) return;
-  throw new CommandError4(
+  throw new CommandError5(
     `Unknown specialist: ${unknown.join(", ")}. Valid lanes: ${PINNABLE_SPECIALISTS.join(", ")}. governance and seam cannot be requested.`,
     2,
     "usage"
@@ -462,7 +637,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 CommandError4("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));
 }
@@ -495,25 +670,25 @@ async function resolveInput(input) {
     ]);
     const relToSandbox = relative(sandboxReal, cwdReal);
     if (relToSandbox === ".." || relToSandbox.startsWith(`..${sep}`)) {
-      throw new CommandError4("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 CommandError4) throw err;
-    throw new CommandError4("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");
   }
   const base = input.base?.trim() || discoverTrunk(cwd);
   return collectReviewInput(base, head, cwd, sandboxRoot);
 }
 async function reviewSubmit(input, cfg, opts = {}) {
-  const resolved = cfg ?? await loadConfig4();
+  const resolved = cfg ?? await loadConfig6();
   const wait = input.wait === true;
   const timeoutMs = waitTimeoutMs(input.timeout_s);
   assertPinnableSpecialists(input.specialists);
   if (input.thread && !REVIEW_THREAD_SLUG_RE.test(input.thread)) {
-    throw new CommandError4("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 CommandError4(
+    throw new CommandError5(
       'context "-" (stdin) is not available over MCP; pass the text directly',
       2,
       "usage"
@@ -563,7 +738,7 @@ async function reviewSubmit(input, cfg, opts = {}) {
     };
   }
   if (!jobId) {
-    throw new CommandError4("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" });
@@ -592,14 +767,14 @@ async function reviewSubmit(input, cfg, opts = {}) {
 // src/tools/review-wait-pr.ts
 import {
   PrReviewPollTimeoutError,
-  loadConfig as loadConfig5,
+  loadConfig as loadConfig7,
   noPrReviewYetMessage,
   pollPrVortexReview
 } from "mergestorm/client";
 
 // src/tools/review-get-pr.ts
 import {
-  CommandError as CommandError5,
+  CommandError as CommandError6,
   getPrVortexReview,
   isCommandErrorCode as isCommandErrorCode3
 } from "mergestorm/client";
@@ -607,7 +782,7 @@ function prReviewTarget(owner, repo, prNumber) {
   const cleanOwner = owner.trim();
   const cleanRepo = repo.trim();
   if (!cleanOwner || !cleanRepo || !Number.isInteger(prNumber) || prNumber <= 0) {
-    throw new CommandError5(
+    throw new CommandError6(
       "owner, repo, and a positive pr_number are required",
       2,
       "usage"
@@ -675,7 +850,7 @@ 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 target2 = prReviewTarget(owner, repo, prNumber);
-  const resolved = cfg ?? await loadConfig5();
+  const resolved = cfg ?? await loadConfig7();
   if (timeout_s === 0) {
     return reviewGetPr(target2.owner, target2.repo, target2.prNumber, resolved, {
       afterSha,
@@ -718,15 +893,26 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
         finding_count: findingCount,
         phase: err.lastEnvelope?.phase ?? null
       });
+      const wakeHead = expectedSha || observedSha || null;
+      const wake = opts.chatId ? await registerChatWake(resolved, opts.chatId, {
+        kind: "vortex",
+        owner: target2.owner,
+        repo: target2.repo,
+        prNumber: target2.prNumber,
+        headSha: wakeHead,
+        minPass: opts.pass ?? (opts.afterPass !== void 0 ? opts.afterPass + 1 : (headShaMatches || !expectedSha) && observedSha ? err.lastEnvelope?.pass ?? null : null)
+      }) : null;
+      const shown = err.reviewSeen ? summary : `${summary} \xB7 ${noPrReviewYetMessage(target2.owner, target2.repo, target2.prNumber, { afterSha, pass: opts.pass, afterPass: opts.afterPass })}`;
       return {
-        summary: err.reviewSeen ? summary : `${summary} \xB7 ${noPrReviewYetMessage(target2.owner, target2.repo, target2.prNumber, { afterSha, pass: opts.pass, afterPass: opts.afterPass })}`,
+        summary: wake ? `${shown} \xB7 ${CHAT_WAKE_REVIEW_NOTE}` : shown,
         data: {
           status,
           head_sha: err.lastEnvelope?.head_sha ?? null,
           pass: headShaMatches ? err.lastEnvelope?.pass ?? null : null,
           finding_count: findingCount,
           phase: err.lastEnvelope?.phase ?? null,
-          error: err.message
+          error: err.message,
+          ...wake ? { chat_wake: wake } : {}
         }
       };
     }
@@ -743,15 +929,15 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
 
 // src/tools/review-wait.ts
 import {
-  CommandError as CommandError7,
+  CommandError as CommandError8,
   ReviewPollTimeoutError as ReviewPollTimeoutError2,
-  loadConfig as loadConfig6,
+  loadConfig as loadConfig8,
   pollReview as pollReview2
 } from "mergestorm/client";
 
 // src/tools/review-get.ts
 import {
-  CommandError as CommandError6,
+  CommandError as CommandError7,
   getReview,
   toReviewJobEnvelope as toReviewJobEnvelope3
 } from "mergestorm/client";
@@ -765,7 +951,7 @@ async function reviewGet(jobId, cfg) {
     throw err;
   }
   if (!row || typeof row !== "object" || typeof row.status !== "string") {
-    throw new CommandError6(`Unexpected response for review ${jobId}.`);
+    throw new CommandError7(`Unexpected response for review ${jobId}.`);
   }
   const envelope = toReviewJobEnvelope3(row, { jobId });
   const bits = [envelope.status];
@@ -778,10 +964,10 @@ async function reviewGet(jobId, cfg) {
 
 // src/tools/review-wait.ts
 async function reviewWait(jobId, timeout_s, cfg, opts = {}) {
-  const resolved = cfg ?? await loadConfig6();
+  const resolved = cfg ?? await loadConfig8();
   const id = jobId.trim();
   if (!id) {
-    throw new CommandError7("job_id is required", 2, "usage");
+    throw new CommandError8("job_id is required", 2, "usage");
   }
   if (timeout_s === 0) return reviewGet(id, resolved);
   try {
@@ -806,7 +992,7 @@ async function reviewWait(jobId, timeout_s, cfg, opts = {}) {
 
 // src/tools/settings-get.ts
 import {
-  CommandError as CommandError8,
+  CommandError as CommandError9,
   getSettings
 } from "mergestorm/client";
 function settingsSummary(settings) {
@@ -824,7 +1010,7 @@ function settingsSummary(settings) {
 async function settingsGet(cfg) {
   const settings = await getSettings(cfg);
   if (!settings) {
-    throw new CommandError8(
+    throw new CommandError9(
       "Settings are not available (offline or API too old). Try again or open https://mergestorm.ai/settings"
     );
   }
@@ -836,7 +1022,7 @@ async function settingsGet(cfg) {
 
 // src/tools/settings-set.ts
 import {
-  CommandError as CommandError9,
+  CommandError as CommandError10,
   BEARER_SETTINGS,
   SETTINGS_WRITABLE_KEYS,
   patchSettings
@@ -848,7 +1034,7 @@ var SETTINGS_READ_ONLY_KEYS = [
 function settingsPatchFromArgs(args) {
   for (const key of SETTINGS_READ_ONLY_KEYS) {
     if (args[key] !== void 0) {
-      throw new CommandError9(`${key} is read-only and cannot be set.`, 2, "usage");
+      throw new CommandError10(`${key} is read-only and cannot be set.`, 2, "usage");
     }
   }
   const patch = {};
@@ -859,7 +1045,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 CommandError9(
+        throw new CommandError10(
           `${key} takes a whole number${unit} from ${row.min} through ${row.max}.`,
           2,
           "usage"
@@ -870,17 +1056,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 CommandError9(`Invalid value for ${key}.`, 2, "usage");
+      if (!valid) throw new CommandError10(`Invalid value for ${key}.`, 2, "usage");
       Object.assign(patch, { [key]: value });
       continue;
     }
     if (typeof value !== "boolean") {
-      throw new CommandError9(`${key} takes a boolean.`, 2, "usage");
+      throw new CommandError10(`${key} takes a boolean.`, 2, "usage");
     }
     Object.assign(patch, { [key]: value });
   }
   if (Object.keys(patch).length === 0) {
-    throw new CommandError9(
+    throw new CommandError10(
       `At least one settings key is required: ${SETTINGS_WRITABLE_KEYS.join(", ")}.`,
       2,
       "usage"
@@ -899,7 +1085,7 @@ async function settingsSet(args, cfg) {
 
 // src/tools/repo-settings.ts
 import {
-  CommandError as CommandError10,
+  CommandError as CommandError11,
   REPO_SETTINGS_KEYS,
   listRepoSettings,
   patchRepoSettings
@@ -911,7 +1097,7 @@ var ARG_BY_KEY = {
 };
 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");
+  if (!match) throw new CommandError11("repo takes <owner>/<repo>.", 2, "usage");
   return { owner: match[1], repo: match[2] };
 }
 function words(value) {
@@ -926,12 +1112,12 @@ function repoSettingsPatchFromArgs(args) {
     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");
+      throw new CommandError11(`${ARG_BY_KEY[key]} takes true, false, or null.`, 2, "usage");
     }
     patch[key] = value;
   }
   if (Object.keys(patch).length === 0) {
-    throw new CommandError10(
+    throw new CommandError11(
       `At least one of ${Object.values(ARG_BY_KEY).join(", ")} is required.`,
       2,
       "usage"
@@ -950,7 +1136,7 @@ async function repoSettingsGet(args, cfg) {
   }
   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.`);
+  if (!entry) throw new CommandError11(`${wanted.owner}/${wanted.repo} is not connected to this account.`);
   return { summary: repoSettingsSummary(entry), data: { ...entry } };
 }
 async function repoSettingsSet(args, cfg) {
@@ -960,11 +1146,11 @@ async function repoSettingsSet(args, cfg) {
 }
 
 // src/tools/stack-adopt.ts
-import { adoptStack, CommandError as CommandError11, stackWatchObligation as stackWatchObligation4 } from "mergestorm/client";
+import { adoptStack, CommandError as CommandError12, stackWatchObligation as stackWatchObligation5 } from "mergestorm/client";
 import { z as z3 } from "zod";
 
 // src/tools/stack-set.ts
-import { setStackPolicy, stackWatchObligation as stackWatchObligation3 } from "mergestorm/client";
+import { setStackPolicy, stackWatchObligation as stackWatchObligation4 } from "mergestorm/client";
 function triWord(value) {
   return value === null ? "default" : value ? "on" : "off";
 }
@@ -1011,7 +1197,7 @@ async function stackSet(stackId, input, cfg) {
   if (input.auto_fix_ci !== void 0) {
     parts.push(`auto-fix-ci ${triWord(input.auto_fix_ci)}`);
   }
-  const watch = stackWatchObligation3({ stackId, terminal: null, unread: true, freshCursor: true });
+  const watch = stackWatchObligation4({ stackId, terminal: null, unread: true, freshCursor: true });
   return {
     summary: withWatchText(watch, `${parts.join(", ")} for stack ${stackId}`),
     data: {
@@ -1059,7 +1245,7 @@ async function stackAdopt(input, cfg) {
     if (typeof stackId !== "string" || !stackId) {
       return { summary, data: { owner, repo, pr_number, result } };
     }
-    const watch = stackWatchObligation4({ stackId, terminal: null, unread: true, freshCursor: true });
+    const watch = stackWatchObligation5({ stackId, terminal: null, unread: true, freshCursor: true });
     return {
       summary: withWatchText(watch, summary),
       data: { owner, repo, pr_number, result, watch }
@@ -1070,11 +1256,11 @@ async function stackAdopt(input, cfg) {
       summary: message,
       data: {
         error: {
-          code: err instanceof CommandError11 ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",
+          code: err instanceof CommandError12 ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",
           message,
-          ...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 } : {}
+          ...err instanceof CommandError12 ? { exit_code: err.exitCode } : {},
+          ...err instanceof CommandError12 && err.reason !== void 0 ? { reason: err.reason } : {},
+          ...err instanceof CommandError12 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
         }
       },
       isError: true
@@ -1145,9 +1331,9 @@ async function stackList(cfg) {
 
 // src/tools/stack-publish.ts
 import {
-  CommandError as CommandError12,
+  CommandError as CommandError13,
   publishWorkingBranch,
-  stackWatchObligation as stackWatchObligation5,
+  stackWatchObligation as stackWatchObligation6,
   workingBranchPublication
 } from "mergestorm/client";
 import { z as z4 } from "zod";
@@ -1160,6 +1346,7 @@ var target = {
 var stackPublishSchema = {
   ...target,
   base: z4.string().trim().min(1).optional(),
+  extend: z4.boolean().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(),
@@ -1174,9 +1361,9 @@ function failure(err, fallback) {
     summary: message,
     data: {
       error: {
-        code: err instanceof CommandError12 ? err.code ?? fallback : fallback,
+        code: err instanceof CommandError13 ? err.code ?? fallback : fallback,
         message,
-        ...err instanceof CommandError12 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
+        ...err instanceof CommandError13 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
       }
     },
     isError: true
@@ -1202,6 +1389,7 @@ async function stackPublish(input, cfg, deps) {
       {
         ...targetOf(parsed.data, cfg),
         ...parsed.data.base ? { base: parsed.data.base } : {},
+        ...parsed.data.extend ? { extend: true } : {},
         ...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 } : {},
@@ -1209,12 +1397,12 @@ async function stackPublish(input, cfg, deps) {
       },
       deps
     );
-    const watch = stackWatchObligation5({ stackId: result.stack.id, terminal: null, unread: true, freshCursor: true });
+    const watch = stackWatchObligation6({ 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}`
+        `Published ${result.owner}/${result.repo} ${result.branch} (${moved}) at ${result.head.sha}, PR #${result.pr.number} (${result.stacked ? `a layer stacked on ${result.baseBranch}` : `a single PR onto ${result.baseBranch}`}), stack ${result.stack.id}`
       ),
       data: { result, watch }
     };
@@ -1246,14 +1434,14 @@ import {
   isCommandErrorCode as isCommandErrorCode5,
   stackBlockers as stackBlockers2,
   stackTerminalReason,
-  stackWatchObligation as stackWatchObligation6
+  stackWatchObligation as stackWatchObligation7
 } 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 = stackWatchObligation6({ stackId, terminal: "not_found" });
+      const watch2 = stackWatchObligation7({ stackId, terminal: "not_found" });
       return {
         summary: withWatchText(watch2, message),
         data: {
@@ -1269,7 +1457,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 = stackWatchObligation6({
+    const watch = stackWatchObligation7({
       stackId: stack.id,
       terminal: stackTerminalReason(stack),
       cursor: { enrolledHeadSha: currentCandidate?.headSha ?? null },
@@ -1282,7 +1470,7 @@ async function stackStatus(stackId, cfg) {
     };
   } catch (err) {
     if (isCommandErrorCode5(err, "rate_limited")) {
-      const watch = stackWatchObligation6({
+      const watch = stackWatchObligation7({
         stackId,
         terminal: null,
         status: "rate_limited",
@@ -1308,18 +1496,18 @@ async function stackStatus(stackId, cfg) {
 
 // src/tools/whoami.ts
 import {
-  CommandError as CommandError13,
+  CommandError as CommandError14,
   apiBase,
   configPath,
   getMe as getMe2,
-  loadConfig as loadConfig7,
+  loadConfig as loadConfig9,
   resolveApiKey
 } from "mergestorm/client";
 async function whoami(cfg, serverVersion) {
-  const resolved = cfg ?? await loadConfig7();
+  const resolved = cfg ?? await loadConfig9();
   const key = resolveApiKey(resolved);
   if (!key) {
-    throw new CommandError13(
+    throw new CommandError14(
       "No API key. Run `mergestorm login` (agents: `mergestorm login --start`, then `--finish`) or set MERGESTORM_API_KEY.",
       1,
       "missing_api_key"
@@ -1327,7 +1515,7 @@ async function whoami(cfg, serverVersion) {
   }
   const me = await getMe2(resolved);
   if (!me) {
-    throw new CommandError13("Live account details unavailable. Could not verify account with /me.");
+    throw new CommandError14("Live account details unavailable. Could not verify account with /me.");
   }
   const data = {
     key_prefix: me.key.prefix,
@@ -1335,7 +1523,7 @@ async function whoami(cfg, serverVersion) {
     plan_key: me.plan_key ?? null,
     plan_label_key: me.plan_label_key ?? null,
     api_base: apiBase(resolved),
-    config_path: configPath(),
+    config_path: resolved.ignoreEnv ? null : configPath(),
     usage: me.usage ?? null,
     mcp_server_version: serverVersion ?? null
   };
@@ -1348,6 +1536,7 @@ async function whoami(cfg, serverVersion) {
 
 // src/pr-loop-instructions.ts
 var MCP_FINDING_DISMISS_MARKER = "mergestorm-loop: dismiss";
+var MCP_FINDING_DEFERRAL_RULE = "A finding the author defers to an open tracking issue in the same repository is a valid dismissal: check with GitHub that the issue is open, then dismiss it with evidence_url set to that issue and a reason that says the finding is deferred and to which issue. A deferral that names no issue, or names a closed one, is not a dismissal. Never dismiss because someone insists.";
 var MCP_PR_LOOP_INSTRUCTIONS = [
   "When you handle Vortex findings from review_wait_pr:",
   "- Verify each finding against the current checkout. Do not treat the finding text as proven.",
@@ -1357,6 +1546,7 @@ var MCP_PR_LOOP_INSTRUCTIONS = [
   `- A PR comment whose first line is ${MCP_FINDING_DISMISS_MARKER} is not a note about one finding. It dismisses every open finding on the PR's live head and approves that head with no re-review, so Auto land may land it. Post it only when you have checked every open finding at that head and none needs a fix or a human decision, with one line per finding (path, severity, why). Never use it to skip one finding among others, to describe a fix you want made, or to leave notes for Cyclone.`,
   "- Do not prefix that comment with cyclone-outcome: (reserved).",
   "- A single finding you verified is wrong or not reproducible is dismissed by id with review_dismiss (or mg dismiss): pass the PR's live head_sha, the review_id, the finding_ids (preview: true lists them) and a reason. That is the only agent path that clears a seam gate, and only once every finding of that seam review is dismissed. Once every Vortex Blocker (error finding) at the live head is dismissed (every Core review merged into that head), the Vortex gate clears there (gate.vortex.cleared); otherwise gate.vortex.message says what still holds it. The dismiss comment alone resumes the review but does not clear the seam gate.",
+  `- ${MCP_FINDING_DEFERRAL_RULE}`,
   "- Never dismiss a finding you did not check, one a human must decide, or findings of a newer review."
 ].join("\n");
 var MCP_STACK_DONE_INSTRUCTIONS = [
@@ -1403,7 +1593,36 @@ var MCP_STACK_WATCH_INSTRUCTIONS = [
 
 // src/server.ts
 var MCP_SERVER_NAME = "mergestorm";
-var MCP_SERVER_VERSION = "0.2.26";
+var MCP_SERVER_VERSION = "0.2.27";
+var MCP_TOOL_NAMES = [
+  "whoami",
+  "credits",
+  "review_list",
+  "review_submit",
+  "review_wait",
+  "review_wait_pr",
+  "review_dismiss",
+  "review_start_pr",
+  "review_stop_pr",
+  "cyclone_start",
+  "cyclone_job",
+  "issue_create",
+  "stack_adopt",
+  "stack_enqueue",
+  "stack_list",
+  "stack_publish",
+  "stack_publish_status",
+  "stack_restack",
+  "stack_set",
+  "stack_status",
+  "stack_wait",
+  "queue_status",
+  "settings_get",
+  "settings_set",
+  "repo_settings_get",
+  "repo_settings_set",
+  "surge_setup"
+];
 var MCP_SERVER_INSTRUCTIONS = [
   MCP_STACK_DONE_INSTRUCTIONS,
   MCP_PR_LOOP_INSTRUCTIONS,
@@ -1423,14 +1642,14 @@ function ok(payload) {
   };
 }
 function fail(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);
+  const message = err instanceof CommandError15 ? 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 CommandError14 ? {
+        ...err instanceof CommandError15 ? {
           exit_code: err.exitCode,
           ...err.code !== void 0 ? { code: err.code } : {},
           ...err.reason !== void 0 ? { reason: err.reason } : {},
@@ -1440,7 +1659,14 @@ function fail(err) {
     }
   });
 }
-function createMergestormMcpServer() {
+var MCP_WORKSPACE_TOOL_NAMES = ["review_submit", "stack_publish", "stack_publish_status"];
+var MCP_HOSTED_TOOL_NAMES = MCP_TOOL_NAMES.filter(
+  (name) => !MCP_WORKSPACE_TOOL_NAMES.includes(name)
+);
+var HOSTED_ISSUE_CREATE_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. owner and repo name the repository. 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.";
+function createMergestormMcpServer(options = {}) {
+  const { config, hosted = false } = options;
+  const chatId = breezeChatId(options.chatId ?? (hosted ? null : process.env.MERGESTORM_CHAT_ID));
   const server2 = new McpServer(
     {
       name: MCP_SERVER_NAME,
@@ -1451,7 +1677,11 @@ function createMergestormMcpServer() {
     },
     { instructions: MCP_SERVER_INSTRUCTIONS }
   );
-  const addTool = server2.registerTool.bind(server2);
+  const registerTool = server2.registerTool.bind(server2);
+  const addTool = (name, toolConfig, cb) => {
+    if (hosted && MCP_WORKSPACE_TOOL_NAMES.includes(name)) return;
+    registerTool(name, toolConfig, cb);
+  };
   addTool(
     "whoami",
     {
@@ -1461,7 +1691,7 @@ function createMergestormMcpServer() {
     },
     async () => {
       try {
-        return ok(await whoami(void 0, MCP_SERVER_VERSION));
+        return ok(await whoami(config, MCP_SERVER_VERSION));
       } catch (err) {
         return fail(err);
       }
@@ -1476,7 +1706,7 @@ function createMergestormMcpServer() {
     },
     async () => {
       try {
-        return ok(await credits());
+        return ok(await credits(config));
       } catch (err) {
         return fail(err);
       }
@@ -1494,7 +1724,7 @@ function createMergestormMcpServer() {
     },
     async ({ limit }) => {
       try {
-        return ok(await reviewList(limit));
+        return ok(await reviewList(limit, config));
       } catch (err) {
         return fail(err);
       }
@@ -1523,7 +1753,7 @@ function createMergestormMcpServer() {
     },
     async (args) => {
       try {
-        return ok(await reviewSubmit(args));
+        return ok(await reviewSubmit(args, config));
       } catch (err) {
         return fail(err);
       }
@@ -1542,7 +1772,7 @@ function createMergestormMcpServer() {
     },
     async ({ job_id, timeout_s }) => {
       try {
-        return ok(await reviewWait(job_id, timeout_s));
+        return ok(await reviewWait(job_id, timeout_s, config));
       } catch (err) {
         return fail(err);
       }
@@ -1573,8 +1803,8 @@ function createMergestormMcpServer() {
             pr_number,
             after_sha,
             timeout_s,
-            void 0,
-            { pass, afterPass: after_pass }
+            config,
+            { pass, afterPass: after_pass, ...chatId ? { chatId } : {} }
           )
         );
       } catch (err) {
@@ -1586,7 +1816,7 @@ function createMergestormMcpServer() {
     "review_dismiss",
     {
       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,
+      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. ` + MCP_FINDING_DEFERRAL_RULE + STACK_WATCH_RESULT_NOTE,
       inputSchema: {
         owner: z5.string().min(1),
         repo: z5.string().min(1),
@@ -1603,7 +1833,83 @@ function createMergestormMcpServer() {
     },
     async (args) => {
       try {
-        return ok(await reviewDismiss(args));
+        return ok(await reviewDismiss(args, config));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  const prInput = {
+    owner: z5.string().min(1),
+    repo: z5.string().min(1),
+    pr_number: z5.number().int().min(1)
+  };
+  addTool(
+    "review_start_pr",
+    {
+      title: "Start Vortex review",
+      description: "Start a Vortex review of an open GitHub pull request on the user's account, at its current head. head_sha, when given, must still be the head; otherwise nothing starts and the answer names the live head. Uses one standard credit. Findings post on the pull request; read them with review_wait_pr. A review already running at that head is reported, not started twice. When this server serves a Breeze chat, the chat is woken with the result.",
+      inputSchema: { ...prInput, head_sha: z5.string().regex(/^[0-9a-fA-F]{7,40}$/).optional() },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await reviewStartPr(args, config, chatId));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "review_stop_pr",
+    {
+      title: "Stop Vortex review",
+      description: "Cancel the Vortex review running on a pull request. Starts nothing; says so when no review is running.",
+      inputSchema: prInput,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await reviewStopPr(args, config));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "cyclone_start",
+    {
+      title: "Start Cyclone job",
+      description: "Have Cyclone work on the user's repository and push the result. task fix_findings fixes the open Vortex findings on pr_number, fix_ci fixes its failing CI check (failing_check names one; default the first failing check), resolve_conflicts merges its base in and resolves the conflicts; each pushes a commit to the pull request's branch. task build builds a first working version of a new project from brief into an empty repository the user created and installed Cyclone on, then opens a pull request. Uses Cyclone credits. When the pull request has nothing to do (CI green, no conflicts, no open findings) nothing starts and the answer says why: tell the user that. Returns dispatch_id. Then wait for the job with cyclone_job until it is pushed, completed or failed, and report what it pushed. When this server serves a Breeze chat and the reply ends before the job does, the chat is woken with the result.",
+      inputSchema: {
+        task: z5.enum(CYCLONE_TASKS),
+        owner: z5.string().min(1),
+        repo: z5.string().min(1),
+        pr_number: z5.number().int().min(1).optional(),
+        failing_check: z5.string().min(1).max(200).optional(),
+        brief: z5.string().min(1).max(4e3).optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await cycloneStart(args, config, chatId));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "cyclone_job",
+    {
+      title: "Wait for Cyclone job",
+      description: `Wait for a Cyclone job started with cyclone_start, by its dispatch_id, and read it: queued, running, pushed, completed or failed, with the outcome, detail, pushed commit and changed files. timeout_s (default ${CYCLONE_JOB_WAIT_DEFAULT_S}, max ${CYCLONE_JOB_WAIT_MAX_S}) waits until the job is pushed, completed or failed, or the time is up; 0 reads it once. While it is queued or running, call again with the same dispatch_id.`,
+      inputSchema: { dispatch_id: z5.string().uuid(), timeout_s: z5.number().int().min(0).max(CYCLONE_JOB_WAIT_MAX_S).optional() },
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    async ({ dispatch_id, timeout_s }, extra) => {
+      try {
+        return ok(await cycloneJob(dispatch_id, config, timeout_s ?? CYCLONE_JOB_WAIT_DEFAULT_S, { signal: extra.signal }));
       } catch (err) {
         return fail(err);
       }
@@ -1613,13 +1919,13 @@ function createMergestormMcpServer() {
     "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,
+      description: hosted ? HOSTED_ISSUE_CREATE_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: hosted ? hostedIssueCreateSchema : issueCreateSchema,
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
     },
     async (args) => {
       try {
-        return ok(await issueCreate(args));
+        return ok(await issueCreate(args, config, hosted ? { parseGithubOriginRepo: () => null } : {}));
       } catch (err) {
         return fail(err);
       }
@@ -1635,7 +1941,7 @@ function createMergestormMcpServer() {
     },
     async (args) => {
       try {
-        return ok(await stackAdopt(args));
+        return ok(await stackAdopt(args, config));
       } catch (err) {
         return fail(err);
       }
@@ -1650,7 +1956,7 @@ function createMergestormMcpServer() {
     },
     async () => {
       try {
-        return ok(await stackList());
+        return ok(await stackList(config));
       } catch (err) {
         return fail(err);
       }
@@ -1660,13 +1966,13 @@ function createMergestormMcpServer() {
     "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 land on for a new stack, and Auto patch and Auto review left to the stack, repository and account settings, so Cyclone patches Vortex findings when Auto patch is on. 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,
+      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 land on for a new stack, and Auto patch and Auto review left to the stack, repository and account settings, so Cyclone patches Vortex findings when Auto patch is on. 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. Two ways to publish: with no base (or trunk as base) the branch opens as a single PR onto trunk; to stack it on another branch, pass that branch as base and extend: true. A base other than trunk without extend is refused with implicit_stack. The result says which one it made. 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));
+        return ok(await stackPublish(args, config));
       } catch (err) {
         return fail(err);
       }
@@ -1682,7 +1988,7 @@ function createMergestormMcpServer() {
     },
     async (args) => {
       try {
-        return ok(await stackPublishStatus(args));
+        return ok(await stackPublishStatus(args, config));
       } catch (err) {
         return fail(err);
       }
@@ -1712,13 +2018,45 @@ function createMergestormMcpServer() {
             ...auto_patch !== void 0 ? { auto_patch } : {},
             ...auto_resolve_conflicts !== void 0 ? { auto_resolve_conflicts } : {},
             ...auto_fix_ci !== void 0 ? { auto_fix_ci } : {}
-          })
+          }, config)
         );
       } catch (err) {
         return fail(err);
       }
     }
   );
+  addTool(
+    "stack_restack",
+    {
+      title: "Restack stack",
+      description: "Rebase one owned stack's layer branches onto their parents and push them, after the trunk or a lower layer moved. Does not merge or enqueue anything." + STACK_WATCH_RESULT_NOTE,
+      inputSchema: { stack_id: z5.string().min(1) },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    async ({ stack_id }) => {
+      try {
+        return ok(await stackRestack(stack_id, config));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "stack_enqueue",
+    {
+      title: "Send stack to merge queue",
+      description: "Send one owned stack to the Mergestorm merge queue, which tests it and lands it when its checks pass. To restart a failed or stuck land, call stack_restack first and then this. When this server serves a Breeze chat, the chat is woken when the stack lands, is bounced or is archived." + STACK_WATCH_RESULT_NOTE,
+      inputSchema: { stack_id: z5.string().min(1) },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async ({ stack_id }) => {
+      try {
+        return ok(await stackEnqueue(stack_id, config, chatId));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
   addTool(
     "stack_status",
     {
@@ -1731,7 +2069,7 @@ function createMergestormMcpServer() {
     },
     async ({ stack_id }) => {
       try {
-        return ok(await stackStatus(stack_id));
+        return ok(await stackStatus(stack_id, config));
       } catch (err) {
         return fail(err);
       }
@@ -1747,7 +2085,7 @@ function createMergestormMcpServer() {
     },
     async (args, extra) => {
       try {
-        const payload = await stackWait(args, void 0, { signal: extra.signal });
+        const payload = await stackWait(args, config, { signal: extra.signal, ...chatId ? { chatId } : {} });
         return ok(payload);
       } catch (err) {
         return fail(err);
@@ -1766,7 +2104,7 @@ function createMergestormMcpServer() {
     },
     async ({ stack_id }) => {
       try {
-        return ok(await queueStatus(stack_id));
+        return ok(await queueStatus(stack_id, config));
       } catch (err) {
         return fail(err);
       }
@@ -1782,7 +2120,7 @@ function createMergestormMcpServer() {
     },
     async (args) => {
       try {
-        return ok(await repoSettingsGet(args ?? {}));
+        return ok(await repoSettingsGet(args ?? {}, config));
       } catch (err) {
         return fail(err);
       }
@@ -1803,7 +2141,23 @@ function createMergestormMcpServer() {
     },
     async (args) => {
       try {
-        return ok(await repoSettingsSet(args ?? {}));
+        return ok(await repoSettingsSet(args ?? {}, config));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "surge_setup",
+    {
+      title: "Set up Surge CI",
+      description: "Set up Surge CI on one repository of the user's account: if Surge does not serve it yet, serve it (it joins the repositories Surge serves and gets the account's Surge settings), then open a pull request that points its workflow jobs at Surge runners and adds the merge queue batch trigger. Nothing in the repository's files changes until that pull request is merged. The answer says what happened, with the pull request link.",
+      inputSchema: { owner: z5.string().min(1), repo: z5.string().min(1) },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await surgeSetup(args, config));
       } catch (err) {
         return fail(err);
       }
@@ -1818,7 +2172,7 @@ function createMergestormMcpServer() {
     },
     async () => {
       try {
-        return ok(await settingsGet());
+        return ok(await settingsGet(config));
       } catch (err) {
         return fail(err);
       }
@@ -1844,7 +2198,7 @@ function createMergestormMcpServer() {
     },
     async (args) => {
       try {
-        return ok(await settingsSet(args ?? {}));
+        return ok(await settingsSet(args ?? {}, config));
       } catch (err) {
         return fail(err);
       }