mergestorm 0.3.62 → 0.3.64

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,21 +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;
@@ -208,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.`);
     }
@@ -223,12 +231,19 @@ 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");
     }
     return { ...publication, baseBranch };
 }
+export function assertExplicitStacking(input) {
+    if (input.extend || input.parent === input.trunk)
+        return;
+    throw new CommandError(`\`${input.parent}\` is not trunk (\`${input.trunk}\`), and stacking onto it needs --extend.\n` +
+        `• Stack onto \`${input.parent}\`: ${input.stackCommand}\n` +
+        `• New stack from \`${input.trunk}\`: ${input.trunkCommand}`, 1, "implicit_stack");
+}
 export function workingBranchTarget(input) {
     const cwd = input.cwd ?? process.cwd();
     const origin = input.owner && input.repo ? { owner: input.owner, repo: input.repo } : parseGithubOriginRepo(cwd);
@@ -242,17 +257,36 @@ export function workingBranchTarget(input) {
 }
 export async function publishWorkingBranch(input, deps = {}) {
     const { cwd, owner, repo, branch } = workingBranchTarget(input);
-    let baseBranch = input.base;
+    const { publishBranchServerSide: publish = publishBranchServerSide, loadConfig: load = loadConfig, discoverTrunk: findTrunk = discoverTrunk, ...publishDeps } = deps;
+    let trunk = null;
+    let trunkError = null;
+    try {
+        trunk = findTrunk(cwd);
+    }
+    catch (err) {
+        trunkError = err;
+    }
+    const trunkMessage = trunkError instanceof Error ? trunkError.message : String(trunkError);
+    const baseBranch = input.base ?? trunk;
     if (!baseBranch) {
-        try {
-            baseBranch = discoverTrunk(cwd);
+        throw new CommandError(`${trunkMessage} Name the base branch.`);
+    }
+    const assertBase = (parent) => {
+        if (trunk) {
+            assertExplicitStacking({
+                parent,
+                trunk,
+                extend: input.extend === true,
+                stackCommand: `\`mg stack publish --base ${parent} --extend\` (MCP stack_publish: extend true)`,
+                trunkCommand: "`mg stack publish` with no --base (MCP stack_publish: no base)",
+            });
         }
-        catch (err) {
-            throw new CommandError(`${err instanceof Error ? err.message : String(err)} Name the base branch.`);
+        else if (input.extend !== true) {
+            throw new CommandError(`${trunkMessage} \`${parent}\` cannot be verified as trunk, so stacking onto it needs --extend.`, 1, "implicit_stack");
         }
-    }
-    const { publishBranchServerSide: publish = publishBranchServerSide, loadConfig: load = loadConfig, ...publishDeps } = deps;
-    return publish({
+    };
+    assertBase(baseBranch);
+    const result = await publish({
         cfg: input.cfg ?? (await load()),
         cwd,
         owner,
@@ -263,7 +297,8 @@ export async function publishWorkingBranch(input, deps = {}) {
         body: input.body ?? buildPrBodyFromCommit(tipCommitMessage(branch, cwd)),
         ...(typeof input.autoLand === "boolean" ? { autoLand: input.autoLand } : {}),
         ...(input.replaceHead ? { replaceHead: input.replaceHead } : {}),
-    }, publishDeps);
+    }, { ...publishDeps, assertBase });
+    return { ...result, stacked: !trunk || result.baseBranch !== trunk };
 }
 export async function workingBranchPublication(input, deps = {}) {
     const { owner, repo, branch } = workingBranchTarget(input);

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";
@@ -170,6 +172,8 @@ export declare const SEAM_REVIEW_STUCK = "Seam review stuck in reviewing, no rev
 export declare const SEAM_REREVIEW_NOT_RUNNING = "Seam re-review pending, no review running";
 export declare const SEAM_VERDICT_STALE = "Seam verdict is for an older head, no review running";
 export declare const VORTEX_FINDINGS_NEED_PERSON = "Vortex findings need a person";
+export declare const CYCLONE_NOT_RUN_ATTENTION_MS: number;
+export declare const CYCLONE_NOT_RUN_REASON = "not_run";
 export declare function cycloneStatusWords(layer: Pick<StackLayerDto, "cycloneStatus" | "cycloneHandoff" | "headSha">): string | null;
 export declare function autoResolveActive(stack: StackDto, layer: StackLayerDto): boolean;
 export declare function autoFixCiActive(stack: StackDto, layer: StackLayerDto): boolean;
@@ -211,12 +215,15 @@ 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): StackRepairHint | null;
+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 ";
 /** Pair-gate attention plus live hard blocks on every other open layer. */
 export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntryDto[], cursor?: Pick<StackWatchCursor, "bounceId" | "afterFinishedAt">, nowMs?: number): {

package/dist/stack-blockers.js

@@ -72,10 +72,26 @@ function vortexFindingsRestAtHead(layer) {
 function vortexChangesRequestedAtHead(layer) {
     return vortexFindingsRestAtHead(layer) && layer.reviewStatus === "changes_requested";
 }
-function cycloneHandoffAtHead(stack, layer) {
+export const CYCLONE_NOT_RUN_ATTENTION_MS = 30 * 60_000;
+export const CYCLONE_NOT_RUN_REASON = "not_run";
+function cycloneNotRunAtHead(layer, nowMs) {
+    const review = layer.vortexReview;
+    if (layer.cycloneFindingsTakenAtHead !== false || layer.vortexStatus !== "findings")
+        return false;
+    if (review?.status !== "done" || !sameHead(review.head_sha, layer.headSha))
+        return false;
+    const settledMs = Date.parse(review.settled_at ?? "");
+    return Number.isFinite(settledMs) && nowMs - settledMs >= CYCLONE_NOT_RUN_ATTENTION_MS;
+}
+function cycloneHandoffAtHead(stack, layer, nowMs) {
     if (sameHead(layer.cycloneHandoff?.headSha, layer.headSha))
         return layer.cycloneHandoff.reason;
-    return stack.cyclonePatchOff ?? (stack.autoPatchOverride === false ? "auto_patch_off" : null);
+    if (layer.cycloneStatus === "failed")
+        return "failed";
+    const off = stack.cyclonePatchOff ?? (stack.autoPatchOverride === false ? "auto_patch_off" : null);
+    if (off)
+        return off;
+    return cycloneNotRunAtHead(layer, nowMs) ? CYCLONE_NOT_RUN_REASON : null;
 }
 const CYCLONE_HANDOFF_WORDS = {
     failed: "Cyclone's patch failed, so it pushed nothing",
@@ -93,6 +109,11 @@ const CYCLONE_HANDOFF_WORDS = {
     unsupported_language: "the findings are in a language Cyclone does not patch",
     policy_owner_changed: "the stack's owner changed while the patch was queued",
     patch_job_lost: "Cyclone's patch job was lost before it finished",
+    pr_state_unavailable: "Cyclone could not read the PR's state, so it pushed nothing",
+    left_for_human: "Cyclone did not patch these findings and pushed nothing",
+    hold: "the review told Cyclone to hold, so it did not patch these findings",
+    vortex_patch_cap: "Cyclone already patched this PR as many times as it may",
+    [CYCLONE_NOT_RUN_REASON]: `Cyclone has not run on this head in the ${CYCLONE_NOT_RUN_ATTENTION_MS / 60_000} minutes since Vortex posted these findings, and nothing is patching it`,
     conflict_needs_person: "Cyclone could not resolve the conflict and left it for a person",
     conflict_unresolved: "Cyclone's conflict resolution failed",
     auto_resolve_daily_cap: "Cyclone already resolved conflicts on this PR twice today, its daily cap",
@@ -179,6 +200,10 @@ const CYCLONE_HELD_FINDINGS_REASONS = [
     "pr_state_unavailable",
     "vortex_patch_cap",
     "patch_job_lost",
+    "unsupported_language",
+    "credits_exhausted",
+    "no_billing",
+    "policy_owner_changed",
 ];
 function vortexImportantFindingsHeldAtHead(layer) {
     return vortexFindingsRestAtHead(layer) && layer.reviewStatus === "reviewed" &&
@@ -189,13 +214,13 @@ function seamApprovedAtHead(stack, layer) {
     const member = (stack.unit?.members ?? []).find((entry) => entry.prNumber === layer.prNumber);
     return member?.seamState?.trim().toLowerCase() === "approved" && sameHead(member.seamReviewedSha, layer.headSha);
 }
-function vortexFindingsLeftForPerson(stack, layer) {
+function vortexFindingsLeftForPerson(stack, layer, nowMs) {
     if (layerAgentsBusy(layer).cyclone)
         return false;
     if (seamApprovedAtHead(stack, layer))
         return false;
     return vortexImportantFindingsHeldAtHead(layer) ||
-        (vortexChangesRequestedAtHead(layer) && cycloneHandoffAtHead(stack, layer) !== null);
+        (vortexChangesRequestedAtHead(layer) && cycloneHandoffAtHead(stack, layer, nowMs) !== null);
 }
 function quotaSkippedReview(layer) {
     const review = layer.vortexReview;
@@ -310,7 +335,7 @@ function headChecksRerunning(layer) {
     return layer.ciStatus === "pending" && !!checks && checks.failure === 0 && checks.pending > 0 && checks.cancelledOnly !== true;
 }
 /** Shared live-fact precedence; bounce history is only passed for the candidate. */
-function layerAttention(stack, layer, queue, cursor) {
+function layerAttention(stack, layer, queue, cursor, nowMs) {
     const none = { blocker: null, reason: null, bounceKind: null };
     if (stack.archivedAt)
         return none;
@@ -363,7 +388,7 @@ function layerAttention(stack, layer, queue, cursor) {
             if (landing && !landGateIsPending(landing))
                 return hardBlock(landing, "land_gate");
         }
-        if (vortexFindingsLeftForPerson(stack, layer))
+        if (vortexFindingsLeftForPerson(stack, layer, nowMs))
             return hardBlock(VORTEX_FINDINGS_NEED_PERSON, "vortex_findings_need_person");
     }
     if (!bounce || !kind || recoverable || !layer || queue.some((entry) => ["queued", "running", "waiting"].includes(entry.state)))
@@ -654,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) {
@@ -682,7 +718,7 @@ export function agentsCannotClear(reason, stack, layer) {
         return false;
     return AGENTS_CANNOT_CLEAR.includes(reason);
 }
-export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
+export function stackRepair(stack, attention, layer, bounce, queueWait = null, nowMs = Date.now()) {
     if (!attention || !layer || attention.prNumber !== layer.prNumber)
         return null;
     const reason = attention.reason;
@@ -700,6 +736,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
     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);
@@ -710,7 +747,8 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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 } : {}),
         };
     }
@@ -723,7 +761,8 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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") {
@@ -866,7 +905,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
     }
     if (reason === "vortex_findings_need_person") {
         const findings = `gh api repos/${stack.owner}/${stack.repo}/pulls/${layer.prNumber}/reviews`;
-        const handoff = cycloneHandoffAtHead(stack, layer);
+        const handoff = cycloneHandoffAtHead(stack, layer, nowMs);
         return {
             kind: "vortex_findings",
             prNumber: layer.prNumber,
@@ -874,7 +913,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             branch: layer.branch,
             handoff,
             findings,
-            steps: `Vortex ${vortexImportantFindingsHeldAtHead(layer) ? "left Important findings" : "requested changes"} on ${layer.branch} at ${layer.headSha ?? "its live head"} and Cyclone left them for a person${handoff ? ` (${cycloneHandoffWords(handoff, cycloneHandoffDetailAtHead(layer))})` : ""}, so nothing will patch them and Auto land waits. Read the newest Vortex review and its inline comments (${findings}), verify each finding against ${layer.branch} at its live remote head, fix the real ones with the smallest patch, run the tests, confirm the remote head is still ${layer.headSha ?? "the head you started from"}, then an ordinary git push (no force). If a finding is wrong, tell the human; mg dismiss ${stack.owner}/${stack.repo}#${layer.prNumber} --head <sha> --review <id> dismisses that review. Do not retarget the PR base.`,
+            steps: `Vortex ${vortexImportantFindingsHeldAtHead(layer) ? "left Important findings" : "requested changes"} on ${layer.branch} at ${layer.headSha ?? "its live head"} and Cyclone left them undone${handoff ? ` (${cycloneHandoffWords(handoff, cycloneHandoffDetailAtHead(layer))})` : ""}, so nothing will patch them and Auto land waits. You fix them: read the newest Vortex review and its inline comments (${findings}), verify each finding against ${layer.branch} at its live remote head, fix the real ones with the smallest patch, run the tests, confirm the remote head is still ${layer.headSha ?? "the head you started from"}, then an ordinary git push (no force). Dismiss a finding you verified is wrong yourself: mg dismiss ${stack.owner}/${stack.repo}#${layer.prNumber} --head <sha> --review <id> --finding <id> --reason <why> --evidence <link>. Ask the human only for a product or design decision. Do not retarget the PR base.`,
         };
     }
     if (reason === "ci_failed" || attention.bounceKind === "ci_failure") {
@@ -964,7 +1003,7 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     for (const layer of open) {
         const selected = layer.prNumber === candidate?.prNumber;
         const inScope = selected || !candidate || layer.position > candidate.position;
-        let result = layerAttention(stack, layer, selected ? queue : [], cursor);
+        let result = layerAttention(stack, layer, selected ? queue : [], cursor, nowMs);
         let disarmed;
         if (!result.blocker && selected) {
             disarmed = disarmingBounce(stack, queue);
@@ -1071,7 +1110,7 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     if (busy.length && attention && classified && agentsCannotClear(classified.reason, stack, attentionLayer)) {
         held = { ...attention, actAfter: "agents_idle", waitingOn: busy.map((entry) => entry.agent) };
         shownIssues = [attention, ...issues];
-        repair = stackRepair(stack, classified, attentionLayer, undefined, queueWait);
+        repair = stackRepair(stack, classified, attentionLayer, undefined, queueWait, nowMs);
         attention = null;
         bounce = undefined;
     }
@@ -1081,7 +1120,7 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
         bounce = undefined;
     }
     else {
-        repair = landMissing?.repair ?? stackRepair(stack, classified, attentionLayer, bounce, queueWait);
+        repair = landMissing?.repair ?? stackRepair(stack, classified, attentionLayer, bounce, queueWait, nowMs);
     }
     if (!attention) {
         const next = found.find((item) => !layerBusy(item.layer));
@@ -1089,7 +1128,7 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
             attention = next.issue;
             repair = next.repair !== undefined
                 ? next.repair
-                : stackRepair(stack, { ...next.issue, reason: next.reason }, next.layer, next.bounce, queueWait);
+                : stackRepair(stack, { ...next.issue, reason: next.reason }, next.layer, next.bounce, queueWait, nowMs);
             bounce = next.bounce;
             if (next.layer)
                 agents = layerAgents(next.layer);

package/dist/stack-dto.d.ts

@@ -59,6 +59,7 @@ export type StackVortexReviewView = {
     phase: string | null;
     /** Earliest live job start while `reviewing`; null when lease-only. */
     started_at: string | null;
+    settled_at?: string | null;
     /** Stop control visibility: true only while a pass can actually be cancelled. */
     stoppable: boolean;
     /** Which table spoke: the authority row, a live job, a lease, or nothing. */
@@ -225,6 +226,7 @@ export type StackLayerDto = {
     cycloneConflictPendingSince?: string | null;
     cycloneCiHandoff?: StackCycloneHandoff | null;
     cycloneCiPendingSince?: string | null;
+    cycloneFindingsTakenAtHead?: boolean;
     conflictDetail: string | null;
     restackError?: RestackError | null;
     lastRestackedSha: string | null;
@@ -495,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

@@ -224,6 +224,12 @@ const WHATS_NEW = {
     "0.3.62": [
         "Watch wakes for a blocker on any layer",
     ],
+    "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")