mergestorm 0.3.39 → 0.3.41

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);
@@ -159,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) {
@@ -186,66 +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.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" && !vortexRetryScheduled(layer) &&
             (!layer.vortexReview?.head_sha || sameHead(layer.vortexReview.head_sha, layer.headSha))) {
-            return hardBlock(VORTEX_REVIEW_FAILED);
+            return hardBlock(VORTEX_REVIEW_FAILED, "vortex_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;
@@ -258,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) {
@@ -313,15 +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: "Mergestorm could not reach Tempest to review the land PR; it keeps trying every 5 minutes",
-    tempest_skipped: "Tempest skipped its review of this head",
     members_remaining: "a PR that is not a layer of this stack is still open on the stack branch",
-    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",
     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",
@@ -376,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;
@@ -385,20 +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 `${AUTO_LAND_MEMBERS_REMAINING_PREFIX}${wait.detail ?? AUTO_LAND_WAIT_WORDS.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 && !vortexRetryScheduled(layer)
-                ? `${AUTO_LAND_VORTEX_WAIT_PREFIX}${minutes}m — Auto land is waiting for an approving Vortex review at this head`
+                ? {
+                    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;
@@ -406,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;
@@ -514,28 +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 || blocker === VORTEX_IGNORED_AUTHOR || blocker === VORTEX_REPO_DISABLED ||
-        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|skipped)\b/i;
-const TEMPEST_TRIGGER_FAILED_BLOCKER = /^(?:landing blocked:\s*)?tempest_trigger_failed\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,
@@ -547,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 {
@@ -561,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",
@@ -573,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",
@@ -583,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 {
@@ -599,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,
@@ -609,49 +611,7 @@ 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`;
-        return {
-            kind: "tempest_findings",
-            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.`,
-        };
-    }
-    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 outcome = rerun[1].toLowerCase();
-        const stoppedByPerson = outcome === "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.`
-                : outcome === "skipped"
-                    ? `Tempest skipped its review of land PR #${layer.prNumber} at ${head}, so Auto land will not land it. There are no findings to fix: do not patch or push. Ask the human to run ${comment} "@mergestorm-tempest review" 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.`,
-        };
-    }
-    if (landPr && TEMPEST_TRIGGER_FAILED_BLOCKER.test(attention.blocker.trim())) {
-        return {
-            kind: "tempest_trigger_failed",
-            prNumber: layer.prNumber,
-            headSha: layer.headSha ?? null,
-            branch: layer.branch,
-            detail: attention.blocker.trim(),
-            steps: `Mergestorm could not reach Tempest to review land PR #${layer.prNumber} at ${layer.headSha ?? "its head"} for over 5 minutes, so Auto land will not land it yet. Mergestorm keeps trying every 5 minutes. Nothing in the PR needs a change: do not patch or push. Keep watching; if this stays, tell the human that Tempest cannot be reached.`,
-        };
-    }
-    if (attention.blocker === VORTEX_REVIEW_FAILED) {
+    if (reason === "vortex_failed") {
         return {
             kind: "vortex_failed",
             prNumber: layer.prNumber,
@@ -662,7 +622,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
         };
     }
     const vortexSkip = vortexIdleSkipBlocker(layer);
-    if (vortexSkip && attention.blocker === vortexSkip.blocker) {
+    if (vortexSkip && reason === "vortex_skipped") {
         return {
             kind: "vortex_skipped",
             prNumber: layer.prNumber,
@@ -673,7 +633,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
         };
     }
     const wait = autoLandWaitOn(stack, layer);
-    if (wait?.reason === "members_remaining" && attention.blocker.startsWith(AUTO_LAND_MEMBERS_REMAINING_PREFIX)) {
+    if (wait?.reason === "members_remaining" && reason === "auto_land_members_remaining") {
         return {
             kind: "members_remaining",
             prNumber: layer.prNumber,
@@ -683,7 +643,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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}.`,
         };
     }
-    if (wait && attention.blocker.startsWith(AUTO_LAND_CI_PENDING_PREFIX)) {
+    if (wait && reason === "auto_land_ci_pending") {
         return {
             kind: "ci_pending",
             prNumber: layer.prNumber,
@@ -693,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,
@@ -703,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 {
@@ -716,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,
@@ -727,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",
@@ -739,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 {
@@ -752,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",
@@ -788,6 +748,7 @@ function landPrMissing(stack, candidate) {
         ? `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`,
@@ -815,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;
@@ -827,25 +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 });
             }
@@ -854,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)
@@ -868,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;
         }
     }
@@ -878,14 +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 = [];
@@ -902,26 +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: landMissing?.repair ?? stackRepair(stack, attention, attentionLayer, bounce, queueWait), landGatePending,
+        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))

package/dist/stack-dto.d.ts

@@ -9,6 +9,7 @@ export type RestackError = {
         branch: string;
         oldSha: string;
     };
+    droppedMergeCommit?: boolean;
 };
 export declare function restackAttemptsExhausted(error: Pick<RestackError, "attempts">): boolean;
 export declare function pushRejectionIsRetryable(message: string): boolean;
@@ -69,8 +70,7 @@ export type StackCycloneHandoff = {
     reason: string;
     at: string | null;
 };
-export type StackTempestStatus = "reviewing" | "findings" | "clear" | "failed" | "stale";
-export type StackAgentName = "vortex" | "cyclone" | "tempest";
+export type StackAgentName = "vortex" | "cyclone";
 /**
  * One live-or-resting agent run for a PR (#1119): a dumb projection of one
  * ledger row (webhook job / lease / review-state / pr_reviews). Two live
@@ -197,8 +197,6 @@ export type StackLayerDto = {
     vortexStatus: StackVortexStatus | null;
     /** null on the fast list or when no Cyclone signal exists. */
     cycloneStatus: StackCycloneStatus | null;
-    /** null when no Tempest signal exists. Fast list and enrich both paint this from pr_reviews (#876). */
-    tempestStatus: StackTempestStatus | null;
     /**
      * Ledger-backed agent runs, one per live row (#1119). Fast list and enrich
      * both paint this from our tables only — never GitHub. The per-agent status
@@ -296,11 +294,10 @@ export type StackUnitDto = {
     landTarget: string;
     members: StackUnitMemberDto[];
     landPrNumber: number | null;
-    tempestLandStatus: string | null;
     landingBlockReason: string | null;
     /**
      * Land-PR chrome. Fast list hydrates last-known CI/title/mergeable/issues from
-     * `review_units` (#878 / #892) and may attach a tempest-only stub (#876). Enrich
+     * `review_units` (#878 / #892). Enrich
      * refreshes GitHub and writes back. Null when the land PR is an open stack
      * layer (chips live on `layers`) or the unit has no land PR.
      */
@@ -385,6 +382,8 @@ export type StackDto = {
      */
     cycloneOwnerMatch?: CycloneOwnerMatch;
     cyclonePatchOff?: CyclonePatchOffReason;
+    infrastructureInstallUserId?: string | null;
+    infrastructureOwnerMatch?: CycloneOwnerMatch;
     layers: StackLayerDto[];
     /** Present when a review-unit row exists for this stack. */
     unit?: StackUnitDto;
@@ -392,9 +391,9 @@ export type StackDto = {
 export type MergeQueueEntryState = "queued" | "running" | "waiting" | "landed" | "bounced" | "cancelled";
 export type MergeQueueEnqueuedBy = "human" | "agent";
 export type MergeQueueEnqueuedVia = "dashboard" | "cli" | "chat" | "api" | "mcp";
-export type MergeQueueBounceKind = "ci_failure" | "ci_timeout" | "head_moved" | "tempest_findings" | "tempest_rerun" | "seam_findings" | "restack_conflict" | "pr_draft" | "must_consolidate" | "merge_failed" | "gh_error";
+export type MergeQueueBounceKind = "ci_failure" | "ci_timeout" | "head_moved" | "seam_findings" | "restack_conflict" | "pr_draft" | "must_consolidate" | "merge_failed" | "gh_error";
 /** Every bounce kind understood by the shared contract. */
-export declare const MERGE_QUEUE_BOUNCE_KINDS: readonly ["ci_failure", "ci_timeout", "head_moved", "tempest_findings", "tempest_rerun", "seam_findings", "restack_conflict", "pr_draft", "must_consolidate", "merge_failed", "gh_error"];
+export declare const MERGE_QUEUE_BOUNCE_KINDS: readonly ["ci_failure", "ci_timeout", "head_moved", "seam_findings", "restack_conflict", "pr_draft", "must_consolidate", "merge_failed", "gh_error"];
 export declare const BOUNCE_KIND_LABELS: Readonly<Record<MergeQueueBounceKind, string>>;
 export declare function mergeQueueBounceLabel(entry: MergeQueueEntryDto): string;
 /** Structured bounce handoff — enough for the bar chip and the chat quote. */