mergestorm 0.3.63 → 0.3.64

package/README.md

@@ -45,12 +45,12 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.63                                             │
+│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.64                                             │
 │ ▀▀▀▀▀▀▀▀▀     ● msk_live_… · maelstrom                                       │
 │  ▀▀▀▀▀▀       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used                      │
 │   ▝▀▀▀▀▀      local reviews + stacked PRs · mergestorm.ai                    │
 │     ▝▀▀▘      review a diff · usage for tabs · /help for all commands        │
-│       ▀       New in v0.3.63: Stack create starts a new stack unless --extend│
+│       ▀       New in v0.3.64: Memory commands and Overdrive merge batches    │
 ╰──────────────────────────────────────────────────────────────────────────────╯
 mergestorm
 ╭──────────────────────────────────────────────────────────────────────────────╮
@@ -113,7 +113,8 @@ mergestorm dismiss <owner/repo>#<n> --head <sha> --review <id> --finding <id> --
 - It prints nothing while the stack is `waiting` or `in_progress`, including while Cyclone or Vortex holds the blocked PR (`busy[]`, `actAfter: "agents_idle"`).
 - On attention it prints `MS-WATCH ATTENTION pr=<n> head=<sha> blocker="<blocker>" repair=<kind>` and exits 3. Attention names the lowest layer with a blocker an agent must fix, on any layer of the stack, not only the current candidate.
 - A confirmed landing prints `MS-WATCH LANDED stack=<id> reason=landed` and exits 0. `closed`, `archived` and `not_found` end the watch with `MS-WATCH ATTENTION stack=<id> reason=<reason>` and exit 3. A missing stack does not prove a landing; verify each PR before reporting it merged.
-- A failed read is retried once. If the retry fails too, it prints `MS-WATCH ATTENTION failed stack=<id> error="<message>"` and exits 3. A rate limit is waited out.
+- A permanent read error is retried once; if the retry fails too, it prints `MS-WATCH ATTENTION failed stack=<id> error="<message>"` and exits 3. Timeouts, 5xx and rate limits are retried, but after 15 minutes with no stack read it prints the same line and exits 3.
+- A watch that cannot start (bad flags, a config it cannot read, a crash) prints `MS-WATCH ATTENTION failed` too, so the command never exits without an `MS-WATCH` line unless you stop it (Ctrl+C or an abort, exit 130). Pass each flag as its own word: in zsh an unquoted `$args` holding several flags stays one word and the command refuses it.
 - `--head <sha>` enrolls the SHA you just pushed. After fixing a blocker, restart the watcher with it.
 - `--ignore <text>` keeps it silent on the first attention whose blocker contains that text (case-insensitive), until the blocker, its PR or its head changes. Use it for a blocker a human has taken over. Repeat the flag for more than one.
 - `--until landed` keeps running after an attention, printing each new attention once, and exits only when the watch is done or reads keep failing.

package/dist/api.d.ts

@@ -182,13 +182,18 @@ export type SettingsResponse = import("./automation-catalog.js").BearerSettingsV
     github_connected: boolean;
     stacks_ready?: boolean;
 };
-export declare const REPO_SETTINGS_KEYS: readonly ["auto_patch_enabled", "auto_review_enabled", "auto_land_default"];
+export declare const REPO_SETTINGS_SWITCH_KEYS: readonly ["auto_patch_enabled", "auto_review_enabled", "auto_land_default", "merge_queue_batch_enabled", "merge_queue_overdrive"];
+export declare const REPO_SETTINGS_KEYS: readonly ["auto_patch_enabled", "auto_review_enabled", "auto_land_default", "merge_queue_batch_enabled", "merge_queue_overdrive", "merge_queue_batch_size", "merge_queue_lands_alone_paths"];
 export type RepoSettingsKey = (typeof REPO_SETTINGS_KEYS)[number];
+export type RepoSettingsValues = Record<(typeof REPO_SETTINGS_SWITCH_KEYS)[number], boolean | null> & {
+    merge_queue_batch_size: number | null;
+    merge_queue_lands_alone_paths: string[] | null;
+};
 export type RepoSettings = {
     owner: string;
     repo: string;
-} & Record<RepoSettingsKey, boolean | null>;
-export type RepoSettingsPatch = Partial<Record<RepoSettingsKey, boolean | null>>;
+} & RepoSettingsValues;
+export type RepoSettingsPatch = Partial<RepoSettingsValues>;
 export declare function listRepoSettings(cfg?: Config, opts?: {
     timeoutMs?: number;
 }): Promise<RepoSettings[]>;

package/dist/api.js

@@ -1,4 +1,4 @@
-import { apiBase, loadConfig, resolveApiKey } from "./config.js";
+import { apiBase, loadConfig, resolveApiKey, resolveChatId } from "./config.js";
 import { BEARER_SETTINGS_KEYS as SETTINGS_WRITABLE_KEYS, } from "./automation-catalog.js";
 import { CommandError, REVIEW_EXIT, rateLimitedMessage, plainServerText, } from "./errors.js";
 /** Default per-request timeout so a hung API cannot stall the shell/CI forever. */
@@ -84,8 +84,10 @@ export async function apiFetch(cfg, route, init = {}) {
         throw new CommandError("No API key. Run `mergestorm login` (agents: `mergestorm login --start`, then `--finish`) or set MERGESTORM_API_KEY.", 1, "missing_api_key");
     }
     const { json, timeoutMs = DEFAULT_API_TIMEOUT_MS, signal: userSignal, ...rest } = init;
+    const chatId = resolveChatId(cfg);
     const headers = {
         Authorization: `Bearer ${key}`,
+        ...(chatId ? { "x-mergestorm-chat-id": chatId } : {}),
         ...rest.headers,
     };
     let body = rest.body;
@@ -172,7 +174,14 @@ export function applyPrReviewQuery(query, opts) {
  * The connected flags are read-only there and deliberately absent here.
  */
 export { SETTINGS_WRITABLE_KEYS };
-export const REPO_SETTINGS_KEYS = ["auto_patch_enabled", "auto_review_enabled", "auto_land_default"];
+export const REPO_SETTINGS_SWITCH_KEYS = [
+    "auto_patch_enabled",
+    "auto_review_enabled",
+    "auto_land_default",
+    "merge_queue_batch_enabled",
+    "merge_queue_overdrive",
+];
+export const REPO_SETTINGS_KEYS = [...REPO_SETTINGS_SWITCH_KEYS, "merge_queue_batch_size", "merge_queue_lands_alone_paths"];
 function repoSettingsFailure(status, body, retryAfterSeconds, action) {
     if (status === 429) {
         return new CommandError(rateLimitedMessage(retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", {

package/dist/automation-catalog.d.ts

@@ -63,7 +63,17 @@ export declare const BEARER_SETTINGS: readonly [{
     readonly label: "Merge queue batch size (pull requests)";
     readonly kind: "count";
     readonly min: 2;
-    readonly max: 8;
+    readonly max: 10;
+}, {
+    readonly key: "merge_queue_lands_alone_paths";
+    readonly flag: "--merge-queue-lands-alone";
+    readonly label: "Merge queue lands-alone paths";
+    readonly kind: "paths";
+    readonly defaults: readonly ["**/migrations/**", "db/migrate/**", ".github/workflows/**"];
+}, {
+    readonly key: "merge_queue_overdrive";
+    readonly flag: "--merge-queue-overdrive";
+    readonly label: "Merge queue overdrive (up to 10 per batch)";
 }, {
     readonly key: "ignored_bot_logins";
     readonly flag: "--ignore-bot";
@@ -95,11 +105,11 @@ export declare const BEARER_SETTINGS_LABELS: Record<BearerSettingsKey, string>;
 /** Omitted kind means boolean for the original toggle rows. */
 export type BearerSettingsValues = {
     [Row in (typeof BEARER_SETTINGS)[number] as Row["key"]]: Row extends {
-        kind: "logins";
+        kind: "logins" | "paths";
     } ? string[] : Row extends {
         kind: "seconds" | "count";
     } ? number : Row extends {
         values: readonly (infer Value)[];
     } ? Value : boolean;
 };
-export declare const BEARER_BOOLEAN_SETTINGS_KEYS: ("auto_review_enabled" | "auto_patch_enabled" | "auto_resolve_conflicts_enabled" | "auto_fix_ci_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check")[];
+export declare const BEARER_BOOLEAN_SETTINGS_KEYS: ("auto_review_enabled" | "auto_patch_enabled" | "auto_resolve_conflicts_enabled" | "auto_fix_ci_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "merge_queue_lands_alone_paths" | "merge_queue_overdrive" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check")[];

package/dist/automation-catalog.js

@@ -13,7 +13,9 @@ export const BEARER_SETTINGS = [
     { key: "auto_land_default", flag: "--auto-land", label: "Auto land (new stacks)" },
     { key: "auto_land_settle_seconds", flag: "--auto-land-settle", label: "Auto land settle (seconds)", kind: "seconds", min: 15, max: 300 },
     { key: "merge_queue_batch_enabled", flag: "--merge-queue-batch", label: "Merge queue batching" },
-    { key: "merge_queue_batch_size", flag: "--merge-queue-batch-size", label: "Merge queue batch size (pull requests)", kind: "count", min: 2, max: 8 },
+    { key: "merge_queue_batch_size", flag: "--merge-queue-batch-size", label: "Merge queue batch size (pull requests)", kind: "count", min: 2, max: 10 },
+    { key: "merge_queue_lands_alone_paths", flag: "--merge-queue-lands-alone", label: "Merge queue lands-alone paths", kind: "paths", defaults: ["**/migrations/**", "db/migrate/**", ".github/workflows/**"] },
+    { key: "merge_queue_overdrive", flag: "--merge-queue-overdrive", label: "Merge queue overdrive (up to 10 per batch)" },
     { key: "ignored_bot_logins", flag: "--ignore-bot", label: "Ignored bot logins", kind: "logins" },
     { key: "vortex_bot_skip_check", flag: "--vortex-skip-check", label: "Vortex bot skip check", kind: "enum", values: ["none", "neutral"] },
     { key: "vortex_findings_check", flag: "--vortex-findings", label: "Vortex findings check", kind: "enum", values: ["failure", "neutral", "success"] },

package/dist/client/index.d.ts

@@ -8,6 +8,7 @@ export { discoverTrunk } from "../git-stack.js";
 export { parseGithubOriginRepo } from "../git.js";
 export { BOUNCE_KIND_LABELS, deriveStackAgentsBusy, mergeQueueBounceLabel, type StackAgentsBusy } from "../stack-dto.js";
 export { STACK_WATCH_SCHEMA, STACK_WATCH_DEFAULT_TIMEOUT_MS, STACK_WATCH_BUSY_RECHECK_S, StackWatchError, StackWatchTimeoutError, pollStackWatch, type PollStackWatchOptions, type StackWatchCursor, type StackWatchEnvelope, } from "../stack-watch.js";
-export { stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, conflictLiveParent, stackRepair, agentsCannotClear, autoFixCiActive, autoResolveActive, type StackAgentBusy, type StackBlocker, type StackBusyAgent, type StackHeldBlocker, type StackLandGatePending, type StackLayerAgents, type StackRepairHint, } from "../stack-blockers.js";
+export { BREEZE_BRANCH_PREFIX, stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, conflictLiveParent, stackRepair, agentsCannotClear, autoFixCiActive, autoResolveActive, type StackAgentBusy, type StackBlocker, type StackBusyAgent, type StackHeldBlocker, type StackLandGatePending, type StackLayerAgents, type StackRepairHint, } from "../stack-blockers.js";
 export { STACK_WATCH_NOT_DONE_SENTENCE, STACK_WATCH_NOTIFY_PATTERN, stackWatchBackgroundCommand, stackTerminalReason, stackWatchNextArgs, stackWatchObligation, type StackWatchDoneReason, type StackWatchNext, type StackWatchNextArgs, type StackWatchObligation, type StackWatchObligationInput, type StackWatchReason, } from "../stack-watch-obligation.js";
-export { publishBranchServerSide, publishWorkingBranch, workingBranchPublication, type ServerPublishResult, type WorkingBranchInput, } from "../server-publish.js";
+export { READ_ONLY_GIT, publishBranchServerSide, publishWorkingBranch, workingBranchPublication, type GitRead, type ServerPublishDeps, type ServerPublishInput, type ServerPublishResult, type WorkingBranchInput, } from "../server-publish.js";
+export { MEMORY_KINDS, MEMORY_MODES, MEMORY_SCOPES, MEMORY_SEARCH_LIMIT_MAX, deleteMemory, getMemoryMode, listMemories, memoryChatId, saveMemory, searchMemories, setMemoryMode, updateMemory, type MemoryItem, type MemoryKind, type MemoryList, type MemoryMode, type MemoryScope, type MemorySearch, } from "../memory-api.js";

package/dist/client/index.js

@@ -8,6 +8,7 @@ export { discoverTrunk } from "../git-stack.js";
 export { parseGithubOriginRepo } from "../git.js";
 export { BOUNCE_KIND_LABELS, deriveStackAgentsBusy, mergeQueueBounceLabel } from "../stack-dto.js";
 export { STACK_WATCH_SCHEMA, STACK_WATCH_DEFAULT_TIMEOUT_MS, STACK_WATCH_BUSY_RECHECK_S, StackWatchError, StackWatchTimeoutError, pollStackWatch, } from "../stack-watch.js";
-export { stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, conflictLiveParent, stackRepair, agentsCannotClear, autoFixCiActive, autoResolveActive, } from "../stack-blockers.js";
+export { BREEZE_BRANCH_PREFIX, stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, conflictLiveParent, stackRepair, agentsCannotClear, autoFixCiActive, autoResolveActive, } from "../stack-blockers.js";
 export { STACK_WATCH_NOT_DONE_SENTENCE, STACK_WATCH_NOTIFY_PATTERN, stackWatchBackgroundCommand, stackTerminalReason, stackWatchNextArgs, stackWatchObligation, } from "../stack-watch-obligation.js";
-export { publishBranchServerSide, publishWorkingBranch, workingBranchPublication, } from "../server-publish.js";
+export { READ_ONLY_GIT, publishBranchServerSide, publishWorkingBranch, workingBranchPublication, } from "../server-publish.js";
+export { MEMORY_KINDS, MEMORY_MODES, MEMORY_SCOPES, MEMORY_SEARCH_LIMIT_MAX, deleteMemory, getMemoryMode, listMemories, memoryChatId, saveMemory, searchMemories, setMemoryMode, updateMemory, } from "../memory-api.js";

package/dist/commands/browse.d.ts

@@ -27,7 +27,7 @@ export declare function buildStatusTabLines(input: StatusTabInput): string[];
 /** In-place job detail for the Jobs tab (same envelope as `status <id>`). */
 export declare function formatJobDetailLines(row: ReviewJobRow): string[];
 /** Human labels for the Config tab and the static `settings` printout. */
-export declare const SETTINGS_LABELS: Record<"auto_review_enabled" | "auto_patch_enabled" | "auto_resolve_conflicts_enabled" | "auto_fix_ci_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check", string>;
+export declare const SETTINGS_LABELS: Record<"auto_review_enabled" | "auto_patch_enabled" | "auto_resolve_conflicts_enabled" | "auto_fix_ci_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "merge_queue_lands_alone_paths" | "merge_queue_overdrive" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check", string>;
 export declare const STACKS_READY_LABEL = "Stacks, merge queue, Auto land";
 export declare const STACKS_READY_WORDS: {
     readonly on: "ready";

package/dist/commands/memory.d.ts

@@ -0,0 +1,30 @@
+import { type Config } from "../config.js";
+import { deleteMemory, getMemoryMode, listMemories, saveMemory, searchMemories, setMemoryMode, updateMemory, type MemoryItem, type MemoryKind, type MemoryScope } from "../memory-api.js";
+export declare const MEMORY_USAGE: string;
+export declare const MEMORY_SUBCOMMANDS: readonly ["list", "search", "add", "update", "delete", "mode"];
+type Flags = {
+    positional: string[];
+    json: boolean;
+    repo?: string;
+    kind?: MemoryKind;
+    scope?: MemoryScope;
+    limit?: number;
+};
+export declare function parseMemoryFlags(args: string[], allowed: ReadonlyArray<"repo" | "kind" | "scope" | "limit">): Flags;
+export declare function formatMemoryLine(memory: MemoryItem): string;
+export type MemoryDeps = {
+    loadConfig?: () => Promise<Config>;
+    chatId?: string | null;
+    print?: (line: string) => void;
+    api?: Partial<{
+        listMemories: typeof listMemories;
+        searchMemories: typeof searchMemories;
+        saveMemory: typeof saveMemory;
+        updateMemory: typeof updateMemory;
+        deleteMemory: typeof deleteMemory;
+        getMemoryMode: typeof getMemoryMode;
+        setMemoryMode: typeof setMemoryMode;
+    }>;
+};
+export declare function cmdMemory(args: string[], deps?: MemoryDeps): Promise<void>;
+export {};

package/dist/commands/memory.js

@@ -0,0 +1,152 @@
+import { loadConfig } from "../config.js";
+import { CommandError, REVIEW_EXIT } from "../errors.js";
+import { MEMORY_KINDS, MEMORY_SEARCH_LIMIT_MAX, deleteMemory, getMemoryMode, isMemoryKind, isMemoryMode, isMemoryScope, listMemories, memoryChatId, saveMemory, searchMemories, setMemoryMode, updateMemory, } from "../memory-api.js";
+export const MEMORY_USAGE = [
+    "usage: mergestorm memory list [--scope user|repo] [--repo <owner/repo>] [--kind <kind>] [--json]",
+    "       mergestorm memory search <query> [--repo <owner/repo>] [--limit <1-20>] [--json]",
+    "       mergestorm memory add <text> --kind <kind> [--repo <owner/repo>] [--json]",
+    "       mergestorm memory update <id> <text> [--kind <kind>] [--json]",
+    "       mergestorm memory delete <id> [--json]",
+    "       mergestorm memory mode [off|on_request|all] [--json]",
+    `  kind is one of ${MEMORY_KINDS.join(", ")}. With --repo a memory is about that repository, otherwise about you.`,
+    "  search covers your memories, and with --repo that repository's memories and standing rules too.",
+    "  Inside a Breeze chat (MERGESTORM_CHAT_ID), add and search follow that chat's memory setting.",
+].join("\n");
+export const MEMORY_SUBCOMMANDS = ["list", "search", "add", "update", "delete", "mode"];
+const REPO = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9._-]{1,100}$/;
+function usage(message) {
+    return new CommandError(message ? `${message}\n${MEMORY_USAGE}` : MEMORY_USAGE, REVIEW_EXIT.usage, "usage");
+}
+export function parseMemoryFlags(args, allowed) {
+    const flags = { positional: [], json: false };
+    const value = (flag, raw) => {
+        if (raw === undefined || raw.startsWith("--"))
+            throw usage(`${flag} needs a value`);
+        return raw.trim();
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const name = arg.startsWith("--") ? arg.slice(2) : null;
+        if (arg === "--json")
+            flags.json = true;
+        else if (name === "repo" && allowed.includes("repo")) {
+            const repo = value(arg, args[++i]).replace(/^https?:\/\/github\.com\//i, "").replace(/\.git$/i, "");
+            if (!REPO.test(repo))
+                throw usage("--repo needs <owner/repo>");
+            flags.repo = repo.toLowerCase();
+        }
+        else if (name === "kind" && allowed.includes("kind")) {
+            const kind = value(arg, args[++i]);
+            if (!isMemoryKind(kind))
+                throw usage(`--kind is one of ${MEMORY_KINDS.join(", ")}`);
+            flags.kind = kind;
+        }
+        else if (name === "scope" && allowed.includes("scope")) {
+            const scope = value(arg, args[++i]);
+            if (!isMemoryScope(scope))
+                throw usage("--scope is user or repo");
+            flags.scope = scope;
+        }
+        else if (name === "limit" && allowed.includes("limit")) {
+            const limit = Number(value(arg, args[++i]));
+            if (!Number.isInteger(limit) || limit < 1 || limit > MEMORY_SEARCH_LIMIT_MAX)
+                throw usage(`--limit is a whole number from 1 to ${MEMORY_SEARCH_LIMIT_MAX}`);
+            flags.limit = limit;
+        }
+        else if (arg.startsWith("--"))
+            throw usage(`unknown argument ${arg}`);
+        else
+            flags.positional.push(arg);
+    }
+    return flags;
+}
+export function formatMemoryLine(memory) {
+    const where = memory.repo ? `${memory.kind}, ${memory.repo}` : memory.kind;
+    return `${memory.id}  (${where}) ${memory.text}`;
+}
+export async function cmdMemory(args, deps = {}) {
+    const print = deps.print ?? ((line) => console.log(line));
+    const api = { listMemories, searchMemories, saveMemory, updateMemory, deleteMemory, getMemoryMode, setMemoryMode, ...deps.api };
+    const sub = args[0]?.toLowerCase();
+    const rest = args.slice(1);
+    if (!sub || sub === "-h" || sub === "--help" || sub === "help" || rest.some((arg) => arg === "-h" || arg === "--help")) {
+        print(MEMORY_USAGE);
+        return;
+    }
+    const config = () => (deps.loadConfig ?? loadConfig)();
+    const chatId = deps.chatId === undefined ? memoryChatId() : deps.chatId;
+    const emit = (json, data, lines) => {
+        if (json)
+            print(JSON.stringify(data, null, 2));
+        else
+            for (const line of lines())
+                print(line);
+    };
+    if (sub === "list" || sub === "ls") {
+        const flags = parseMemoryFlags(rest, ["repo", "kind", "scope"]);
+        if (flags.positional.length > 0)
+            throw usage(`unexpected argument ${flags.positional[0]}`);
+        const listed = await api.listMemories({ ...(flags.scope ? { scope: flags.scope } : {}), ...(flags.repo ? { repo: flags.repo } : {}), ...(flags.kind ? { kind: flags.kind } : {}) }, await config());
+        emit(flags.json, listed, () => [
+            `Memory is ${listed.memory_mode}. ${listed.items.length === 1 ? "1 memory" : `${listed.items.length} memories`}.`,
+            ...listed.items.map(formatMemoryLine),
+        ]);
+        return;
+    }
+    if (sub === "search") {
+        const flags = parseMemoryFlags(rest, ["repo", "limit"]);
+        const query = flags.positional.join(" ").trim();
+        if (!query)
+            throw usage("search needs a query");
+        const found = await api.searchMemories({ query, ...(flags.repo ? { repo: flags.repo } : {}), ...(flags.limit ? { limit: flags.limit } : {}), chatId }, await config());
+        emit(flags.json, found, () => {
+            if (found.memory_mode === "off")
+                return ["Memory is off, so nothing was searched."];
+            const all = [...found.rules, ...found.items];
+            return all.length === 0 ? ["Nothing in memory matches."] : all.map(formatMemoryLine);
+        });
+        return;
+    }
+    if (sub === "add" || sub === "save" || sub === "remember") {
+        const flags = parseMemoryFlags(rest, ["repo", "kind"]);
+        const text = flags.positional.join(" ").trim();
+        if (!text)
+            throw usage("add needs the text to remember");
+        if (!flags.kind)
+            throw usage(`add needs --kind (${MEMORY_KINDS.join(", ")})`);
+        const saved = await api.saveMemory({ text, kind: flags.kind, ...(flags.repo ? { repo: flags.repo } : {}), chatId }, await config());
+        emit(flags.json, saved, () => [saved.merged ? `That matched memory ${saved.id}, which now says this.` : `Saved to memory as ${saved.id}.`]);
+        return;
+    }
+    if (sub === "update" || sub === "edit") {
+        const flags = parseMemoryFlags(rest, ["kind"]);
+        const [id, ...words] = flags.positional;
+        const text = words.join(" ").trim();
+        if (!id || !text)
+            throw usage("update needs a memory id and the new text");
+        const updated = await api.updateMemory(id, { text, ...(flags.kind ? { kind: flags.kind } : {}) }, await config());
+        emit(flags.json, updated, () => [`Memory ${updated.id} updated.`]);
+        return;
+    }
+    if (sub === "delete" || sub === "rm" || sub === "forget") {
+        const flags = parseMemoryFlags(rest, []);
+        const [id, extra] = flags.positional;
+        if (!id || extra !== undefined)
+            throw usage("delete needs one memory id");
+        const deleted = await api.deleteMemory(id, await config());
+        emit(flags.json, deleted, () => [`Memory ${deleted.id} deleted.`]);
+        return;
+    }
+    if (sub === "mode") {
+        const flags = parseMemoryFlags(rest, []);
+        const [mode, extra] = flags.positional;
+        if (extra !== undefined)
+            throw usage(`unexpected argument ${extra}`);
+        if (mode !== undefined && !isMemoryMode(mode))
+            throw usage("mode is off, on_request or all");
+        const result = mode === undefined ? await api.getMemoryMode(await config()) : await api.setMemoryMode(mode, await config());
+        emit(flags.json, result, () => [`Memory is ${result.memory_mode}.`]);
+        return;
+    }
+    throw usage(`unknown memory subcommand: ${sub}`);
+}

package/dist/commands/registry.js

@@ -8,6 +8,7 @@ import { cmdIssue } from "./issue.js";
 import { cmdJobs, cmdThread } from "./jobs.js";
 import { cmdLogin } from "./login.js";
 import { cmdLogout } from "./logout.js";
+import { cmdMemory } from "./memory.js";
 import { cmdQueue } from "./queue.js";
 import { cmdPr } from "./pr.js";
 import { cmdReview } from "./review.js";
@@ -203,7 +204,8 @@ export const COMMAND_REGISTRY = [
             "  [--auto-land on|off]  Auto land default for new stacks",
             "  [--auto-land-settle <seconds>]  How long Auto land waits before queueing (15-300, default 60)",
             "  [--merge-queue-batch on|off]  Test several queued pull requests on one CI run",
-            "  [--merge-queue-batch-size <n>]  Most pull requests per batch (2-8, default 4)",
+            "  [--merge-queue-batch-size <n>]  Most pull requests per batch (2-10, default 4)",
+            "  [--merge-queue-overdrive on|off]  Account default: batch up to 10 queued pull requests; --repo overrides it per repository",
             "  [--ignore-bot add <login>|remove <login>|clear]",
             "  [--vortex-skip-check none|neutral] [--vortex-findings failure|neutral|success]",
             "  [--cyclone-fail-check failure|neutral]",
@@ -217,6 +219,21 @@ export const COMMAND_REGISTRY = [
             await cmdSettings(args, { mode: ctx.mode });
         },
     },
+    {
+        name: "memory",
+        summary: "Your memories: list, search, add, update, delete, mode",
+        usage: [
+            "mergestorm memory list [--scope user|repo] [--repo <owner/repo>] [--kind <kind>] [--json]",
+            "mergestorm memory search <query> [--repo <owner/repo>] [--limit <1-20>] [--json]",
+            "mergestorm memory add <text> --kind rule|style|preference|fact|project [--repo <owner/repo>] [--json]",
+            "mergestorm memory update <id> <text> [--kind <kind>] [--json]",
+            "mergestorm memory delete <id> [--json]",
+            "mergestorm memory mode [off|on_request|all] [--json]  Read or set whether Breeze remembers",
+        ],
+        async run(args) {
+            await cmdMemory(args);
+        },
+    },
     {
         name: "skill",
         summary: "Install Mergestorm skills for Claude, Cursor, or agents",

package/dist/commands/settings.d.ts

@@ -3,7 +3,7 @@ import { type RepoSettings, type RepoSettingsPatch, type SettingsPatch, type Set
  * CLI flag → Bearer settings key. Boolean flags take on|off. The connected flags are
  * read-only on the API and deliberately have no flag here.
  */
-export declare const SETTINGS_FLAGS: Record<string, "auto_review_enabled" | "auto_patch_enabled" | "auto_resolve_conflicts_enabled" | "auto_fix_ci_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check">;
+export declare const SETTINGS_FLAGS: Record<string, "auto_review_enabled" | "auto_patch_enabled" | "auto_resolve_conflicts_enabled" | "auto_fix_ci_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "merge_queue_lands_alone_paths" | "merge_queue_overdrive" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check">;
 type IgnoreBotOperation = {
     action: "add" | "remove";
     login: string;
@@ -22,6 +22,7 @@ export type SettingsArgs = {
     repo?: RepoSettingsScope;
     listRepos?: boolean;
 };
+export declare function parsePathsFlagValue(flag: string, value: string | undefined, defaults: readonly string[]): string[];
 export declare function formatRepoSettingsLines(repos: readonly RepoSettings[]): string[];
 /** Parse boolean and enum flags plus ordered ignore-list operations. */
 export declare function parseSettingsArgs(rawArgs: string[]): SettingsArgs;

package/dist/commands/settings.js

@@ -14,7 +14,25 @@ const REPO_FLAG_LABELS = {
     auto_patch_enabled: "Auto patch",
     auto_review_enabled: "Auto review",
     auto_land_default: "Auto land (new stacks)",
+    merge_queue_batch_enabled: "Merge queue batching",
+    merge_queue_batch_size: "Merge queue batch size (pull requests)",
+    merge_queue_lands_alone_paths: "Merge queue lands-alone paths",
+    merge_queue_overdrive: "Merge queue overdrive",
 };
+export function parsePathsFlagValue(flag, value, defaults) {
+    if (value === undefined || value === "" || value.startsWith("--")) {
+        throw new CommandError(`${flag} takes a comma-separated list of path patterns, default, or none.`, 2, "usage");
+    }
+    if (value === "default")
+        return [...defaults];
+    if (value === "none")
+        return [];
+    const paths = [...new Set(value.split(",").map((entry) => entry.trim()).filter((entry) => entry !== ""))];
+    if (paths.length === 0 || paths.some((entry) => /\s/.test(entry))) {
+        throw new CommandError(`${flag} takes a comma-separated list of path patterns, default, or none.`, 2, "usage");
+    }
+    return paths;
+}
 function parseRepoSlug(raw) {
     const match = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(raw ?? "");
     if (!match)
@@ -61,18 +79,41 @@ function parseRepoSettingsArgs(slug, args) {
             throw new CommandError(`Unknown settings flag: ${flag}. See \`mergestorm --help\`.`, 2, "usage");
         }
         if (!REPO_SETTINGS_KEYS.includes(key)) {
-            throw new CommandError(`${flag} is an account setting. With --repo only --auto-patch, --auto-review and --auto-land can be set.`, 2, "usage");
+            throw new CommandError(`${flag} is an account setting. With --repo only --auto-patch, --auto-review, --auto-land, --merge-queue-batch, --merge-queue-batch-size, --merge-queue-lands-alone and --merge-queue-overdrive can be set.`, 2, "usage");
         }
         const value = eq >= 0 ? arg.slice(eq + 1) : args[++i];
-        if (value !== "on" && value !== "off" && value !== "inherit") {
+        const row = BEARER_SETTINGS.find((row) => row.key === key);
+        if (value === "inherit") {
+            scope.patch[key] = null;
+            continue;
+        }
+        if ("kind" in row && row.kind === "count") {
+            const amount = value !== undefined && /^\d+$/.test(value) ? Number(value) : Number.NaN;
+            if (!Number.isInteger(amount) || amount < row.min || amount > row.max) {
+                throw new CommandError(`${flag} takes a whole number from ${row.min} through ${row.max}, or inherit, with --repo.`, 2, "usage");
+            }
+            scope.patch.merge_queue_batch_size = amount;
+            continue;
+        }
+        if ("kind" in row && row.kind === "paths") {
+            scope.patch.merge_queue_lands_alone_paths = parsePathsFlagValue(flag, value, row.defaults);
+            continue;
+        }
+        if (value !== "on" && value !== "off") {
             throw new CommandError(`${flag} takes on, off or inherit with --repo.`, 2, "usage");
         }
-        scope.patch[key] = value === "inherit" ? null : value === "on";
+        scope.patch[key] = value === "on";
     }
     return { json, patch: {}, repo: scope };
 }
 function repoSettingWords(value) {
-    return value === null ? "inherit (follows the account)" : value ? "on" : "off";
+    if (value === null)
+        return "inherit (follows the account)";
+    if (Array.isArray(value))
+        return value.length === 0 ? "(none)" : value.join(", ");
+    if (typeof value === "number")
+        return String(value);
+    return value ? "on" : "off";
 }
 export function formatRepoSettingsLines(repos) {
     if (repos.length === 0)
@@ -149,6 +190,10 @@ export function parseSettingsArgs(rawArgs) {
         }
         const value = eq >= 0 ? arg.slice(eq + 1) : args[++i];
         const row = BEARER_SETTINGS.find((row) => row.key === key);
+        if ("kind" in row && row.kind === "paths") {
+            Object.assign(patch, { [key]: parsePathsFlagValue(flag, value, row.defaults) });
+            continue;
+        }
         if ("kind" in row && row.kind === "logins") {
             if (value === "clear")
                 ignoreBots.push({ action: "clear" });

package/dist/commands/stack.d.ts

@@ -180,6 +180,7 @@ export declare function cmdStackWatch(args: string[], deps?: {
     loadConfig?: typeof loadConfig;
     runStackWatch?: typeof runStackWatch;
     signal?: AbortSignal;
+    writeMarker?: (line: string) => void;
 }): Promise<void>;
 export declare function cmdStackStatus(args: string[], deps?: {
     loadConfig?: typeof loadConfig;

package/dist/commands/stack.js

@@ -11,7 +11,7 @@ import { publishBranchServerSide, assertExplicitStacking, publishWorkingBranch,
 import { gitTopLevel } from "../repo-identity.js";
 import { activeLayers, appendLayer, emptyStackMeta, loadStackMeta, removeActiveStack, resetStackMeta, saveStackMeta, selectStackForCreate, setActivePolicy, } from "../stack-meta.js";
 import { pollStackWatch, StackWatchError, StackWatchTimeoutError, } from "../stack-watch.js";
-import { runStackWatch, STACK_WATCH_EXIT } from "../stack-watch-loop.js";
+import { runStackWatch, STACK_WATCH_EXIT, stackWatchFailedLine } from "../stack-watch-loop.js";
 import { isMgParkBranch, planSubmitLayerBases } from "../submit-pr-base.js";
 import { ansi } from "../ui/ansi.js";
 import { runLineTabsBrowser } from "../ui/line-tabs.js";
@@ -62,7 +62,8 @@ const STACK_USAGE = `usage:
   mergestorm stack watch <stack-id> [--until attention|landed] [--ignore <blocker-substring>] [--max <minutes>] [--head <sha>] [--bounce-id <id>] [--after-finished-at <iso>] [--json]
     Loops stack wait with the cursor and stays silent while the stack is waiting or in progress.
     Prints one MS-WATCH ATTENTION line and exits 3 on attention or on reads that keep failing (a permanent
-    error twice, or 15 minutes of timeouts and 5xx, which it retries with backoff); prints MS-WATCH LANDED
+    error twice, or 15 minutes with no stack read: timeouts, 5xx and rate limits, which it retries with backoff).
+    It also prints MS-WATCH ATTENTION failed when it cannot start (bad flags, no config), so it never exits without an MS-WATCH line unless you stop it; prints MS-WATCH LANDED
     and exits 0 only for a confirmed landing, including a stack Mergestorm deleted after its queue entry landed. Other terminal reasons exit 3 with ATTENTION. Run it as a background command.
     An ATTENTION line for a merge queue bounce ends with restart="mg stack watch <id> --bounce-id <id> --after-finished-at <iso>":
     restart with that command (plus --head <sha> after a push) so a bounce you already handled is not reported again.
@@ -1213,7 +1214,7 @@ export async function cmdStackWait(args, deps = {}) {
         throw new CommandError(err.message, REVIEW_EXIT.timeout, "review_timeout");
     }
 }
-export async function cmdStackWatch(args, deps = {}) {
+async function startStackWatch(args, deps) {
     const usage = "usage: mergestorm stack watch <stack-id> [--until attention|landed] [--ignore <blocker-substring>] [--max <minutes>] [--head <sha>] [--bounce-id <id>] [--after-finished-at <iso>] [--json]";
     const fail = (detail) => new CommandError(detail ? `${usage}\n${detail}` : usage, REVIEW_EXIT.usage, "usage");
     const positional = [];
@@ -1286,6 +1287,30 @@ export async function cmdStackWatch(args, deps = {}) {
                 ...(afterFinishedAt ? { afterFinishedAt } : {}),
             } } : {}),
     });
+    return { stackId, result };
+}
+export async function cmdStackWatch(args, deps = {}) {
+    let started;
+    try {
+        started = await startStackWatch(args, deps);
+    }
+    catch (err) {
+        const valueFlags = new Set(["--until", "--ignore", "--max", "--head", "--bounce-id", "--after-finished-at"]);
+        let json = false;
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === "--json")
+                json = true;
+            else if (valueFlags.has(args[i]))
+                i++;
+        }
+        const marker = deps.writeMarker ?? (json ? console.error : console.log);
+        const stackId = args.find((arg, i) => UUID_RE.test(arg.trim()) && !valueFlags.has(args[i - 1]))?.trim() ?? "none";
+        marker(stackWatchFailedLine(stackId, err instanceof Error ? err.message : String(err)));
+        if (json)
+            console.log(JSON.stringify({ stackId, outcome: "failed" }));
+        throw err;
+    }
+    const { stackId, result } = started;
     if (result.exitCode === STACK_WATCH_EXIT.landed)
         return;
     const reason = result.outcome === "timeout"

package/dist/config.d.ts

@@ -10,6 +10,7 @@ export declare function loadConfig(): Promise<Config>;
 export declare function saveConfig(cfg: Config): Promise<void>;
 export declare function clearConfig(): Promise<void>;
 export declare function apiBase(cfg: Config): string;
+export declare function resolveChatId(cfg: Config): string | undefined;
 export declare function resolveApiKey(cfg: Config): string | undefined;
 /** Short display form of a stored key (prefix only). */
 export declare function keyDisplay(key: string | undefined): string | null;

package/dist/config.js

@@ -33,6 +33,13 @@ export function apiBase(cfg) {
     const fromEnv = cfg.ignoreEnv ? undefined : process.env.MERGESTORM_API_URL?.trim();
     return (fromEnv || cfg.apiBase || DEFAULT_API).replace(/\/$/, "");
 }
+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 resolveChatId(cfg) {
+    if (cfg.ignoreEnv)
+        return undefined;
+    const chatId = process.env.MERGESTORM_CHAT_ID?.trim() ?? "";
+    return CHAT_ID.test(chatId) ? chatId.toLowerCase() : undefined;
+}
 export function resolveApiKey(cfg) {
     if (cfg.ignoreEnv)
         return cfg.apiKey;

package/dist/errors.d.ts

@@ -2,7 +2,7 @@
  * Stable machine codes for CommandError control flow.
  * UX copy in `message` may change freely; match on `code`, never on message text.
  */
-export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "implicit_stack" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited" | "cyclone_not_installed" | "pr_merged" | "pr_closed" | "not_stacked" | "draft" | "reserved_branch" | "supabase_unconfigured" | "cyclone_not_connected" | "cyclone_permission_missing" | "busy" | "adopt_failed" | "github_unreadable" | "stack_attention" | "head_changed" | "base_changed" | "tree_mismatch" | "protected_branch" | "payload_too_large" | "unsupported_publication" | "publication_failed" | "unknown_label";
+export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "implicit_stack" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited" | "cyclone_not_installed" | "pr_merged" | "pr_closed" | "not_stacked" | "draft" | "reserved_branch" | "supabase_unconfigured" | "cyclone_not_connected" | "cyclone_permission_missing" | "busy" | "adopt_failed" | "github_unreadable" | "stack_attention" | "head_changed" | "base_changed" | "tree_mismatch" | "protected_branch" | "payload_too_large" | "unsupported_publication" | "publication_failed" | "git_failed" | "unknown_label" | "invalid_input" | "memory_off" | "memory_full" | "memory_unavailable";
 /** Stable one-shot exit codes for machine callers of `mergestorm review`. */
 export declare const REVIEW_EXIT: {
     readonly success: 0;

package/dist/memory-api.d.ts

@@ -0,0 +1,73 @@
+import { type Config } from "./config.js";
+export declare const MEMORY_MODES: readonly ["off", "on_request", "all"];
+export declare const MEMORY_SCOPES: readonly ["user", "repo"];
+export declare const MEMORY_KINDS: readonly ["rule", "style", "preference", "fact", "project"];
+export declare const MEMORY_SEARCH_LIMIT_MAX = 20;
+export type MemoryMode = (typeof MEMORY_MODES)[number];
+export type MemoryScope = (typeof MEMORY_SCOPES)[number];
+export type MemoryKind = (typeof MEMORY_KINDS)[number];
+export type MemoryItem = {
+    id: string;
+    scope: MemoryScope;
+    repo: string | null;
+    kind: MemoryKind;
+    text: string;
+    source: string | null;
+    source_url: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export type MemoryList = {
+    memory_mode: MemoryMode;
+    items: MemoryItem[];
+};
+export type MemorySearch = {
+    memory_mode: MemoryMode;
+    rules: MemoryItem[];
+    items: MemoryItem[];
+    total: number;
+};
+export type MemorySaved = {
+    id: string;
+    merged: boolean;
+};
+export type MemoryUpdated = {
+    id: string;
+    text: string;
+    kind?: MemoryKind;
+};
+export declare function memoryChatId(value?: string | null | undefined): string | null;
+export declare function isMemoryMode(value: unknown): value is MemoryMode;
+export declare function isMemoryKind(value: unknown): value is MemoryKind;
+export declare function isMemoryScope(value: unknown): value is MemoryScope;
+export declare function listMemories(filter?: {
+    scope?: MemoryScope;
+    repo?: string;
+    kind?: MemoryKind;
+}, cfg?: Config): Promise<MemoryList>;
+export declare function searchMemories(input: {
+    query: string;
+    repo?: string;
+    limit?: number;
+    chatId?: string | null;
+}, cfg?: Config): Promise<MemorySearch>;
+export declare function saveMemory(input: {
+    text: string;
+    kind: MemoryKind;
+    repo?: string | null;
+    chatId?: string | null;
+}, cfg?: Config): Promise<MemorySaved>;
+export declare function updateMemory(id: string, change: {
+    text: string;
+    kind?: MemoryKind;
+}, cfg?: Config): Promise<MemoryUpdated>;
+export declare function deleteMemory(id: string, cfg?: Config): Promise<{
+    id: string;
+    deleted: true;
+}>;
+export declare function getMemoryMode(cfg?: Config): Promise<{
+    memory_mode: MemoryMode;
+}>;
+export declare function setMemoryMode(mode: MemoryMode, cfg?: Config): Promise<{
+    memory_mode: MemoryMode;
+}>;

package/dist/memory-api.js

@@ -0,0 +1,69 @@
+import { apiFetch } from "./api.js";
+import { loadConfig } from "./config.js";
+import { CommandError, REVIEW_EXIT, rateLimitedMessage } from "./errors.js";
+export const MEMORY_MODES = ["off", "on_request", "all"];
+export const MEMORY_SCOPES = ["user", "repo"];
+export const MEMORY_KINDS = ["rule", "style", "preference", "fact", "project"];
+export const MEMORY_SEARCH_LIMIT_MAX = 20;
+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 memoryChatId(value = process.env.MERGESTORM_CHAT_ID) {
+    const trimmed = value?.trim() ?? "";
+    return CHAT_ID.test(trimmed) ? trimmed.toLowerCase() : null;
+}
+export function isMemoryMode(value) {
+    return typeof value === "string" && MEMORY_MODES.includes(value);
+}
+export function isMemoryKind(value) {
+    return typeof value === "string" && MEMORY_KINDS.includes(value);
+}
+export function isMemoryScope(value) {
+    return typeof value === "string" && MEMORY_SCOPES.includes(value);
+}
+const KNOWN_CODES = new Set(["invalid_input", "not_found", "memory_off", "memory_full", "memory_unavailable", "payload_too_large"]);
+function memoryFailure(status, body, retryAfterSeconds, action) {
+    const row = (body && typeof body === "object" ? body : {});
+    if (status === 429 || row.error === "rate_limited") {
+        return new CommandError(rateLimitedMessage(retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", retryAfterSeconds !== undefined ? { retryAfterSeconds } : undefined);
+    }
+    const message = typeof row.message === "string" && row.message ? row.message : null;
+    const code = typeof row.error === "string" && KNOWN_CODES.has(row.error) ? row.error : undefined;
+    if (status === 404 && !code)
+        return new CommandError("This Mergestorm server does not manage memories yet.", 1, "not_found");
+    return new CommandError(message ?? `${action} (HTTP ${status})`, 1, code);
+}
+async function call(cfg, route, init, ok, action) {
+    const { status, body, retryAfterSeconds } = await apiFetch(cfg ?? (await loadConfig()), route, init);
+    if (!ok.includes(status))
+        throw memoryFailure(status, body, retryAfterSeconds, action);
+    return body;
+}
+function query(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params))
+        if (value !== undefined && value !== null && value !== "")
+            search.set(key, String(value));
+    const text = search.toString();
+    return text ? `?${text}` : "";
+}
+export function listMemories(filter = {}, cfg) {
+    return call(cfg, `/api/v1/memories${query(filter)}`, {}, [200], "Could not list memories");
+}
+export function searchMemories(input, cfg) {
+    return call(cfg, `/api/v1/memories/search${query({ query: input.query, repo: input.repo, limit: input.limit, chat_id: input.chatId })}`, {}, [200], "Could not search memories");
+}
+export function saveMemory(input, cfg) {
+    const json = { text: input.text, kind: input.kind, ...(input.repo ? { repo: input.repo } : {}), ...(input.chatId ? { chat_id: input.chatId } : {}) };
+    return call(cfg, "/api/v1/memories", { method: "POST", json }, [200, 201], "Could not save the memory");
+}
+export function updateMemory(id, change, cfg) {
+    return call(cfg, `/api/v1/memories/${encodeURIComponent(id)}`, { method: "PATCH", json: change }, [200], "Could not update the memory");
+}
+export function deleteMemory(id, cfg) {
+    return call(cfg, `/api/v1/memories/${encodeURIComponent(id)}`, { method: "DELETE" }, [200], "Could not delete the memory");
+}
+export function getMemoryMode(cfg) {
+    return call(cfg, "/api/v1/memories/mode", {}, [200], "Could not read the memory mode");
+}
+export function setMemoryMode(mode, cfg) {
+    return call(cfg, "/api/v1/memories/mode", { method: "PUT", json: { memory_mode: mode } }, [200], "Could not set the memory mode");
+}

package/dist/server-publish.d.ts

@@ -8,26 +8,28 @@ export declare const SERVER_PUBLISH_MAX_TOTAL_BYTES: number;
 export declare const SERVER_PUBLISH_MAX_COMMIT_BYTES: number;
 export declare const SERVER_PUBLISH_FILE_MODES: readonly ["100644", "100755", "120000"];
 export declare const SERVER_PUBLISH_HISTORY_SCAN = 500;
-export type GitRead = (args: string[], cwd: string) => Buffer;
+export type GitRead = (args: string[], cwd: string) => Buffer | Promise<Buffer>;
+export declare const READ_ONLY_GIT: Set<string>;
 export declare function readGit(args: string[], cwd: string): Buffer;
-export declare function readCommitHeader(read: GitRead, sha: string, cwd: string): {
+export declare function readCommitHeader(read: GitRead, sha: string, cwd: string): Promise<{
     tree: string;
     parents: string[];
     author: StackPublicationIdentity;
     committer: StackPublicationIdentity;
     message: string;
-};
+}>;
 export declare function readCommitChanges(read: GitRead, parent: string, sha: string, cwd: string, budget: {
     changes: number;
     bytes: number;
-}): StackPublicationChange[];
-export declare function readPublicationCommits(read: GitRead, from: string, to: string, cwd: string): StackPublicationCommit[];
+}): Promise<StackPublicationChange[]>;
+export declare function readPublicationCommits(read: GitRead, from: string, to: string, cwd: string): Promise<StackPublicationCommit[]>;
 export type ServerPublishInput = {
     cfg: Config;
     cwd: string;
     owner: string;
     repo: string;
     branch: string;
+    localRef?: string;
     baseBranch: string;
     localBaseRef?: string;
     remoteBaseSha?: string;

package/dist/server-publish.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { getStackPublication, submitStackPublication, } from "./api.js";
 import { loadConfig } from "./config.js";
-import { CommandError } from "./errors.js";
+import { CommandError, isCommandErrorCode } from "./errors.js";
 import { parseGithubOriginRepo } from "./git.js";
 import { currentBranch, discoverTrunk, tipCommitMessage, tipCommitSubject } from "./git-stack.js";
 import { buildPrBodyFromCommit } from "./pr-body.js";
@@ -12,26 +12,30 @@ export const SERVER_PUBLISH_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
 export const SERVER_PUBLISH_MAX_COMMIT_BYTES = 1024 * 1024;
 export const SERVER_PUBLISH_FILE_MODES = ["100644", "100755", "120000"];
 export const SERVER_PUBLISH_HISTORY_SCAN = 500;
-const READ_ONLY_GIT = new Set(["cat-file", "diff-tree", "merge-base", "rev-list", "rev-parse", "symbolic-ref"]);
+export const READ_ONLY_GIT = new Set(["cat-file", "diff-tree", "merge-base", "rev-list", "rev-parse", "symbolic-ref"]);
 export function readGit(args, cwd) {
     if (!READ_ONLY_GIT.has(args[0] ?? "")) {
         throw new Error(`server-side publication only reads the repository; refusing git ${args[0] ?? ""}`);
     }
     const result = spawnSync("git", args, { cwd, maxBuffer: 256 * 1024 * 1024 });
+    if (result.error)
+        throw result.error;
     if (result.status !== 0) {
-        throw new Error(result.stderr?.toString("utf8").trim() || `git ${args.join(" ")} failed`);
+        throw new CommandError(result.stderr?.toString("utf8").trim() || `git ${args.join(" ")} failed`, 1, "git_failed");
     }
     return result.stdout;
 }
-function text(read, args, cwd) {
-    return read(args, cwd).toString("utf8").trim();
+async function text(read, args, cwd) {
+    return (await read(args, cwd)).toString("utf8").trim();
 }
-function resolves(read, ref, cwd) {
+async function resolves(read, ref, cwd) {
     try {
-        return text(read, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd) || null;
+        return await text(read, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd) || null;
     }
-    catch {
-        return null;
+    catch (err) {
+        if (isCommandErrorCode(err, "git_failed"))
+            return null;
+        throw err;
     }
 }
 function isoWithOffset(epochSeconds, offset) {
@@ -52,12 +56,12 @@ function parseIdentity(line, sha) {
     }
     return { name: match[1].trim() ? match[1] : match[2], email: match[2], date };
 }
-export function readCommitHeader(read, sha, cwd) {
-    const commitBytes = Number(text(read, ["cat-file", "-s", sha], cwd));
+export async function readCommitHeader(read, sha, cwd) {
+    const commitBytes = Number(await text(read, ["cat-file", "-s", sha], cwd));
     if (commitBytes > SERVER_PUBLISH_MAX_COMMIT_BYTES) {
         throw new CommandError(`Commit ${sha} is ${commitBytes} bytes; server-side publication reads commits up to ${SERVER_PUBLISH_MAX_COMMIT_BYTES} bytes.`, 1, "payload_too_large");
     }
-    const commitObject = read(["cat-file", "commit", sha], cwd);
+    const commitObject = await read(["cat-file", "commit", sha], cwd);
     let raw;
     try {
         raw = new TextDecoder("utf-8", { fatal: true }).decode(commitObject);
@@ -87,8 +91,8 @@ export function readCommitHeader(read, sha, cwd) {
     }
     return { tree, parents, author: parseIdentity(author, sha), committer: parseIdentity(committer, sha), message };
 }
-export function readCommitChanges(read, parent, sha, cwd, budget) {
-    const listing = read(["diff-tree", "-r", "-z", "--raw", "--no-renames", "--no-commit-id", "--abbrev=40", parent, sha], cwd);
+export async function readCommitChanges(read, parent, sha, cwd, budget) {
+    const listing = await read(["diff-tree", "-r", "-z", "--raw", "--no-renames", "--no-commit-id", "--abbrev=40", parent, sha], cwd);
     let raw;
     try {
         raw = new TextDecoder("utf-8", { fatal: true }).decode(listing);
@@ -114,7 +118,7 @@ export function readCommitChanges(read, parent, sha, cwd, budget) {
             throw new CommandError(`${path} has Git mode ${newMode}, which server-side publication does not support` +
                 `${newMode === "160000" ? " (it is a submodule)" : ""}. Supported modes are ${SERVER_PUBLISH_FILE_MODES.join(", ")}.`, 1, "unsupported_publication");
         }
-        const size = Number(text(read, ["cat-file", "-s", newSha], cwd));
+        const size = Number(await text(read, ["cat-file", "-s", newSha], cwd));
         if (size > SERVER_PUBLISH_MAX_FILE_BYTES) {
             throw new CommandError(`${path} is ${size} bytes; server-side publication carries files up to ${SERVER_PUBLISH_MAX_FILE_BYTES} bytes.`, 1, "payload_too_large");
         }
@@ -122,30 +126,32 @@ export function readCommitChanges(read, parent, sha, cwd, budget) {
         if (budget.bytes > SERVER_PUBLISH_MAX_TOTAL_BYTES) {
             throw new CommandError(`More than ${SERVER_PUBLISH_MAX_TOTAL_BYTES} bytes of file content; server-side publication cannot carry this branch in one request.`, 1, "payload_too_large");
         }
-        const content = read(["cat-file", "blob", newSha], cwd);
+        const content = await read(["cat-file", "blob", newSha], cwd);
         changes.push({ path, mode: newMode, sha: newSha, content: content.toString("base64") });
     }
     return changes;
 }
-export function readPublicationCommits(read, from, to, cwd) {
+export async function readPublicationCommits(read, from, to, cwd) {
     try {
-        read(["merge-base", "--is-ancestor", from, to], cwd);
+        await read(["merge-base", "--is-ancestor", from, to], cwd);
     }
-    catch {
+    catch (err) {
+        if (!isCommandErrorCode(err, "git_failed"))
+            throw err;
         throw new CommandError(`${from} is not an ancestor of ${to}; the commits to publish are not a straight line.`, 1, "unsupported_publication");
     }
-    if (text(read, ["rev-list", "--min-parents=2", "--max-count=1", `${from}..${to}`], cwd)) {
+    if (await text(read, ["rev-list", "--min-parents=2", "--max-count=1", `${from}..${to}`], cwd)) {
         throw new CommandError(`A merge commit sits between ${from} and ${to}. Server-side publication carries single-parent commits only; rebase or squash the branch.`, 1, "unsupported_publication");
     }
-    const shas = text(read, ["rev-list", "--reverse", `${from}..${to}`], cwd).split("\n").filter(Boolean);
+    const shas = (await text(read, ["rev-list", "--reverse", `${from}..${to}`], cwd)).split("\n").filter(Boolean);
     if (shas.length > SERVER_PUBLISH_MAX_COMMITS) {
         throw new CommandError(`${shas.length} commits to publish; server-side publication carries at most ${SERVER_PUBLISH_MAX_COMMITS} at once. Squash the branch.`, 1, "payload_too_large");
     }
     const commits = [];
     const budget = { changes: 0, bytes: 0 };
     for (const sha of shas) {
-        const header = readCommitHeader(read, sha, cwd);
-        const changes = readCommitChanges(read, header.parents[0], sha, cwd, budget);
+        const header = await readCommitHeader(read, sha, cwd);
+        const changes = await readCommitChanges(read, header.parents[0], sha, cwd, budget);
         commits.push({
             message: header.message,
             author: header.author,
@@ -156,8 +162,8 @@ export function readPublicationCommits(read, from, to, cwd) {
     }
     return commits;
 }
-function localCommitWithTree(read, from, branch, head, cwd) {
-    const lines = text(read, ["rev-list", `--max-count=${SERVER_PUBLISH_HISTORY_SCAN}`, "--format=%H %T", "--no-commit-header", `${from}..${branch}`], cwd)
+async function localCommitWithTree(read, from, branch, head, cwd) {
+    const lines = (await text(read, ["rev-list", `--max-count=${SERVER_PUBLISH_HISTORY_SCAN}`, "--format=%H %T", "--no-commit-header", `${from}..${branch}`], cwd))
         .split("\n")
         .filter(Boolean);
     let match = null;
@@ -176,22 +182,23 @@ export async function publishBranchServerSide(input, deps = {}) {
     const status = deps.getStackPublication ?? getStackPublication;
     const submit = deps.submitStackPublication ?? submitStackPublication;
     const { cfg, cwd, owner, repo, branch } = input;
-    if (!resolves(read, branch, cwd))
-        throw new CommandError(`Branch missing locally: ${branch}`);
+    const local = input.localRef ?? branch;
+    if (!(await resolves(read, local, cwd)))
+        throw new CommandError(`Branch missing locally: ${local}`);
     const remote = await status(cfg, { owner, repo, branch });
     const baseBranch = remote.pr?.base ?? input.baseBranch;
     deps.assertBase?.(baseBranch);
     const localBase = input.localBaseRef ??
-        (resolves(read, `refs/remotes/origin/${input.baseBranch}`, cwd) ? `refs/remotes/origin/${input.baseBranch}` : input.baseBranch);
-    if (!resolves(read, localBase, cwd))
+        ((await resolves(read, `refs/remotes/origin/${input.baseBranch}`, cwd)) ? `refs/remotes/origin/${input.baseBranch}` : input.baseBranch);
+    if (!(await resolves(read, localBase, cwd)))
         throw new CommandError(`Base branch missing locally: ${localBase}`);
-    const fork = text(read, ["merge-base", localBase, branch], cwd);
+    const fork = await text(read, ["merge-base", localBase, local], cwd);
     const baseSha = input.remoteBaseSha ?? fork;
     let onto = "base";
     let expectedHead = null;
     let from = fork;
     if (remote.head) {
-        const published = remote.head.tree ? localCommitWithTree(read, fork, branch, { sha: remote.head.sha, tree: remote.head.tree }, cwd) : null;
+        const published = remote.head.tree ? await localCommitWithTree(read, fork, local, { sha: remote.head.sha, tree: remote.head.tree }, cwd) : null;
         if (published) {
             onto = "head";
             expectedHead = remote.head.sha;
@@ -209,7 +216,7 @@ export async function publishBranchServerSide(input, deps = {}) {
                 `To replace that head with your local branch, pass --replace-head ${remote.head.sha}.`, 1, "head_changed");
         }
     }
-    const commits = readPublicationCommits(read, from, branch, cwd);
+    const commits = await readPublicationCommits(read, from, local, cwd);
     if (commits.length === 0 && onto === "base") {
         throw new CommandError(`No commits on \`${branch}\` ahead of \`${input.baseBranch}\`. Commit your changes, then retry.`);
     }
@@ -224,7 +231,7 @@ export async function publishBranchServerSide(input, deps = {}) {
         pr: { title: input.title, body: input.body },
         ...(typeof input.autoLand === "boolean" ? { autoLand: input.autoLand } : {}),
     });
-    const localTree = text(read, ["rev-parse", `${branch}^{tree}`], cwd);
+    const localTree = await text(read, ["rev-parse", `${local}^{tree}`], cwd);
     if (publication.head.tree !== localTree) {
         throw new CommandError(`GitHub has tree ${publication.head.tree} at ${branch}, but your local branch has tree ${localTree}.`, 1, "tree_mismatch");
     }

package/dist/stack-blockers.d.ts

@@ -43,6 +43,7 @@ export type StackRepairHint = {
     branch: string;
     liveParent: string | null;
     files: string[];
+    publishedBy?: "breeze";
     steps: string;
     note?: string;
 } | {
@@ -74,6 +75,7 @@ export type StackRepairHint = {
     branch: string;
     liveParent: string | null;
     restackKind: string;
+    publishedBy?: "breeze";
     steps: string;
 } | {
     kind: "seam_review_stuck";
@@ -213,10 +215,13 @@ export type MergeQueueWait = {
 export declare function mergeQueueWait(queue: readonly MergeQueueEntryDto[], nowMs: number): MergeQueueWait | null;
 export declare function conflictLiveParent(stack: StackDto, layer: StackLayerDto): string | null;
 export declare function conflictRepairSteps(branch: string, liveParent: string | null): string;
+export declare const BREEZE_BRANCH_PREFIX = "breeze/";
+export declare function isBreezeBranch(branch: string | null | undefined): boolean;
+export declare function breezeConflictRepairSteps(branch: string, liveParent: string | null, prNumber: number): string;
 export declare function restackFailedRepairSteps(branch: string, liveParent: string | null, failure: {
     kind: string;
     detail?: string | null;
-}): string;
+}, prNumber?: number): string;
 export declare function agentsCannotClear(reason: StackBlockerReason, stack?: StackDto, layer?: StackLayerDto): boolean;
 export declare function stackRepair(stack: StackDto, attention: ClassifiedStackBlocker | null, layer: StackLayerDto | undefined, bounce: MergeQueueEntryDto | undefined, queueWait?: MergeQueueWait | null, nowMs?: number): StackRepairHint | null;
 export declare const LAND_PR_MISSING_PREFIX = "No open land PR for ";

package/dist/stack-blockers.js

@@ -679,11 +679,22 @@ export function conflictRepairSteps(branch, liveParent) {
     }
     return `Merge ${liveParent} into ${branch}: git fetch origin, check out ${branch} at its live remote head, git merge origin/${liveParent}, resolve the conflicts, run the tests, then an ordinary git push (no force). Do not rebase onto trunk, main, or mg-park-*, and do not retarget the PR base.`;
 }
-export function restackFailedRepairSteps(branch, liveParent, failure) {
+export const BREEZE_BRANCH_PREFIX = "breeze/";
+export function isBreezeBranch(branch) {
+    return typeof branch === "string" && branch.startsWith(BREEZE_BRANCH_PREFIX);
+}
+export function breezeConflictRepairSteps(branch, liveParent, prNumber) {
+    if (!liveParent)
+        return conflictRepairSteps(branch, liveParent);
+    return `${branch} is a Breeze branch: Breeze updates it only with open_pull_request, which publishes single-parent commits, so it cannot publish a merge of ${liveParent}. Rebase it in the Breeze chat that opened #${prNumber}: fetch ${liveParent} with fetch_repository, git rebase origin/${liveParent}, resolve the conflicts, run the tests, then call open_pull_request again. Or have Cyclone resolve it: cyclone_start with task resolve_conflicts and pr_number ${prNumber}. Do not retarget the PR base.`;
+}
+export function restackFailedRepairSteps(branch, liveParent, failure, prNumber) {
     const why = `Mergestorm could not restack ${branch}${liveParent ? ` onto ${liveParent}` : ""} (${failure.kind}${failure.detail?.trim() ? `: ${failure.detail.trim()}` : ""}) and will not try this head again.`;
     if (!liveParent) {
         return `${why} The live parent of ${branch} is unknown (it is never an mg-park-* freeze). Do not merge or rebase anything; stop and tell the human.`;
     }
+    if (prNumber !== undefined && isBreezeBranch(branch))
+        return `${why} ${breezeConflictRepairSteps(branch, liveParent, prNumber)}`;
     return `${why} Merge ${liveParent} into ${branch}: git fetch origin, check out ${branch} at its live remote head, git merge origin/${liveParent}, resolve any conflicts, run the tests, then an ordinary git push (no force). Mergestorm clears Restack failed once the pushed head contains the tip of ${liveParent}. If GitHub refuses the push (branch protection or permissions), stop and tell the human. Do not rebase onto trunk, main, or mg-park-*, and do not retarget the PR base.`;
 }
 function landPrLiveParent(stack, layer) {
@@ -725,6 +736,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null, n
     const landPr = !!stack.unit?.branch && layer.prNumber === stack.unit.landPrNumber && layer.branch === stack.unit.branch;
     const restackConflict = reason === "restack_conflict" || attention.bounceKind === "restack_conflict";
     const mergeConflict = reason === "merge_conflict";
+    const breeze = !landPr && isBreezeBranch(layer.branch);
     if (restackConflict || mergeConflict) {
         const liveParent = landPr ? landPrLiveParent(stack, layer) : conflictLiveParent(stack, layer);
         const note = conflictHandoffNote(stack, layer);
@@ -735,7 +747,8 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null, n
             branch: layer.branch,
             liveParent,
             files: conflictFiles(layer, bounce),
-            steps: conflictRepairSteps(layer.branch, liveParent),
+            ...(breeze ? { publishedBy: "breeze" } : {}),
+            steps: breeze ? breezeConflictRepairSteps(layer.branch, liveParent, layer.prNumber) : conflictRepairSteps(layer.branch, liveParent),
             ...(note ? { note } : {}),
         };
     }
@@ -748,7 +761,8 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null, n
             branch: layer.branch,
             liveParent,
             restackKind: layer.restackError.kind,
-            steps: restackFailedRepairSteps(layer.branch, liveParent, layer.restackError),
+            ...(breeze ? { publishedBy: "breeze" } : {}),
+            steps: restackFailedRepairSteps(layer.branch, liveParent, layer.restackError, layer.prNumber),
         };
     }
     if (reason === "unit_abandoned") {

package/dist/stack-dto.d.ts

@@ -497,6 +497,7 @@ export type MergeQueueEntryDto = {
     verifyBaseSha: string | null;
     cancelRequestedAt?: string | null;
     batch?: MergeQueueEntryBatchDto | null;
+    ci?: MergeQueueBatchCiDto | null;
     finishedAt: string | null;
     claimedAt?: string | null;
     aheadInRepo?: MergeQueueAheadDto | null;

package/dist/stack-watch-loop.js

@@ -171,9 +171,17 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
         await pause(STACK_WATCH_FAILED_RETRY_MS);
         return null;
     };
+    const unreadTooLong = (message, envelope, since) => {
+        transientSince ??= since;
+        if (now() - transientSince < STACK_WATCH_TRANSIENT_WINDOW_MS)
+            return null;
+        emit(stackWatchFailedLine(id, `No stack read for 15 minutes: ${message}`), envelope, "failed");
+        return { outcome: "failed", exitCode: STACK_WATCH_EXIT.attention, envelope };
+    };
     try {
         while (now() < deadline) {
             let envelope;
+            const sliceStartedAt = now();
             try {
                 envelope = await poll(cfg, id, {
                     timeoutMs: Math.min(STACK_WATCH_SLICE_MS, Math.max(0, deadline - now())),
@@ -189,8 +197,13 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
                     cursor = err.lastEnvelope.cursor;
                     failures = 0;
                     permanentFailures = 0;
-                    if (err.lastEnvelope.assessment === "available")
+                    if (err.lastEnvelope.status !== "failed")
                         transientSince = null;
+                    else {
+                        const unread = unreadTooLong("No stack snapshot was read in a whole watch slice", err.lastEnvelope, sliceStartedAt);
+                        if (unread)
+                            return unread;
+                    }
                     continue;
                 }
                 if (err instanceof StackWatchError && err.lastEnvelope.watch.done) {
@@ -198,7 +211,15 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
                     return await finished(err.lastEnvelope);
                 }
                 if (err instanceof StackWatchError && err.lastEnvelope.status === "rate_limited") {
-                    await pause(err.retryAfterSeconds !== undefined ? Math.max(1_000, err.retryAfterSeconds * 1000) : STACK_WATCH_RATE_LIMIT_WAIT_MS);
+                    if (err.readSnapshot)
+                        transientSince = now();
+                    else {
+                        const unread = unreadTooLong(err.message, err.lastEnvelope, sliceStartedAt);
+                        if (unread)
+                            return unread;
+                    }
+                    const retryAfterMs = err.retryAfterSeconds !== undefined ? Math.max(1_000, err.retryAfterSeconds * 1000) : STACK_WATCH_RATE_LIMIT_WAIT_MS;
+                    await pause(Math.min(retryAfterMs, Math.max(1_000, transientSince + STACK_WATCH_TRANSIENT_WINDOW_MS - now())));
                     continue;
                 }
                 const result = await failed(err instanceof Error ? err.message : String(err), err instanceof StackWatchError ? err.lastEnvelope : null, isTransientWatchFailure(err));

package/dist/stack-watch.d.ts

@@ -58,7 +58,8 @@ export declare class StackWatchTimeoutError extends Error {
 export declare class StackWatchError extends Error {
     readonly lastEnvelope: StackWatchEnvelope;
     readonly retryAfterSeconds?: number | undefined;
-    constructor(message: string, lastEnvelope: StackWatchEnvelope, options?: ErrorOptions, retryAfterSeconds?: number | undefined);
+    readonly readSnapshot: boolean;
+    constructor(message: string, lastEnvelope: StackWatchEnvelope, options?: ErrorOptions, retryAfterSeconds?: number | undefined, readSnapshot?: boolean);
 }
 /** Wait on queue invalidations, then evaluate a fresh stack snapshot. */
 export declare function pollStackWatch(cfg: Config, stackId: string, opts?: PollStackWatchOptions): Promise<StackWatchEnvelope>;

package/dist/stack-watch.js

@@ -20,10 +20,12 @@ export class StackWatchTimeoutError extends Error {
 export class StackWatchError extends Error {
     lastEnvelope;
     retryAfterSeconds;
-    constructor(message, lastEnvelope, options, retryAfterSeconds) {
+    readSnapshot;
+    constructor(message, lastEnvelope, options, retryAfterSeconds, readSnapshot = false) {
         super(message, options);
         this.lastEnvelope = lastEnvelope;
         this.retryAfterSeconds = retryAfterSeconds;
+        this.readSnapshot = readSnapshot;
         this.name = "StackWatchError";
     }
 }
@@ -55,6 +57,7 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         landGatePending: null,
     };
     let terminal = null;
+    let readSnapshot = false;
     const seal = (snapshot, retryAfterSeconds) => ({
         ...snapshot,
         watch: stackWatchObligation({
@@ -116,7 +119,7 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
             throw new StackWatchError(`Stack poll failed (HTTP ${response.status})`, seal({
                 ...lastEnvelope, status: response.status === 429 ? "rate_limited" : "failed",
                 assessment: "unavailable",
-            }, response.retryAfterSeconds), undefined, response.retryAfterSeconds);
+            }, response.retryAfterSeconds), undefined, response.retryAfterSeconds, readSnapshot);
         }
         throw timeout();
     };
@@ -149,6 +152,7 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
     };
     const evaluate = (stack, entries) => {
         const { attention, held: named, issues, currentCandidate, bounce, busy, agents, repair, landGatePending, queueWait } = stackBlockers(stack, entries, cursor, now());
+        readSnapshot = true;
         if (bounce)
             cursor = Object.freeze({ ...cursor, bounceId: bounce.id,
                 ...(bounce.finishedAt !== undefined ? { afterFinishedAt: bounce.finishedAt } : {}) });

package/dist/ui/banner.js

@@ -227,6 +227,9 @@ const WHATS_NEW = {
     "0.3.63": [
         "Stack create starts a new stack unless --extend",
     ],
+    "0.3.64": [
+        "Memory commands and Overdrive merge batches",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.63",
+  "version": "0.3.64",
   "description": "Mergestorm CLI (mg) — local reviews & stacked PRs. MIT; build from source: https://github.com/marginsystems/mergestorm-cli",
   "license": "MIT",
   "type": "module",
@@ -39,6 +39,8 @@
   },
   "files": [
     "dist",
+    "!dist/.tsbuildinfo",
+    "!dist/.build-inputs",
     "skill",
     "LICENSE",
     "README.md"