mergestorm-mcp 0.2.27 → 0.2.28

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() };
+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: (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 };
+        }),
+    };
+}

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

@@ -3,6 +3,10 @@ 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",
 };
 function parseRepo(raw) {
     const match = typeof raw === "string" ? /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(raw.trim()) : null;
@@ -11,7 +15,13 @@ 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) {
     return `${entry.owner}/${entry.repo}: ${REPO_SETTINGS_KEYS.map((key) => `${ARG_BY_KEY[key]} ${words(entry[key])}`).join(" · ")}`;
@@ -22,6 +32,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-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-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.js

@@ -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-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-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,28 @@ 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 type HostedStackRepair = Omit<StackRepairHint, "steps" | "note">;
+export declare function hostedStackRepair(repair: StackRepairHint): HostedStackRepair;
+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 {};

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

@@ -1,6 +1,6 @@
 import { loadConfig, stackBlockersSummary, pollStackWatch, StackWatchError, StackWatchTimeoutError, stackWatchBackgroundCommand, stackWatchObligation, } from "mergestorm/client";
 import { z } from "zod";
-import { CHAT_WAKE_STACK_NOTE, registerChatWake } from "./chat-wake.js";
+import { chatTaskNote, trackInChat } from "./chat-task.js";
 export const stackWaitSchema = {
     stack_id: z.string().trim().min(1),
     timeout_s: z.number().finite().min(0).max(45).default(45),
@@ -18,15 +18,76 @@ export function repairSummary(repair) {
 export function withWatchText(watch, body) {
     return `${watch.message}\n\n${body}`;
 }
+const KEEP_EARLIER_CURSOR = "If you already hold a cursor from an earlier stack_wait on this stack, keep passing that cursor instead.";
+export 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}`,
+    };
+}
+export 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 `\nRepair #${repair.prNumber} (${repair.kind}).${files}${breeze}`;
+}
+export 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, terminal: null, cursor: envelope.cursor, 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} · ${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" ? " · assessment unavailable" : ""}`;
     if (envelopeWatch(envelope).done || (envelope.status !== "waiting" && envelope.status !== "in_progress"))
         return base;
@@ -36,7 +97,8 @@ function stackWaitStatusLine(envelope) {
         ...(envelope.cursor.afterFinishedAt !== undefined ? [`after_finished_at ${JSON.stringify(envelope.cursor.afterFinishedAt)}`] : []),
         ...(envelope.cursor.bounceId !== undefined ? [`bounce_id ${JSON.stringify(envelope.cursor.bounceId)}`] : []),
     ];
-    return `${base} · 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} · watch not finished: ${background}call stack_wait again with timeout_s 45 and the same cursor: ${selectors.join(", ")}`;
 }
 export async function stackWait(input, cfg, deps = {}) {
     const args = z.object(stackWaitSchema).parse(input);
@@ -61,7 +123,7 @@ export async function stackWait(input, cfg, deps = {}) {
         if (err instanceof StackWatchError) {
             const envelope = { ...err.lastEnvelope, watch: envelopeWatch(err.lastEnvelope) };
             return {
-                summary: stackWaitSummary(envelope),
+                summary: stackWaitSummary(envelope, deps.hosted),
                 data: {
                     ...envelope,
                     ...(err.retryAfterSeconds !== undefined ? { retry_after_seconds: err.retryAfterSeconds } : {}),
@@ -74,11 +136,11 @@ export async function stackWait(input, cfg, deps = {}) {
         envelope = err.lastEnvelope;
     }
     const sealed = { ...envelope, watch: envelopeWatch(envelope) };
-    const wake = deps.chatId && !sealed.watch.done
-        ? await registerChatWake(config, deps.chatId, { kind: "stack", stackId: sealed.stackId }, deps.signal)
+    const task = deps.chatId && !sealed.watch.done
+        ? await trackInChat(config, deps.chatId, { kind: "stack", stackId: sealed.stackId }, deps.signal)
         : null;
     return {
-        summary: wake ? `${stackWaitSummary(sealed)}\n\n${CHAT_WAKE_STACK_NOTE}` : stackWaitSummary(sealed),
-        data: wake ? { ...sealed, chat_wake: wake } : sealed,
+        summary: task ? `${stackWaitSummary(sealed, deps.hosted)}\n\n${chatTaskNote(task)}` : stackWaitSummary(sealed, deps.hosted),
+        data: task ? { ...sealed, background_task: task } : sealed,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm-mcp",
-  "version": "0.2.27",
+  "version": "0.2.28",
   "description": "Mergestorm MCP server — identity, review, and read-only stack tools over stdio",
   "license": "MIT",
   "type": "module",
@@ -23,6 +23,8 @@
   },
   "files": [
     "dist",
+    "!dist/.tsbuildinfo",
+    "!dist/.build-inputs",
     "README.md",
     "LICENSE"
   ],
@@ -37,7 +39,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "mergestorm": "0.3.63",
+    "mergestorm": "0.3.64",
     "zod": "^3.24.2"
   },
   "devDependencies": {

package/dist/lib/tools/chat-wake.d.ts

@@ -1,21 +0,0 @@
-import { type Config } from "mergestorm/client";
-export type ChatWakeTarget = {
-    kind: "vortex";
-    owner: string;
-    repo: string;
-    prNumber: number;
-    headSha: string | null;
-    minPass: number | null;
-} | {
-    kind: "stack";
-    stackId: string;
-};
-export declare function breezeChatId(value: string | null | undefined): string | null;
-export type ChatWake = {
-    id: string;
-    result: "waiting" | "existing" | "finished";
-};
-export declare const CHAT_WAKE_REVIEW_NOTE = "Keep waiting: call review_wait_pr again until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
-export declare const REVIEW_START_WAIT_NOTE = "Wait for it now: call review_wait_pr for this pull request until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
-export declare const CHAT_WAKE_STACK_NOTE = "If your reply ends before the stack is done, this chat is woken when the stack lands, is bounced out of the merge queue, or is archived.";
-export declare function registerChatWake(cfg: Config, chatId: string, target: ChatWakeTarget, signal?: AbortSignal): Promise<ChatWake | null>;

package/dist/lib/tools/chat-wake.js

@@ -1,26 +0,0 @@
-import { apiFetch } from "mergestorm/client";
-const CHAT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-export function breezeChatId(value) {
-    const trimmed = value?.trim() ?? "";
-    return CHAT_ID.test(trimmed) ? trimmed.toLowerCase() : null;
-}
-export const CHAT_WAKE_REVIEW_NOTE = "Keep waiting: call review_wait_pr again until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
-export const REVIEW_START_WAIT_NOTE = "Wait for it now: call review_wait_pr for this pull request until the review finishes, then tell the user its verdict and findings. If your reply ends first, this chat is woken with the review's result.";
-export const CHAT_WAKE_STACK_NOTE = "If your reply ends before the stack is done, this chat is woken when the stack lands, is bounced out of the merge queue, or is archived.";
-export async function registerChatWake(cfg, chatId, target, signal) {
-    const json = target.kind === "vortex"
-        ? { chat_id: chatId, kind: "vortex", owner: target.owner, repo: target.repo, pr_number: target.prNumber, head_sha: target.headSha, min_pass: target.headSha ? target.minPass : null }
-        : { chat_id: chatId, kind: "stack", stack_id: target.stackId };
-    try {
-        const response = await apiFetch(cfg, "/api/v1/stacks/chat-waits", { method: "POST", json, signal, timeoutMs: 10_000 });
-        const body = response.body;
-        if (response.status !== 200 || !body || typeof body.id !== "string")
-            return null;
-        if (body.result !== "waiting" && body.result !== "existing" && body.result !== "finished")
-            return null;
-        return { id: body.id, result: body.result };
-    }
-    catch {
-        return null;
-    }
-}