mergestorm-mcp 0.2.27 → 0.2.29

package/dist/lib/tools/cyclone-job.js

@@ -1,11 +1,11 @@
 import { agentRequest } from "./agent-request.js";
+import { chatTaskNote, chatTaskOf } from "./chat-task.js";
 export const CYCLONE_TASKS = ["fix_findings", "fix_ci", "resolve_conflicts", "build"];
 export const CYCLONE_JOB_WAIT_DEFAULT_S = 45;
 export const CYCLONE_JOB_WAIT_MAX_S = 100;
-export const CYCLONE_JOB_POLL_MS = 5_000;
-export const CYCLONE_JOB_TERMINAL_STATES = ["pushed", "completed", "failed"];
+const CYCLONE_JOB_POLL_MS = 5_000;
+const CYCLONE_JOB_TERMINAL_STATES = ["pushed", "completed", "failed"];
 export const 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.`;
-export const CHAT_WAKE_CYCLONE_NOTE = "If your reply ends before Cyclone finishes, this chat is woken with the job's result.";
 export const 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.`;
 export async function cycloneStart(input, cfg, chatId) {
     const payload = await agentRequest("/api/v1/agents/cyclone/jobs", {
@@ -22,9 +22,10 @@ export async function cycloneStart(input, cfg, chatId) {
     }, cfg);
     if (payload.isError || typeof payload.data.dispatch_id !== "string" || isCycloneJobTerminal(payload.data))
         return payload;
-    return { ...payload, summary: [payload.summary, CYCLONE_START_WAIT_NOTE, ...(payload.data.chat_wake ? [CHAT_WAKE_CYCLONE_NOTE] : [])].join(" ") };
+    const task = chatTaskOf(payload.data.background_task);
+    return { ...payload, summary: `${payload.summary} ${task ? chatTaskNote(task) : CYCLONE_START_WAIT_NOTE}` };
 }
-export function isCycloneJobTerminal(job) {
+function isCycloneJobTerminal(job) {
     return CYCLONE_JOB_TERMINAL_STATES.includes(job.state);
 }
 export function cycloneJobSummary(job) {

package/dist/lib/tools/issue-create.js

@@ -31,7 +31,7 @@ export async function issueCreate(input, cfg, deps = {}) {
         }
         const issue = await (deps.openStackIssue ?? openStackIssue)({ owner: target.owner, repo: target.repo, title, body: body ?? "", labels: labels ?? [] }, cfg);
         return {
-            summary: `${issue.created ? "Opened" : "Already open:"} ${target.owner}/${target.repo}#${issue.number} ${issue.url}. Put "Fixes #${issue.number}" in the commit or pull request body.`,
+            summary: `${issue.created ? "Opened" : "Already open:"} ${target.owner}/${target.repo}#${issue.number} ${issue.url}. Call issue_review_wait for #${issue.number} and open the pull request only once it is approved, with "Fixes #${issue.number}" in the commit or pull request body.`,
             data: { owner: target.owner, repo: target.repo, ...issue },
         };
     }

package/dist/lib/tools/issue-review-wait.d.ts

@@ -0,0 +1,37 @@
+import { getIssueReview, pollIssueReview, type Config, type IssueReviewStatus } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const ISSUE_REVIEW_WAIT_MAX_S = 45;
+export declare const issueReviewWaitSchema: {
+    owner: z.ZodString;
+    repo: z.ZodString;
+    number: z.ZodNumber;
+    timeout_s: z.ZodOptional<z.ZodNumber>;
+};
+declare const inputSchema: z.ZodObject<{
+    owner: z.ZodString;
+    repo: z.ZodString;
+    number: z.ZodNumber;
+    timeout_s: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    number: number;
+    owner: string;
+    repo: string;
+    timeout_s?: number | undefined;
+}, {
+    number: number;
+    owner: string;
+    repo: string;
+    timeout_s?: number | undefined;
+}>;
+export type IssueReviewWaitInput = z.infer<typeof inputSchema>;
+export type IssueReviewWaitDeps = {
+    getIssueReview?: typeof getIssueReview;
+    pollIssueReview?: typeof pollIssueReview;
+    pollIntervalMs?: number;
+};
+export declare function issueReviewSummary(status: IssueReviewStatus): string;
+export declare const ISSUE_NOT_APPROVED_HINT = "Do not open the pull request yet: answer the points in a comment on each issue, call issue_review_wait until it returns approved, then try again.";
+export declare function withIssueReviewHint(err: unknown, message: string): string;
+export declare function issueReviewWait(input: IssueReviewWaitInput, cfg?: Config, deps?: IssueReviewWaitDeps): Promise<ToolPayload>;
+export {};

package/dist/lib/tools/issue-review-wait.js

@@ -0,0 +1,57 @@
+import { CommandError, IssueReviewTimeoutError, getIssueReview, loadConfig, pollIssueReview, } from "mergestorm/client";
+import { z } from "zod";
+export const ISSUE_REVIEW_WAIT_MAX_S = 45;
+export const issueReviewWaitSchema = {
+    owner: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/),
+    repo: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/),
+    number: z.number().int().min(1),
+    timeout_s: z.number().min(0).max(ISSUE_REVIEW_WAIT_MAX_S).optional(),
+};
+const inputSchema = z.object(issueReviewWaitSchema);
+export function issueReviewSummary(status) {
+    const ref = `${status.owner}/${status.repo}#${status.number}`;
+    const round = status.round ? ` (round ${status.round} of ${status.maxRounds})` : "";
+    const head = status.state === "approved"
+        ? `${ref} is approved by ${status.approvedBy === "human" ? "a person" : "Vortex"}; you may open the pull request.`
+        : status.state === "off"
+            ? `Issue reviews are off for ${status.owner}/${status.repo}; ${ref} needs no approval.`
+            : status.state === "pending"
+                ? `${ref}: Vortex is still reviewing${round}; call issue_review_wait again.`
+                : `${ref}: ${status.state}${round}, ${status.points.length} point${status.points.length === 1 ? "" : "s"} to answer. Do not open the pull request yet.`;
+    return status.next ? `${head} ${status.next}` : head;
+}
+export const ISSUE_NOT_APPROVED_HINT = "Do not open the pull request yet: answer the points in a comment on each issue, call issue_review_wait until it returns approved, then try again.";
+export function withIssueReviewHint(err, message) {
+    return err instanceof CommandError && err.code === "issue_not_approved" ? `${message}\n${ISSUE_NOT_APPROVED_HINT}` : message;
+}
+function failure(code, message, extra = {}) {
+    return { summary: message, data: { error: { code, message, ...extra } }, isError: true };
+}
+export async function issueReviewWait(input, cfg, deps = {}) {
+    const parsed = inputSchema.safeParse(input);
+    if (!parsed.success) {
+        return failure("invalid_input", `issue_review_wait needs owner, repo, a positive issue number and timeout_s from 0 to ${ISSUE_REVIEW_WAIT_MAX_S}`);
+    }
+    const { owner, repo, number, timeout_s } = parsed.data;
+    const target = { owner, repo, number };
+    try {
+        const resolved = cfg ?? (await loadConfig());
+        const status = timeout_s === 0
+            ? await (deps.getIssueReview ?? getIssueReview)(resolved, target)
+            : await (deps.pollIssueReview ?? pollIssueReview)(resolved, target, {
+                timeoutMs: Math.max(1, Math.round((timeout_s ?? ISSUE_REVIEW_WAIT_MAX_S) * 1000)),
+                ...(deps.pollIntervalMs !== undefined ? { intervalMs: deps.pollIntervalMs } : {}),
+            });
+        if (!status) {
+            return failure("issue_review_unavailable", "This Mergestorm server does not review issues yet. Open the pull request as before.");
+        }
+        return { summary: issueReviewSummary(status), data: { ...status } };
+    }
+    catch (err) {
+        if (err instanceof IssueReviewTimeoutError) {
+            return { summary: issueReviewSummary(err.lastStatus), data: { ...err.lastStatus } };
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return failure(err instanceof CommandError ? err.code ?? "issue_review_wait_failed" : "issue_review_wait_failed", message, err instanceof CommandError && err.retryAfterSeconds !== undefined ? { retry_after_seconds: err.retryAfterSeconds } : {});
+    }
+}

package/dist/lib/tools/memory.d.ts

@@ -0,0 +1,70 @@
+import { MEMORY_KINDS, MEMORY_MODES, MEMORY_SCOPES, deleteMemory, getMemoryMode, listMemories, saveMemory, searchMemories, setMemoryMode, updateMemory, type Config, type MemoryItem } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const listMemoriesSchema: {
+    scope: z.ZodOptional<z.ZodEnum<["user", "repo"]>>;
+    repo: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<["rule", "style", "preference", "fact", "project"]>>;
+};
+export declare const searchMemorySchema: {
+    query: z.ZodString;
+    repo: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+};
+export declare const rememberSchema: {
+    text: z.ZodString;
+    kind: z.ZodEnum<["rule", "style", "preference", "fact", "project"]>;
+    repo: z.ZodOptional<z.ZodString>;
+    keep_both: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const updateMemorySchema: {
+    id: z.ZodString;
+    text: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<["rule", "style", "preference", "fact", "project"]>>;
+};
+export declare const forgetMemorySchema: {
+    id: z.ZodString;
+};
+export declare const setMemoryModeSchema: {
+    memory_mode: z.ZodEnum<["off", "on_request", "all"]>;
+};
+export type MemoryApi = {
+    listMemories: typeof listMemories;
+    searchMemories: typeof searchMemories;
+    saveMemory: typeof saveMemory;
+    updateMemory: typeof updateMemory;
+    deleteMemory: typeof deleteMemory;
+    getMemoryMode: typeof getMemoryMode;
+    setMemoryMode: typeof setMemoryMode;
+};
+export declare function memoryLine(memory: MemoryItem): string;
+export declare function createMemoryToolHandlers(cfg: Config | undefined, chatId: string | null, api?: MemoryApi): {
+    list: (input: {
+        scope?: (typeof MEMORY_SCOPES)[number];
+        repo?: string;
+        kind?: (typeof MEMORY_KINDS)[number];
+    }) => Promise<ToolPayload>;
+    search: (input: {
+        query: string;
+        repo?: string;
+        limit?: number;
+    }) => Promise<ToolPayload>;
+    remember: ({ keep_both, ...input }: {
+        text: string;
+        kind: (typeof MEMORY_KINDS)[number];
+        repo?: string;
+        keep_both?: boolean;
+    }) => Promise<ToolPayload>;
+    update: (input: {
+        id: string;
+        text: string;
+        kind?: (typeof MEMORY_KINDS)[number];
+    }) => Promise<ToolPayload>;
+    forget: (input: {
+        id: string;
+    }) => Promise<ToolPayload>;
+    getMode: () => Promise<ToolPayload>;
+    setMode: (input: {
+        memory_mode: (typeof MEMORY_MODES)[number];
+    }) => Promise<ToolPayload>;
+};

package/dist/lib/tools/memory.js

@@ -0,0 +1,74 @@
+import { CommandError, MEMORY_KINDS, MEMORY_MODES, MEMORY_SCOPES, MEMORY_SEARCH_LIMIT_MAX, deleteMemory, getMemoryMode, listMemories, saveMemory, searchMemories, setMemoryMode, updateMemory, } from "mergestorm/client";
+import { z } from "zod";
+const memoryId = z.string().uuid();
+const memoryText = z.string().trim().min(1).max(500);
+const repo = z.string().trim().min(3).max(200);
+export const listMemoriesSchema = {
+    scope: z.enum(MEMORY_SCOPES).optional(),
+    repo: repo.optional(),
+    kind: z.enum(MEMORY_KINDS).optional(),
+};
+export const searchMemorySchema = {
+    query: z.string().trim().min(1).max(2000),
+    repo: repo.optional(),
+    limit: z.number().int().min(1).max(MEMORY_SEARCH_LIMIT_MAX).optional(),
+};
+export const rememberSchema = { text: memoryText, kind: z.enum(MEMORY_KINDS), repo: repo.optional(), keep_both: z.boolean().optional() };
+export const updateMemorySchema = { id: memoryId, text: memoryText, kind: z.enum(MEMORY_KINDS).optional() };
+export const forgetMemorySchema = { id: memoryId };
+export const setMemoryModeSchema = { memory_mode: z.enum(MEMORY_MODES) };
+const liveApi = { listMemories, searchMemories, saveMemory, updateMemory, deleteMemory, getMemoryMode, setMemoryMode };
+export 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 CommandError ? err.code ?? "memory_failed" : "memory_failed";
+        return {
+            summary: message,
+            data: { error: { code, message, ...(err instanceof CommandError && err.retryAfterSeconds !== undefined ? { retry_after_seconds: err.retryAfterSeconds } : {}) } },
+            isError: true,
+        };
+    }
+}
+export 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: ({ keep_both, ...input }) => guarded(async () => {
+            const saved = await api.saveMemory({ ...input, chatId, ...(keep_both ? { keepBoth: true } : {}) }, cfg);
+            return { summary: saved.merged ? `Memory ${saved.id} already 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 };
+        }),
+    };
+}

package/dist/lib/tools/repo-settings.d.ts

@@ -1,6 +1,5 @@
-import { type Config, type RepoSettings, type RepoSettingsPatch } from "mergestorm/client";
+import { type Config, type RepoSettingsPatch } from "mergestorm/client";
 import type { ToolPayload } from "./types.js";
-export declare function repoSettingsSummary(entry: RepoSettings): string;
 export declare function repoSettingsPatchFromArgs(args: Record<string, unknown>): RepoSettingsPatch;
 export declare function repoSettingsGet(args: Record<string, unknown>, cfg?: Config): Promise<ToolPayload>;
 export declare function repoSettingsSet(args: Record<string, unknown>, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/repo-settings.js

@@ -3,6 +3,11 @@ const ARG_BY_KEY = {
     auto_patch_enabled: "auto_patch",
     auto_review_enabled: "auto_review",
     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",
+    issue_review_enabled: "issue_review",
 };
 function parseRepo(raw) {
     const match = typeof raw === "string" ? /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(raw.trim()) : null;
@@ -11,9 +16,15 @@ function parseRepo(raw) {
     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";
 }
-export function repoSettingsSummary(entry) {
+function repoSettingsSummary(entry) {
     return `${entry.owner}/${entry.repo}: ${REPO_SETTINGS_KEYS.map((key) => `${ARG_BY_KEY[key]} ${words(entry[key])}`).join(" · ")}`;
 }
 export function repoSettingsPatchFromArgs(args) {
@@ -22,6 +33,20 @@ export function repoSettingsPatchFromArgs(args) {
         const value = args[ARG_BY_KEY[key]];
         if (value === undefined)
             continue;
+        if (key === "merge_queue_batch_size") {
+            if (value !== null && (typeof value !== "number" || !Number.isInteger(value))) {
+                throw new CommandError(`${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 CommandError(`${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 CommandError(`${ARG_BY_KEY[key]} takes true, false, or null.`, 2, "usage");
         }

package/dist/lib/tools/review-dismiss.d.ts

@@ -1,4 +1,4 @@
-import { type Config, type PrFindingDismissResult } from "mergestorm/client";
+import { type Config } from "mergestorm/client";
 import type { ToolPayload } from "./types.js";
 export type ReviewDismissInput = {
     owner: string;
@@ -12,5 +12,4 @@ export type ReviewDismissInput = {
     evidence_url?: string;
     preview?: boolean;
 };
-export declare function reviewDismissSummary(result: PrFindingDismissResult): string;
 export declare function reviewDismiss(input: ReviewDismissInput, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/review-dismiss.js

@@ -3,7 +3,7 @@ import { withWatchText } from "./stack-wait.js";
 function findingText(finding) {
     return `${finding.finding_id} (${finding.path ?? "review body"}: ${finding.title})`;
 }
-export function reviewDismissSummary(result) {
+function reviewDismissSummary(result) {
     const pr = `${result.owner}/${result.repo}#${result.pr_number}`;
     const kind = result.review_kind === "seam" ? "seam review" : "Vortex review";
     const head = `${kind} ${result.review_id} at ${result.head_sha.slice(0, 7)}`;

package/dist/lib/tools/review-start.js

@@ -1,5 +1,5 @@
 import { agentRequest } from "./agent-request.js";
-import { REVIEW_START_WAIT_NOTE } from "./chat-wake.js";
+import { chatTaskNote, chatTaskOf } from "./chat-task.js";
 export async function reviewStartPr(input, cfg, chatId) {
     const payload = await agentRequest("/api/v1/agents/vortex/review", {
         method: "POST",
@@ -11,7 +11,8 @@ export async function reviewStartPr(input, cfg, chatId) {
             ...(chatId ? { chat_id: chatId } : {}),
         },
     }, cfg);
-    return payload.data.chat_wake ? { ...payload, summary: `${payload.summary} ${REVIEW_START_WAIT_NOTE}` } : payload;
+    const task = chatTaskOf(payload.data.background_task);
+    return task ? { ...payload, summary: `${payload.summary} ${chatTaskNote(task)}` } : payload;
 }
 export async function reviewStopPr(input, cfg) {
     return agentRequest("/api/v1/agents/vortex/stop", {

package/dist/lib/tools/review-submit.d.ts

@@ -8,13 +8,6 @@ export declare const MCP_WAIT_CEILING_S = 300;
  * slice. The skill loops until the review finishes.
  */
 export declare const MCP_PR_WAIT_DEFAULT_S = 45;
-export declare function assertPinnableSpecialists(specialists: string[] | undefined): void;
-/**
- * Host-configured root that agent-chosen `context_files` may not escape.
- * The `cwd` tool argument is agent-controlled, so it cannot serve as the
- * sandbox root; default to the MCP server's own working directory.
- */
-export declare function mcpSandboxRoot(): string;
 export type ReviewSubmitInput = {
     cwd?: string;
     base?: string;

package/dist/lib/tools/review-submit.js

@@ -21,7 +21,7 @@ const PINNABLE_SPECIALISTS = [
     "api",
     "frontend",
 ];
-export function assertPinnableSpecialists(specialists) {
+function assertPinnableSpecialists(specialists) {
     if (!specialists?.length)
         return;
     const unknown = specialists.filter((id) => !PINNABLE_SPECIALISTS.includes(id));
@@ -34,7 +34,7 @@ export function assertPinnableSpecialists(specialists) {
  * The `cwd` tool argument is agent-controlled, so it cannot serve as the
  * sandbox root; default to the MCP server's own working directory.
  */
-export function mcpSandboxRoot() {
+function mcpSandboxRoot() {
     return process.env.MERGESTORM_SANDBOX_ROOT?.trim() || process.cwd();
 }
 export function waitTimeoutMs(timeout_s, defaultSeconds = MCP_PR_WAIT_DEFAULT_S) {

package/dist/lib/tools/review-wait-pr.js

@@ -1,7 +1,7 @@
 import { PrReviewPollTimeoutError, loadConfig, noPrReviewYetMessage, pollPrVortexReview, } from "mergestorm/client";
 import { payloadFromPrRateLimit, payloadFromPrReview, prReviewSummary, prReviewTarget, reviewGetPr, } from "./review-get-pr.js";
 import { MCP_PR_WAIT_DEFAULT_S, waitTimeoutMs } from "./review-submit.js";
-import { CHAT_WAKE_REVIEW_NOTE, registerChatWake } from "./chat-wake.js";
+import { chatTaskNote, trackInChat } from "./chat-task.js";
 export async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, cfg, opts = {}) {
     const target = prReviewTarget(owner, repo, prNumber);
     const resolved = cfg ?? (await loadConfig());
@@ -39,22 +39,14 @@ export async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, c
                 finding_count: findingCount,
                 phase: err.lastEnvelope?.phase ?? null,
             });
-            const wakeHead = expectedSha || observedSha || null;
-            const wake = opts.chatId
-                ? await registerChatWake(resolved, opts.chatId, {
-                    kind: "vortex",
-                    owner: target.owner,
-                    repo: target.repo,
-                    prNumber: target.prNumber,
-                    headSha: wakeHead,
-                    minPass: opts.pass ?? (opts.afterPass !== undefined ? opts.afterPass + 1 : (headShaMatches || !expectedSha) && observedSha ? err.lastEnvelope?.pass ?? null : null),
-                })
+            const task = opts.chatId
+                ? await trackInChat(resolved, opts.chatId, { kind: "review", owner: target.owner, repo: target.repo, prNumber: target.prNumber })
                 : null;
             const shown = err.reviewSeen
                 ? summary
                 : `${summary} · ${noPrReviewYetMessage(target.owner, target.repo, target.prNumber, { afterSha, pass: opts.pass, afterPass: opts.afterPass })}`;
             return {
-                summary: wake ? `${shown} · ${CHAT_WAKE_REVIEW_NOTE}` : shown,
+                summary: task ? `${shown} · ${chatTaskNote(task)}` : shown,
                 data: {
                     status,
                     head_sha: err.lastEnvelope?.head_sha ?? null,
@@ -62,7 +54,7 @@ export async function reviewWaitPr(owner, repo, prNumber, afterSha, timeout_s, c
                     finding_count: findingCount,
                     phase: err.lastEnvelope?.phase ?? null,
                     error: err.message,
-                    ...(wake ? { chat_wake: wake } : {}),
+                    ...(task ? { background_task: task } : {}),
                 },
             };
         }

package/dist/lib/tools/settings-set.d.ts

@@ -1,11 +1,3 @@
-import { type Config, type SettingsPatch } from "mergestorm/client";
+import { type Config } from "mergestorm/client";
 import type { ToolPayload } from "./types.js";
-/** Read-only on `/api/v1/settings`; the API owns them, agents never write them. */
-export declare const SETTINGS_READ_ONLY_KEYS: readonly ["cyclone_connected", "github_connected"];
-/**
- * Build a PATCH body from raw tool args. Only the Bearer-writable allowlist
- * passes through; read-only keys and empty patches are usage errors so the
- * failure is the caller's wording, never a silent no-op.
- */
-export declare function settingsPatchFromArgs(args: Record<string, unknown>): SettingsPatch;
 export declare function settingsSet(args: Record<string, unknown>, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/settings-set.js

@@ -1,7 +1,7 @@
 import { CommandError, BEARER_SETTINGS, SETTINGS_WRITABLE_KEYS, patchSettings, } from "mergestorm/client";
 import { settingsSummary } from "./settings-get.js";
 /** Read-only on `/api/v1/settings`; the API owns them, agents never write them. */
-export const SETTINGS_READ_ONLY_KEYS = [
+const SETTINGS_READ_ONLY_KEYS = [
     "cyclone_connected",
     "github_connected",
 ];
@@ -10,7 +10,7 @@ export const SETTINGS_READ_ONLY_KEYS = [
  * passes through; read-only keys and empty patches are usage errors so the
  * failure is the caller's wording, never a silent no-op.
  */
-export function settingsPatchFromArgs(args) {
+function settingsPatchFromArgs(args) {
     for (const key of SETTINGS_READ_ONLY_KEYS) {
         if (args[key] !== undefined) {
             throw new CommandError(`${key} is read-only and cannot be set.`, 2, "usage");
@@ -34,8 +34,8 @@ export function settingsPatchFromArgs(args) {
             continue;
         }
         if ("kind" in row) {
-            const valid = row.kind === "logins"
-                ? Array.isArray(value) && value.every((login) => typeof login === "string")
+            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 CommandError(`Invalid value for ${key}.`, 2, "usage");

package/dist/lib/tools/stack-actions.js

@@ -1,5 +1,5 @@
 import { enqueueStack, loadConfig, restackStack, stackWatchObligation } from "mergestorm/client";
-import { CHAT_WAKE_STACK_NOTE, registerChatWake } from "./chat-wake.js";
+import { chatTaskNote, trackInChat } from "./chat-task.js";
 import { withWatchText } from "./stack-wait.js";
 export async function stackRestack(stackId, cfg) {
     const result = await restackStack(stackId, cfg);
@@ -13,10 +13,10 @@ export async function stackEnqueue(stackId, cfg, chatId) {
     const resolved = cfg ?? (await loadConfig());
     const result = await enqueueStack(stackId, resolved);
     const watch = stackWatchObligation({ stackId, terminal: null, unread: true, freshCursor: true });
-    const wake = chatId ? await registerChatWake(resolved, chatId, { kind: "stack", stackId }) : null;
+    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: wake ? `${summary} ${CHAT_WAKE_STACK_NOTE}` : summary,
-        data: { stack_id: stackId, result, watch, ...(wake ? { chat_wake: wake } : {}) },
+        summary: task ? `${summary} ${chatTaskNote(task)}` : summary,
+        data: { stack_id: stackId, result, watch, ...(task ? { background_task: task } : {}) },
     };
 }

package/dist/lib/tools/stack-adopt.js

@@ -2,6 +2,7 @@ import { adoptStack, CommandError, stackWatchObligation } from "mergestorm/clien
 import { z } from "zod";
 import { stackSetPatch } from "./stack-set.js";
 import { withWatchText } from "./stack-wait.js";
+import { withIssueReviewHint } from "./issue-review-wait.js";
 export const stackAdoptSchema = {
     owner: z.string().trim().min(1),
     repo: z.string().trim().min(1),
@@ -38,7 +39,7 @@ export async function stackAdopt(input, cfg) {
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return {
-            summary: message,
+            summary: withIssueReviewHint(err, message),
             data: {
                 error: {
                     code: err instanceof CommandError ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",

package/dist/lib/tools/stack-publish.d.ts

@@ -31,8 +31,8 @@ declare const publishInput: z.ZodObject<{
     repo: z.ZodOptional<z.ZodString>;
     branch: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    owner?: string | undefined;
     title?: string | undefined;
+    owner?: string | undefined;
     body?: string | undefined;
     repo?: string | undefined;
     cwd?: string | undefined;
@@ -42,8 +42,8 @@ declare const publishInput: z.ZodObject<{
     extend?: boolean | undefined;
     replace_head?: string | undefined;
 }, {
-    owner?: string | undefined;
     title?: string | undefined;
+    owner?: string | undefined;
     body?: string | undefined;
     repo?: string | undefined;
     cwd?: string | undefined;

package/dist/lib/tools/stack-publish.js

@@ -1,5 +1,6 @@
 import { CommandError, publishWorkingBranch, stackWatchObligation, workingBranchPublication, } from "mergestorm/client";
 import { z } from "zod";
+import { withIssueReviewHint } from "./issue-review-wait.js";
 import { withWatchText } from "./stack-wait.js";
 const target = {
     cwd: z.string().trim().min(1).optional(),
@@ -22,7 +23,7 @@ const statusInput = z.object(stackPublishStatusSchema);
 function failure(err, fallback) {
     const message = err instanceof Error ? err.message : String(err);
     return {
-        summary: message,
+        summary: withIssueReviewHint(err, message),
         data: {
             error: {
                 code: err instanceof CommandError ? err.code ?? fallback : fallback,

package/dist/lib/tools/stack-wait.d.ts

@@ -1,4 +1,4 @@
-import { pollStackWatch, type Config, type StackRepairHint, type StackWatchObligation } from "mergestorm/client";
+import { pollStackWatch, type Config, type StackRepairHint, type StackWatchObligation, type StackWatchNextArgs } from "mergestorm/client";
 import { z } from "zod";
 import type { ToolPayload } from "./types.js";
 export declare const stackWaitSchema: {
@@ -17,8 +17,26 @@ export type StackWaitInput = {
 };
 export declare function repairSummary(repair: StackRepairHint | null | undefined): string;
 export declare function withWatchText(watch: StackWatchObligation, body: string): string;
+export type HostedStackWatch = Omit<StackWatchObligation, "next"> & {
+    next: {
+        tool: "stack_wait";
+        args: StackWatchNextArgs;
+    } | null;
+};
+export declare function hostedStackWatch(watch: StackWatchObligation): HostedStackWatch;
+type McpTextResult = {
+    isError?: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent?: Record<string, unknown>;
+};
+export declare function hostedToolResult<T extends McpTextResult>(result: T): T;
 export declare function stackWait(input: StackWaitInput, cfg?: Config, deps?: {
     pollStackWatch?: typeof pollStackWatch;
     signal?: AbortSignal;
     chatId?: string;
+    hosted?: boolean;
 }): Promise<ToolPayload>;
+export {};