mergestorm 0.3.34 → 0.3.36

package/README.md

@@ -45,7 +45,7 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.34                                             │
+│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.36                                             │
 │ ▀▀▀▀▀▀▀▀▀     ● msk_live_… · maelstrom                                       │
 │  ▀▀▀▀▀▀       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used                      │
 │   ▝▀▀▀▀▀      local reviews + stacked PRs · mergestorm.ai                    │

package/dist/commands/stack.d.ts

@@ -1,6 +1,6 @@
 import { type StackHeldBlocker, type StackRepairHint } from "../stack-blockers.js";
 import { type StackWatchObligation } from "../stack-watch-obligation.js";
-import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, listStacks, openStackPull, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
+import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, listMergeQueueEntries, listStacks, openStackPull, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
 import { loadConfig } from "../config.js";
 import { createPrs, findOpenPrNumber } from "../gh.js";
 import { parseGithubOriginRepo } from "../git.js";
@@ -147,6 +147,7 @@ export declare function cmdStackWatch(args: string[], deps?: {
 export declare function cmdStackStatus(args: string[], deps?: {
     loadConfig?: typeof loadConfig;
     getEnrichedStack?: typeof getEnrichedStack;
+    listMergeQueueEntries?: typeof listMergeQueueEntries;
 }): Promise<void>;
 export type StackSetDeps = {
     loadConfig?: typeof loadConfig;

package/dist/commands/stack.js

@@ -1,6 +1,6 @@
 import { stackBlockers, stackBlockersSummary } from "../stack-blockers.js";
 import { STACK_WATCH_NOT_DONE_SENTENCE, STACK_WATCH_NOTIFY_PATTERN, stackTerminalReason, stackWatchObligation, } from "../stack-watch-obligation.js";
-import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, landNextStack, listStacks, openStackPull, restackStack, setStackPolicy, } from "../api.js";
+import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, landNextStack, listMergeQueueEntries, listStacks, openStackPull, restackStack, setStackPolicy, } from "../api.js";
 import { loadConfig } from "../config.js";
 import { rateLimitedMessage, REVIEW_EXIT, CommandError } from "../errors.js";
 import { createPrs, findOpenPrNumber, ghReady, githubApiFromEnv, } from "../gh.js";
@@ -910,7 +910,7 @@ export async function cmdStackWait(args, deps = {}) {
             ...(retryAfterSeconds !== undefined ? { retry_after_seconds: retryAfterSeconds } : {}),
         }, null, 2)
         : [
-            `Stack ${envelope.stackId} · ${envelope.status}${stackBlockersSummary(envelope.blocker && envelope.prNumber != null ? { prNumber: envelope.prNumber, blocker: envelope.blocker } : null, envelope.issues, envelope.busy, envelope.landGatePending ?? null, envelope.actAfter ?? null)}${envelope.assessment === "unavailable" ? " · assessment unavailable" : ""}`,
+            `Stack ${envelope.stackId} · ${envelope.status}${stackBlockersSummary(envelope.blocker && envelope.prNumber != null ? { prNumber: envelope.prNumber, blocker: envelope.blocker } : null, envelope.issues, envelope.busy, envelope.landGatePending ?? null, envelope.actAfter ?? null, envelope.queueWait ?? null)}${envelope.assessment === "unavailable" ? " · assessment unavailable" : ""}`,
             ...stackRepairLine(envelope.repair),
             ...stackWatchTextLines(envelope.watch),
         ].join("\n"));
@@ -1018,7 +1018,10 @@ export async function cmdStackStatus(args, deps = {}) {
         console.log(watch.message);
         throw new CommandError(`Stack not found or not owned by the current user: ${stackId}`, 1, "not_found");
     }
-    const { attention, held, currentCandidate, repair } = stackBlockers(stack);
+    const entries = await (deps.listMergeQueueEntries ?? listMergeQueueEntries)(cfg, {
+        stackId: stack.id,
+    });
+    const { attention, held, currentCandidate, repair, queueWait } = stackBlockers(stack, entries);
     const watch = stackWatchObligation({
         stackId: stack.id,
         terminal: stackTerminalReason(stack),
@@ -1027,7 +1030,7 @@ export async function cmdStackStatus(args, deps = {}) {
         freshCursor: true,
     });
     if (asJson) {
-        console.log(JSON.stringify({ ...stack, held, repair, watch }, null, 2));
+        console.log(JSON.stringify({ ...stack, held, repair, queueWait, watch }, null, 2));
         return;
     }
     const lines = formatStackHuman(stack, false);
@@ -1040,6 +1043,8 @@ export async function cmdStackStatus(args, deps = {}) {
             (layer.cycloneStatus ? `  Cyclone: ${layer.cycloneStatus}` : "") +
             (layer.tempestStatus ? `  Tempest: ${layer.tempestStatus}` : ""));
     }
+    if (queueWait && !attention)
+        lines.push(`  Queue: #${queueWait.prNumber} ${queueWait.text}`);
     lines.push(...[...stackHeldLine(held), ...stackRepairLine(repair), ...stackWatchTextLines(watch)].map((line) => `  ${line}`));
     await present("Stack status", lines);
 }

package/dist/stack-blockers.d.ts

@@ -54,12 +54,42 @@ export type StackRepairHint = {
     branch: string;
     findings: string;
     steps: string;
+} | {
+    kind: "tempest_rerun";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    stoppedByPerson: boolean;
+    steps: string;
+} | {
+    kind: "vortex_findings";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    handoff: string | null;
+    findings: string;
+    steps: string;
 } | {
     kind: "unit_abandoned";
     prNumber: number;
     headSha: string | null;
     branch: string;
     steps: string;
+} | {
+    kind: "restack_failed";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    liveParent: string | null;
+    restackKind: string;
+    steps: string;
+} | {
+    kind: "seam_review_stuck";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    seamState: string;
+    steps: string;
 } | {
     kind: "auto_land_off";
     prNumber: number;
@@ -67,6 +97,36 @@ export type StackRepairHint = {
     branch: string;
     bounceKind: string;
     steps: string;
+} | {
+    kind: "ci_pending" | "vortex_not_green";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    since: string;
+    steps: string;
+} | {
+    kind: "queue_stalled";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    since: string | null;
+    waitReason: string | null;
+    steps: string;
+} | {
+    kind: "vortex_skipped";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    skipReason: string;
+    steps: string;
+} | {
+    kind: "promote_failed";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    attempts: number;
+    message: string | null;
+    steps: string;
 };
 export type StackLandGatePending = {
     prNumber: number;
@@ -82,14 +142,48 @@ 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 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 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 function autoLandWaitBlocker(stack: StackDto, layer: StackLayerDto, nowMs: number): string | null;
+export declare const MERGE_QUEUE_STALL_ATTENTION_MS: number;
+export type StackQueueWait = {
+    prNumber: number;
+    headSha: string | null;
+    text: string;
+    since: string | null;
+    waitReason: string | null;
+};
+export type MergeQueueWait = {
+    text: string;
+    stalled: boolean;
+    since: string | null;
+    waitReason: string | null;
+    aheadStackId: string | null;
+    aheadOther: boolean;
+};
+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 function agentsCannotClear(blocker: string): boolean;
-export declare function stackRepair(stack: StackDto, attention: StackBlocker | null, layer: StackLayerDto | undefined, bounce: MergeQueueEntryDto | undefined): StackRepairHint | null;
+export declare function stackRepair(stack: StackDto, attention: StackBlocker | null, layer: StackLayerDto | undefined, bounce: MergeQueueEntryDto | undefined, queueWait?: MergeQueueWait | null): StackRepairHint | null;
 /** 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">): {
+export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntryDto[], cursor?: Pick<StackWatchCursor, "bounceId" | "afterFinishedAt">, nowMs?: number): {
     attention: null;
     held: StackHeldBlocker;
     issues: StackBlocker[];
@@ -102,6 +196,7 @@ export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntry
     agents: StackLayerAgents | null;
     repair: StackRepairHint | null;
     landGatePending: StackLandGatePending | null;
+    queueWait: StackQueueWait | null;
 } | {
     attention: StackBlocker | null;
     held: null;
@@ -115,6 +210,7 @@ export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntry
     agents: StackLayerAgents | null;
     repair: StackRepairHint | null;
     landGatePending: StackLandGatePending | null;
+    queueWait: StackQueueWait | null;
 };
 /** 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): string;
+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;

package/dist/stack-blockers.js

@@ -51,13 +51,81 @@ 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 STUCK_SEAM_BLOCKERS = [SEAM_REVIEW_STUCK, SEAM_REREVIEW_NOT_RUNNING, SEAM_VERDICT_STALE];
+function coreReviewDoneAtHead(layer) {
+    const review = layer.vortexReview;
+    return review?.status === "done" && sameHead(review.head_sha, layer.headSha);
+}
+export const VORTEX_FINDINGS_NEED_PERSON = "Vortex findings need a person";
+function vortexChangesRequestedAtHead(layer) {
+    const review = layer.vortexReview;
+    if (review && !(review.status === "done" && sameHead(review.head_sha, layer.headSha)))
+        return false;
+    return layer.vortexStatus === "findings" && layer.reviewStatus === "changes_requested";
+}
+function cycloneHandoffAtHead(stack, layer) {
+    if (sameHead(layer.cycloneHandoff?.headSha, layer.headSha))
+        return layer.cycloneHandoff.reason;
+    return stack.cyclonePatchOff ?? (stack.autoPatchOverride === false ? "auto_patch_off" : null);
+}
+const CYCLONE_HANDOFF_WORDS = {
+    auto_patch_off: "auto-patch is off for this stack",
+    stack_auto_patch_off: "auto-patch is off for this stack",
+    account_auto_patch_off: "auto-patch is off for the account and this stack does not turn it on",
+    cyclone_not_connected: "Cyclone is not connected to this repo",
+};
+function cycloneHandoffWords(reason) {
+    return CYCLONE_HANDOFF_WORDS[reason] ?? reason.replaceAll("_", " ");
+}
+function vortexFindingsLeftForPerson(stack, layer) {
+    return vortexChangesRequestedAtHead(layer) && !layerAgentsBusy(layer).cyclone &&
+        cycloneHandoffAtHead(stack, layer) !== null;
+}
 function quotaSkippedReview(layer) {
     const review = layer.vortexReview;
     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";
+const VORTEX_SKIP_BLOCKERS = {
+    auto_review_off: VORTEX_AUTO_REVIEW_OFF,
+    billing_blocked: VORTEX_BILLING_SKIPPED,
+    billing_unavailable: VORTEX_BILLING_SKIPPED,
+};
+function vortexIdleSkipBlocker(layer) {
+    if (layerAgentsBusy(layer).vortex)
+        return null;
+    const review = layer.vortexReview;
+    if (review?.status === "skipped" && sameHead(review.head_sha, layer.headSha)) {
+        const reason = review.skip_reason?.trim() ?? "";
+        const blocker = VORTEX_SKIP_BLOCKERS[reason];
+        if (blocker)
+            return { blocker, skipReason: reason };
+    }
+    if (layer.vortexStatus === "incomplete" && sameHead(review?.head_sha, layer.headSha)) {
+        return { blocker: VORTEX_REVIEW_INCOMPLETE, skipReason: "incomplete" };
+    }
+    return null;
+}
+function vortexSkippedSteps(stack, layer, skipReason) {
+    const head = layer.headSha ?? "its live head";
+    const mention = `comment @mergestorm-vortex review on #${layer.prNumber}`;
+    if (skipReason === "auto_review_off") {
+        return `Vortex auto-review is off for ${stack.owner}/${stack.repo} or for this stack, so it skipped #${layer.prNumber} at ${head} and Auto land waits for a review that will not come. Do not patch or push for this. Tell the human: they can turn auto-review on (mg stack set ${stack.id} --auto-review on, or the repo setting in the dashboard), which does not review this head by itself, and then ${mention} to review it now.`;
+    }
+    if (skipReason === "incomplete") {
+        return `Vortex reviewed only some of the files in #${layer.prNumber} at ${head} and left the rest unreviewed, so Auto land waits for full coverage. Do not patch or push for this. To review the remaining files, ${mention} (the Continue button on the stack is unrelated), or tell the human to do it; turning on automatic overflow reviews in the dashboard settings covers this for later heads.`;
+    }
+    return `Vortex skipped #${layer.prNumber} at ${head} because it could not confirm billing for this account, so Auto land waits for a review that will not come. Do not patch or push for this. Re-run the review: ${mention}. If it is skipped again, tell the human to check the plan and billing in the Mergestorm dashboard.`;
+}
 function seamGateBlocker(stack, layer) {
     const members = stack.unit?.members ?? [];
     if (layer.prNumber === stack.unit?.landPrNumber)
@@ -72,8 +140,20 @@ function seamGateBlocker(stack, layer) {
         return "Seam review failed";
     if (seamState === "findings" && sameHead(member.seamReviewedSha, layer.headSha))
         return "Seam findings";
-    if (seamState === "pending" && !layerAgentsBusy(layer).vortex)
+    if (layerAgentsBusy(layer).vortex)
+        return null;
+    if (seamState === "pending")
         return SEAM_REVIEW_NOT_RUNNING;
+    if (seamState === "reviewing")
+        return SEAM_REVIEW_STUCK;
+    if (seamState === "pending_rereview")
+        return SEAM_REREVIEW_NOT_RUNNING;
+    if (!layer.headSha?.trim() || sameHead(member.seamReviewedSha, layer.headSha))
+        return null;
+    if (seamState === "findings")
+        return SEAM_VERDICT_STALE;
+    if (seamState === "approved" && !coreReviewDoneAtHead(layer))
+        return SEAM_VERDICT_STALE;
     return null;
 }
 function headChecksAllGreen(layer) {
@@ -96,7 +176,7 @@ function layerAttention(stack, layer, queue, cursor) {
             if (layer.restackError.kind === "rebase_conflict")
                 return hardBlock("Conflict");
             if (!restackRetryPending(layer.restackError, layer))
-                return hardBlock("Restack failed");
+                return hardBlock(RESTACK_FAILED);
         }
         if (layer.state === "conflict")
             return hardBlock("Conflict");
@@ -116,13 +196,16 @@ function layerAttention(stack, layer, queue, cursor) {
             sameHead(run.sha, layer.headSha)))
             return hardBlock("Cyclone failed");
         const tempest = layer.agentRuns?.find((run) => run.agent === "tempest" &&
-            ["findings", "failed"].includes(run.status) && sameHead(run.sha, layer.headSha));
+            run.status === "findings" && sameHead(run.sha, layer.headSha));
         if (tempest)
             return hardBlock(`Tempest ${tempest.status}`);
         if (layer.vortexStatus === "failed")
             return hardBlock("Review failed");
         if (quotaSkippedReview(layer))
             return hardBlock(VORTEX_REVIEW_OUT_OF_QUOTA);
+        const vortexSkip = vortexIdleSkipBlocker(layer);
+        if (vortexSkip)
+            return hardBlock(vortexSkip.blocker);
         const seam = seamGateBlocker(stack, layer);
         if (seam)
             return hardBlock(seam);
@@ -136,6 +219,8 @@ function layerAttention(stack, layer, queue, cursor) {
             if (stack.unit.tempestLandStatus?.toLowerCase() === "failed")
                 return hardBlock("Tempest failed");
         }
+        if (vortexFindingsLeftForPerson(stack, layer))
+            return hardBlock(VORTEX_FINDINGS_NEED_PERSON);
     }
     if (!bounce || !kind || recoverable || !layer || queue.some((entry) => ["queued", "running", "waiting"].includes(entry.state)))
         return none;
@@ -179,6 +264,101 @@ function disarmingBounce(stack, queue) {
         return recorded;
     return 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_PREFIX = "CI pending for ";
+const AUTO_LAND_VORTEX_WAIT_PREFIX = "No green Vortex review for ";
+const AUTO_LAND_PROMOTE_FAILED_PREFIX = "Promote failed ";
+function waitedMs(since, nowMs) {
+    const sinceMs = Date.parse(since);
+    return Number.isFinite(sinceMs) ? Math.max(0, nowMs - sinceMs) : null;
+}
+function autoLandWaitOn(stack, layer) {
+    const wait = stack.autoLandWait;
+    if (!wait || stack.archivedAt || stack.autoEnqueueWhenReady !== true)
+        return null;
+    if (wait.prNumber !== layer.prNumber || !sameHead(wait.headSha, layer.headSha))
+        return null;
+    return wait;
+}
+export function autoLandWaitBlocker(stack, layer, nowMs) {
+    const wait = autoLandWaitOn(stack, layer);
+    if (!wait)
+        return null;
+    const waited = waitedMs(wait.since, nowMs);
+    if (waited == null)
+        return null;
+    const minutes = Math.floor(waited / 60_000);
+    switch (wait.reason) {
+        case "ci_failure":
+            return AUTO_LAND_CI_FAILED_BLOCKER;
+        case "ci_pending":
+            return waited >= AUTO_LAND_CI_PENDING_ATTENTION_MS
+                ? `${AUTO_LAND_CI_PENDING_PREFIX}${minutes}m — a check on this head has not finished, so Auto land will not queue it`
+                : null;
+        case "vortex_not_green":
+            return waited >= AUTO_LAND_VORTEX_WAIT_ATTENTION_MS
+                ? `${AUTO_LAND_VORTEX_WAIT_PREFIX}${minutes}m — Auto land is waiting for an approving Vortex review at this head`
+                : null;
+        case "promote_merge_failed":
+            return (wait.attempts ?? 0) >= AUTO_LAND_PROMOTE_FAILED_ATTEMPTS
+                ? `${AUTO_LAND_PROMOTE_FAILED_PREFIX}${wait.attempts} times (merge_failed) — Auto land stopped retrying this head${wait.detail ? `: ${wait.detail}` : ""}`
+                : null;
+        default:
+            return null;
+    }
+}
+export 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) {
+    return ms == null ? 0 : Math.floor(ms / 60_000);
+}
+export function mergeQueueWait(queue, nowMs) {
+    const entry = queue.find((candidate) => LIVE_QUEUE_STATES.includes(candidate.state));
+    if (!entry)
+        return null;
+    const reason = entry.waitReason?.trim() || null;
+    if (entry.state === "queued") {
+        const queuedFor = minutesOf(waitedMs(entry.enqueuedAt, nowMs));
+        const ahead = entry.aheadInRepo;
+        if (!ahead) {
+            return {
+                text: `Queued ${queuedFor}m in the merge queue, not picked up yet${reason ? ` (last note: ${reason})` : ""}`,
+                stalled: false,
+                since: entry.enqueuedAt, waitReason: reason, aheadStackId: null, aheadOther: false,
+            };
+        }
+        const aheadMs = ahead.claimedAt ? waitedMs(ahead.claimedAt, nowMs) : null;
+        const aheadReason = ahead.waitReason?.trim() || null;
+        const who = ahead.stackId ? `stack ${ahead.stackId}` : "another user's stack";
+        const aheadFor = aheadMs == null ? "an unknown duration" : `${minutesOf(aheadMs)}m`;
+        return {
+            text: `Queued ${queuedFor}m behind ${who}, which has been ${ahead.state} in the merge queue for ${aheadFor}${aheadReason ? `: ${aheadReason}` : ""}`,
+            stalled: aheadMs != null && aheadMs >= MERGE_QUEUE_STALL_ATTENTION_MS,
+            since: ahead.claimedAt, waitReason: aheadReason, aheadStackId: ahead.stackId, aheadOther: !ahead.stackId,
+        };
+    }
+    const since = entry.claimedAt ?? null;
+    const liveMs = since === null ? null : waitedMs(since, nowMs);
+    const liveFor = liveMs == null ? "an unknown duration" : `${minutesOf(liveMs)}m`;
+    return {
+        text: `Merge queue ${entry.state === "waiting" ? "waiting" : "running"} for ${liveFor}: ${reason ?? "no reason recorded"}`,
+        stalled: liveMs != null && liveMs >= MERGE_QUEUE_STALL_ATTENTION_MS,
+        since, waitReason: reason, aheadStackId: null, aheadOther: false,
+    };
+}
+function queueStalledSteps(stack, layer, wait) {
+    if (wait.aheadStackId || wait.aheadOther) {
+        const ahead = wait.aheadStackId
+            ? `Run mg stack status ${wait.aheadStackId} and fix what it names there; this stack moves once that entry lands or bounces.`
+            : "That entry belongs to another Mergestorm user, so you cannot fix it from here.";
+        return `#${layer.prNumber} is waiting in the merge queue behind another entry in ${stack.owner}/${stack.repo} that has made no progress since ${wait.since ?? "it was claimed"}. Nothing on ${layer.branch} needs a change. ${ahead} If it stays stuck, tell the human: the queue for this repo is held by that entry.`;
+    }
+    return `The merge queue has held #${layer.prNumber} at ${layer.headSha ?? "its head"} since ${wait.since ?? "it was claimed"} without landing or bouncing it${wait.waitReason ? `; its last note is: ${wait.waitReason}` : ", and it recorded no reason"}. If the note names a failing check or a conflict on ${layer.branch}, fix that with an ordinary push. If it waits on CI, list the head's checks (gh run list --branch ${layer.branch}) and re-run the one that never finished (gh run rerun <run-id>). If nothing moves after that, tell the human: they can take the stack out of the queue and enqueue it again (mg queue rm ${stack.id}, then mg queue add ${stack.id}). Do not retarget the PR base.`;
+}
 function isTerminalLayer(layer) {
     return layer.state === "merged" || layer.state === "closed";
 }
@@ -215,23 +395,48 @@ 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) {
+    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.`;
+    }
+    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) {
     const base = stack.unit?.landTarget?.trim() || layer.parentBranch?.trim();
     return base && !isMgParkBase(base) && base !== layer.branch ? base : null;
 }
 export function agentsCannotClear(blocker) {
-    return blocker === "Conflict" || blocker === "Restack failed" || blocker === "Draft PR" ||
+    return blocker === "Conflict" || blocker === RESTACK_FAILED || blocker === "Draft PR" ||
         blocker === SEAM_REVIEW_NOT_RUNNING || blocker === VORTEX_REVIEW_OUT_OF_QUOTA ||
+        blocker === VORTEX_AUTO_REVIEW_OFF || blocker === VORTEX_BILLING_SKIPPED ||
+        blocker === VORTEX_REVIEW_INCOMPLETE ||
+        STUCK_SEAM_BLOCKERS.includes(blocker) ||
         blocker.startsWith("Merge conflicts") || blocker.startsWith(UNIT_ABANDONED_BLOCKER_PREFIX);
 }
-function isTempestFindingsBlocker(attention) {
+const TEMPEST_RERUN_BLOCKER = /^(?:landing blocked:\s*)?tempest_(failed|stopped)\b/i;
+function isTempestFindingsBlocker(attention, bounce) {
     const blocker = attention.blocker.trim();
+    const reason = bounce?.bounceDetail?.message?.trim();
+    if (reason && TEMPEST_RERUN_BLOCKER.test(reason))
+        return false;
     return attention.bounceKind === "tempest_findings" || /^Tempest findings\b/i.test(blocker) ||
         /^(?:landing blocked:\s*)?tempest_findings\b/i.test(blocker);
 }
-export function stackRepair(stack, attention, layer, bounce) {
+export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
     if (!attention || !layer || attention.prNumber !== layer.prNumber)
         return null;
+    if (queueWait && attention.blocker.startsWith(MERGE_QUEUE_STALLED_PREFIX)) {
+        return {
+            kind: "queue_stalled",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            since: queueWait.since,
+            waitReason: queueWait.waitReason,
+            steps: queueStalledSteps(stack, layer, queueWait),
+        };
+    }
     const landPr = !!stack.unit?.branch && layer.prNumber === stack.unit.landPrNumber && layer.branch === stack.unit.branch;
     const restackConflict = attention.blocker === "Conflict" || attention.bounceKind === "restack_conflict";
     const mergeConflict = attention.blocker.startsWith("Merge conflicts");
@@ -247,6 +452,18 @@ export function stackRepair(stack, attention, layer, bounce) {
             steps: conflictRepairSteps(layer.branch, liveParent),
         };
     }
+    if (attention.blocker === RESTACK_FAILED && layer.restackError) {
+        const liveParent = landPr ? landPrLiveParent(stack, layer) : conflictLiveParent(stack, layer);
+        return {
+            kind: "restack_failed",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            liveParent,
+            restackKind: layer.restackError.kind,
+            steps: restackFailedRepairSteps(layer.branch, liveParent, layer.restackError),
+        };
+    }
     if (attention.blocker.startsWith(UNIT_ABANDONED_BLOCKER_PREFIX)) {
         const openPrCount = stack.layers.filter((candidate) => candidate.prNumber > 0 && !isTerminalLayer(candidate)).length;
         return {
@@ -257,6 +474,22 @@ export function stackRepair(stack, attention, layer, bounce) {
             steps: `The stack's review unit was abandoned when #${layer.prNumber}'s base on GitHub was changed off its mg-stack trunk, so Auto land cannot promote or land this stack. Ask the human whether to re-root it. ${openPrCount < 2 ? `With only one open PR, re-adopting #${layer.prNumber} will not create a review unit; close and resubmit it to create a fresh stack.` : `If yes, tell the human that mg stack adopt ${stack.owner}/${stack.repo}#${layer.prNumber} re-roots it on a new review unit.`} Do not retarget the PR base yourself.`,
         };
     }
+    if (STUCK_SEAM_BLOCKERS.includes(attention.blocker)) {
+        const member = stack.unit?.members?.find((entry) => entry.prNumber === layer.prNumber);
+        const seamState = member?.seamState?.trim().toLowerCase() || "unknown";
+        const reviewed = member?.seamReviewedSha?.trim();
+        const what = attention.blocker === SEAM_VERDICT_STALE
+            ? `The seam (integration) review verdict on #${layer.prNumber} (${seamState}) was made at ${reviewed ? reviewed.slice(0, 7) : "an older head"}, not the live head ${layer.headSha ?? "(unknown)"}, and no seam review is queued or running to replace it`
+            : `The seam (integration) review of #${layer.prNumber} is ${seamState} but no seam review is queued or running at ${layer.headSha ?? "the live head"}`;
+        return {
+            kind: "seam_review_stuck",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            seamState,
+            steps: `${what}, so Auto land cannot promote it. Do not patch or push for this. Tell the human to click Continue on the stack in the Mergestorm dashboard, which re-queues the seam review at the live head of ${layer.branch}; a new commit pushed to ${layer.branch} also queues one. Then keep watching.`,
+        };
+    }
     if (attention.blocker.startsWith(AUTO_LAND_OFF_BLOCKER_PREFIX) && attention.bounceKind) {
         return {
             kind: "auto_land_off",
@@ -267,7 +500,7 @@ export function stackRepair(stack, attention, layer, bounce) {
             steps: `The ${attention.bounceKind} bounce turned Auto land off, so nothing will enqueue this stack. Fix the cause of the bounce on ${layer.branch}, then turn Auto land back on (mg stack set ${stack.id} --auto-land on) or enqueue the stack.`,
         };
     }
-    if (landPr && isTempestFindingsBlocker(attention)) {
+    if (landPr && isTempestFindingsBlocker(attention, bounce)) {
         const findings = `gh api repos/${stack.owner}/${stack.repo}/issues/${layer.prNumber}/comments`;
         return {
             kind: "tempest_findings",
@@ -278,6 +511,81 @@ export function stackRepair(stack, attention, layer, bounce) {
             steps: `Tempest never patches, and Cyclone is not patching this land PR. Read the Tempest report on it (${findings}), verify each finding against ${layer.branch} at its live remote head, fix the real ones with the smallest patch on ${layer.branch}, run the tests, confirm the remote head is still ${layer.headSha ?? "the head you started from"}, then an ordinary git push (no force). Do not retarget the PR base.`,
         };
     }
+    const rerunBlocker = attention.blocker.trim().match(TEMPEST_RERUN_BLOCKER) ??
+        bounce?.bounceDetail?.message?.trim().match(TEMPEST_RERUN_BLOCKER);
+    const rerun = landPr ? rerunBlocker : null;
+    if (rerun) {
+        const stoppedByPerson = rerun[1].toLowerCase() === "stopped";
+        const comment = `gh pr comment ${layer.prNumber} --repo ${stack.owner}/${stack.repo} --body`;
+        const head = layer.headSha ?? "its live head";
+        return {
+            kind: "tempest_rerun",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            stoppedByPerson,
+            steps: stoppedByPerson
+                ? `Tempest's review of land PR #${layer.prNumber} at ${head} was stopped, so Auto land will not land it. There are no findings to fix: do not patch or push. Ask the human whether to run Tempest again. If they say yes, run ${comment} "@mergestorm-tempest review --force" and keep watching.`
+                : `Tempest's review of land PR #${layer.prNumber} at ${head} broke before it produced a result, and Mergestorm already re-ran it the most times it will on its own. There are no findings to fix: do not patch or push. Run it once more with ${comment} "@mergestorm-tempest review" and keep watching. If it breaks again, tell the human.`,
+        };
+    }
+    const vortexSkip = vortexIdleSkipBlocker(layer);
+    if (vortexSkip && attention.blocker === vortexSkip.blocker) {
+        return {
+            kind: "vortex_skipped",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            skipReason: vortexSkip.skipReason,
+            steps: vortexSkippedSteps(stack, layer, vortexSkip.skipReason),
+        };
+    }
+    const wait = autoLandWaitOn(stack, layer);
+    if (wait && attention.blocker.startsWith(AUTO_LAND_CI_PENDING_PREFIX)) {
+        return {
+            kind: "ci_pending",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            since: wait.since,
+            steps: `A check on ${layer.branch} at ${layer.headSha ?? "its head"} has been pending since ${wait.since}, and Auto land will not queue an unfinished head. List the head's checks (gh api repos/${stack.owner}/${stack.repo}/commits/${layer.headSha ?? "<sha>"}/check-runs, and gh run list --branch ${layer.branch}) and find the one that never finished. Re-run it (gh run rerun <run-id>) if it is stuck or was never picked up. If it is a required check that no workflow reports, or it fails again, tell the human. Push a fix only when the check is red for a reason in the code. Do not retarget the PR base.`,
+        };
+    }
+    if (wait && attention.blocker.startsWith(AUTO_LAND_VORTEX_WAIT_PREFIX)) {
+        return {
+            kind: "vortex_not_green",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            since: wait.since,
+            steps: `Auto land has waited since ${wait.since} for an approving Vortex review of ${layer.branch} at ${layer.headSha ?? "its head"}, and no Vortex run is working on it. Read the PR's latest Vortex review (gh api repos/${stack.owner}/${stack.repo}/pulls/${layer.prNumber}/reviews). If it has findings, verify and fix the real ones on ${layer.branch} with an ordinary push, or record a wrong one with mg dismiss as mergestorm-pr-loop describes. If no review exists at this head, or it failed or was skipped, tell the human: nothing re-reviews this head until they re-run the review or push a new head.`,
+        };
+    }
+    if (wait && attention.blocker.startsWith(AUTO_LAND_PROMOTE_FAILED_PREFIX)) {
+        const attempts = wait.attempts ?? AUTO_LAND_PROMOTE_FAILED_ATTEMPTS;
+        return {
+            kind: "promote_failed",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            attempts,
+            message: wait.detail,
+            steps: `Auto land tried to promote #${layer.prNumber} at ${layer.headSha ?? "its head"} ${attempts} times and GitHub refused the merge each time${wait.detail ? ` (${wait.detail})` : ""}, so it stopped retrying this head. Read why: gh api repos/${stack.owner}/${stack.repo}/pulls/${layer.prNumber} --jq '{mergeable, mergeable_state, base: .base.ref}', and the branch protection on that base. If the cause is in ${layer.branch}, fix it and push with an ordinary push: a new head is retried. If it is outside the PR (branch protection, permissions, a required review), tell the human, and that once it is fixed they can retry the promote by turning Auto land off and on (mg stack set ${stack.id} --auto-land off, then --auto-land on). Do not toggle Auto land yourself, and do not retarget the PR base.`,
+        };
+    }
+    if (attention.blocker === VORTEX_FINDINGS_NEED_PERSON) {
+        const findings = `gh api repos/${stack.owner}/${stack.repo}/pulls/${layer.prNumber}/reviews`;
+        const handoff = cycloneHandoffAtHead(stack, layer);
+        return {
+            kind: "vortex_findings",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            handoff,
+            findings,
+            steps: `Vortex requested changes on ${layer.branch} at ${layer.headSha ?? "its live head"} and Cyclone left them for a person${handoff ? ` (${cycloneHandoffWords(handoff)})` : ""}, 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.`,
+        };
+    }
     if (attention.blocker.startsWith("CI failed") || attention.bounceKind === "ci_failure") {
         const failingCheck = bounce?.bounceDetail?.failingCheck?.trim() || layer.checks?.failingName?.trim() || null;
         return {
@@ -292,7 +600,7 @@ export function stackRepair(stack, attention, layer, bounce) {
     return null;
 }
 /** Pair-gate attention plus live hard blocks on every other open layer. */
-export function stackBlockers(stack, entries = [], cursor = {}) {
+export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now()) {
     const candidate = currentLayer(stack);
     const currentCandidate = candidate ? { prNumber: candidate.prNumber, headSha: candidate.headSha ?? null } : null;
     const queue = entries.filter((entry) => entry.stackId.trim().toLowerCase() === stack.id.trim().toLowerCase());
@@ -307,6 +615,7 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
     let attentionLayer;
     let bounce;
     const issues = [];
+    const queueWait = stack.archivedAt ? null : mergeQueueWait(queue, nowMs);
     for (const layer of open) {
         const selected = layer.prNumber === candidate?.prNumber;
         let result = layerAttention(stack, layer, selected ? queue : [], cursor);
@@ -318,6 +627,17 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
                 result = { blocker: `${AUTO_LAND_OFF_BLOCKER_PREFIX}${kind} bounce`, bounceKind: kind, bounce: disarmed };
             }
         }
+        let waitNamed = false;
+        if (!result.blocker) {
+            const waiting = autoLandWaitBlocker(stack, layer, nowMs);
+            if (waiting) {
+                result = { blocker: waiting, bounceKind: null };
+                waitNamed = true;
+            }
+        }
+        if (!result.blocker && selected && queueWait?.stalled) {
+            result = { blocker: `${MERGE_QUEUE_STALLED_PREFIX}${queueWait.text}`, bounceKind: null };
+        }
         if (!result.blocker) {
             if (mergeabilityPending(layer) && (selected || !candidate || layer.position > candidate.position)) {
                 issues.push({ prNumber: layer.prNumber, headSha: layer.headSha ?? null,
@@ -329,7 +649,7 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
             blocker: result.blocker, bounceKind: result.bounceKind };
         if (selected ||
             result.blocker.startsWith(UNIT_ABANDONED_BLOCKER_PREFIX) ||
-            (!attention && layer === child)) {
+            (!attention && (layer === child || waitNamed))) {
             attention = issue;
             attentionLayer = layer;
             bounce = result.bounce;
@@ -340,6 +660,10 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
         else if (!candidate || layer.position > candidate.position)
             issues.push(issue);
     }
+    const queued = queueWait && candidate && !queueWait.stalled
+        ? { prNumber: candidate.prNumber, headSha: candidate.headSha ?? null, text: queueWait.text,
+            since: queueWait.since, waitReason: queueWait.waitReason }
+        : null;
     const settleIssue = mergeabilitySettleIssue(stack, open, issues, attention);
     if (settleIssue)
         issues.push(settleIssue);
@@ -362,11 +686,14 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
     if (busy.length && attention && agentsCannotClear(attention.blocker)) {
         const held = { ...attention, actAfter: "agents_idle", waitingOn: busy.map((entry) => entry.agent) };
         return { attention: null, held, issues: [attention, ...issues], currentCandidate, bounce: undefined, busy, agents,
-            repair: stackRepair(stack, attention, attentionLayer, undefined), landGatePending };
+            repair: stackRepair(stack, attention, attentionLayer, undefined, queueWait), landGatePending, queueWait: queued };
+    }
+    if (busy.length) {
+        return { attention: null, held: null, issues, currentCandidate, bounce: undefined, busy, agents, repair: null, landGatePending,
+            queueWait: queued };
     }
-    if (busy.length)
-        return { attention: null, held: null, issues, currentCandidate, bounce: undefined, busy, agents, repair: null, landGatePending };
-    return { attention, held: null, issues, currentCandidate, bounce, busy, agents, repair: stackRepair(stack, attention, attentionLayer, bounce), landGatePending };
+    return { attention, held: null, issues, currentCandidate, bounce, busy, agents,
+        repair: stackRepair(stack, attention, attentionLayer, bounce, queueWait), landGatePending, queueWait: queued };
 }
 function mergeabilitySettleIssue(stack, open, issues, attention) {
     const settle = stack.autoEnqueueSettle;
@@ -384,7 +711,7 @@ function mergeabilitySettleIssue(stack, open, issues, attention) {
         blocker: `Merge state unknown${vs}; Auto land is waiting for a mergeability verdict`, bounceKind: null };
 }
 /** Compact contract text shared by status and wait summaries. */
-export function stackBlockersSummary(attention, issues, busy = [], landGatePending = null, actAfter = null) {
+export function stackBlockersSummary(attention, issues, busy = [], landGatePending = null, actAfter = null, queueWait = null) {
     const agentWork = (entry) => entry.agent === "cyclone" ? "Cyclone patches" : "Vortex reviews";
     const blocked = attention && actAfter && busy.length
         ? ` · blocked after the agents: #${attention.prNumber} ${attention.blocker} (plan the fix; act once ${busy.map(agentWork).join(" and ")} finish and the watch returns attention)`
@@ -397,5 +724,6 @@ export function stackBlockersSummary(attention, issues, busy = [], landGatePendi
     const gate = landGatePending && !attention
         ? ` · land gate: #${landGatePending.prNumber} ${landGatePending.reason} (nothing to fix; wait)`
         : "";
-    return blocked + working + gate + (listed.length ? ` · issues: ${labels}${listed.length > 3 ? `; +${listed.length - 3} more` : ""}` : "");
+    const queue = queueWait && !attention ? ` · queue: #${queueWait.prNumber} ${queueWait.text}` : "";
+    return blocked + working + gate + queue + (listed.length ? ` · issues: ${labels}${listed.length > 3 ? `; +${listed.length - 3} more` : ""}` : "");
 }

package/dist/stack-dto.d.ts

@@ -64,6 +64,11 @@ export type StackVortexReviewView = {
     source: "pr_reviews" | "github_webhook_jobs" | "lease" | "none";
 };
 export type StackCycloneStatus = "patching" | "awaiting_fix" | "failed";
+export type StackCycloneHandoff = {
+    headSha: string;
+    reason: string;
+    at: string | null;
+};
 export type StackTempestStatus = "reviewing" | "findings" | "clear" | "failed" | "stale";
 export type StackAgentName = "vortex" | "cyclone" | "tempest";
 /**
@@ -208,6 +213,7 @@ export type StackLayerDto = {
      */
     vortexReview?: StackVortexReviewView;
     agentsBusy?: StackAgentsBusy | null;
+    cycloneHandoff?: StackCycloneHandoff | null;
     conflictDetail: string | null;
     restackError?: RestackError | null;
     lastRestackedSha: string | null;
@@ -301,6 +307,7 @@ export type StackUnitDto = {
     landPr: StackLayerDto | null;
 };
 export type CycloneOwnerMatch = "same" | "different" | "none" | "lookup_failed";
+export type CyclonePatchOffReason = "stack_auto_patch_off" | "account_auto_patch_off" | "cyclone_not_connected";
 export type StackDto = {
     id: string;
     owner: string;
@@ -339,6 +346,14 @@ export type StackDto = {
         startedAt: string;
         windowSeconds?: number;
     } | null;
+    autoLandWait?: {
+        reason: string;
+        prNumber: number | null;
+        headSha: string | null;
+        since: string;
+        attempts: number | null;
+        detail: string | null;
+    } | null;
     /**
      * Per-stack Vortex auto-review override. `null` (or missing) follows the
      * account `auto_review_enabled` flag; a boolean wins in both directions.
@@ -369,6 +384,7 @@ export type StackDto = {
      * `lookup_failed`: the comparison could not be loaded. Fail closed.
      */
     cycloneOwnerMatch?: CycloneOwnerMatch;
+    cyclonePatchOff?: CyclonePatchOffReason;
     layers: StackLayerDto[];
     /** Present when a review-unit row exists for this stack. */
     unit?: StackUnitDto;
@@ -408,6 +424,12 @@ export type MergeQueueEntryBatchDto = {
     state: MergeQueueBatchState;
     landedCount: number;
 };
+export type MergeQueueAheadDto = {
+    stackId: string | null;
+    state: "running" | "waiting";
+    claimedAt: string | null;
+    waitReason: string | null;
+};
 export type MergeQueueEntryDto = {
     id: string;
     stackId: string;
@@ -431,4 +453,6 @@ export type MergeQueueEntryDto = {
     cancelRequestedAt?: string | null;
     batch?: MergeQueueEntryBatchDto | null;
     finishedAt: string | null;
+    claimedAt?: string | null;
+    aheadInRepo?: MergeQueueAheadDto | null;
 };

package/dist/stack-watch.d.ts

@@ -1,4 +1,4 @@
-import { type StackAgentBusy, type StackBlocker, type StackBusyAgent, type StackHeldBlocker, type StackLayerAgents, type StackLandGatePending, type StackRepairHint } from "./stack-blockers.js";
+import { type StackAgentBusy, type StackBlocker, type StackBusyAgent, type StackHeldBlocker, type StackLayerAgents, type StackLandGatePending, type StackQueueWait, type StackRepairHint } from "./stack-blockers.js";
 import { type StackWatchObligation } from "./stack-watch-obligation.js";
 import { apiFetch } from "./api.js";
 import type { Config } from "./config.js";
@@ -33,6 +33,7 @@ export type StackWatchEnvelope = {
     agents: StackLayerAgents | null;
     repair: StackRepairHint | null;
     landGatePending: StackLandGatePending | null;
+    queueWait?: StackQueueWait | null;
     watch: StackWatchObligation;
 };
 export type PollStackWatchOptions = {

package/dist/stack-watch.js

@@ -120,7 +120,7 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         if (snapshot && Array.isArray(snapshot.stacks) && !stack) {
             terminal = "not_found";
             throw new StackWatchError("Stack not found or not owned by the current user", seal({ ...lastEnvelope, status: "failed", assessment: "unavailable", blocker: null, issues: [], busy: [], actAfter: null, waitingOn: [],
-                prNumber: null, headSha: null, repair: null, agents: null, currentCandidate: null, landGatePending: null }));
+                prNumber: null, headSha: null, repair: null, agents: null, currentCandidate: null, landGatePending: null, queueWait: null }));
         }
         if (!stack || !Array.isArray(stack.layers)) {
             throw new StackWatchError("Stack snapshot missing or invalid", seal({ ...lastEnvelope, status: "failed", assessment: "unavailable" }));
@@ -140,13 +140,13 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         };
     };
     const evaluate = (stack, entries) => {
-        const { attention, held: named, issues, currentCandidate, bounce, busy, agents, repair, landGatePending } = stackBlockers(stack, entries, cursor);
+        const { attention, held: named, issues, currentCandidate, bounce, busy, agents, repair, landGatePending, queueWait } = stackBlockers(stack, entries, cursor, now());
         if (bounce)
             cursor = Object.freeze({ ...cursor, bounceId: bounce.id,
                 ...(bounce.finishedAt !== undefined ? { afterFinishedAt: bounce.finishedAt } : {}) });
         const held = busy[0];
         const shown = attention ?? named;
-        lastEnvelope = { ...lastEnvelope, cursor, issues, currentCandidate, assessment: "available", busy, agents, repair, landGatePending,
+        lastEnvelope = { ...lastEnvelope, cursor, issues, currentCandidate, assessment: "available", busy, agents, repair, landGatePending, queueWait,
             actAfter: named?.actAfter ?? null, waitingOn: named?.waitingOn ?? [],
             blocker: shown?.blocker ?? null, bounceKind: shown?.bounceKind ?? null,
             prNumber: shown?.prNumber ?? held?.prNumber ?? currentCandidate?.prNumber ?? null,

package/dist/ui/banner.js

@@ -136,6 +136,16 @@ const WHATS_NEW = {
         "stack watch names an abandoned review unit",
         "stack watch names Auto land's mergeability wait",
     ],
+    "0.3.35": [
+        "stack watch names why Auto land is waiting",
+        "stack watch names a stuck seam review",
+        "stack watch names findings Cyclone left for you",
+    ],
+    "0.3.36": [
+        "stack watch names what the merge queue waits on",
+        "stack watch names why Vortex skipped a head",
+        "stack watch says how to re-run Tempest",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.34",
+  "version": "0.3.36",
   "description": "Mergestorm CLI (mg) — local reviews & stacked PRs. MIT; build from source: https://github.com/marginsystems/mergestorm-cli",
   "license": "MIT",
   "type": "module",

package/skill/mergestorm-bounce-watch/SKILL.md

@@ -35,9 +35,9 @@ Call `stack_status` with `stack_id`. Require that stack's `autoEnqueueWhenReady`
 
 1. Call `stack_wait` with the named `stack_id` and `timeout_s: 45`. On initial enrollment, omit the cursor selectors. Save the returned `cursor`: map `cursor.enrolledHeadSha` to `enrolled_head_sha`, `cursor.afterFinishedAt` to `after_finished_at`, and `cursor.bounceId` to `bounce_id` (omit only absent fields; preserve explicit nulls). Keep `bounce_id` alongside `after_finished_at`; never pass one without the other when the returned cursor has both. The shipped tool accepts these selectors, not a nested cursor argument. `watch.next.args` already holds them in that shape, with `timeout_s: 45`; passing it unchanged is the same call.
 2. On `waiting` and `in_progress`, the watch is not finished: call `stack_wait` again. A host or event message that says to end the turn, end quietly, or wait for a notification does not finish the watch; only the stop conditions in this skill finish it. Ending your turn while `mg stack watch` runs in the background is waiting, not finishing. Keep the same cursor across retries. An unread deadline times out as `failed`; stop and report. Timeout `waiting` or `in_progress` after a snapshot is not failure — call `stack_wait` again in 45s slices with the same cursor after inspecting `issues[]`. Inspect `issues[]` on `in_progress` too: a live queue does not erase upstack hard blocks. `waiting` with issues is not idle. If `assessment` is `unavailable`, do not infer that the stack is issue-free; refresh `stack_status`, whose `attention`, `issues`, and `currentCandidate` come from the same blocker rules as `stack_wait`. Do not replace the enrolled head with a newer snapshot head or advance the timestamp just because a wait timed out. On a surfaced `rate_limited` error, honor the retry delay and retain the cursor; on `failed` or an unrecoverable tool error, call `stack_wait` once more with the same cursor; if it fails again, stop and report the reason and that the stack is not landed. `queue_status` returning `queue_entry_not_found` is not a failure: an empty queue for the stack is a normal wait.
-3. `attention` always means something for you to fix. A land gate that is only waiting (`landGatePending` with `ci_pending`, `tempest_pending`, `tempest_running`, or another `*_pending` / `*_running` reason on the land PR) returns `in_progress`, not `attention`: keep watching. On `attention`, read `repair` when present: it names the blocked PR's `branch` and the concrete fix. For `restack_conflict` and `merge_conflict` it gives `liveParent` (the sibling PR head, or `mg-stack-N` once the lower layers are merged or promoted, or the land PR's base such as `main` when the blocked PR is the land PR, never `mg-park-*`) and the conflicted `files`; a null `liveParent` means stop and tell the human. For `ci_failure` it names the failing check. For `tempest_findings` on the land PR it names the land PR, its `branch` (`mg-stack-N`), and where the Tempest report is (`findings`). A stack whose `autoLandOff.reason` is `bounced` (a `merge_failed`, `gh_error`, or `ci_timeout` bounce turned Auto land off and nobody took the stack back since) returns `attention` with the blocker `Auto land off after <kind> bounce`, the bounce in `issues[]`, and a `repair` of kind `auto_land_off`; handle it as "Re-arm after a bounce" describes. A stack whose review unit was abandoned because a human moved its bottom PR off `mg-stack-N` returns `attention` with the blocker `Review unit abandoned: based on <base>` and a `repair` of kind `unit_abandoned`: do not patch or retarget anything. Ask the human whether to re-root it: if at least two PRs remain open, tell them that `mg stack adopt owner/repo#<bottom PR>` re-roots it on a new review unit; with only one open PR, re-adopting will not create a review unit, so tell them to close and resubmit it to create a fresh stack, then stop. `repair` does not replace the checks below. On `attention`, fix the named PR: `prNumber` and `headSha` identify the blocked PR, while `currentCandidate` identifies the promote candidate. The gate covers the bottom and its direct child only when the child has current-head DIRTY on the live bottom branch. A GitHub DIRTY whose `parentBranch` starts with `mg-park-` is not that gate. Refresh `stack_status`; use `queue_status` with the same `stack_id` when bounce details are needed. Verify the blocker still applies to the current PR head. Never treat `verifyHeadSha` as the current head: it is a queue verification SHA and can be stale or synthetic. Compare the live PR branch head, the current stack layer head, and the checkout before editing. Read the live PR head with `git ls-remote origin refs/heads/<branch>` or `gh api repos/OWNER/REPO/pulls/N --jq .head.sha`. If you need CI logs, use `gh run list --branch <branch>`, `gh run view <run-id> --log-failed`, or `gh api repos/OWNER/REPO/commits/SHA/check-runs`. Read GitHub only through git and these REST calls; do not use other `gh pr` subcommands. Restack `clean` does not mean mergeable or CI-green. Attention is a diagnosis, not permission to mutate stack or queue policy; the only policy change you make is the re-arm in "Re-arm after a bounce". A bounce is the reason to look, not the moment to commit. `stack_wait` and `stack_status` hold the blocked PR's attention themselves while Vortex or Cyclone is still working on that PR, whatever the blocker (a red CI failure, a merge conflict, a bounce, Draft, a failed restack or review): they return `in_progress` instead of `attention`, with `busy[]` naming the PR (`prNumber`, `headSha`), the `blocker`, and the `agent` (`vortex` or `cyclone`), and `agents` carrying that PR's `vortexStatus`, `cycloneStatus`, `vortexReview`, and `busy` flags. `in_progress` with a nonempty `busy[]` means do not patch yet: keep calling `stack_wait` with the same cursor until that work has finished and the watch returns `attention`, then make the follow-up commit. You do not need an extra `stack_status` refresh each slice for this check. A nonempty `busy[]` reports still-working agents on that PR's current head. Vortex holds when `vortexReview` is `reviewing` at the head, an unfinished vortex `agentRuns` row at the head is `reviewing`, or an unfinished vortex run at the head is `queued` and started within the last 15 minutes (with no `agentRuns` or `vortexReview` on the layer, `vortexStatus` `reviewing` holds). Cyclone holds when `cycloneStatus` is `patching`, an unfinished cyclone `agentRuns` row is `patching`, or the server sees a live Cyclone patch lease or an open Cyclone check run on the head. `seam_pending` alone, and a `queued` run older than 15 minutes, are not treated as work in progress. `all_clear`, `findings`, `skipped`, `failed`, `throttled`, `awaiting_fix`, and a null status are finished. A queued Vortex run holds for at most 15 minutes; reviewing and patching hold until the run finishes or its lease or check run is cleared. A blocker no Vortex or Cyclone run can clear is not hidden by the hold: a merge conflict vs the live parent, a restack `Conflict` or `Restack failed` (a parked freeze included), a Draft PR, `Seam review pending, no review running`, or `Review skipped, out of review quota`. For those the envelope stays `in_progress` but names the blocker in the top-level `blocker`, `prNumber`, `headSha`, and `issues[]`, with `actAfter: "agents_idle"`, `waitingOn` listing the busy agents, and `repair` when there is one. Plan the fix from it, but do not patch, merge, or push while `actAfter` is set: keep calling `stack_wait` with the same cursor, and act when a snapshot after the agents finish returns `attention`; a Cyclone push can change or clear the blocker, so re-read it then. Blockers the agents can change (a red CI failure, a failed review or Tempest run, seam findings, a bounce) keep the plain hold: `blocker` is null, `actAfter` is null, and only `busy[]` names them. If a hold looks stuck, refresh `stack_status` and tell the human. Do not turn Cyclone off or Auto land off, and do not turn Auto land on to end the wait; turn it on only as "Re-arm after a bounce" allows. If the remote head moves while you wait, stop and tell the human.
+3. `attention` always means something for you to fix. A land gate that is only waiting (`landGatePending` with `ci_pending`, `tempest_pending`, `tempest_running`, or another `*_pending` / `*_running` reason on the land PR) returns `in_progress`, not `attention`: keep watching. On `attention`, read `repair` when present: it names the blocked PR's `branch` and the concrete fix. For `restack_conflict` and `merge_conflict` it gives `liveParent` (the sibling PR head, or `mg-stack-N` once the lower layers are merged or promoted, or the land PR's base such as `main` when the blocked PR is the land PR, never `mg-park-*`) and the conflicted `files`; a null `liveParent` means stop and tell the human. For `ci_failure` it names the failing check. For `tempest_findings` on the land PR it names the land PR, its `branch` (`mg-stack-N`), and where the Tempest report is (`findings`). A stack whose `autoLandOff.reason` is `bounced` (a `merge_failed`, `gh_error`, or `ci_timeout` bounce turned Auto land off and nobody took the stack back since) returns `attention` with the blocker `Auto land off after <kind> bounce`, the bounce in `issues[]`, and a `repair` of kind `auto_land_off`; handle it as "Re-arm after a bounce" describes. A stack whose review unit was abandoned because a human moved its bottom PR off `mg-stack-N` returns `attention` with the blocker `Review unit abandoned: based on <base>` and a `repair` of kind `unit_abandoned`: do not patch or retarget anything. Ask the human whether to re-root it: if at least two PRs remain open, tell them that `mg stack adopt owner/repo#<bottom PR>` re-roots it on a new review unit; with only one open PR, re-adopting will not create a review unit, so tell them to close and resubmit it to create a fresh stack, then stop. Auto land records why it is waiting in the stack's `autoLandWait` (`reason`, `prNumber`, `headSha`, `since`), and the watch returns `attention` on that PR when the wait cannot clear on its own: a failing check Auto land reads live on GitHub while the ledger may still show CI green (blocker `CI failed — Auto land reads a failing check on GitHub at this head`, `repair` kind `ci_failure`); a check pending for 45 minutes (`repair` kind `ci_pending`: find the check that never finished and re-run it, or tell the human when no workflow reports it); no approving Vortex review for 30 minutes with no Vortex run working (`repair` kind `vortex_not_green`: fix or dismiss the findings, or tell the human when no review exists at the head); and a promote GitHub refused 3 times with `merge_failed`, after which Auto land stops retrying that head (`repair` kind `promote_failed`: fix the cause on the PR and push a new head, or tell the human when the cause is outside the PR; never toggle Auto land yourself for it). A layer whose live head has a Vortex verdict that requests changes after Cyclone left those findings for a person (a hold directive, the Vortex patch cap, auto-patch off, no billing, a batch it gave up on, or a PR state it could not read) returns `attention` with the blocker `Vortex findings need a person` and a `repair` of kind `vortex_findings` naming the Cyclone reason (`handoff`) and where the review is (`findings`): verify each finding against the checkout, fix the real ones with the smallest patch and an ordinary push, and tell the human about the ones you judge wrong. `repair` does not replace the checks below. On `attention`, fix the named PR: `prNumber` and `headSha` identify the blocked PR, while `currentCandidate` identifies the promote candidate. The gate covers the bottom and its direct child only when the child has current-head DIRTY on the live bottom branch. A GitHub DIRTY whose `parentBranch` starts with `mg-park-` is not that gate. Refresh `stack_status`; use `queue_status` with the same `stack_id` when bounce details are needed. Verify the blocker still applies to the current PR head. Never treat `verifyHeadSha` as the current head: it is a queue verification SHA and can be stale or synthetic. Compare the live PR branch head, the current stack layer head, and the checkout before editing. Read the live PR head with `git ls-remote origin refs/heads/<branch>` or `gh api repos/OWNER/REPO/pulls/N --jq .head.sha`. If you need CI logs, use `gh run list --branch <branch>`, `gh run view <run-id> --log-failed`, or `gh api repos/OWNER/REPO/commits/SHA/check-runs`. Read GitHub only through git and these REST calls; do not use other `gh pr` subcommands. Restack `clean` does not mean mergeable or CI-green. Attention is a diagnosis, not permission to mutate stack or queue policy; the only policy change you make is the re-arm in "Re-arm after a bounce". A bounce is the reason to look, not the moment to commit. `stack_wait` and `stack_status` hold the blocked PR's attention themselves while Vortex or Cyclone is still working on that PR, whatever the blocker (a red CI failure, a merge conflict, a bounce, Draft, a failed restack or review): they return `in_progress` instead of `attention`, with `busy[]` naming the PR (`prNumber`, `headSha`), the `blocker`, and the `agent` (`vortex` or `cyclone`), and `agents` carrying that PR's `vortexStatus`, `cycloneStatus`, `vortexReview`, and `busy` flags. `in_progress` with a nonempty `busy[]` means do not patch yet: keep calling `stack_wait` with the same cursor until that work has finished and the watch returns `attention`, then make the follow-up commit. You do not need an extra `stack_status` refresh each slice for this check. A nonempty `busy[]` reports still-working agents on that PR's current head. Vortex holds when `vortexReview` is `reviewing` at the head, an unfinished vortex `agentRuns` row at the head is `reviewing`, or an unfinished vortex run at the head is `queued` and started within the last 15 minutes (with no `agentRuns` or `vortexReview` on the layer, `vortexStatus` `reviewing` holds). Cyclone holds when `cycloneStatus` is `patching`, an unfinished cyclone `agentRuns` row is `patching`, or the server sees a live Cyclone patch lease or an open Cyclone check run on the head. `seam_pending` alone, and a `queued` run older than 15 minutes, are not treated as work in progress. `all_clear`, `findings`, `skipped`, `failed`, `throttled`, `awaiting_fix`, and a null status are finished. A queued Vortex run holds for at most 15 minutes; reviewing and patching hold until the run finishes or its lease or check run is cleared. A blocker no Vortex or Cyclone run can clear is not hidden by the hold: a merge conflict vs the live parent, a restack `Conflict` or `Restack failed` (a parked freeze included), a Draft PR, `Seam review pending, no review running`, or `Review skipped, out of review quota`. For those the envelope stays `in_progress` but names the blocker in the top-level `blocker`, `prNumber`, `headSha`, and `issues[]`, with `actAfter: "agents_idle"`, `waitingOn` listing the busy agents, and `repair` when there is one. Plan the fix from it, but do not patch, merge, or push while `actAfter` is set: keep calling `stack_wait` with the same cursor, and act when a snapshot after the agents finish returns `attention`; a Cyclone push can change or clear the blocker, so re-read it then. Blockers the agents can change (a red CI failure, a failed review or Tempest run, seam findings, a bounce) keep the plain hold: `blocker` is null, `actAfter` is null, and only `busy[]` names them. If a hold looks stuck, refresh `stack_status` and tell the human. Do not turn Cyclone off or Auto land off, and do not turn Auto land on to end the wait; turn it on only as "Re-arm after a bounce" allows. If the remote head moves while you wait, stop and tell the human.
 4. Use a clean worktree on that named PR's head branch and record the remote starting SHA. Fix the current blocker with the smallest patch, and run the relevant checks. For conflicts, the live parent is the sibling PR head or the unit branch (`mg-stack-N`, Mergestorm's owned trunk, not an alias for main) — not the DTO `parentBranch` when that field starts with `mg-park-*`. If `parentBranch` is `mg-park-*`, never merge or rebase onto it; if the real live parent is unknown, stop. The land PR is the one PR whose head is `mg-stack-N`: its live parent is its base (`main`), and merging that base into `mg-stack-N` with an ordinary push is its conflict repair, the same as for any other layer. Tempest never patches: Cyclone patches a land PR when auto-patch is on for that stack, otherwise you do. On `tempest_findings` on the land PR, when `busy[]` shows no Cyclone run on it, read the Tempest report, verify each finding against the checkout as for Vortex findings, fix the real ones with the smallest patch on `mg-stack-N`, and push with an ordinary push, never a force push; while Cyclone is patching it the envelope stays `in_progress` with `busy[]`, so wait. Otherwise prefer merging that live parent into the PR branch, resolving locally, then an ordinary push. Never use Dashboard Continue. When the live parent is a sibling, never rebase onto trunk or `mg-stack-N` instead. Parked-freeze DIRTY alone needs no conflict patch. Leave GitHub bases as Mergestorm set them: the bottom of a 2+ PR stack is based on `mg-stack-N`, layer 2 on layer 1, PR3+ on `mg-park-*`.
-5. CI-only fixes may run while Cyclone auto-patch is still on for the stack. Auto-patch may stay on, and you still wait until the current Vortex run and the current Cyclone run on that PR have finished before the follow-up commit. When the gate is clean, inspect `issues[]` and fix a live upstack CI failure one PR at a time, refreshing the gate before the next PR. Do not use higher-layer bounce history as a patch target. Do not fight Cyclone: if the remote head moved, stop and tell the human. Do not take over Cyclone's review-finding work while it is active; if the blocker requires that or a policy/queue action rather than a concrete patch, stop and explain what needs human attention. On a `Seam findings` blocker, read that PR's seam finding, the Vortex review "Integration review — U<n> seam" (`gh api repos/OWNER/REPO/pulls/N/reviews` and `gh api repos/OWNER/REPO/pulls/N/comments`), and patch its concrete findings on that PR's head; a "Decision required" seam finding needs a human, so tell them and do not guess. A seam finding you verified is wrong is recorded with `mg dismiss` (the audited dismissal in `mergestorm-pr-loop`) at that PR's live head and that seam review's id; a `mergestorm-loop: dismiss` comment alone does not clear the seam gate. On `Seam review failed`, do not patch; tell the human, unless a new push already has a seam re-review held in `busy[]`. On `Seam review pending, no review running`, do not patch; tell the human: the seam review was skipped (usually because the monthly review limit is reached) and nothing re-runs it until they raise the limit and click Continue on the stack, or push a new head. On `Review skipped, out of review quota`, do not patch; tell the human: the review credit limit for the period is reached and nothing re-reviews that head until they raise the limit and push a new head or re-run the review.
+5. CI-only fixes may run while Cyclone auto-patch is still on for the stack. Auto-patch may stay on, and you still wait until the current Vortex run and the current Cyclone run on that PR have finished before the follow-up commit. When the gate is clean, inspect `issues[]` and fix a live upstack CI failure one PR at a time, refreshing the gate before the next PR. Do not use higher-layer bounce history as a patch target. Do not fight Cyclone: if the remote head moved, stop and tell the human. Do not take over Cyclone's review-finding work while it is active; if the blocker requires that or a policy/queue action rather than a concrete patch, stop and explain what needs human attention. On a `Seam findings` blocker, read that PR's seam finding, the Vortex review "Integration review — U<n> seam" (`gh api repos/OWNER/REPO/pulls/N/reviews` and `gh api repos/OWNER/REPO/pulls/N/comments`), and patch its concrete findings on that PR's head; a "Decision required" seam finding needs a human, so tell them and do not guess. A seam finding you verified is wrong is recorded with `mg dismiss` (the audited dismissal in `mergestorm-pr-loop`) at that PR's live head and that seam review's id; a `mergestorm-loop: dismiss` comment alone does not clear the seam gate. On `Seam review failed`, do not patch; tell the human, unless a new push already has a seam re-review held in `busy[]`. On `Seam review pending, no review running`, do not patch; tell the human: the seam review was skipped (usually because the monthly review limit is reached) and nothing re-runs it until they raise the limit and click Continue on the stack, or push a new head. On `Seam review stuck in reviewing, no review running`, `Seam re-review pending, no review running`, or `Seam verdict is for an older head, no review running` (repair kind `seam_review_stuck`), do not patch or push; tell the human: no seam review is queued or running for that PR's live head, and clicking Continue on the stack re-queues it (a new pushed head also does). On `Review skipped, out of review quota`, do not patch; tell the human: the review credit limit for the period is reached and nothing re-reviews that head until they raise the limit and push a new head or re-run the review.
 6. Recheck Auto land (off is expected only after a disarming bounce you are handling) and the remote PR head (`git ls-remote origin refs/heads/<branch>`) immediately before pushing. Commit the patch and push the PR head with an ordinary push. A rebase onto that same live parent followed by force-with-lease is allowed only if the remote is still exactly the SHA you started from and Cyclone did not move it; use an explicit lease bound to that starting SHA. This exception never permits rebasing onto a parked freeze or substituting trunk / the unit for a sibling parent. If the remote head moved or the push is rejected because it moved, stop; do not rebase and retry.
 7. After your successful push, leave a clean worktree and keep watching the named stack. Start a new watch cycle with `enrolled_head_sha` set to the SHA you pushed (in the background: `mg stack watch <stack-id> --head <pushed-sha>`). If you handled a bounce, retain the returned `cursor.afterFinishedAt` as `after_finished_at` and `cursor.bounceId` as `bounce_id` so that attempt is not handled again. Keep these selectors unchanged across subsequent retries. Continue watching; do not enqueue anything. If the bounce you handled turned Auto land off, turn it back on as "Re-arm after a bounce" allows; if that section does not allow it, report and stop.