mergestorm 0.3.35 → 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.35                                             │
+│  ▀▀▀▀▀▀▀▀▀▀▘  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,6 +54,13 @@ 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;
@@ -68,6 +75,14 @@ export type StackRepairHint = {
     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;
@@ -89,6 +104,21 @@ export type StackRepairHint = {
     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;
@@ -112,21 +142,46 @@ 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">, nowMs?: number): {
     attention: null;
@@ -141,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;
@@ -154,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,6 +51,7 @@ 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";
@@ -71,7 +72,16 @@ function vortexChangesRequestedAtHead(layer) {
 function cycloneHandoffAtHead(stack, layer) {
     if (sameHead(layer.cycloneHandoff?.headSha, layer.headSha))
         return layer.cycloneHandoff.reason;
-    return stack.autoPatchOverride === false ? "auto_patch_off" : null;
+    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 &&
@@ -82,6 +92,40 @@ 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";
+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)
@@ -132,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");
@@ -152,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);
@@ -263,6 +310,55 @@ export function autoLandWaitBlocker(stack, layer, nowMs) {
             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";
 }
@@ -299,24 +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");
@@ -332,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 {
@@ -368,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",
@@ -379,6 +511,35 @@ 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 {
@@ -422,7 +583,7 @@ export function stackRepair(stack, attention, layer, bounce) {
             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 ? ` (${handoff.replaceAll("_", " ")})` : ""}, so nothing will patch them and Auto land waits. Read the newest Vortex review and its inline comments (${findings}), verify each finding against ${layer.branch} at its live remote head, fix the real ones with the smallest patch, run the tests, confirm the remote head is still ${layer.headSha ?? "the head you started from"}, then an ordinary git push (no force). If a finding is wrong, tell the human; mg dismiss ${stack.owner}/${stack.repo}#${layer.prNumber} --head <sha> --review <id> dismisses that review. Do not retarget the PR base.`,
+            steps: `Vortex 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") {
@@ -454,6 +615,7 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     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);
@@ -473,6 +635,9 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
                 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,
@@ -495,6 +660,10 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
         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);
@@ -517,11 +686,14 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     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;
@@ -539,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)`
@@ -552,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

@@ -307,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;
@@ -383,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;
@@ -422,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;
@@ -445,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, now());
+        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

@@ -141,6 +141,11 @@ const WHATS_NEW = {
         "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.35",
+  "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",