mergestorm-mcp 0.2.26 → 0.2.28

package/dist/index.js

@@ -3,10 +3,36 @@
 // src/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/tools/chat-task.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;
+}
+function chatTaskOf(value) {
+  if (!value || typeof value !== "object") return null;
+  const { id, title } = value;
+  return typeof id === "string" && typeof title === "string" ? { id, title } : null;
+}
+function chatTaskNote(task) {
+  return `This chat tracks it as background task ${task.id} "${task.title}" and is told the result when it ends. If the user is waiting for the outcome, wait for it before you end the reply, then tell them what actually happened.`;
+}
+async function trackInChat(cfg, chatId, target2, signal) {
+  const json = target2.kind === "review" ? { chat_id: chatId, kind: "review", owner: target2.owner, repo: target2.repo, pr_number: target2.prNumber } : { 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;
+    return response.status === 200 ? chatTaskOf(body?.task) : null;
+  } 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 { z as z6 } from "zod";
+import { CommandError as CommandError16, BEARER_SETTINGS as BEARER_SETTINGS2 } from "mergestorm/client";
 
 // src/brand-icons.ts
 var MARK_RECTS = [
@@ -86,6 +112,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);
@@ -93,9 +126,9 @@ async function issueCreate(input, cfg, deps = {}) {
     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;
+  const { title, body, labels, owner, repo: repo2, cwd } = parsed.data;
   try {
-    const target2 = owner && repo ? { owner, repo } : (deps.parseGithubOriginRepo ?? parseGithubOriginRepo)(cwd);
+    const target2 = owner && repo2 ? { owner, repo: repo2 } : (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 };
@@ -124,10 +157,96 @@ async function issueCreate(input, cfg, deps = {}) {
   }
 }
 
-// src/tools/queue-status.ts
+// src/tools/memory.ts
 import {
-  apiFetch,
   CommandError as CommandError3,
+  MEMORY_KINDS,
+  MEMORY_MODES,
+  MEMORY_SCOPES,
+  MEMORY_SEARCH_LIMIT_MAX,
+  deleteMemory,
+  getMemoryMode,
+  listMemories,
+  saveMemory,
+  searchMemories,
+  setMemoryMode,
+  updateMemory
+} from "mergestorm/client";
+import { z as z2 } from "zod";
+var memoryId = z2.string().uuid();
+var memoryText = z2.string().trim().min(1).max(500);
+var repo = z2.string().trim().min(3).max(200);
+var listMemoriesSchema = {
+  scope: z2.enum(MEMORY_SCOPES).optional(),
+  repo: repo.optional(),
+  kind: z2.enum(MEMORY_KINDS).optional()
+};
+var searchMemorySchema = {
+  query: z2.string().trim().min(1).max(2e3),
+  repo: repo.optional(),
+  limit: z2.number().int().min(1).max(MEMORY_SEARCH_LIMIT_MAX).optional()
+};
+var rememberSchema = { text: memoryText, kind: z2.enum(MEMORY_KINDS), repo: repo.optional() };
+var updateMemorySchema = { id: memoryId, text: memoryText, kind: z2.enum(MEMORY_KINDS).optional() };
+var forgetMemorySchema = { id: memoryId };
+var setMemoryModeSchema = { memory_mode: z2.enum(MEMORY_MODES) };
+var liveApi = { listMemories, searchMemories, saveMemory, updateMemory, deleteMemory, getMemoryMode, setMemoryMode };
+function memoryLine(memory) {
+  return `- [${memory.id}] (${memory.repo ? `${memory.kind}, ${memory.repo}` : memory.kind}) ${memory.text}`;
+}
+async function guarded(run) {
+  try {
+    return await run();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const code = err instanceof CommandError3 ? err.code ?? "memory_failed" : "memory_failed";
+    return {
+      summary: message,
+      data: { error: { code, message, ...err instanceof CommandError3 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {} } },
+      isError: true
+    };
+  }
+}
+function createMemoryToolHandlers(cfg, chatId, api = liveApi) {
+  return {
+    list: (input) => guarded(async () => {
+      const listed = await api.listMemories(input, cfg);
+      const count = listed.items.length === 1 ? "1 memory" : `${listed.items.length} memories`;
+      return { summary: [`Memory is ${listed.memory_mode}. ${count}.`, ...listed.items.map(memoryLine)].join("\n"), data: listed };
+    }),
+    search: (input) => guarded(async () => {
+      const found = await api.searchMemories({ ...input, chatId }, cfg);
+      const all = [...found.rules, ...found.items];
+      const summary = found.memory_mode === "off" ? "Memory is off, so nothing was searched." : all.length === 0 ? "Nothing in memory matches." : ["Memories that match, best first:", ...all.map(memoryLine)].join("\n");
+      return { summary, data: found };
+    }),
+    remember: (input) => guarded(async () => {
+      const saved = await api.saveMemory({ ...input, chatId }, cfg);
+      return { summary: saved.merged ? `That matched memory ${saved.id}, which now says this.` : `Saved to memory as ${saved.id}.`, data: saved };
+    }),
+    update: (input) => guarded(async () => {
+      const updated = await api.updateMemory(input.id, { text: input.text, ...input.kind ? { kind: input.kind } : {} }, cfg);
+      return { summary: `Memory ${updated.id} updated.`, data: updated };
+    }),
+    forget: (input) => guarded(async () => {
+      const deleted = await api.deleteMemory(input.id, cfg);
+      return { summary: `Memory ${deleted.id} forgotten.`, data: deleted };
+    }),
+    getMode: () => guarded(async () => {
+      const mode = await api.getMemoryMode(cfg);
+      return { summary: `Memory is ${mode.memory_mode}.`, data: mode };
+    }),
+    setMode: (input) => guarded(async () => {
+      const mode = await api.setMemoryMode(input.memory_mode, cfg);
+      return { summary: `Memory is now ${mode.memory_mode}.`, data: mode };
+    })
+  };
+}
+
+// src/tools/queue-status.ts
+import {
+  apiFetch as apiFetch2,
+  CommandError as CommandError4,
   isCommandErrorCode,
   loadConfig as loadConfig2,
   rateLimitedMessage,
@@ -135,12 +254,12 @@ import {
 } from "mergestorm/client";
 function entrySummary(entry) {
   const prNumber = entry.bounceDetail?.prNumber;
-  const repo = `${entry.owner}/${entry.repo}${prNumber ? `#${prNumber}` : ""}`;
+  const repo2 = `${entry.owner}/${entry.repo}${prNumber ? `#${prNumber}` : ""}`;
   const reason = entry.bounceDetail?.kind ?? entry.bounceReason ?? entry.waitReason ?? void 0;
   const sha = entry.bounceDetail?.headSha ?? entry.verifyHeadSha ?? void 0;
   return [
     entry.state,
-    repo,
+    repo2,
     `stack ${entry.stackId}`,
     reason,
     sha?.slice(0, 7)
@@ -150,17 +269,17 @@ 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"
     );
     if (status === 404) {
-      throw new CommandError3(
+      throw new CommandError4(
         "Merge queue route returned 404. Deploy the API."
       );
     }
     if (status === 429) {
-      throw new CommandError3(
+      throw new CommandError4(
         rateLimitedMessage(retryAfterSeconds),
         REVIEW_EXIT.rate_limited,
         "rate_limited",
@@ -168,13 +287,13 @@ async function queueStatus(stackId, cfg) {
       );
     }
     if (status !== 200) {
-      throw new CommandError3(
+      throw new CommandError4(
         `Failed to get queue status (HTTP ${status}): ${JSON.stringify(body)}`
       );
     }
     const entries = body.entries;
     if (!Array.isArray(entries)) {
-      throw new CommandError3(
+      throw new CommandError4(
         `Failed to get queue status (HTTP 200): ${JSON.stringify(body)}`
       );
     }
@@ -226,6 +345,7 @@ async function queueStatus(stackId, cfg) {
 // src/tools/review-dismiss.ts
 import {
   dismissPrFindings,
+  dismissThreadsLine,
   stackWatchObligation as stackWatchObligation2
 } from "mergestorm/client";
 
@@ -239,13 +359,13 @@ import {
   stackWatchBackgroundCommand,
   stackWatchObligation
 } from "mergestorm/client";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var stackWaitSchema = {
-  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()
+  stack_id: z3.string().trim().min(1),
+  timeout_s: z3.number().finite().min(0).max(45).default(45),
+  enrolled_head_sha: z3.string().nullable().optional(),
+  after_finished_at: z3.string().nullable().optional(),
+  bounce_id: z3.string().nullable().optional()
 };
 function repairSummary(repair) {
   if (!repair) return "";
@@ -259,6 +379,58 @@ function withWatchText(watch, body) {
 
 ${body}`;
 }
+var KEEP_EARLIER_CURSOR = "If you already hold a cursor from an earlier stack_wait on this stack, keep passing that cursor instead.";
+function hostedStackWatch(watch) {
+  if (watch.done) {
+    return {
+      ...watch,
+      next: null,
+      message: watch.reason === "not_found" ? "No stack with this id exists for this account. Mergestorm deletes a stack once none of its layers is open, which can mean merged or closed, so landing is unconfirmed: check on GitHub that each PR is merged before reporting it landed. The watch is done." : watch.message
+    };
+  }
+  const args = watch.next?.args;
+  const attention = watch.reason === "attention";
+  const retry = watch.reason === "rate_limited" ? " Wait retry_after_seconds first." : "";
+  const failed = watch.reason === "failed" ? " This read failed; if the next one fails too, tell the human the stack is no longer watched." : "";
+  const keep = watch.message.includes(KEEP_EARLIER_CURSOR) ? ` ${KEEP_EARLIER_CURSOR}` : "";
+  const resume = args ? attention ? ` After the blocker is handled, call stack_wait ${JSON.stringify(args)}.` : ` Next call: stack_wait ${JSON.stringify(args)}.` : "";
+  return {
+    ...watch,
+    next: args && !attention ? { tool: "stack_wait", args } : null,
+    message: `This stack is not landed and the watch is not done.${retry}${failed}${resume}${keep}`
+  };
+}
+function hostedStackRepair(repair) {
+  const { steps: _steps, note: _note, findings: _findings, ...facts } = repair;
+  return facts;
+}
+function hostedRepairSummary(repair) {
+  const files = "files" in repair && repair.files.length ? ` Files: ${repair.files.join(", ")}.` : "";
+  const breeze = "publishedBy" in repair && repair.publishedBy === "breeze" ? ` ${repair.branch} is a Breeze branch${repair.liveParent ? ` on ${repair.liveParent}` : ""}: open_pull_request publishes it with single-parent commits only, so a merge commit cannot be published.` : "";
+  return `
+Repair #${repair.prNumber} (${repair.kind}).${files}${breeze}`;
+}
+function hostedToolResult(result) {
+  const data = result.structuredContent;
+  const watch = data?.watch;
+  const repair = data?.repair;
+  const hasWatch = !!watch && typeof watch.message === "string";
+  const hasRepair = !!repair && typeof repair.steps === "string";
+  if (!data || !hasWatch && !hasRepair) return result;
+  let text = result.content[0]?.text ?? "";
+  const structured = { ...data };
+  if (hasWatch) {
+    const hosted = hostedStackWatch(watch);
+    structured.watch = hosted;
+    if (text.startsWith(watch.message)) text = `${hosted.message}${text.slice(watch.message.length)}`;
+  }
+  if (hasRepair) {
+    const hosted = hostedStackRepair(repair);
+    structured.repair = hosted;
+    text = text.replace(repairSummary(repair), hostedRepairSummary(repair));
+  }
+  return { ...result, content: [{ type: "text", text }, { type: "text", text: JSON.stringify(structured) }], structuredContent: structured };
+}
 function envelopeWatch(envelope) {
   return envelope.watch ?? stackWatchObligation({
     stackId: envelope.stackId,
@@ -267,10 +439,10 @@ function envelopeWatch(envelope) {
     status: envelope.status
   });
 }
-function stackWaitSummary(envelope) {
-  return withWatchText(envelopeWatch(envelope), `${stackWaitStatusLine(envelope)}${repairSummary(envelope.repair)}`);
+function stackWaitSummary(envelope, hosted = false) {
+  return withWatchText(envelopeWatch(envelope), `${stackWaitStatusLine(envelope, hosted)}${repairSummary(envelope.repair)}`);
 }
-function stackWaitStatusLine(envelope) {
+function stackWaitStatusLine(envelope, hosted) {
   const base = `Stack ${envelope.stackId} \xB7 ${envelope.status}${stackBlockersSummary(envelope.blocker && envelope.prNumber != null ? { prNumber: envelope.prNumber, blocker: envelope.blocker } : null, envelope.issues, envelope.busy, envelope.landGatePending, envelope.actAfter ?? null, envelope.queueWait ?? null)}${envelope.assessment === "unavailable" ? " \xB7 assessment unavailable" : ""}`;
   if (envelopeWatch(envelope).done || envelope.status !== "waiting" && envelope.status !== "in_progress") return base;
   const selectors = [
@@ -279,10 +451,12 @@ function stackWaitStatusLine(envelope) {
     ...envelope.cursor.afterFinishedAt !== void 0 ? [`after_finished_at ${JSON.stringify(envelope.cursor.afterFinishedAt)}`] : [],
     ...envelope.cursor.bounceId !== void 0 ? [`bounce_id ${JSON.stringify(envelope.cursor.bounceId)}`] : []
   ];
-  return `${base} \xB7 watch not finished: only with a confirmed host notification that resumes this task, run ${stackWatchBackgroundCommand(envelope.stackId, envelope.cursor)} as a background command and end your turn; otherwise call stack_wait again with timeout_s 45 and the same cursor: ${selectors.join(", ")}`;
+  const background = hosted ? "" : `only with a confirmed host notification that resumes this task, run ${stackWatchBackgroundCommand(envelope.stackId, envelope.cursor)} as a background command and end your turn; otherwise `;
+  return `${base} \xB7 watch not finished: ${background}call stack_wait again with timeout_s 45 and the same cursor: ${selectors.join(", ")}`;
 }
 async function stackWait(input, cfg, deps = {}) {
-  const args = z2.object(stackWaitSchema).parse(input);
+  const args = z3.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 +465,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
@@ -300,7 +474,7 @@ async function stackWait(input, cfg, deps = {}) {
     if (err instanceof StackWatchError) {
       const envelope2 = { ...err.lastEnvelope, watch: envelopeWatch(err.lastEnvelope) };
       return {
-        summary: stackWaitSummary(envelope2),
+        summary: stackWaitSummary(envelope2, deps.hosted),
         data: {
           ...envelope2,
           ...err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
@@ -312,9 +486,12 @@ async function stackWait(input, cfg, deps = {}) {
     envelope = err.lastEnvelope;
   }
   const sealed = { ...envelope, watch: envelopeWatch(envelope) };
+  const task = deps.chatId && !sealed.watch.done ? await trackInChat(config, deps.chatId, { kind: "stack", stackId: sealed.stackId }, deps.signal) : null;
   return {
-    summary: stackWaitSummary(sealed),
-    data: sealed
+    summary: task ? `${stackWaitSummary(sealed, deps.hosted)}
+
+${chatTaskNote(task)}` : stackWaitSummary(sealed, deps.hosted),
+    data: task ? { ...sealed, background_task: task } : sealed
   };
 }
 
@@ -335,6 +512,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 +557,145 @@ async function reviewDismiss(input, cfg) {
   return { summary: withWatchText(watch, summary), data: { ...result, watch } };
 }
 
+// src/tools/agent-request.ts
+import { apiFetch as apiFetch3, CommandError as CommandError5, 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 CommandError5("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);
+  const task = chatTaskOf(payload.data.background_task);
+  return task ? { ...payload, summary: `${payload.summary} ${chatTaskNote(task)}` } : 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 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;
+  const task = chatTaskOf(payload.data.background_task);
+  return { ...payload, summary: `${payload.summary} ${task ? chatTaskNote(task) : CYCLONE_START_WAIT_NOTE}` };
+}
+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 task = chatId ? await trackInChat(resolved, chatId, { kind: "stack", stackId }) : null;
+  const summary = withWatchText(watch, `Sent stack ${stackId} to the Mergestorm merge queue`);
+  return {
+    summary: task ? `${summary} ${chatTaskNote(task)}` : summary,
+    data: { stack_id: stackId, result, watch, ...task ? { background_task: task } : {} }
+  };
+}
+
+// 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 +713,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 CommandError6,
   REVIEW_THREAD_SLUG_RE,
   ReviewPollTimeoutError,
   collectReviewInput,
   discoverTrunk,
   formatReviewSubmitError,
-  loadConfig as loadConfig4,
+  loadConfig as loadConfig6,
   loadReviewContext,
   pollReview,
   rateLimitedMessage as rateLimitedMessage2,
@@ -450,7 +768,7 @@ function assertPinnableSpecialists(specialists) {
     (id) => !PINNABLE_SPECIALISTS.includes(id)
   );
   if (unknown.length === 0) return;
-  throw new CommandError4(
+  throw new CommandError6(
     `Unknown specialist: ${unknown.join(", ")}. Valid lanes: ${PINNABLE_SPECIALISTS.join(", ")}. governance and seam cannot be requested.`,
     2,
     "usage"
@@ -462,7 +780,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 CommandError6("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 +813,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 CommandError6("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 CommandError6) throw err;
+    throw new CommandError6("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 CommandError6("thread must be 1\u2013120 chars [A-Za-z0-9._/-]", 2, "usage");
   }
   if (input.context === "-") {
-    throw new CommandError4(
+    throw new CommandError6(
       'context "-" (stdin) is not available over MCP; pass the text directly',
       2,
       "usage"
@@ -563,7 +881,7 @@ async function reviewSubmit(input, cfg, opts = {}) {
     };
   }
   if (!jobId) {
-    throw new CommandError4("Review API returned no job_id");
+    throw new CommandError6("Review API returned no job_id");
   }
   if (!wait) {
     return payloadFromRow(submitted.row, { jobId, status: submitted.row.status ?? "queued" });
@@ -592,22 +910,22 @@ 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 CommandError7,
   getPrVortexReview,
   isCommandErrorCode as isCommandErrorCode3
 } from "mergestorm/client";
-function prReviewTarget(owner, repo, prNumber) {
+function prReviewTarget(owner, repo2, prNumber) {
   const cleanOwner = owner.trim();
-  const cleanRepo = repo.trim();
+  const cleanRepo = repo2.trim();
   if (!cleanOwner || !cleanRepo || !Number.isInteger(prNumber) || prNumber <= 0) {
-    throw new CommandError5(
+    throw new CommandError7(
       "owner, repo, and a positive pr_number are required",
       2,
       "usage"
@@ -615,8 +933,8 @@ function prReviewTarget(owner, repo, prNumber) {
   }
   return { owner: cleanOwner, repo: cleanRepo, prNumber };
 }
-function prReviewSummary(owner, repo, prNumber, envelope) {
-  const bits = [`${owner}/${repo}#${prNumber}`, envelope.status];
+function prReviewSummary(owner, repo2, prNumber, envelope) {
+  const bits = [`${owner}/${repo2}#${prNumber}`, envelope.status];
   const sha = envelope.head_sha?.trim();
   if (sha) bits.push(`sha ${sha.slice(0, 7)}`);
   if (typeof envelope.finding_count === "number") {
@@ -627,16 +945,16 @@ function prReviewSummary(owner, repo, prNumber, envelope) {
   if (envelope.phase) bits.push(String(envelope.phase));
   return bits.join(" \xB7 ");
 }
-function payloadFromPrReview(owner, repo, prNumber, envelope) {
+function payloadFromPrReview(owner, repo2, prNumber, envelope) {
   return {
-    summary: prReviewSummary(owner, repo, prNumber, envelope),
+    summary: prReviewSummary(owner, repo2, prNumber, envelope),
     data: { ...envelope }
   };
 }
-function payloadFromPrRateLimit(err, owner, repo, prNumber) {
+function payloadFromPrRateLimit(err, owner, repo2, prNumber) {
   if (!isCommandErrorCode3(err, "rate_limited")) return null;
   return {
-    summary: `${owner}/${repo}#${prNumber} \xB7 rate_limited`,
+    summary: `${owner}/${repo2}#${prNumber} \xB7 rate_limited`,
     data: {
       status: "rate_limited",
       error: err.message,
@@ -644,8 +962,8 @@ function payloadFromPrRateLimit(err, owner, repo, prNumber) {
     }
   };
 }
-async function reviewGetPr(owner, repo, prNumber, cfg, opts = {}) {
-  const target2 = prReviewTarget(owner, repo, prNumber);
+async function reviewGetPr(owner, repo2, prNumber, cfg, opts = {}) {
+  const target2 = prReviewTarget(owner, repo2, prNumber);
   try {
     const envelope = await getPrVortexReview(
       target2.owner,
@@ -673,9 +991,9 @@ 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();
+async function reviewWaitPr(owner, repo2, prNumber, afterSha, timeout_s, cfg, opts = {}) {
+  const target2 = prReviewTarget(owner, repo2, prNumber);
+  const resolved = cfg ?? await loadConfig7();
   if (timeout_s === 0) {
     return reviewGetPr(target2.owner, target2.repo, target2.prNumber, resolved, {
       afterSha,
@@ -718,15 +1036,18 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
         finding_count: findingCount,
         phase: err.lastEnvelope?.phase ?? null
       });
+      const task = opts.chatId ? await trackInChat(resolved, opts.chatId, { kind: "review", owner: target2.owner, repo: target2.repo, prNumber: target2.prNumber }) : 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: task ? `${shown} \xB7 ${chatTaskNote(task)}` : 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,
+          ...task ? { background_task: task } : {}
         }
       };
     }
@@ -743,15 +1064,15 @@ async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opt
 
 // src/tools/review-wait.ts
 import {
-  CommandError as CommandError7,
+  CommandError as CommandError9,
   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 CommandError8,
   getReview,
   toReviewJobEnvelope as toReviewJobEnvelope3
 } from "mergestorm/client";
@@ -765,7 +1086,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 CommandError8(`Unexpected response for review ${jobId}.`);
   }
   const envelope = toReviewJobEnvelope3(row, { jobId });
   const bits = [envelope.status];
@@ -778,10 +1099,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 CommandError9("job_id is required", 2, "usage");
   }
   if (timeout_s === 0) return reviewGet(id, resolved);
   try {
@@ -806,7 +1127,7 @@ async function reviewWait(jobId, timeout_s, cfg, opts = {}) {
 
 // src/tools/settings-get.ts
 import {
-  CommandError as CommandError8,
+  CommandError as CommandError10,
   getSettings
 } from "mergestorm/client";
 function settingsSummary(settings) {
@@ -824,7 +1145,7 @@ function settingsSummary(settings) {
 async function settingsGet(cfg) {
   const settings = await getSettings(cfg);
   if (!settings) {
-    throw new CommandError8(
+    throw new CommandError10(
       "Settings are not available (offline or API too old). Try again or open https://mergestorm.ai/settings"
     );
   }
@@ -836,7 +1157,7 @@ async function settingsGet(cfg) {
 
 // src/tools/settings-set.ts
 import {
-  CommandError as CommandError9,
+  CommandError as CommandError11,
   BEARER_SETTINGS,
   SETTINGS_WRITABLE_KEYS,
   patchSettings
@@ -848,7 +1169,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 CommandError11(`${key} is read-only and cannot be set.`, 2, "usage");
     }
   }
   const patch = {};
@@ -859,7 +1180,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 CommandError11(
           `${key} takes a whole number${unit} from ${row.min} through ${row.max}.`,
           2,
           "usage"
@@ -869,18 +1190,18 @@ function settingsPatchFromArgs(args) {
       continue;
     }
     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");
+      const valid = row.kind === "logins" || row.kind === "paths" ? Array.isArray(value) && value.every((entry) => typeof entry === "string") : typeof value === "string" && row.values.includes(value);
+      if (!valid) throw new CommandError11(`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 CommandError11(`${key} takes a boolean.`, 2, "usage");
     }
     Object.assign(patch, { [key]: value });
   }
   if (Object.keys(patch).length === 0) {
-    throw new CommandError9(
+    throw new CommandError11(
       `At least one settings key is required: ${SETTINGS_WRITABLE_KEYS.join(", ")}.`,
       2,
       "usage"
@@ -899,7 +1220,7 @@ async function settingsSet(args, cfg) {
 
 // src/tools/repo-settings.ts
 import {
-  CommandError as CommandError10,
+  CommandError as CommandError12,
   REPO_SETTINGS_KEYS,
   listRepoSettings,
   patchRepoSettings
@@ -907,15 +1228,22 @@ import {
 var ARG_BY_KEY = {
   auto_patch_enabled: "auto_patch",
   auto_review_enabled: "auto_review",
-  auto_land_default: "auto_land"
+  auto_land_default: "auto_land",
+  merge_queue_batch_enabled: "merge_queue_batch",
+  merge_queue_batch_size: "merge_queue_batch_size",
+  merge_queue_lands_alone_paths: "merge_queue_lands_alone_paths",
+  merge_queue_overdrive: "merge_queue_overdrive"
 };
 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 CommandError12("repo takes <owner>/<repo>.", 2, "usage");
   return { owner: match[1], repo: match[2] };
 }
 function words(value) {
-  return value === null ? "inherit" : value ? "on" : "off";
+  if (value === null) return "inherit";
+  if (Array.isArray(value)) return value.length === 0 ? "none" : value.join(",");
+  if (typeof value === "number") return String(value);
+  return 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 ")}`;
@@ -925,13 +1253,27 @@ function repoSettingsPatchFromArgs(args) {
   for (const key of REPO_SETTINGS_KEYS) {
     const value = args[ARG_BY_KEY[key]];
     if (value === void 0) continue;
+    if (key === "merge_queue_batch_size") {
+      if (value !== null && (typeof value !== "number" || !Number.isInteger(value))) {
+        throw new CommandError12(`${ARG_BY_KEY[key]} takes a whole number or null.`, 2, "usage");
+      }
+      patch[key] = value;
+      continue;
+    }
+    if (key === "merge_queue_lands_alone_paths") {
+      if (value !== null && !(Array.isArray(value) && value.every((entry) => typeof entry === "string"))) {
+        throw new CommandError12(`${ARG_BY_KEY[key]} takes a list of path patterns or null.`, 2, "usage");
+      }
+      patch[key] = value;
+      continue;
+    }
     if (value !== null && typeof value !== "boolean") {
-      throw new CommandError10(`${ARG_BY_KEY[key]} takes true, false, or null.`, 2, "usage");
+      throw new CommandError12(`${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 CommandError12(
       `At least one of ${Object.values(ARG_BY_KEY).join(", ")} is required.`,
       2,
       "usage"
@@ -950,21 +1292,21 @@ 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 CommandError12(`${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);
+  const { owner, repo: repo2 } = parseRepo(args.repo);
+  const entry = await patchRepoSettings(owner, repo2, repoSettingsPatchFromArgs(args), cfg);
   return { summary: repoSettingsSummary(entry), data: { ...entry } };
 }
 
 // src/tools/stack-adopt.ts
-import { adoptStack, CommandError as CommandError11, stackWatchObligation as stackWatchObligation4 } from "mergestorm/client";
-import { z as z3 } from "zod";
+import { adoptStack, CommandError as CommandError13, stackWatchObligation as stackWatchObligation5 } from "mergestorm/client";
+import { z as z4 } 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 +1353,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: {
@@ -1029,40 +1371,40 @@ async function stackSet(stackId, input, cfg) {
 
 // src/tools/stack-adopt.ts
 var stackAdoptSchema = {
-  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()
+  owner: z4.string().trim().min(1),
+  repo: z4.string().trim().min(1),
+  pr_number: z4.number().int().min(1),
+  auto_land: z4.boolean().optional(),
+  auto_review: z4.boolean().nullable().optional(),
+  auto_patch: z4.boolean().nullable().optional(),
+  auto_resolve_conflicts: z4.boolean().nullable().optional(),
+  auto_fix_ci: z4.boolean().nullable().optional()
 };
-var inputSchema2 = z3.object(stackAdoptSchema);
+var inputSchema2 = z4.object(stackAdoptSchema);
 async function stackAdopt(input, cfg) {
   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 };
   }
-  const { owner, repo, pr_number } = parsed.data;
+  const { owner, repo: repo2, pr_number } = parsed.data;
   try {
     const result = await adoptStack(
       owner,
-      repo,
+      repo2,
       pr_number,
       cfg,
       stackSetPatch(parsed.data)
     );
-    const summary = `Adopted stack for ${owner}/${repo}#${pr_number}`;
+    const summary = `Adopted stack for ${owner}/${repo2}#${pr_number}`;
     const stackId = typeof result === "object" && result !== null ? result.stack?.id : void 0;
     if (typeof stackId !== "string" || !stackId) {
-      return { summary, data: { owner, repo, pr_number, result } };
+      return { summary, data: { owner, repo: repo2, 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 }
+      data: { owner, repo: repo2, pr_number, result, watch }
     };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1070,11 +1412,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 CommandError13 ? 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 CommandError13 ? { exit_code: err.exitCode } : {},
+          ...err instanceof CommandError13 && err.reason !== void 0 ? { reason: err.reason } : {},
+          ...err instanceof CommandError13 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
         }
       },
       isError: true
@@ -1145,38 +1487,39 @@ async function stackList(cfg) {
 
 // src/tools/stack-publish.ts
 import {
-  CommandError as CommandError12,
+  CommandError as CommandError14,
   publishWorkingBranch,
-  stackWatchObligation as stackWatchObligation5,
+  stackWatchObligation as stackWatchObligation6,
   workingBranchPublication
 } from "mergestorm/client";
-import { z as z4 } from "zod";
+import { z as z5 } 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()
+  cwd: z5.string().trim().min(1).optional(),
+  owner: z5.string().trim().min(1).optional(),
+  repo: z5.string().trim().min(1).optional(),
+  branch: z5.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()
+  base: z5.string().trim().min(1).optional(),
+  extend: z5.boolean().optional(),
+  title: z5.string().trim().min(1).max(256).optional(),
+  body: z5.string().max(6e4).optional(),
+  replace_head: z5.string().regex(/^[0-9a-f]{40}$/).optional(),
+  auto_land: z5.boolean().optional()
 };
 var stackPublishStatusSchema = target;
-var publishInput = z4.object(stackPublishSchema);
-var statusInput = z4.object(stackPublishStatusSchema);
+var publishInput = z5.object(stackPublishSchema);
+var statusInput = z5.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,
+        code: err instanceof CommandError14 ? err.code ?? fallback : fallback,
         message,
-        ...err instanceof CommandError12 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
+        ...err instanceof CommandError14 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
       }
     },
     isError: true
@@ -1202,6 +1545,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 +1553,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 +1590,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 +1613,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 +1626,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 +1652,18 @@ async function stackStatus(stackId, cfg) {
 
 // src/tools/whoami.ts
 import {
-  CommandError as CommandError13,
+  CommandError as CommandError15,
   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 CommandError15(
       "No API key. Run `mergestorm login` (agents: `mergestorm login --start`, then `--finish`) or set MERGESTORM_API_KEY.",
       1,
       "missing_api_key"
@@ -1327,7 +1671,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 CommandError15("Live account details unavailable. Could not verify account with /me.");
   }
   const data = {
     key_prefix: me.key.prefix,
@@ -1335,7 +1679,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 +1692,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,13 +1702,14 @@ 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 = [
   "When stack work is done:",
   "- Stack work is done only when the stack is landed, or when the human takes it back (archives it or tells you to stop). A clean push, a submit, an adopt, or one merged layer is not done: merging a lower layer can break a layer above it.",
   "- Every stack_wait, stack_status, stack_adopt, and stack_set result carries watch: {done, until, reason, next, message}. While watch.done is false, keep calling stack_wait with watch.next.args (the returned cursor), 45s at a time, or hand the waiting to the background watcher below, and do not end your task. Stop only when watch.done is true.",
-  "- Only when your host has a confirmed notification that resumes this task, run `mg stack watch <stack-id>` as a background command with a notification on output matching `MS-WATCH (ATTENTION|LANDED)`, then end your turn. The watcher runs stack_wait against the Mergestorm API in slices of at most 300s, carries the cursor, stays silent while the stack is waiting or in_progress (busy[] holds and actAfter included), and costs no model tokens. It exits on attention (`MS-WATCH ATTENTION pr=<n> head=<sha> blocker=... repair=<kind>`, exit 3), on reads that keep failing (`MS-WATCH ATTENTION failed`, exit 3, after an auth or other permanent error twice, or after 15 minutes of timeouts and 5xx; tell the human the stack is no longer watched), on a closed, archived, or missing stack (`MS-WATCH ATTENTION stack=<id> reason=<reason>`, exit 3; verify missing stacks before reporting a landing), or on a confirmed landing (`MS-WATCH LANDED stack=<id> reason=landed`, exit 0). On an attention wake, read stack_status once, fix the blocker per mergestorm-bounce-watch, push, and start `mg stack watch <stack-id> --head <pushed-sha>` again. The command monitors the stack; it cannot wake an agent by itself. A confirmed notification is a host feature you can name that turns the command's exit or matching output into your next turn; a process left running, or output written to a log or terminal you do not read, is not one. Without a confirmed notification, keep using stack_wait with watch.next.args, or report that automatic follow-up is unavailable before ending the turn. Ending your turn while the watcher runs is not ending the task. Do not subscribe to GitHub events to wait on a stack.",
+  "- Only when your host has a confirmed notification that resumes this task, run `mg stack watch <stack-id>` as a background command with a notification on output matching `MS-WATCH (ATTENTION|LANDED)`, then end your turn. The watcher runs stack_wait against the Mergestorm API in slices of at most 300s, carries the cursor, stays silent while the stack is waiting or in_progress (busy[] holds and actAfter included), and costs no model tokens. It exits on attention (`MS-WATCH ATTENTION pr=<n> head=<sha> blocker=... repair=<kind>`, exit 3), on reads that keep failing (`MS-WATCH ATTENTION failed`, exit 3, after an auth or other permanent error twice, or after 15 minutes with no stack read (timeouts, 5xx, rate limits); tell the human the stack is no longer watched), or when the command cannot start (`MS-WATCH ATTENTION failed` with exit 2 for bad flags, exit 1 for no config or another startup error; tell the human the stack is not watched), on a closed, archived, or missing stack (`MS-WATCH ATTENTION stack=<id> reason=<reason>`, exit 3; verify missing stacks before reporting a landing), or on a confirmed landing (`MS-WATCH LANDED stack=<id> reason=landed`, exit 0). On an attention wake, read stack_status once, fix the blocker per mergestorm-bounce-watch, push, and start `mg stack watch <stack-id> --head <pushed-sha>` again. The command monitors the stack; it cannot wake an agent by itself. A confirmed notification is a host feature you can name that turns the command's exit or matching output into your next turn; a process left running, or output written to a log or terminal you do not read, is not one. Without a confirmed notification, keep using stack_wait with watch.next.args, or report that automatic follow-up is unavailable before ending the turn. Ending your turn while the watcher runs is not ending the task. Do not subscribe to GitHub events to wait on a stack.",
   "- A layer PR shown as merged is merged into mg-stack-<n>, not main. The stack is landed only when the land PR (head mg-stack-<n>) merges into main or watch.done says landed. Never judge landing from GitHub PR state alone.",
   "- attention means something for you to fix; repair, when present, names the concrete fix. A pending land gate (landGatePending: ci_pending) is a wait, not attention. attention covers every open layer, not only currentCandidate: it names the lowest layer with a blocker an agent must fix and no Vortex or Cyclone run working on it; once that blocker clears, the next read names the next blocked layer."
 ].join("\n");
@@ -1400,10 +1746,58 @@ var MCP_STACK_WATCH_INSTRUCTIONS = [
   '- More states the watch names: a Vortex review skipped because the PR author is on the ignored authors list or because reviews are turned off for the repository is attention at once with repair kind vortex_skipped; a Vortex retry that is scheduled ("Vortex hit a temporary error on this head and will retry by itself") is a wait listed in issues[], never attention; "Review failed" carries repair kind vortex_failed (comment @mergestorm-vortex review or push a new commit; if it fails again tell the human); a PR open on mg-stack-N that is not a layer of the stack is attention at once, blocker "The land PR cannot be queued: ...", repair kind members_remaining (do not patch or push; close, retarget or adopt that PR).',
   "- Use the mergestorm-bounce-watch skill for the fix-then-watch policy."
 ].join("\n");
+var MCP_HOSTED_SERVER_INSTRUCTIONS = [
+  "Stacks:",
+  "- A stack is done only when it is landed, or when the human takes it back (archives it or tells you to stop). A submit, an adopt or one merged layer is not done: merging a lower layer can break a layer above it.",
+  "- A layer PR shown as merged is merged into mg-stack-<n>, not main. The stack is landed only when its land PR (head mg-stack-<n>) merges into main, which watch.done with reason landed reports. Never judge landing from GitHub PR state alone.",
+  "- Results of the stack tools and review_dismiss carry watch: {done, reason, next, message}. While watch.done is false, call stack_wait with watch.next.args, which carry the cursor. Stop when watch.done is true.",
+  "- attention means a layer needs a fix: it names the PR and the blocker, and repair, when present, names the fix. in_progress means Vortex or Cyclone is still working on it (busy[] says which) or a blocker waits for them to finish (actAfter agents_idle): wait, do not act. A pending land gate (landGatePending) is a wait, not attention.",
+  "",
+  "Vortex findings:",
+  "- Dismiss a finding only after you checked it against the PR's live head and found it wrong or not actionable, with review_dismiss and a reason that gives your evidence. Never dismiss a finding you did not check or one from a newer review.",
+  "- A finding a human must decide (Decision required, policy fork, needs a human) stays open: do not dismiss it; tell the human which finding it is."
+].join("\n");
 
 // src/server.ts
+var BATCH_SIZE_ROW = BEARER_SETTINGS2.find((row) => row.key === "merge_queue_batch_size");
 var MCP_SERVER_NAME = "mergestorm";
-var MCP_SERVER_VERSION = "0.2.26";
+var MCP_SERVER_VERSION = "0.2.28";
+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",
+  "list_memories",
+  "search_memory",
+  "remember",
+  "update_memory",
+  "forget_memory",
+  "get_memory_mode",
+  "set_memory_mode"
+];
 var MCP_SERVER_INSTRUCTIONS = [
   MCP_STACK_DONE_INSTRUCTIONS,
   MCP_PR_LOOP_INSTRUCTIONS,
@@ -1423,14 +1817,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 CommandError16 ? 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 CommandError16 ? {
           exit_code: err.exitCode,
           ...err.code !== void 0 ? { code: err.code } : {},
           ...err.reason !== void 0 ? { reason: err.reason } : {},
@@ -1440,7 +1834,19 @@ function fail(err) {
     }
   });
 }
-function createMergestormMcpServer() {
+var MCP_WORKSPACE_TOOL_NAMES = ["review_submit", "review_wait", "stack_publish", "stack_publish_status"];
+var MCP_HOSTED_TOOL_NAMES = MCP_TOOL_NAMES.filter(
+  (name) => !MCP_WORKSPACE_TOOL_NAMES.includes(name)
+);
+var HOSTED_WAIT_MAX_S = 45;
+var HOSTED_REVIEW_WAIT_PR_DESCRIPTION = "Read the Vortex pass on a GitHub PR; review identity is head SHA + pass. timeout_s: 0 reads it once; otherwise it waits up to timeout_s (at most 45) 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, start one with review_start_pr). 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. With timeout_s: 0, a pass that does not exist yet returns not_found. On rate_limited, wait retry_after_seconds before trying again. Returns the verdict and each finding.";
+var HOSTED_REVIEW_DISMISS_DESCRIPTION = `Dismiss Vortex findings you checked and found wrong or not actionable, at the PR's live head: head_sha, review_id, finding_ids (the GitHub review comment ids, offdiff-<n> for a body-only finding; preview: true lists them without writing) or scope "review" to dismiss every finding of that review, and a reason of at least 20 characters. A deferral needs evidence_url set to an open tracking issue in the same repository. Refused, with nothing written, when the head moved, an id is unknown or the user's GitHub account lacks write access; retries are idempotent. Returns which gates cleared (gate.vortex.cleared, else gate.vortex.message) and the stack watch.`;
+var HOSTED_STACK_STATUS_DESCRIPTION = "Read one owned stack: its layers, checks and agent state, with the same attention, issues, repair and currentCandidate as stack_wait. Use it to see where a stack stands now; to wait for a change, use stack_wait.";
+var HOSTED_STACK_WAIT_DESCRIPTION = "Wait up to timeout_s (1-45) for a stack to need attention, or read it once with 0. Returns a mergestorm.stack_watch/v1 envelope: attention names the PR, blocker and repair; waiting or in_progress means call again with watch.next.args; watch.done true means stop (landed, closed, archived or gone).";
+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,
@@ -1449,9 +1855,15 @@ function createMergestormMcpServer() {
       websiteUrl: MCP_WEBSITE_URL,
       icons: MCP_SERVER_ICONS
     },
-    { instructions: MCP_SERVER_INSTRUCTIONS }
+    { instructions: hosted ? MCP_HOSTED_SERVER_INSTRUCTIONS : MCP_SERVER_INSTRUCTIONS }
   );
-  const addTool = server2.registerTool.bind(server2);
+  const registerTool = server2.registerTool.bind(server2);
+  const watchNote = hosted ? "" : STACK_WATCH_RESULT_NOTE;
+  const waitMaxS = hosted ? HOSTED_WAIT_MAX_S : 300;
+  const addTool = (name, toolConfig, cb) => {
+    if (hosted && MCP_WORKSPACE_TOOL_NAMES.includes(name)) return;
+    registerTool(name, toolConfig, hosted ? async (...args) => hostedToolResult(await cb(...args)) : cb);
+  };
   addTool(
     "whoami",
     {
@@ -1461,7 +1873,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 +1888,7 @@ function createMergestormMcpServer() {
     },
     async () => {
       try {
-        return ok(await credits());
+        return ok(await credits(config));
       } catch (err) {
         return fail(err);
       }
@@ -1488,13 +1900,13 @@ function createMergestormMcpServer() {
       title: "List reviews",
       description: "List recent Mergestorm review jobs as job envelopes.",
       inputSchema: {
-        limit: z5.number().int().min(1).max(50).optional()
+        limit: z6.number().int().min(1).max(50).optional()
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
     async ({ limit }) => {
       try {
-        return ok(await reviewList(limit));
+        return ok(await reviewList(limit, config));
       } catch (err) {
         return fail(err);
       }
@@ -1506,24 +1918,24 @@ 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: 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()
+        cwd: z6.string().optional(),
+        base: z6.string().optional(),
+        head: z6.string().optional(),
+        diff: z6.string().optional(),
+        router: z6.enum(["off", "standard", "max", "manual"]).optional(),
+        specialists: z6.array(z6.string().min(1)).max(5).optional(),
+        context: z6.string().optional(),
+        context_files: z6.array(z6.string().min(1)).max(10).optional(),
+        thread: z6.string().min(1).max(120).optional(),
+        idempotency_key: z6.string().min(1).max(128).optional(),
+        wait: z6.boolean().optional(),
+        timeout_s: z6.number().positive().max(300).optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
     },
     async (args) => {
       try {
-        return ok(await reviewSubmit(args));
+        return ok(await reviewSubmit(args, config));
       } catch (err) {
         return fail(err);
       }
@@ -1535,14 +1947,14 @@ 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: z5.string().min(1),
-        timeout_s: z5.number().min(0).max(300).optional()
+        job_id: z6.string().min(1),
+        timeout_s: z6.number().min(0).max(300).optional()
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
     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);
       }
@@ -1552,29 +1964,29 @@ function createMergestormMcpServer() {
     "review_wait_pr",
     {
       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.",
+      description: hosted ? HOSTED_REVIEW_WAIT_PR_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: 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()
+        owner: z6.string().min(1),
+        repo: z6.string().min(1),
+        pr_number: z6.number().int().min(1),
+        after_sha: z6.string().optional(),
+        pass: z6.number().int().min(1).optional(),
+        after_pass: z6.number().int().min(1).optional(),
+        timeout_s: z6.number().min(0).max(waitMaxS).optional()
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
-    async ({ owner, repo, pr_number, after_sha, pass, after_pass, timeout_s }) => {
+    async ({ owner, repo: repo2, pr_number, after_sha, pass, after_pass, timeout_s }) => {
       try {
         return ok(
           await reviewWaitPr(
             owner,
-            repo,
+            repo2,
             pr_number,
             after_sha,
             timeout_s,
-            void 0,
-            { pass, afterPass: after_pass }
+            config,
+            { pass, afterPass: after_pass, ...chatId ? { chatId } : {} }
           )
         );
       } catch (err) {
@@ -1586,24 +1998,100 @@ 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: hosted ? HOSTED_REVIEW_DISMISS_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),
-        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()
+        owner: z6.string().min(1),
+        repo: z6.string().min(1),
+        pr_number: z6.number().int().min(1),
+        head_sha: z6.string().regex(/^[0-9a-fA-F]{40}$/),
+        review_id: z6.number().int().min(1),
+        finding_ids: z6.array(z6.string().min(1)).max(50).optional(),
+        scope: z6.enum(["findings", "review"]).optional(),
+        reason: z6.string().optional(),
+        evidence_url: z6.string().url().optional(),
+        preview: z6.boolean().optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
     },
     async (args) => {
       try {
-        return ok(await reviewDismiss(args));
+        return ok(await reviewDismiss(args, config));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  const prInput = {
+    owner: z6.string().min(1),
+    repo: z6.string().min(1),
+    pr_number: z6.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 the result names a background task, its result also arrives through that task when the work finishes.",
+      inputSchema: { ...prInput, head_sha: z6.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. When the user has not named the pull request, find it before you call, and ask them for owner/repo#number if you cannot. 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. Wait for the job with cyclone_job until it is pushed, completed or failed, then report what it pushed. When the result names a background task, its result also arrives through that task when the work finishes.",
+      inputSchema: {
+        task: z6.enum(CYCLONE_TASKS),
+        owner: z6.string().min(1),
+        repo: z6.string().min(1),
+        pr_number: z6.number().int().min(1).optional(),
+        failing_check: z6.string().min(1).max(200).optional(),
+        brief: z6.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: z6.string().uuid(), timeout_s: z6.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 +2101,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);
       }
@@ -1629,13 +2117,13 @@ function createMergestormMcpServer() {
     "stack_adopt",
     {
       title: "Adopt PR stack",
-      description: "Adopt an open GitHub PR chain into a Mergestorm stack. auto_land is boolean; auto_review, auto_patch, auto_resolve_conflicts, and auto_fix_ci accept true, false, or null, where null clears the override. Omitted auto_land seeds from auto_land_default; omitted overrides are not seeded. Never changes account settings. Adoption needs the Mergestorm Surge GitHub App on the repository. Stacks, the merge queue and Auto land run through that App; Cyclone is the auto-patch App. Without it the API returns cyclone_not_connected or cyclone_not_installed; the message, and error.reason starting with surge_ when Surge is the one to install, say which App is missing \u2014 do not retry, tell the human what the message says. Read stack_status with result.stack.id afterward to verify policy and Cyclone ownership. With 2+ PRs, adopt moves the bottom PR's GitHub base to mg-stack-<n> and parks PR3+ on an mg-park-* freeze; a 1-PR stack stays on main. Leave those bases. Never retarget the bottom back to main." + STACK_WATCH_RESULT_NOTE,
+      description: "Adopt an open GitHub PR chain into a Mergestorm stack. auto_land is boolean; auto_review, auto_patch, auto_resolve_conflicts, and auto_fix_ci accept true, false, or null, where null clears the override. Omitted auto_land seeds from auto_land_default; omitted overrides are not seeded. Never changes account settings. Adoption needs the Mergestorm Surge GitHub App on the repository. Stacks, the merge queue and Auto land run through that App; Cyclone is the auto-patch App. Without it the API returns cyclone_not_connected or cyclone_not_installed; the message, and error.reason starting with surge_ when Surge is the one to install, say which App is missing \u2014 do not retry, tell the human what the message says. Read stack_status with result.stack.id afterward to verify policy and Cyclone ownership. With 2+ PRs, adopt moves the bottom PR's GitHub base to mg-stack-<n> and parks PR3+ on an mg-park-* freeze; a 1-PR stack stays on main. Leave those bases. Never retarget the bottom back to main." + watchNote,
       inputSchema: stackAdoptSchema,
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
     },
     async (args) => {
       try {
-        return ok(await stackAdopt(args));
+        return ok(await stackAdopt(args, config));
       } catch (err) {
         return fail(err);
       }
@@ -1650,7 +2138,7 @@ function createMergestormMcpServer() {
     },
     async () => {
       try {
-        return ok(await stackList());
+        return ok(await stackList(config));
       } catch (err) {
         return fail(err);
       }
@@ -1660,13 +2148,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." + watchNote,
       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 +2170,7 @@ function createMergestormMcpServer() {
     },
     async (args) => {
       try {
-        return ok(await stackPublishStatus(args));
+        return ok(await stackPublishStatus(args, config));
       } catch (err) {
         return fail(err);
       }
@@ -1692,14 +2180,14 @@ function createMergestormMcpServer() {
     "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,
+      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." + watchNote,
       inputSchema: {
-        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()
+        stack_id: z6.string().min(1),
+        auto_land: z6.boolean().optional(),
+        auto_review: z6.boolean().nullable().optional(),
+        auto_patch: z6.boolean().nullable().optional(),
+        auto_resolve_conflicts: z6.boolean().nullable().optional(),
+        auto_fix_ci: z6.boolean().nullable().optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
     },
@@ -1712,26 +2200,58 @@ 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." + watchNote,
+      inputSchema: { stack_id: z6.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 the result names a background task, its result also arrives through that task when the work finishes." + watchNote,
+      inputSchema: { stack_id: z6.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",
     {
       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. auto_land_switched_off (returned only when the PR has no live blocker of its own): Auto land was switched off without a bounce (queue entry cancelled, or nothing left to land); do not patch, push or turn it back on yourself, tell the human. 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_ATTENTION_NOTE + STACK_WATCH_RESULT_NOTE,
+      description: hosted ? HOSTED_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. auto_land_switched_off (returned only when the PR has no live blocker of its own): Auto land was switched off without a bounce (queue entry cancelled, or nothing left to land); do not patch, push or turn it back on yourself, tell the human. 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_ATTENTION_NOTE + STACK_WATCH_RESULT_NOTE,
       inputSchema: {
-        stack_id: z5.string().min(1)
+        stack_id: z6.string().min(1)
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
     async ({ stack_id }) => {
       try {
-        return ok(await stackStatus(stack_id));
+        return ok(await stackStatus(stack_id, config));
       } catch (err) {
         return fail(err);
       }
@@ -1741,13 +2261,13 @@ function createMergestormMcpServer() {
     "stack_wait",
     {
       title: "Wait for stack attention",
-      description: `Wait for a stack to need attention. Returns a mergestorm.stack_watch/v1 envelope; timeout_s: 0 returns one snapshot and timeout_s: 1-45 waits up to that many seconds, returning the current status (waiting or in_progress) if a snapshot was read and no attention is found. A timeout with either of those statuses is not a failure; waiting and in_progress end this slice, and the next call is stack_wait again with the same cursor. A timeout of failed means no assessment was produced. A stack that no longer exists returns status failed with watch.done true (reason not_found) and is not an error. While Cyclone or Vortex is still working on the blocked PR it returns in_progress, not attention, with busy[] naming the PR, blocker, and agent; agents carries that PR's vortexStatus, cycloneStatus, vortexReview, and busy flags. When another layer has a blocker no agent works on, attention names that blocker instead and busy[] is empty. 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: plan the fix, and act when a snapshot after the agents finish returns attention, re-reading the blocker then. Blockers the agents can change keep blocker and actAfter null. Attention never calls for changing a PR's GitHub base. When present, repair names the concrete fix for attention (restack_conflict and merge_conflict carry liveParent, never mg-park-*). For the three stuck-seam blockers, repair 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. A pending land gate (landGatePending) returns in_progress, not attention. 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. auto_land_switched_off (returned only when the PR has no live blocker of its own): Auto land was switched off without a bounce (queue entry cancelled, or nothing left to land); do not patch, push or turn it back on yourself, tell the human. 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_ATTENTION_NOTE + STACK_WATCH_RESULT_NOTE,
+      description: hosted ? HOSTED_STACK_WAIT_DESCRIPTION : `Wait for a stack to need attention. Returns a mergestorm.stack_watch/v1 envelope; timeout_s: 0 returns one snapshot and timeout_s: 1-45 waits up to that many seconds, returning the current status (waiting or in_progress) if a snapshot was read and no attention is found. A timeout with either of those statuses is not a failure; waiting and in_progress end this slice, and the next call is stack_wait again with the same cursor. A timeout of failed means no assessment was produced. A stack that no longer exists returns status failed with watch.done true (reason not_found) and is not an error. While Cyclone or Vortex is still working on the blocked PR it returns in_progress, not attention, with busy[] naming the PR, blocker, and agent; agents carries that PR's vortexStatus, cycloneStatus, vortexReview, and busy flags. When another layer has a blocker no agent works on, attention names that blocker instead and busy[] is empty. 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: plan the fix, and act when a snapshot after the agents finish returns attention, re-reading the blocker then. Blockers the agents can change keep blocker and actAfter null. Attention never calls for changing a PR's GitHub base. When present, repair names the concrete fix for attention (restack_conflict and merge_conflict carry liveParent, never mg-park-*). For the three stuck-seam blockers, repair 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. A pending land gate (landGatePending) returns in_progress, not attention. 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. auto_land_switched_off (returned only when the PR has no live blocker of its own): Auto land was switched off without a bounce (queue entry cancelled, or nothing left to land); do not patch, push or turn it back on yourself, tell the human. 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_ATTENTION_NOTE + STACK_WATCH_RESULT_NOTE,
       inputSchema: stackWaitSchema,
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
     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 } : {}, hosted });
         return ok(payload);
       } catch (err) {
         return fail(err);
@@ -1760,13 +2280,13 @@ 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: z5.string().min(1).optional()
+        stack_id: z6.string().min(1).optional()
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
     async ({ stack_id }) => {
       try {
-        return ok(await queueStatus(stack_id));
+        return ok(await queueStatus(stack_id, config));
       } catch (err) {
         return fail(err);
       }
@@ -1776,13 +2296,13 @@ function createMergestormMcpServer() {
     "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() },
+      description: "Read the repository-level Auto patch, Auto review, Auto land, merge queue (merge_queue_batch_enabled, merge_queue_batch_size, merge_queue_lands_alone_paths) and merge queue overdrive values for the repositories connected to this account. auto_patch_enabled, auto_review_enabled, auto_land_default, merge_queue_batch_enabled and merge_queue_overdrive are true, false, or null; merge_queue_batch_size is a whole number or null; merge_queue_lands_alone_paths is a list of path patterns 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. merge_queue_overdrive is the repository value over the account default; while it resolves on, that repository batches up to 10 queued pull requests. Pass repo as owner/repo for one repository, or omit it for all.",
+      inputSchema: { repo: z6.string().min(3).optional() },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
     async (args) => {
       try {
-        return ok(await repoSettingsGet(args ?? {}));
+        return ok(await repoSettingsGet(args ?? {}, config));
       } catch (err) {
         return fail(err);
       }
@@ -1792,18 +2312,38 @@ function createMergestormMcpServer() {
     "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.",
+      description: "Set Auto patch (Cyclone), Auto review (Vortex), the Auto land default, or the merge queue settings (merge_queue_batch, merge_queue_batch_size, merge_queue_lands_alone_paths, merge_queue_overdrive) for every stack and pull request in one repository connected to this account, and return the stored result. A value 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. merge_queue_lands_alone_paths is a list of folder prefixes or globs; a queued pull request that changes a matching file is never batched with others, and an empty list keeps only the built-in rule that a stack with more than one open pull request lands alone. merge_queue_overdrive true makes that repository batch up to 10 queued pull requests, even with batching off; false turns overdrive off for that repository whatever the account default is, and null clears the repository value so the account default (settings_get merge_queue_overdrive) applies again. 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()
+        repo: z6.string().min(3),
+        auto_patch: z6.boolean().nullable().optional(),
+        auto_review: z6.boolean().nullable().optional(),
+        auto_land: z6.boolean().nullable().optional(),
+        merge_queue_batch: z6.boolean().nullable().optional(),
+        merge_queue_batch_size: z6.number().int().min(BATCH_SIZE_ROW.min).max(BATCH_SIZE_ROW.max).nullable().optional(),
+        merge_queue_lands_alone_paths: z6.array(z6.string()).nullable().optional(),
+        merge_queue_overdrive: z6.boolean().nullable().optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
     },
     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: z6.string().min(1), repo: z6.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);
       }
@@ -1813,12 +2353,12 @@ function createMergestormMcpServer() {
     "settings_get",
     {
       title: "Get settings",
-      description: "Read the Bearer /api/v1/settings toggles, including auto_patch_enabled, auto_land_settle_seconds (how long Auto land waits before queueing), merge_queue_batch_enabled and merge_queue_batch_size (whether the merge queue tests several pull requests on one CI run, and how many), cyclone_connected (the Cyclone auto-patch App), and stacks_ready (whether stacks, the merge queue and Auto land can run for this account, which needs Mergestorm Surge).",
+      description: "Read the Bearer /api/v1/settings toggles, including auto_patch_enabled, auto_land_settle_seconds (how long Auto land waits before queueing), merge_queue_batch_enabled and merge_queue_batch_size (whether the merge queue tests several pull requests on one CI run, and how many), merge_queue_overdrive (the account default for overdrive: the merge queue batches up to 10 queued pull requests per repository; repo_settings_set overrides it per repository), cyclone_connected (the Cyclone auto-patch App), and stacks_ready (whether stacks, the merge queue and Auto land can run for this account, which needs Mergestorm Surge).",
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
     async () => {
       try {
-        return ok(await settingsGet());
+        return ok(await settingsGet(config));
       } catch (err) {
         return fail(err);
       }
@@ -1828,28 +2368,93 @@ function createMergestormMcpServer() {
     "settings_set",
     {
       title: "Update settings",
-      description: "Update writable Bearer /api/v1/settings values and return the stored result. At least one key is required. auto_land_settle_seconds is a whole number of seconds from 15 through 300; it applies to settle clocks that start after the write. merge_queue_batch_enabled turns merge queue batching on or off for the account, and merge_queue_batch_size is a whole number from 2 through 8. cyclone_connected and github_connected are read-only and cannot be set.",
+      description: "Update writable Bearer /api/v1/settings values and return the stored result. At least one key is required. auto_land_settle_seconds is a whole number of seconds from 15 through 300; it applies to settle clocks that start after the write. merge_queue_batch_enabled turns merge queue batching on or off for the account, merge_queue_batch_size is a whole number from 2 through 10, merge_queue_lands_alone_paths is the list of folder prefixes or globs whose changed files keep a pull request out of a batch, and merge_queue_overdrive is the account default for overdrive: while it resolves on, a repository batches up to 10 queued pull requests, even with batching off, without changing merge_queue_batch_size, and it stays on until turned off (repo_settings_set overrides each of these per repository). cyclone_connected and github_connected are read-only and cannot be set.",
       inputSchema: {
         ...Object.fromEntries(
           BEARER_SETTINGS2.map((row) => [
             row.key,
-            ("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()
+            ("kind" in row ? row.kind === "logins" || row.kind === "paths" ? z6.array(z6.string()) : row.kind === "seconds" || row.kind === "count" ? z6.number().int().min(row.min).max(row.max) : z6.enum(row.values) : z6.boolean()).optional()
           ])
         ),
         // Preserve these args so the handler rejects them even alongside a writable key.
-        cyclone_connected: z5.unknown().optional(),
-        github_connected: z5.unknown().optional()
+        cyclone_connected: z6.unknown().optional(),
+        github_connected: z6.unknown().optional()
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
     },
     async (args) => {
       try {
-        return ok(await settingsSet(args ?? {}));
+        return ok(await settingsSet(args ?? {}, config));
       } catch (err) {
         return fail(err);
       }
     }
   );
+  const memory = createMemoryToolHandlers(config, chatId);
+  const memoryTools = [
+    {
+      name: "list_memories",
+      title: "List memories",
+      description: "List what Mergestorm remembers about the user, newest first, with each memory's id. Filter by scope (user or repo), repo (owner/repo) or kind. Works with memory off, so the user can still see and delete what is stored.",
+      inputSchema: listMemoriesSchema,
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+      run: memory.list
+    },
+    {
+      name: "search_memory",
+      title: "Search memory",
+      description: "Search what Mergestorm remembers about the user by meaning, best match first. Give repo as owner/repo to search that repository's memories and standing rules too. Returns nothing when memory is off.",
+      inputSchema: searchMemorySchema,
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+      run: memory.search
+    },
+    {
+      name: "remember",
+      title: "Remember",
+      description: "Remember one thing about the user for later conversations, on every device: a standing rule for a repository, their code or writing style, how they like to work, a fact about them or their team, or what they built or decided. One thing per call, as a plain sentence under 500 characters that still makes sense months from now. kind: rule, style, preference, fact or project. Give repo as owner/repo only for a memory about one repository. When memory is on_request, save only what the user asks you to remember. Refused with memory_off when memory is off. Never keys, tokens, passwords or other secrets.",
+      inputSchema: rememberSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+      run: memory.remember
+    },
+    {
+      name: "update_memory",
+      title: "Update memory",
+      description: "Correct a memory that is wrong or out of date: its id from list_memories or search_memory, the new text, and optionally a new kind.",
+      inputSchema: updateMemorySchema,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+      run: memory.update
+    },
+    {
+      name: "forget_memory",
+      title: "Forget memory",
+      description: "Forget a memory that no longer holds, or anything the user asks you to forget, by its id from list_memories or search_memory.",
+      inputSchema: forgetMemorySchema,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+      run: memory.forget
+    },
+    {
+      name: "get_memory_mode",
+      title: "Read memory mode",
+      description: "Read the account's memory mode: off (nothing is saved or recalled), on_request (save only what the user asks to remember) or all (save what will matter later).",
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+      run: memory.getMode
+    },
+    {
+      name: "set_memory_mode",
+      title: "Set memory mode",
+      description: "Set the account's memory mode when the user asks: off, on_request or all.",
+      inputSchema: setMemoryModeSchema,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+      run: memory.setMode
+    }
+  ];
+  for (const tool of memoryTools) {
+    addTool(
+      tool.name,
+      { title: tool.title, description: tool.description, ...tool.inputSchema ? { inputSchema: tool.inputSchema } : {}, annotations: tool.annotations },
+      async (args) => ok(await tool.run(tool.inputSchema ? args : {}))
+    );
+  }
   return server2;
 }