mergestorm 0.3.38 → 0.3.40

package/dist/stack-blockers.js

@@ -57,7 +57,7 @@ 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];
+const STUCK_SEAM_REASONS = ["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);
@@ -79,6 +79,13 @@ const CYCLONE_HANDOFF_WORDS = {
     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",
+    infra_failure: "Cyclone could not start the patch: GitHub sign-in, comment load or checkout kept failing",
+    no_changes: "Cyclone found nothing to change for these findings",
+    credits_exhausted: "the account is out of standard credits this month",
+    no_billing: "the account has no billing set up",
+    unsupported_language: "the findings are in a language Cyclone does not patch",
+    policy_owner_changed: "the stack's owner changed while the patch was queued",
+    patch_job_lost: "Cyclone's patch job was lost before it finished",
 };
 function cycloneHandoffWords(reason) {
     return CYCLONE_HANDOFF_WORDS[reason] ?? reason.replaceAll("_", " ");
@@ -95,11 +102,21 @@ function quotaSkippedReview(layer) {
 export const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
 export const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
 export const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";
+export const VORTEX_IGNORED_AUTHOR = "Vortex skipped this head: the PR author is on the ignored authors list";
+export const VORTEX_REPO_DISABLED = "Vortex skipped this head: reviews are turned off for this repository";
+export const VORTEX_RETRY_SCHEDULED = "Vortex hit a temporary error on this head and will retry by itself";
+export const VORTEX_REVIEW_FAILED = "Review failed";
 const VORTEX_SKIP_BLOCKERS = {
     auto_review_off: VORTEX_AUTO_REVIEW_OFF,
     billing_blocked: VORTEX_BILLING_SKIPPED,
     billing_unavailable: VORTEX_BILLING_SKIPPED,
+    ignored_author: VORTEX_IGNORED_AUTHOR,
+    repo_disabled: VORTEX_REPO_DISABLED,
 };
+export function vortexRetryScheduled(layer) {
+    const review = layer.vortexReview;
+    return review?.skip_reason?.trim() === "retry_scheduled" && sameHead(review.head_sha, layer.headSha);
+}
 function vortexIdleSkipBlocker(layer) {
     if (layerAgentsBusy(layer).vortex)
         return null;
@@ -121,6 +138,12 @@ function vortexSkippedSteps(stack, layer, skipReason) {
     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: turning auto-review on (mg stack set ${stack.id} --auto-review on, or the account setting in the dashboard) queues a review of this head by itself. To review only this head and leave auto-review off, ${mention}.`;
     }
+    if (skipReason === "ignored_author") {
+        return `Vortex skipped #${layer.prNumber} at ${head} because the PR's author is on the account's ignored authors list, so Auto land waits for a review that will not come. Do not patch or push for this. To review this head once, ${mention}. To have this author's PRs reviewed by themselves, tell the human to remove the author from the ignored authors list in the Mergestorm dashboard settings.`;
+    }
+    if (skipReason === "repo_disabled") {
+        return `Vortex skipped #${layer.prNumber} at ${head} because reviews are turned off for ${stack.owner}/${stack.repo}, so Auto land waits for a review that will not come. Do not patch or push for this, and a mention will not run a review while the repository is off. Tell the human to turn the repository on in the Mergestorm dashboard; after that a push or a comment @mergestorm-vortex review on #${layer.prNumber} runs the review.`;
+    }
     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.`;
     }
@@ -136,24 +159,26 @@ function seamGateBlocker(stack, layer) {
     if (!member || member.promotedHeadSha?.trim())
         return null;
     const seamState = member.seamState?.trim().toLowerCase();
+    const stale = { blocker: SEAM_VERDICT_STALE, reason: "seam_verdict_stale" };
     if (seamState === "failed")
-        return "Seam review failed";
-    if (seamState === "findings" && sameHead(member.seamReviewedSha, layer.headSha))
-        return "Seam findings";
+        return { blocker: "Seam review failed", reason: "seam_failed" };
+    if (seamState === "findings" && sameHead(member.seamReviewedSha, layer.headSha)) {
+        return { blocker: "Seam findings", reason: "seam_findings" };
+    }
     if (layerAgentsBusy(layer).vortex)
         return null;
     if (seamState === "pending")
-        return SEAM_REVIEW_NOT_RUNNING;
+        return { blocker: SEAM_REVIEW_NOT_RUNNING, reason: "seam_not_running" };
     if (seamState === "reviewing")
-        return SEAM_REVIEW_STUCK;
+        return { blocker: SEAM_REVIEW_STUCK, reason: "seam_review_stuck" };
     if (seamState === "pending_rereview")
-        return SEAM_REREVIEW_NOT_RUNNING;
+        return { blocker: SEAM_REREVIEW_NOT_RUNNING, reason: "seam_rereview_not_running" };
     if (!layer.headSha?.trim() || sameHead(member.seamReviewedSha, layer.headSha))
         return null;
     if (seamState === "findings")
-        return SEAM_VERDICT_STALE;
+        return stale;
     if (seamState === "approved" && !coreReviewDoneAtHead(layer))
-        return SEAM_VERDICT_STALE;
+        return stale;
     return null;
 }
 function headChecksAllGreen(layer) {
@@ -163,64 +188,58 @@ function headChecksAllGreen(layer) {
 }
 /** Shared live-fact precedence; bounce history is only passed for the candidate. */
 function layerAttention(stack, layer, queue, cursor) {
-    const none = { blocker: null, bounceKind: null };
+    const none = { blocker: null, reason: null, bounceKind: null };
     if (stack.archivedAt)
         return none;
     const bounce = queue.filter((entry) => entry.state === "bounced")
         .sort((a, b) => (Date.parse(b.finishedAt ?? "") || 0) - (Date.parse(a.finishedAt ?? "") || 0))[0];
     const kind = bounce?.bounceDetail?.kind;
     const recoverable = kind === "head_moved" || kind === "must_consolidate";
-    const hardBlock = (blocker) => ({ blocker, bounceKind: null });
+    const hardBlock = (blocker, reason) => ({ blocker, reason, bounceKind: null });
     if (layer) {
         if (layer.restackError && layer.state !== "restacking") {
             if (layer.restackError.kind === "rebase_conflict")
-                return hardBlock("Conflict");
+                return hardBlock("Conflict", "restack_conflict");
             if (!restackRetryPending(layer.restackError, layer))
-                return hardBlock(RESTACK_FAILED);
+                return hardBlock(RESTACK_FAILED, "restack_failed");
         }
         if (layer.state === "conflict")
-            return hardBlock("Conflict");
+            return hardBlock("Conflict", "restack_conflict");
         if (layer.draft)
             return {
-                blocker: "Draft PR", bounceKind: "pr_draft",
+                blocker: "Draft PR", reason: "draft_pr", bounceKind: "pr_draft",
                 ...(kind === "pr_draft" && sameHead(bounce.bounceDetail?.headSha ?? bounce.verifyHeadSha, layer.headSha) &&
                     (bounce.bounceDetail?.prNumber == null || bounce.bounceDetail.prNumber === layer.prNumber) ? { bounce } : {}),
             };
-        if (boundDirty(layer))
-            return hardBlock(`Merge conflicts${layer.parentBranch ? ` vs ${layer.parentBranch}` : ""}`);
+        if (boundDirty(layer)) {
+            return hardBlock(`Merge conflicts${layer.parentBranch ? ` vs ${layer.parentBranch}` : ""}`, "merge_conflict");
+        }
         if (layer.ciStatus === "failure" || (layer.checks?.failure ?? 0) > 0) {
             const name = layer.checks?.failingName?.trim();
-            return hardBlock(`CI failed${name ? ` — ${name}` : ""}`);
+            return hardBlock(`CI failed${name ? ` — ${name}` : ""}`, "ci_failed");
+        }
+        if (layer.vortexStatus === "failed" && !vortexRetryScheduled(layer) &&
+            (!layer.vortexReview?.head_sha || sameHead(layer.vortexReview.head_sha, layer.headSha))) {
+            return hardBlock(VORTEX_REVIEW_FAILED, "vortex_failed");
         }
-        if (layer.agentRuns?.some((run) => run.agent === "cyclone" && run.status === "failed" &&
-            sameHead(run.sha, layer.headSha)))
-            return hardBlock("Cyclone failed");
-        const tempest = layer.agentRuns?.find((run) => run.agent === "tempest" &&
-            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);
+            return hardBlock(VORTEX_REVIEW_OUT_OF_QUOTA, "vortex_out_of_quota");
         const vortexSkip = vortexIdleSkipBlocker(layer);
         if (vortexSkip)
-            return hardBlock(vortexSkip.blocker);
+            return hardBlock(vortexSkip.blocker, "vortex_skipped");
         const seam = seamGateBlocker(stack, layer);
         if (seam)
-            return hardBlock(seam);
+            return hardBlock(seam.blocker, seam.reason);
         if (unitAbandonedUnder(stack, layer)) {
-            return hardBlock(`${UNIT_ABANDONED_BLOCKER_PREFIX}${layer.parentBranch?.trim() || stack.trunkBranch}`);
+            return hardBlock(`${UNIT_ABANDONED_BLOCKER_PREFIX}${layer.parentBranch?.trim() || stack.trunkBranch}`, "unit_abandoned");
         }
         if (stack.unit?.landPrNumber === layer.prNumber) {
             const landing = stack.unit.landingBlockReason?.trim();
             if (landing && !landGateIsPending(landing))
-                return hardBlock(landing);
-            if (stack.unit.tempestLandStatus?.toLowerCase() === "failed")
-                return hardBlock("Tempest failed");
+                return hardBlock(landing, "land_gate");
         }
         if (vortexFindingsLeftForPerson(stack, layer))
-            return hardBlock(VORTEX_FINDINGS_NEED_PERSON);
+            return hardBlock(VORTEX_FINDINGS_NEED_PERSON, "vortex_findings_need_person");
     }
     if (!bounce || !kind || recoverable || !layer || queue.some((entry) => ["queued", "running", "waiting"].includes(entry.state)))
         return none;
@@ -233,7 +252,8 @@ function layerAttention(stack, layer, queue, cursor) {
         return none;
     if (kind === "ci_failure" && !bounce.bounceDetail?.batch && headChecksAllGreen(layer))
         return none;
-    return { blocker: mergeQueueBounceLabel(bounce), bounceKind: kind, bounce };
+    const label = mergeQueueBounceLabel(bounce);
+    return { blocker: label, reason: "bounce", bounceKind: kind, bounce };
 }
 const UNIT_ABANDONED_BLOCKER_PREFIX = "Review unit abandoned: based on ";
 function unitAbandonedUnder(stack, layer) {
@@ -275,6 +295,7 @@ export const AUTO_LAND_WAIT_ATTENTION_MS = 45 * 60_000;
 export const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS = 10 * 60_000;
 const AUTO_LAND_CI_UNREADABLE_PREFIX = "Mergestorm cannot read ";
 const AUTO_LAND_WAITED_PREFIX = "Auto land has waited ";
+const AUTO_LAND_MEMBERS_REMAINING_PREFIX = "The land PR cannot be queued: ";
 const CI_UNREADABLE_WHAT = {
     check_runs_unreadable: "the check runs",
     commit_statuses_unreadable: "the commit statuses",
@@ -287,13 +308,7 @@ const CI_UNREADABLE_PERMISSION = {
 };
 const AUTO_LAND_WAIT_WORDS = {
     mergeability_unknown: "GitHub has not said whether this PR can merge into its base",
-    tempest_pending: "Tempest's review of this head has not started",
-    tempest_running: "Tempest's review of this head has not finished",
-    tempest_trigger_failed: "Tempest's review of this head could not be started",
-    tempest_stopped: "Tempest's review of this head was stopped",
-    tempest_failed: "Tempest's review of this head broke without a result",
-    tempest_findings: "Tempest reported findings on this head",
-    cyclone_failed: "Cyclone's patch run failed on this head",
+    members_remaining: "a PR that is not a layer of this stack is still open on the stack branch",
     stack_dirty: "this layer is not clean (it has a conflict or needs a restack)",
     must_consolidate: "this PR's base is not the stack's land target, and the stack has no review unit to promote it into",
     missing_head: "GitHub returned no head commit for this PR",
@@ -348,6 +363,9 @@ function autoLandWaitOn(stack, layer) {
     return autoLandWaitLayer(stack)?.prNumber === layer.prNumber ? armedAutoLandWait(stack) : null;
 }
 export function autoLandWaitBlocker(stack, layer, nowMs) {
+    return autoLandWaitNamed(stack, layer, nowMs)?.blocker ?? null;
+}
+function autoLandWaitNamed(stack, layer, nowMs) {
     const wait = autoLandWaitOn(stack, layer);
     if (!wait)
         return null;
@@ -357,18 +375,32 @@ export function autoLandWaitBlocker(stack, layer, nowMs) {
     const minutes = Math.floor(waited / 60_000);
     switch (wait.reason) {
         case "ci_failure":
-            return AUTO_LAND_CI_FAILED_BLOCKER;
+            return { blocker: AUTO_LAND_CI_FAILED_BLOCKER, reason: "ci_failed" };
         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`
+                ? {
+                    blocker: `${AUTO_LAND_CI_PENDING_PREFIX}${minutes}m — a check on this head has not finished, so Auto land will not queue it`,
+                    reason: "auto_land_ci_pending",
+                }
                 : null;
+        case "members_remaining":
+            return {
+                blocker: `${AUTO_LAND_MEMBERS_REMAINING_PREFIX}${wait.detail ?? AUTO_LAND_WAIT_WORDS.members_remaining}`,
+                reason: "auto_land_members_remaining",
+            };
         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`
+            return waited >= AUTO_LAND_VORTEX_WAIT_ATTENTION_MS && !vortexRetryScheduled(layer)
+                ? {
+                    blocker: `${AUTO_LAND_VORTEX_WAIT_PREFIX}${minutes}m — Auto land is waiting for an approving Vortex review at this head`,
+                    reason: "auto_land_vortex_wait",
+                }
                 : 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}` : ""}`
+                ? {
+                    blocker: `${AUTO_LAND_PROMOTE_FAILED_PREFIX}${wait.attempts} times (merge_failed) — Auto land stopped retrying this head${wait.detail ? `: ${wait.detail}` : ""}`,
+                    reason: "auto_land_promote_failed",
+                }
                 : null;
         default:
             break;
@@ -376,11 +408,14 @@ export function autoLandWaitBlocker(stack, layer, nowMs) {
     const unreadable = CI_UNREADABLE_WHAT[wait.reason];
     if (unreadable) {
         return ciUnreadableForGood(wait) || waited >= AUTO_LAND_CI_UNREADABLE_ATTENTION_MS
-            ? `${AUTO_LAND_CI_UNREADABLE_PREFIX}${unreadable} on this head${wait.detail ? ` (${wait.detail})` : ""} — Auto land cannot tell whether CI passed`
+            ? {
+                blocker: `${AUTO_LAND_CI_UNREADABLE_PREFIX}${unreadable} on this head${wait.detail ? ` (${wait.detail})` : ""} — Auto land cannot tell whether CI passed`,
+                reason: "auto_land_ci_unreadable",
+            }
             : null;
     }
     return waited >= AUTO_LAND_WAIT_ATTENTION_MS
-        ? `${AUTO_LAND_WAITED_PREFIX}${minutes}m: ${autoLandWaitWords(wait.reason)}`
+        ? { blocker: `${AUTO_LAND_WAITED_PREFIX}${minutes}m: ${autoLandWaitWords(wait.reason)}`, reason: "auto_land_waited" }
         : null;
 }
 export const MERGE_QUEUE_STALL_ATTENTION_MS = 45 * 60_000;
@@ -484,27 +519,25 @@ 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" ||
-        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);
-}
-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);
+const AGENTS_CANNOT_CLEAR = [
+    "restack_conflict",
+    "restack_failed",
+    "draft_pr",
+    "merge_conflict",
+    "seam_not_running",
+    ...STUCK_SEAM_REASONS,
+    "vortex_out_of_quota",
+    "vortex_skipped",
+    "unit_abandoned",
+];
+export function agentsCannotClear(reason) {
+    return AGENTS_CANNOT_CLEAR.includes(reason);
 }
 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)) {
+    const reason = attention.reason;
+    if (queueWait && reason === "queue_stalled") {
         return {
             kind: "queue_stalled",
             prNumber: layer.prNumber,
@@ -516,8 +549,8 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
         };
     }
     const landPr = !!stack.unit?.branch && layer.prNumber === stack.unit.landPrNumber && layer.branch === stack.unit.branch;
-    const restackConflict = attention.blocker === "Conflict" || attention.bounceKind === "restack_conflict";
-    const mergeConflict = attention.blocker.startsWith("Merge conflicts");
+    const restackConflict = reason === "restack_conflict" || attention.bounceKind === "restack_conflict";
+    const mergeConflict = reason === "merge_conflict";
     if (restackConflict || mergeConflict) {
         const liveParent = landPr ? landPrLiveParent(stack, layer) : conflictLiveParent(stack, layer);
         return {
@@ -530,7 +563,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             steps: conflictRepairSteps(layer.branch, liveParent),
         };
     }
-    if (attention.blocker === RESTACK_FAILED && layer.restackError) {
+    if (reason === "restack_failed" && layer.restackError) {
         const liveParent = landPr ? landPrLiveParent(stack, layer) : conflictLiveParent(stack, layer);
         return {
             kind: "restack_failed",
@@ -542,7 +575,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             steps: restackFailedRepairSteps(layer.branch, liveParent, layer.restackError),
         };
     }
-    if (attention.blocker.startsWith(UNIT_ABANDONED_BLOCKER_PREFIX)) {
+    if (reason === "unit_abandoned") {
         const openPrCount = stack.layers.filter((candidate) => candidate.prNumber > 0 && !isTerminalLayer(candidate)).length;
         return {
             kind: "unit_abandoned",
@@ -552,11 +585,11 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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)) {
+    if (STUCK_SEAM_REASONS.includes(reason)) {
         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
+        const what = reason === "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 {
@@ -568,7 +601,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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) {
+    if (reason === "auto_land_off" && attention.bounceKind) {
         return {
             kind: "auto_land_off",
             prNumber: layer.prNumber,
@@ -578,48 +611,39 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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, bounce)) {
-        const findings = `gh api repos/${stack.owner}/${stack.repo}/issues/${layer.prNumber}/comments`;
+    if (reason === "vortex_failed") {
         return {
-            kind: "tempest_findings",
+            kind: "vortex_failed",
             prNumber: layer.prNumber,
             headSha: layer.headSha ?? null,
             branch: layer.branch,
-            findings,
-            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.`,
+            detail: null,
+            steps: `Vortex's review of #${layer.prNumber} at ${layer.headSha ?? "its head"} failed and nothing will run it again by itself, so Auto land waits. There are no findings to fix. Run the review again: comment @mergestorm-vortex review on #${layer.prNumber} (gh pr comment ${layer.prNumber} --repo ${stack.owner}/${stack.repo} --body "@mergestorm-vortex review"); a new commit pushed to ${layer.branch} also queues one. If it fails again, tell the human.`,
         };
     }
-    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";
+    const vortexSkip = vortexIdleSkipBlocker(layer);
+    if (vortexSkip && reason === "vortex_skipped") {
         return {
-            kind: "tempest_rerun",
+            kind: "vortex_skipped",
             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.`,
+            skipReason: vortexSkip.skipReason,
+            steps: vortexSkippedSteps(stack, layer, vortexSkip.skipReason),
         };
     }
-    const vortexSkip = vortexIdleSkipBlocker(layer);
-    if (vortexSkip && attention.blocker === vortexSkip.blocker) {
+    const wait = autoLandWaitOn(stack, layer);
+    if (wait?.reason === "members_remaining" && reason === "auto_land_members_remaining") {
         return {
-            kind: "vortex_skipped",
+            kind: "members_remaining",
             prNumber: layer.prNumber,
             headSha: layer.headSha ?? null,
             branch: layer.branch,
-            skipReason: vortexSkip.skipReason,
-            steps: vortexSkippedSteps(stack, layer, vortexSkip.skipReason),
+            detail: wait.detail,
+            steps: `Auto land will not send land PR #${layer.prNumber} to the merge queue while another PR is open on ${layer.branch} that is not a layer of this stack${wait.detail ? ` (${wait.detail})` : ""}. Nothing on ${layer.branch} needs a change: do not patch or push for this. Close that PR, retarget it to another base, or adopt it into the stack (mg stack adopt ${stack.owner}/${stack.repo}#<that PR>); a draft PR or a PR from a fork cannot be adopted, so close or retarget it. If the PR is not yours, tell the human. Auto land sends the land PR to the queue by itself once that PR is gone from ${layer.branch}.`,
         };
     }
-    const wait = autoLandWaitOn(stack, layer);
-    if (wait && attention.blocker.startsWith(AUTO_LAND_CI_PENDING_PREFIX)) {
+    if (wait && reason === "auto_land_ci_pending") {
         return {
             kind: "ci_pending",
             prNumber: layer.prNumber,
@@ -629,7 +653,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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)) {
+    if (wait && reason === "auto_land_vortex_wait") {
         return {
             kind: "vortex_not_green",
             prNumber: layer.prNumber,
@@ -639,7 +663,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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_CI_UNREADABLE_PREFIX)) {
+    if (wait && reason === "auto_land_ci_unreadable") {
         const what = CI_UNREADABLE_WHAT[wait.reason] ?? "the checks";
         const permission = CI_UNREADABLE_PERMISSION[wait.reason] ?? "Checks: read and Commit statuses: read";
         return {
@@ -652,7 +676,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             steps: `GitHub has not let Mergestorm read ${what} for #${layer.prNumber} at ${layer.headSha ?? "its head"} since ${wait.since}${wait.detail ? ` (${wait.detail})` : ""}, so Auto land cannot tell whether CI passed and will not move this PR. Nothing on ${layer.branch} needs a change: do not patch or push for this. Tell the human: the Mergestorm GitHub App needs the permission ${permission} on ${stack.owner}/${stack.repo}. They open the app's installation on GitHub (Settings, then GitHub Apps or Installed GitHub Apps), accept the pending permission request, and check that ${stack.repo} is in the app's repository access. Auto land continues by itself once the read works. If GitHub itself is having an outage, the wait clears when it ends.`,
         };
     }
-    if (wait && attention.blocker.startsWith(AUTO_LAND_WAITED_PREFIX)) {
+    if (wait && reason === "auto_land_waited") {
         return {
             kind: "auto_land_waiting",
             prNumber: layer.prNumber,
@@ -663,7 +687,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             steps: `Auto land has been waiting on this stack since ${wait.since} because ${autoLandWaitWords(wait.reason)} (reason ${wait.reason}${wait.detail ? `: ${wait.detail}` : ""}), and nothing has changed that in the meantime. Run mg stack status ${stack.id} and read what it shows for #${layer.prNumber}. If it names something on ${layer.branch} that a commit fixes, fix it there with an ordinary push. Otherwise do not patch or push: tell the human what Auto land is waiting for and since when. Do not retarget the PR base.`,
         };
     }
-    if (wait && attention.blocker.startsWith(AUTO_LAND_PROMOTE_FAILED_PREFIX)) {
+    if (wait && reason === "auto_land_promote_failed") {
         const attempts = wait.attempts ?? AUTO_LAND_PROMOTE_FAILED_ATTEMPTS;
         return {
             kind: "promote_failed",
@@ -675,7 +699,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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) {
+    if (reason === "vortex_findings_need_person") {
         const findings = `gh api repos/${stack.owner}/${stack.repo}/pulls/${layer.prNumber}/reviews`;
         const handoff = cycloneHandoffAtHead(stack, layer);
         return {
@@ -688,7 +712,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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") {
+    if (reason === "ci_failed" || attention.bounceKind === "ci_failure") {
         const failingCheck = bounce?.bounceDetail?.failingCheck?.trim() || layer.checks?.failingName?.trim() || null;
         return {
             kind: "ci_failure",
@@ -701,6 +725,44 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
     }
     return null;
 }
+export const LAND_PR_MISSING_PREFIX = "No open land PR for ";
+function landPrMissing(stack, candidate) {
+    const unit = stack.unit;
+    if (!unit || candidate || stack.archivedAt || unit.state === "landed" || unit.state === "abandoned")
+        return null;
+    if (stack.layers.some((layer) => !isTerminalLayer(layer)))
+        return null;
+    const landing = unit.landingBlockReason?.trim();
+    if (!landing || landGateIsPending(landing) || unit.landPr?.state === "merged")
+        return null;
+    const closed = unit.landPr && unit.landPr.prNumber > 0 ? unit.landPr : null;
+    const prNumber = unit.landPrNumber ?? closed?.prNumber ??
+        stack.layers.filter((layer) => layer.prNumber > 0).sort((a, b) => b.position - a.position)[0]?.prNumber;
+    if (prNumber == null || prNumber <= 0)
+        return null;
+    const headSha = closed?.headSha ?? null;
+    const target = unit.landTarget?.trim() || stack.landTarget;
+    const detail = landing.replace(/^landing blocked:\s*/i, "").replace(/^land_pr_unavailable:\s*/i, "").trim() || null;
+    const landPrRef = unit.landPrNumber ?? closed?.prNumber ?? null;
+    const restore = landPrRef != null
+        ? `restore it from the closed land PR's head (gh pr view ${landPrRef} --repo ${stack.owner}/${stack.repo} --json headRefOid,state, then git push origin <that sha>:refs/heads/${unit.branch}) and reopen #${landPrRef}`
+        : `restore it from the commit it pointed at (git push origin <sha>:refs/heads/${unit.branch})`;
+    return {
+        reason: "land_pr_missing",
+        attention: {
+            prNumber, headSha, bounceKind: null,
+            blocker: `${LAND_PR_MISSING_PREFIX}${unit.branch} — every layer is merged into it, but it cannot land in ${target} without one`,
+        },
+        repair: {
+            kind: "land_pr_unavailable",
+            prNumber,
+            headSha,
+            branch: unit.branch,
+            detail,
+            steps: `Every layer of this stack is merged into ${unit.branch}, but there is no open land PR from ${unit.branch} into ${target} and Mergestorm cannot open one${detail ? ` (${detail})` : ""}, so the stack cannot land. Nothing in the layers needs a change: do not patch or push for this. Check whether the stack branch still exists: git ls-remote origin refs/heads/${unit.branch}. If it is gone (deleting it makes GitHub close the land PR), tell the human: ${restore}, or close the stack if the work is no longer wanted. If the branch exists, tell the human that Mergestorm cannot open the land PR and give them the error above. Do not open a PR into ${target} yourself.`,
+        },
+    };
+}
 /** Pair-gate attention plus live hard blocks on every other open layer. */
 export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now()) {
     const candidate = currentLayer(stack);
@@ -714,9 +776,11 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
         (boundDirty(layer) || layer.state === "conflict" ||
             (layer.state !== "restacking" && layer.restackError?.kind === "rebase_conflict"))).sort((a, b) => a.position - b.position)[0];
     let attention = null;
+    let attentionReason = null;
     let attentionLayer;
     let bounce;
     const issues = [];
+    const mergeStateUnknownPrs = new Set();
     const queueWait = stack.archivedAt ? null : mergeQueueWait(queue, nowMs);
     for (const layer of open) {
         const selected = layer.prNumber === candidate?.prNumber;
@@ -726,22 +790,26 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
             disarmed = disarmingBounce(stack, queue);
             if (disarmed) {
                 const kind = disarmed.bounceDetail.kind;
-                result = { blocker: `${AUTO_LAND_OFF_BLOCKER_PREFIX}${kind} bounce`, bounceKind: kind, bounce: disarmed };
+                result = { blocker: `${AUTO_LAND_OFF_BLOCKER_PREFIX}${kind} bounce`, reason: "auto_land_off", bounceKind: kind, bounce: disarmed };
             }
         }
         let waitNamed = false;
         if (!result.blocker) {
-            const waiting = autoLandWaitBlocker(stack, layer, nowMs);
+            const waiting = autoLandWaitNamed(stack, layer, nowMs);
             if (waiting) {
-                result = { blocker: waiting, bounceKind: null };
+                result = { ...waiting, bounceKind: null };
                 waitNamed = true;
             }
         }
         if (!result.blocker && selected && queueWait?.stalled) {
-            result = { blocker: `${MERGE_QUEUE_STALLED_PREFIX}${queueWait.text}`, bounceKind: null };
+            result = { blocker: `${MERGE_QUEUE_STALLED_PREFIX}${queueWait.text}`, reason: "queue_stalled", bounceKind: null };
         }
         if (!result.blocker) {
+            if (vortexRetryScheduled(layer) && (selected || !candidate || layer.position > candidate.position)) {
+                issues.push({ prNumber: layer.prNumber, headSha: layer.headSha ?? null, blocker: VORTEX_RETRY_SCHEDULED, bounceKind: null });
+            }
             if (mergeabilityPending(layer) && (selected || !candidate || layer.position > candidate.position)) {
+                mergeStateUnknownPrs.add(layer.prNumber);
                 issues.push({ prNumber: layer.prNumber, headSha: layer.headSha ?? null,
                     blocker: `Merge state unknown${layer.parentBranch ? ` vs ${layer.parentBranch}` : ""}`, bounceKind: null });
             }
@@ -750,9 +818,10 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
         const issue = { prNumber: layer.prNumber, headSha: layer.headSha ?? null,
             blocker: result.blocker, bounceKind: result.bounceKind };
         if (selected ||
-            result.blocker.startsWith(UNIT_ABANDONED_BLOCKER_PREFIX) ||
+            result.reason === "unit_abandoned" ||
             (!attention && (layer === child || waitNamed))) {
             attention = issue;
+            attentionReason = result.reason;
             attentionLayer = layer;
             bounce = result.bounce;
             if (disarmed)
@@ -764,9 +833,10 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     }
     if (!attention) {
         const unlisted = autoLandWaitLayer(stack);
-        const waiting = unlisted && !open.includes(unlisted) ? autoLandWaitBlocker(stack, unlisted, nowMs) : null;
+        const waiting = unlisted && !open.includes(unlisted) ? autoLandWaitNamed(stack, unlisted, nowMs) : null;
         if (unlisted && waiting) {
-            attention = { prNumber: unlisted.prNumber, headSha: unlisted.headSha ?? null, blocker: waiting, bounceKind: null };
+            attention = { prNumber: unlisted.prNumber, headSha: unlisted.headSha ?? null, blocker: waiting.blocker, bounceKind: null };
+            attentionReason = waiting.reason;
             attentionLayer = unlisted;
         }
     }
@@ -774,9 +844,18 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
         ? { prNumber: candidate.prNumber, headSha: candidate.headSha ?? null, text: queueWait.text,
             since: queueWait.since, waitReason: queueWait.waitReason }
         : null;
-    const settleIssue = mergeabilitySettleIssue(stack, open, issues, attention);
+    const settleIssue = mergeabilitySettleIssue(stack, open, mergeStateUnknownPrs, attention);
     if (settleIssue)
         issues.push(settleIssue);
+    const landMissing = landPrMissing(stack, candidate);
+    if (landMissing) {
+        attention = landMissing.attention;
+        attentionReason = landMissing.reason;
+        attentionLayer = undefined;
+    }
+    const classified = attention && attentionReason
+        ? { ...attention, reason: attentionReason }
+        : null;
     const focus = attentionLayer ?? candidate;
     const agents = focus ? layerAgents(focus) : null;
     const busy = [];
@@ -793,25 +872,26 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     const landGatePending = landLayer && landing && landGateIsPending(landing)
         ? { prNumber: landLayer.prNumber, headSha: landLayer.headSha ?? null, reason: landing }
         : null;
-    if (busy.length && attention && agentsCannotClear(attention.blocker)) {
+    if (busy.length && attention && classified && agentsCannotClear(classified.reason)) {
         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, queueWait), landGatePending, queueWait: queued };
+            repair: stackRepair(stack, classified, 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 };
     }
     return { attention, held: null, issues, currentCandidate, bounce, busy, agents,
-        repair: stackRepair(stack, attention, attentionLayer, bounce, queueWait), landGatePending, queueWait: queued };
+        repair: landMissing?.repair ?? stackRepair(stack, classified, attentionLayer, bounce, queueWait), landGatePending,
+        queueWait: queued };
 }
-function mergeabilitySettleIssue(stack, open, issues, attention) {
+function mergeabilitySettleIssue(stack, open, mergeStateUnknownPrs, attention) {
     const settle = stack.autoEnqueueSettle;
     if (stack.archivedAt || settle?.action !== "mergeability")
         return null;
     if (attention?.prNumber === settle.prNumber)
         return null;
-    if (issues.some((issue) => issue.prNumber === settle.prNumber && issue.blocker.startsWith("Merge state unknown")))
+    if (mergeStateUnknownPrs.has(settle.prNumber))
         return null;
     const layer = open.find((candidate) => candidate.prNumber === settle.prNumber);
     if (layer && !sameHead(layer.headSha, settle.headSha))