mergestorm 0.3.63 → 0.3.66

package/dist/stack-blockers.d.ts

@@ -6,8 +6,8 @@ export type StackBlocker = {
     blocker: string;
     bounceKind: string | null;
 };
-export type StackBlockerReason = "restack_conflict" | "restack_failed" | "draft_pr" | "merge_conflict" | "ci_failed" | "vortex_failed" | "vortex_out_of_quota" | "vortex_skipped" | "vortex_findings_need_person" | "seam_failed" | "seam_findings" | "seam_not_running" | "seam_review_stuck" | "seam_rereview_not_running" | "seam_verdict_stale" | "unit_abandoned" | "land_gate" | "bounce" | "auto_land_off" | "auto_land_switched_off" | "auto_land_ci_pending" | "auto_land_members_remaining" | "auto_land_vortex_wait" | "auto_land_promote_failed" | "auto_land_ci_unreadable" | "auto_land_waited" | "queue_stalled" | "land_pr_missing";
-export type ClassifiedStackBlocker = StackBlocker & {
+export type StackBlockerReason = "restack_conflict" | "restack_failed" | "draft_pr" | "merge_conflict" | "ci_failed" | "vortex_failed" | "vortex_out_of_quota" | "vortex_skipped" | "vortex_findings_need_person" | "seam_failed" | "seam_findings" | "seam_not_running" | "seam_review_stuck" | "seam_rereview_not_running" | "seam_verdict_stale" | "unit_abandoned" | "land_gate" | "bounce" | "auto_land_off" | "auto_land_switched_off" | "auto_land_ci_pending" | "auto_land_members_remaining" | "auto_land_vortex_wait" | "auto_land_promote_failed" | "auto_land_ci_unreadable" | "auto_land_waited" | "queue_stalled" | "cyclone_stalled" | "land_pr_missing";
+type ClassifiedStackBlocker = StackBlocker & {
     reason: StackBlockerReason;
 };
 export type StackAgentBusy = {
@@ -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";
@@ -111,6 +113,14 @@ export type StackRepairHint = {
     since: string;
     reason: string;
     steps: string;
+} | {
+    kind: "cyclone_stalled";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    runSha: string | null;
+    since: string | null;
+    steps: string;
 } | {
     kind: "queue_stalled";
     prNumber: number;
@@ -157,42 +167,14 @@ export type StackLandGatePending = {
 export declare function landGateIsPending(reason: string | null | undefined): boolean;
 export declare function layerAgentsBusy(layer: StackLayerDto): StackAgentsBusy;
 export declare function layerAgents(layer: StackLayerDto): StackLayerAgents;
-export declare function isMgParkBase(branch: string | null | undefined): boolean;
-/** GitHub DIRTY vs an mg-park-* freeze is not a merge conflict, verified or not. */
-export declare function boundDirty(layer: StackLayerDto): boolean;
-export declare function mergeabilityPending(layer: StackLayerDto): boolean;
 export declare function sameHead(a: string | null | undefined, b: string | null | undefined): boolean;
 export declare function currentLayer(stack: StackDto): StackLayerDto | undefined;
-export declare const RESTACK_FAILED = "Restack failed";
-export declare const SEAM_REVIEW_NOT_RUNNING = "Seam review pending, no review running";
-export declare const VORTEX_REVIEW_OUT_OF_QUOTA = "Review skipped, out of review quota";
-export declare const SEAM_REVIEW_STUCK = "Seam review stuck in reviewing, no review running";
-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;
 export declare const CI_DID_NOT_FINISH_BLOCKER = "CI did not finish \u2014 left for a person";
-export declare function pendingCiLeftForPerson(stack: StackDto, layer: StackLayerDto): boolean;
-export declare const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
-export declare const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
-export declare const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";
-export declare const VORTEX_IGNORED_AUTHOR = "Vortex skipped this head: the PR author is on the ignored authors list";
-export declare const VORTEX_REPO_DISABLED = "Vortex skipped this head: reviews are turned off for this repository";
-export declare const VORTEX_RETRY_SCHEDULED = "Vortex hit a temporary error on this head and will retry by itself";
-export declare const VORTEX_REVIEW_FAILED = "Review failed";
-export declare function vortexRetryScheduled(layer: StackLayerDto): boolean;
-export declare const AUTO_LAND_CI_PENDING_ATTENTION_MS: number;
-export declare const AUTO_LAND_VORTEX_WAIT_ATTENTION_MS: number;
-export declare const AUTO_LAND_PROMOTE_FAILED_ATTEMPTS = 3;
-export declare const AUTO_LAND_CI_FAILED_BLOCKER = "CI failed \u2014 Auto land reads a failing check on GitHub at this head";
-export declare const AUTO_LAND_WAIT_ATTENTION_MS: number;
-export declare const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS: number;
-export declare function autoLandWaitLayer(stack: StackDto): StackLayerDto | undefined;
-export declare const MERGE_QUEUE_STALL_ATTENTION_MS: number;
+export declare const CYCLONE_STALLED_PREFIX = "Cyclone stalled: ";
 export type StackQueueWait = {
     prNumber: number;
     headSha: string | null;
@@ -213,13 +195,9 @@ 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 function restackFailedRepairSteps(branch: string, liveParent: string | null, failure: {
-    kind: string;
-    detail?: string | null;
-}): string;
+export declare const BREEZE_BRANCH_PREFIX = "breeze/";
 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 ";
 /** 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): {
     attention: StackBlocker | null;
@@ -238,3 +216,4 @@ export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntry
 };
 /** Compact contract text shared by status and wait summaries. */
 export declare function stackBlockersSummary(attention: Pick<StackBlocker, "prNumber" | "blocker"> | null, issues: StackBlocker[], busy?: readonly StackAgentBusy[], landGatePending?: Pick<StackLandGatePending, "prNumber" | "reason"> | null, actAfter?: StackHeldBlocker["actAfter"] | null, queueWait?: Pick<StackQueueWait, "prNumber" | "text"> | null): string;
+export {};

package/dist/stack-blockers.js

@@ -1,4 +1,4 @@
-import { CYCLONE_CI_FIX_HELD_REASON, CYCLONE_FIX_HELD_REASON, deriveStackAgentsBusy, mergeQueueBounceLabel, restackRetryPending, } from "./stack-dto.js";
+import { CYCLONE_CI_FIX_HELD_REASON, CYCLONE_FIX_HELD_REASON, deriveStackAgentsBusy, mergeQueueBounceLabel, restackRetryPending, STACK_AGENT_PATCHING_STALE_MS, stalledCycloneRun, } from "./stack-dto.js";
 export function landGateIsPending(reason) {
     const token = reason?.trim().replace(/^landing blocked:\s*/i, "").match(/^[a-z_]+/i)?.[0] ?? "";
     return /_(?:pending|running)$/i.test(token);
@@ -18,11 +18,11 @@ export function layerAgents(layer) {
         busy: { vortex: busy.vortex, cyclone: busy.cyclone },
     };
 }
-export function isMgParkBase(branch) {
+function isMgParkBase(branch) {
     return (branch ?? "").trim().toLowerCase().startsWith("mg-park-");
 }
 /** GitHub DIRTY vs an mg-park-* freeze is not a merge conflict, verified or not. */
-export function boundDirty(layer) {
+function boundDirty(layer) {
     if (isMgParkBase(layer.parentBranch))
         return false;
     if (layer.mergeable == null)
@@ -30,7 +30,7 @@ export function boundDirty(layer) {
     return (!layer.headSha || layer.mergeableHeadSha === layer.headSha) &&
         (layer.mergeable === false || layer.mergeableState?.toLowerCase() === "dirty");
 }
-export function mergeabilityPending(layer) {
+function mergeabilityPending(layer) {
     if (isMgParkBase(layer.parentBranch))
         return false;
     return layer.mergeable == null && !!layer.headSha && layer.mergeableHeadSha === layer.headSha &&
@@ -51,12 +51,12 @@ export function currentLayer(stack) {
     return promote[0] ?? open.find((layer) => layer.prNumber === stack.unit?.landPrNumber) ??
         (land && land.prNumber > 0 && land.state !== "merged" && land.state !== "closed" ? land : undefined);
 }
-export const RESTACK_FAILED = "Restack failed";
-export const SEAM_REVIEW_NOT_RUNNING = "Seam review pending, no review running";
-export const VORTEX_REVIEW_OUT_OF_QUOTA = "Review skipped, out of review quota";
-export const SEAM_REVIEW_STUCK = "Seam review stuck in reviewing, no review running";
-export const SEAM_REREVIEW_NOT_RUNNING = "Seam re-review pending, no review running";
-export const SEAM_VERDICT_STALE = "Seam verdict is for an older head, no review running";
+const RESTACK_FAILED = "Restack failed";
+const SEAM_REVIEW_NOT_RUNNING = "Seam review pending, no review running";
+const VORTEX_REVIEW_OUT_OF_QUOTA = "Review skipped, out of review quota";
+const SEAM_REVIEW_STUCK = "Seam review stuck in reviewing, no review running";
+const SEAM_REREVIEW_NOT_RUNNING = "Seam re-review pending, no review running";
+const SEAM_VERDICT_STALE = "Seam verdict is for an older head, no review running";
 const STUCK_SEAM_REASONS = ["seam_review_stuck", "seam_rereview_not_running", "seam_verdict_stale"];
 function coreReviewDoneAtHead(layer) {
     const review = layer.vortexReview;
@@ -72,8 +72,8 @@ function vortexFindingsRestAtHead(layer) {
 function vortexChangesRequestedAtHead(layer) {
     return vortexFindingsRestAtHead(layer) && layer.reviewStatus === "changes_requested";
 }
-export const CYCLONE_NOT_RUN_ATTENTION_MS = 30 * 60_000;
-export const CYCLONE_NOT_RUN_REASON = "not_run";
+const CYCLONE_NOT_RUN_ATTENTION_MS = 30 * 60_000;
+const CYCLONE_NOT_RUN_REASON = "not_run";
 function cycloneNotRunAtHead(layer, nowMs) {
     const review = layer.vortexReview;
     if (layer.cycloneFindingsTakenAtHead !== false || layer.vortexStatus !== "findings")
@@ -109,6 +109,7 @@ 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",
+    run_deadline: "Cyclone's patch ran past its time limit and stopped without pushing",
     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",
@@ -175,7 +176,7 @@ export function autoFixCiActive(stack, layer) {
         !sameHead(layer.cycloneCiHandoff?.headSha, layer.headSha);
 }
 export const CI_DID_NOT_FINISH_BLOCKER = "CI did not finish — left for a person";
-export function pendingCiLeftForPerson(stack, layer) {
+function pendingCiLeftForPerson(stack, layer) {
     return layer.ciStatus === "pending" && layer.checks?.cancelledOnly === true &&
         sameHead(layer.checks.namedRunsCompleteHeadSha, layer.headSha) && !isLandPrLayer(stack, layer) &&
         sameHead(layer.cycloneCiHandoff?.headSha, layer.headSha);
@@ -200,6 +201,7 @@ const CYCLONE_HELD_FINDINGS_REASONS = [
     "pr_state_unavailable",
     "vortex_patch_cap",
     "patch_job_lost",
+    "run_deadline",
     "unsupported_language",
     "credits_exhausted",
     "no_billing",
@@ -227,13 +229,13 @@ function quotaSkippedReview(layer) {
     return review?.status === "skipped" && review.skip_reason === "quota_exceeded" &&
         sameHead(review.head_sha, layer.headSha);
 }
-export const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
-export const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
-export const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";
-export const VORTEX_IGNORED_AUTHOR = "Vortex skipped this head: the PR author is on the ignored authors list";
-export const VORTEX_REPO_DISABLED = "Vortex skipped this head: reviews are turned off for this repository";
-export const VORTEX_RETRY_SCHEDULED = "Vortex hit a temporary error on this head and will retry by itself";
-export const VORTEX_REVIEW_FAILED = "Review failed";
+const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
+const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
+const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";
+const VORTEX_IGNORED_AUTHOR = "Vortex skipped this head: the PR author is on the ignored authors list";
+const VORTEX_REPO_DISABLED = "Vortex skipped this head: reviews are turned off for this repository";
+const VORTEX_RETRY_SCHEDULED = "Vortex hit a temporary error on this head and will retry by itself";
+const VORTEX_REVIEW_FAILED = "Review failed";
 const VORTEX_SKIP_BLOCKERS = {
     auto_review_off: VORTEX_AUTO_REVIEW_OFF,
     billing_blocked: VORTEX_BILLING_SKIPPED,
@@ -241,7 +243,7 @@ const VORTEX_SKIP_BLOCKERS = {
     ignored_author: VORTEX_IGNORED_AUTHOR,
     repo_disabled: VORTEX_REPO_DISABLED,
 };
-export function vortexRetryScheduled(layer) {
+function vortexRetryScheduled(layer) {
     const review = layer.vortexReview;
     const reason = review?.skip_reason?.trim();
     return (reason === "retry_scheduled" || reason === "post_delayed") && sameHead(review?.head_sha, layer.headSha);
@@ -388,6 +390,9 @@ function layerAttention(stack, layer, queue, cursor, nowMs) {
             if (landing && !landGateIsPending(landing))
                 return hardBlock(landing, "land_gate");
         }
+        const stalled = stalledCycloneRun(layer, nowMs);
+        if (stalled)
+            return hardBlock(cycloneStalledBlocker(stalled, nowMs), "cyclone_stalled");
         if (vortexFindingsLeftForPerson(stack, layer, nowMs))
             return hardBlock(VORTEX_FINDINGS_NEED_PERSON, "vortex_findings_need_person");
     }
@@ -408,6 +413,11 @@ function layerAttention(stack, layer, queue, cursor, nowMs) {
     return { blocker: label, reason: "bounce", bounceKind: kind, bounce };
 }
 const UNIT_ABANDONED_BLOCKER_PREFIX = "Review unit abandoned: based on ";
+export const CYCLONE_STALLED_PREFIX = "Cyclone stalled: ";
+function cycloneStalledBlocker(run, nowMs) {
+    const minutes = Math.floor((nowMs - Date.parse(run.startedAt ?? "")) / 60_000);
+    return `${CYCLONE_STALLED_PREFIX}patching ${run.sha?.slice(0, 7) ?? "this PR"} for ${minutes}m with no push or result`;
+}
 function unitAbandonedUnder(stack, layer) {
     if (stack.unit?.state !== "abandoned")
         return false;
@@ -447,15 +457,15 @@ function switchedOffByAnotherActor(stack) {
     const reason = stack.autoLandOff?.reason;
     return reason && AUTO_LAND_SWITCHED_OFF_BY[reason] ? reason : undefined;
 }
-export const AUTO_LAND_CI_PENDING_ATTENTION_MS = 45 * 60_000;
-export const AUTO_LAND_VORTEX_WAIT_ATTENTION_MS = 30 * 60_000;
-export const AUTO_LAND_PROMOTE_FAILED_ATTEMPTS = 3;
-export const AUTO_LAND_CI_FAILED_BLOCKER = "CI failed — Auto land reads a failing check on GitHub at this head";
+const AUTO_LAND_CI_PENDING_ATTENTION_MS = 45 * 60_000;
+const AUTO_LAND_VORTEX_WAIT_ATTENTION_MS = 30 * 60_000;
+const AUTO_LAND_PROMOTE_FAILED_ATTEMPTS = 3;
+const AUTO_LAND_CI_FAILED_BLOCKER = "CI failed — Auto land reads a failing check on GitHub at this head";
 const AUTO_LAND_CI_PENDING_PREFIX = "CI pending for ";
 const AUTO_LAND_VORTEX_WAIT_PREFIX = "No green Vortex review for ";
 const AUTO_LAND_PROMOTE_FAILED_PREFIX = "Promote failed ";
-export const AUTO_LAND_WAIT_ATTENTION_MS = 45 * 60_000;
-export const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS = 10 * 60_000;
+const AUTO_LAND_WAIT_ATTENTION_MS = 45 * 60_000;
+const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS = 10 * 60_000;
 const AUTO_LAND_CI_UNREADABLE_PREFIX = "Mergestorm cannot read ";
 const AUTO_LAND_WAITED_PREFIX = "Auto land has waited ";
 const AUTO_LAND_MEMBERS_REMAINING_PREFIX = "The land PR cannot be queued: ";
@@ -510,7 +520,7 @@ function lastPrLayer(stack) {
         return land;
     return stack.layers.filter((layer) => layer.prNumber > 0).sort((a, b) => b.position - a.position)[0];
 }
-export function autoLandWaitLayer(stack) {
+function autoLandWaitLayer(stack) {
     const wait = armedAutoLandWait(stack);
     if (!wait)
         return undefined;
@@ -578,7 +588,7 @@ function autoLandWaitNamed(stack, layer, nowMs) {
         ? { blocker: `${AUTO_LAND_WAITED_PREFIX}${minutes}m: ${autoLandWaitWords(wait.reason)}`, reason: "auto_land_waited" }
         : null;
 }
-export const MERGE_QUEUE_STALL_ATTENTION_MS = 45 * 60_000;
+const MERGE_QUEUE_STALL_ATTENTION_MS = 45 * 60_000;
 const MERGE_QUEUE_STALLED_PREFIX = "Merge queue stuck: ";
 const LIVE_QUEUE_STATES = ["queued", "running", "waiting"];
 function minutesOf(ms) {
@@ -679,11 +689,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/";
+function isBreezeBranch(branch) {
+    return typeof branch === "string" && branch.startsWith(BREEZE_BRANCH_PREFIX);
+}
+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.`;
+}
+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 +746,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 +757,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 +771,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") {
@@ -801,6 +825,18 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null, n
             steps: `Auto land is off for this stack (autoLandOff reason ${offReason}: ${AUTO_LAND_SWITCHED_OFF_BY[offReason] ?? offReason}), so nothing will enqueue it and it will not land by itself. No bounce did this and nothing in the layers needs a change: do not patch or push for it. A person or another agent session may have switched it off on purpose, so do not turn Auto land back on yourself. Tell the human that Auto land is off and why, and turn it back on (mg stack set ${stack.id} --auto-land on) only when they say so.`,
         };
     }
+    if (reason === "cyclone_stalled") {
+        const run = stalledCycloneRun(layer, nowMs);
+        return {
+            kind: "cyclone_stalled",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            runSha: run?.sha ?? null,
+            since: run?.startedAt ?? null,
+            steps: `Cyclone has been patching #${layer.prNumber}${run?.sha ? ` (a run for ${run.sha.slice(0, 7)})` : ""} since ${run?.startedAt ?? "an unknown time"} without pushing or finishing, past the ${STACK_AGENT_PATCHING_STALE_MS / 60_000}-minute limit, so the watch no longer waits for it. Patch the open Vortex findings at ${layer.headSha ?? "the head"} yourself: verify each one against a checkout of ${layer.branch}, fix the real ones with the smallest patch and an ordinary push, and dismiss the ones you judge wrong with mg dismiss. If ${layer.branch} moves before you push, Cyclone pushed after all: re-read stack_status instead of pushing. Tell the human Cyclone stalled on this PR.`,
+        };
+    }
     if (reason === "vortex_failed") {
         return {
             kind: "vortex_failed",
@@ -919,7 +955,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null, n
     }
     return null;
 }
-export const LAND_PR_MISSING_PREFIX = "No open land PR for ";
+const LAND_PR_MISSING_PREFIX = "No open land PR for ";
 function landPrMissing(stack, candidate) {
     const unit = stack.unit;
     if (!unit || candidate || stack.archivedAt || unit.state === "landed" || unit.state === "abandoned")

package/dist/stack-dto.d.ts

@@ -120,7 +120,9 @@ export type StackAgentsBusy = {
     headSha: string | null;
 };
 export declare const STACK_AGENT_QUEUED_STALE_MS: number;
+export declare const STACK_AGENT_PATCHING_STALE_MS: number;
 export declare const AUTO_RESOLVE_ENQUEUE_GRACE_MS: number;
+export declare function stalledCycloneRun(layer: Pick<StackLayerDto, "agentRuns">, nowMs?: number): StackAgentRun | null;
 export declare function deriveStackAgentsBusy(layer: Pick<StackLayerDto, "headSha" | "vortexStatus" | "cycloneStatus" | "agentRuns" | "vortexReview" | "cycloneConflictPendingSince" | "cycloneCiPendingSince">, opts?: {
     cycloneClaimed?: boolean;
     nowMs?: number;
@@ -238,6 +240,7 @@ export type StackLayerDto = {
     headSha?: string | null;
     /** Head SHA that produced mergeable / mergeableState. */
     mergeableHeadSha?: string | null;
+    staleBaseMergeable?: boolean;
     /** GitHub PR draft flag from enrich; the auto-land watcher never enqueues a draft. */
     draft?: boolean | null;
     /**
@@ -497,6 +500,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-dto.js

@@ -26,6 +26,7 @@ export const AUTO_LAND_OFF_REASONS = ["user", "archive", "watcher", "cancelled",
 export const CYCLONE_FIX_HELD_REASON = "fix_held";
 export const CYCLONE_CI_FIX_HELD_REASON = "ci_fix_held";
 export const STACK_AGENT_QUEUED_STALE_MS = 15 * 60 * 1000;
+export const STACK_AGENT_PATCHING_STALE_MS = 60 * 60 * 1000;
 export const AUTO_RESOLVE_ENQUEUE_GRACE_MS = 2 * 60_000;
 function agentShaMayBeHead(sha, head) {
     const left = sha?.trim().toLowerCase();
@@ -34,6 +35,17 @@ function agentShaMayBeHead(sha, head) {
         return false;
     return left.startsWith(right) || right.startsWith(left);
 }
+export function stalledCycloneRun(layer, nowMs = Date.now()) {
+    const patching = (layer.agentRuns ?? [])
+        .filter((run) => !run.finishedAt && run.agent === "cyclone" && run.status === "patching")
+        .map((run) => ({ run, startedMs: Date.parse(run.startedAt ?? "") }));
+    if (!patching.length)
+        return null;
+    if (!patching.every(({ startedMs }) => Number.isFinite(startedMs) && nowMs - startedMs > STACK_AGENT_PATCHING_STALE_MS)) {
+        return null;
+    }
+    return patching.reduce((newest, entry) => (entry.startedMs > newest.startedMs ? entry : newest)).run;
+}
 export function deriveStackAgentsBusy(layer, opts = {}) {
     const headSha = layer.headSha?.trim() || null;
     const nowMs = opts.nowMs ?? Date.now();
@@ -54,8 +66,9 @@ export function deriveStackAgentsBusy(layer, opts = {}) {
         const sinceMs = Date.parse(since ?? "");
         return Number.isFinite(sinceMs) && nowMs - sinceMs <= AUTO_RESOLVE_ENQUEUE_GRACE_MS;
     };
-    const cyclone = opts.cycloneClaimed === true || layer.cycloneStatus === "patching" ||
-        runs.some((run) => run.agent === "cyclone" && run.status === "patching") ||
+    const stalled = stalledCycloneRun(layer, nowMs) !== null;
+    const cyclone = (!stalled && (opts.cycloneClaimed === true || layer.cycloneStatus === "patching" ||
+        runs.some((run) => run.agent === "cyclone" && run.status === "patching"))) ||
         runs.some((run) => run.agent === "cyclone" && agentShaMayBeHead(run.sha, headSha) && queuedFresh(run)) ||
         withinGrace(layer.cycloneConflictPendingSince) ||
         withinGrace(layer.cycloneCiPendingSince);

package/dist/stack-meta.d.ts

@@ -3,7 +3,7 @@ export type StackLayerMeta = {
     /** Parent branch name (trunk for the bottom layer). */
     parentBranch: string;
 };
-export type LocalStack = {
+type LocalStack = {
     layers: StackLayerMeta[];
     autoEnqueueWhenReady?: boolean;
     /** Per-open override carried from `stack create` to `stack submit`; absent = account flag. */
@@ -22,7 +22,6 @@ export type StackMeta = {
 export declare function stackMetaPath(cwd?: string, stacksRoot?: string): string;
 export declare function loadStackMeta(cwd?: string, stacksRoot?: string): Promise<StackMeta | null>;
 export declare function emptyStackMeta(trunk: string): StackMeta;
-export declare function activeStack(meta: StackMeta): LocalStack;
 export declare function activeLayers(meta: StackMeta): StackLayerMeta[];
 export declare function setActiveAutoEnqueue(meta: StackMeta, enabled: boolean | undefined): StackMeta;
 /** Per-open automation flags remembered on the active local stack until submit. */
@@ -45,3 +44,4 @@ export declare function appendLayer(meta: StackMeta, layer: StackLayerMeta): Sta
 export declare function selectStackForCreate(meta: StackMeta, parentBranch: string): StackMeta;
 /** Drop the active stack after a successful submit. */
 export declare function removeActiveStack(meta: StackMeta): StackMeta;
+export {};

package/dist/stack-meta.js

@@ -102,7 +102,7 @@ export function emptyStackMeta(trunk) {
         active: 0,
     };
 }
-export function activeStack(meta) {
+function activeStack(meta) {
     const stack = meta.stacks[meta.active];
     if (!stack) {
         throw new Error("Stack authoring state has an out-of-range active stack; run `mg stack reset --force` to clear it.");

package/dist/stack-watch-loop.d.ts

@@ -1,21 +1,14 @@
 import type { Config } from "./config.js";
 import { readLandedQueueEntry } from "./api.js";
 import { pollStackWatch, type StackWatchCursor, type StackWatchEnvelope } from "./stack-watch.js";
-export declare const STACK_WATCH_MARKER = "MS-WATCH";
 export declare const STACK_WATCH_EXIT: {
     readonly landed: 0;
     readonly attention: 3;
     readonly timeout: 5;
 };
 export declare const STACK_WATCH_SLICE_MS = 300000;
-export declare const STACK_WATCH_RECHECK_MS = 30000;
-export declare const STACK_WATCH_FAILED_RETRY_MS = 15000;
-export declare const STACK_WATCH_RATE_LIMIT_WAIT_MS = 30000;
-export declare const STACK_WATCH_TRANSIENT_WINDOW_MS: number;
-export declare const STACK_WATCH_TRANSIENT_MAX_WAIT_MS = 60000;
-export declare function isTransientWatchFailure(err: unknown): boolean;
 export type StackWatchUntil = "attention" | "landed";
-export type StackWatchOutcome = "attention" | "landed" | "failed" | "timeout" | "aborted";
+type StackWatchOutcome = "attention" | "landed" | "failed" | "timeout" | "aborted";
 export type RunStackWatchOptions = {
     until?: StackWatchUntil;
     ignore?: readonly string[];
@@ -35,10 +28,6 @@ export type StackWatchLoopResult = {
     exitCode: number;
     envelope: StackWatchEnvelope | null;
 };
-export declare function blockerWithoutElapsedMinutes(blocker: string | null | undefined): string;
-export declare function stackWatchAttentionKey(envelope: Pick<StackWatchEnvelope, "prNumber" | "headSha" | "blocker">): string;
-export declare function stackWatchAttentionLine(envelope: StackWatchEnvelope): string;
-export declare function stackWatchLandedLine(envelope: StackWatchEnvelope): string;
 export declare function stackWatchFailedLine(stackId: string, message: string): string;
-export declare function stackWatchTimeoutLine(stackId: string, maxMs: number): string;
 export declare function runStackWatch(cfg: Config, stackId: string, opts?: RunStackWatchOptions): Promise<StackWatchLoopResult>;
+export {};

package/dist/stack-watch-loop.js

@@ -3,16 +3,16 @@ import { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, LandedQueueReadError, readL
 import { isTransientReviewPollError } from "./commands/review-client.js";
 import { stackWatchBackgroundCommand } from "./stack-watch-obligation.js";
 import { pollStackWatch, StackWatchError, StackWatchTimeoutError, } from "./stack-watch.js";
-export const STACK_WATCH_MARKER = "MS-WATCH";
+const STACK_WATCH_MARKER = "MS-WATCH";
 export const STACK_WATCH_EXIT = { landed: 0, attention: 3, timeout: 5 };
 export const STACK_WATCH_SLICE_MS = 300_000;
-export const STACK_WATCH_RECHECK_MS = 30_000;
-export const STACK_WATCH_FAILED_RETRY_MS = 15_000;
-export const STACK_WATCH_RATE_LIMIT_WAIT_MS = 30_000;
-export const STACK_WATCH_TRANSIENT_WINDOW_MS = 15 * 60_000;
-export const STACK_WATCH_TRANSIENT_MAX_WAIT_MS = 60_000;
+const STACK_WATCH_RECHECK_MS = 30_000;
+const STACK_WATCH_FAILED_RETRY_MS = 15_000;
+const STACK_WATCH_RATE_LIMIT_WAIT_MS = 30_000;
+const STACK_WATCH_TRANSIENT_WINDOW_MS = 15 * 60_000;
+const STACK_WATCH_TRANSIENT_MAX_WAIT_MS = 60_000;
 const TRANSIENT_WATCH_FAILURE = /HTTP (?:408|429|5\d\d)|snapshot missing|fetch failed|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|network|connection/i;
-export function isTransientWatchFailure(err) {
+function isTransientWatchFailure(err) {
     if (!(err instanceof Error))
         return false;
     if (err instanceof LandedQueueReadError)
@@ -24,24 +24,24 @@ export function isTransientWatchFailure(err) {
     return err.message.startsWith(API_TIMEOUT_PREFIX) || TRANSIENT_WATCH_FAILURE.test(err.message);
 }
 const ELAPSED_MINUTES = /\b\d+m\b/g;
-export function blockerWithoutElapsedMinutes(blocker) {
+function blockerWithoutElapsedMinutes(blocker) {
     return (blocker ?? "").replace(ELAPSED_MINUTES, "Nm");
 }
-export function stackWatchAttentionKey(envelope) {
+function stackWatchAttentionKey(envelope) {
     return `${envelope.prNumber ?? ""}|${envelope.headSha ?? ""}|${blockerWithoutElapsedMinutes(envelope.blocker)}`;
 }
-export function stackWatchAttentionLine(envelope) {
+function stackWatchAttentionLine(envelope) {
     const restart = envelope.cursor.bounceId
         ? ` restart=${JSON.stringify(stackWatchBackgroundCommand(envelope.stackId, envelope.cursor))}` : "";
     return `${STACK_WATCH_MARKER} ATTENTION pr=${envelope.prNumber ?? "none"} head=${envelope.headSha ?? "none"} blocker=${JSON.stringify(envelope.blocker ?? "")} repair=${envelope.repair?.kind ?? "none"}${restart}`;
 }
-export function stackWatchLandedLine(envelope) {
+function stackWatchLandedLine(envelope) {
     return `${STACK_WATCH_MARKER} LANDED stack=${envelope.stackId} reason=${envelope.watch.reason}`;
 }
 export function stackWatchFailedLine(stackId, message) {
     return `${STACK_WATCH_MARKER} ATTENTION failed stack=${stackId} error=${JSON.stringify(message)}`;
 }
-export function stackWatchTimeoutLine(stackId, maxMs) {
+function stackWatchTimeoutLine(stackId, maxMs) {
     return `${STACK_WATCH_MARKER} TIMEOUT stack=${stackId} after=${Math.round(maxMs / 60_000)}m`;
 }
 function isAbort(err, signal) {
@@ -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 } : {}) });