mergestorm 0.3.37 → 0.3.39

package/README.md

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

package/dist/automation-catalog.d.ts

@@ -49,6 +49,17 @@ export declare const BEARER_SETTINGS: readonly [{
     readonly kind: "seconds";
     readonly min: 15;
     readonly max: 300;
+}, {
+    readonly key: "merge_queue_batch_enabled";
+    readonly flag: "--merge-queue-batch";
+    readonly label: "Merge queue batching";
+}, {
+    readonly key: "merge_queue_batch_size";
+    readonly flag: "--merge-queue-batch-size";
+    readonly label: "Merge queue batch size (pull requests)";
+    readonly kind: "count";
+    readonly min: 2;
+    readonly max: 8;
 }, {
     readonly key: "ignored_bot_logins";
     readonly flag: "--ignore-bot";
@@ -82,9 +93,9 @@ export type BearerSettingsValues = {
     [Row in (typeof BEARER_SETTINGS)[number] as Row["key"]]: Row extends {
         kind: "logins";
     } ? string[] : Row extends {
-        kind: "seconds";
+        kind: "seconds" | "count";
     } ? number : Row extends {
         values: readonly (infer Value)[];
     } ? Value : boolean;
 };
-export declare const BEARER_BOOLEAN_SETTINGS_KEYS: ("auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check")[];
+export declare const BEARER_BOOLEAN_SETTINGS_KEYS: ("auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check")[];

package/dist/automation-catalog.js

@@ -11,6 +11,8 @@ export const BEARER_SETTINGS = [
     { key: "vortex_seam_specialist_enabled", flag: "--vortex-seam", label: "Vortex seam specialist" },
     { key: "auto_land_default", flag: "--auto-land", label: "Auto land (new stacks)" },
     { key: "auto_land_settle_seconds", flag: "--auto-land-settle", label: "Auto land settle (seconds)", kind: "seconds", min: 15, max: 300 },
+    { key: "merge_queue_batch_enabled", flag: "--merge-queue-batch", label: "Merge queue batching" },
+    { key: "merge_queue_batch_size", flag: "--merge-queue-batch-size", label: "Merge queue batch size (pull requests)", kind: "count", min: 2, max: 8 },
     { key: "ignored_bot_logins", flag: "--ignore-bot", label: "Ignored bot logins", kind: "logins" },
     { key: "vortex_bot_skip_check", flag: "--vortex-skip-check", label: "Vortex bot skip check", kind: "enum", values: ["none", "neutral"] },
     { key: "vortex_findings_check", flag: "--vortex-findings", label: "Vortex findings check", kind: "enum", values: ["failure", "neutral", "success"] },

package/dist/client/index.d.ts

@@ -2,7 +2,7 @@ export { DEFAULT_API, apiBase, clearConfig, configPath, keyDisplay, loadConfig,
 export { BEARER_SETTINGS, BEARER_BOOLEAN_SETTINGS_KEYS, BEARER_SETTINGS_FLAGS, BEARER_SETTINGS_KEYS, BEARER_SETTINGS_LABELS, type BearerSettingsKey, } from "../automation-catalog.js";
 export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, dismissPrFindings, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, setStackAutoLand, setStackPolicy, stackPolicyBody, type ApiFetchInit, type ApiFetchResult, type JobListItem, type MeResponse, type MergeQueueBounceDetail, type MergeQueueBounceKind, type MergeQueueEnqueuedBy, type MergeQueueEnqueuedVia, type MergeQueueEntryDto, type MergeQueueEntryState, type PrDismissedFinding, type PrFindingDismissInput, type PrFindingDismissOutcome, type PrFindingDismissResult, type PrReviewFinding, type PrReviewFindings, type PrVortexReview, type SettingsPatch, type SettingsResponse, type SettingsWritableKey, type StackDto, type StackPolicyPatch, type ThreadDetail, type ThreadListItem, } from "../api.js";
 export { CommandError, DetachedError, RATE_LIMITED_HINT, REVIEW_EXIT, isCommandErrorCode, rateLimitedMessage, type CommandErrorCode, type CommandErrorExtras, } from "../errors.js";
-export { REVIEW_POLL_BACKOFF_MS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_POLL_STRETCH_AFTER_MS, REVIEW_POLL_STRETCH_SPAN_MS, REVIEW_THREAD_SLUG_RE, PrReviewPollTimeoutError, ReviewPollTimeoutError, collectReviewInput, formatReviewSubmitError, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollPrVortexReview, pollReview, stretchedPollIntervalMs, submitReview, transientRetryWaitMs, type PollReviewOptions, type PollPrVortexReviewOptions, type ReviewInput, type SubmitReviewOptions, } from "../commands/review-client.js";
+export { REVIEW_POLL_BACKOFF_MS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_POLL_STRETCH_AFTER_MS, REVIEW_POLL_STRETCH_SPAN_MS, REVIEW_THREAD_SLUG_RE, PrReviewPollTimeoutError, ReviewPollTimeoutError, noPrReviewYetMessage, collectReviewInput, formatReviewSubmitError, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollPrVortexReview, pollReview, stretchedPollIntervalMs, submitReview, transientRetryWaitMs, type PollReviewOptions, type PollPrVortexReviewOptions, type ReviewInput, type SubmitReviewOptions, } from "../commands/review-client.js";
 export { REVIEW_JOB_ENVELOPE_SCHEMA, toReviewJobEnvelope, type ReviewEnvelopeFallbacks, type ReviewJobEnvelope, type ReviewJobRow, } from "../ui/job-envelope.js";
 export { discoverTrunk } from "../git-stack.js";
 export { BOUNCE_KIND_LABELS, deriveStackAgentsBusy, mergeQueueBounceLabel, type StackAgentsBusy } from "../stack-dto.js";

package/dist/client/index.js

@@ -2,7 +2,7 @@ export { DEFAULT_API, apiBase, clearConfig, configPath, keyDisplay, loadConfig,
 export { BEARER_SETTINGS, BEARER_BOOLEAN_SETTINGS_KEYS, BEARER_SETTINGS_FLAGS, BEARER_SETTINGS_KEYS, BEARER_SETTINGS_LABELS, } from "../automation-catalog.js";
 export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, dismissPrFindings, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, setStackAutoLand, setStackPolicy, stackPolicyBody, } from "../api.js";
 export { CommandError, DetachedError, RATE_LIMITED_HINT, REVIEW_EXIT, isCommandErrorCode, rateLimitedMessage, } from "../errors.js";
-export { REVIEW_POLL_BACKOFF_MS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_POLL_STRETCH_AFTER_MS, REVIEW_POLL_STRETCH_SPAN_MS, REVIEW_THREAD_SLUG_RE, PrReviewPollTimeoutError, ReviewPollTimeoutError, collectReviewInput, formatReviewSubmitError, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollPrVortexReview, pollReview, stretchedPollIntervalMs, submitReview, transientRetryWaitMs, } from "../commands/review-client.js";
+export { REVIEW_POLL_BACKOFF_MS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_POLL_STRETCH_AFTER_MS, REVIEW_POLL_STRETCH_SPAN_MS, REVIEW_THREAD_SLUG_RE, PrReviewPollTimeoutError, ReviewPollTimeoutError, noPrReviewYetMessage, collectReviewInput, formatReviewSubmitError, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollPrVortexReview, pollReview, stretchedPollIntervalMs, submitReview, transientRetryWaitMs, } from "../commands/review-client.js";
 export { REVIEW_JOB_ENVELOPE_SCHEMA, toReviewJobEnvelope, } from "../ui/job-envelope.js";
 export { discoverTrunk } from "../git-stack.js";
 export { BOUNCE_KIND_LABELS, deriveStackAgentsBusy, mergeQueueBounceLabel } from "../stack-dto.js";

package/dist/commands/browse.d.ts

@@ -27,7 +27,7 @@ export declare function buildStatusTabLines(input: StatusTabInput): string[];
 /** In-place job detail for the Jobs tab (same envelope as `status <id>`). */
 export declare function formatJobDetailLines(row: ReviewJobRow): string[];
 /** Human labels for the Config tab and the static `settings` printout. */
-export declare const SETTINGS_LABELS: Record<"auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check", string>;
+export declare const SETTINGS_LABELS: Record<"auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check", string>;
 /** Config rows in a stable order: writable toggles, then connected flags. */
 export declare function buildConfigRows(settings: SettingsResponse): TabsConfigRow[];
 /**

package/dist/commands/registry.js

@@ -186,6 +186,8 @@ export const COMMAND_REGISTRY = [
             "  [--vortex-seam on|off] [--vortex-skip-all-clear on|off]",
             "  [--auto-land on|off]  Auto land default for new stacks",
             "  [--auto-land-settle <seconds>]  How long Auto land waits before queueing (15-300, default 60)",
+            "  [--merge-queue-batch on|off]  Test several queued pull requests on one CI run",
+            "  [--merge-queue-batch-size <n>]  Most pull requests per batch (2-8, default 4)",
             "  [--ignore-bot add <login>|remove <login>|clear]",
             "  [--vortex-skip-check none|neutral] [--vortex-findings failure|neutral|success]",
             "  [--cyclone-fail-check failure|neutral]",

package/dist/commands/review-client.d.ts

@@ -84,12 +84,19 @@ export declare class ReviewPollTimeoutError extends Error {
     readonly lastRow: ReviewJobRow;
     constructor(jobId: string, lastRow: ReviewJobRow);
 }
+export type PrReviewWaitTarget = {
+    afterSha?: string;
+    pass?: number;
+    afterPass?: number;
+};
+export declare function noPrReviewYetMessage(owner: string, repo: string, prNumber: number, target?: PrReviewWaitTarget): string;
 export declare class PrReviewPollTimeoutError extends Error {
     readonly owner: string;
     readonly repo: string;
     readonly prNumber: number;
     readonly lastEnvelope: PrVortexReview | null;
-    constructor(owner: string, repo: string, prNumber: number, lastEnvelope: PrVortexReview | null);
+    readonly reviewSeen: boolean;
+    constructor(owner: string, repo: string, prNumber: number, lastEnvelope: PrVortexReview | null, target?: PrReviewWaitTarget, reviewSeen?: boolean);
 }
 export type PollReviewOptions = {
     timeoutMs?: number;

package/dist/commands/review-client.js

@@ -249,18 +249,31 @@ export class ReviewPollTimeoutError extends Error {
         this.lastRow = lastRow;
     }
 }
+export function noPrReviewYetMessage(owner, repo, prNumber, target = {}) {
+    const sha = target.afterSha?.trim();
+    const pass = target.pass !== undefined
+        ? `Vortex pass ${target.pass}`
+        : target.afterPass !== undefined ? `Vortex pass after pass ${target.afterPass}` : "Vortex review";
+    return `No ${pass} exists for ${owner}/${repo}#${prNumber}${sha ? ` at ${sha.slice(0, 12)}` : ""} yet. ` +
+        "If the push was in the last few minutes, wait once more. If it is still missing after that, Vortex is not reviewing this head " +
+        "(auto-review may be off for the repo or the stack, or the push did not reach Mergestorm): " +
+        `comment "@mergestorm-vortex review" on the PR to run it, or review the branch locally with mg review; a new push also queues a review.`;
+}
 export class PrReviewPollTimeoutError extends Error {
     owner;
     repo;
     prNumber;
     lastEnvelope;
-    constructor(owner, repo, prNumber, lastEnvelope) {
-        super(`Timed out waiting for PR review ${owner}/${repo}#${prNumber}`);
+    reviewSeen;
+    constructor(owner, repo, prNumber, lastEnvelope, target = {}, reviewSeen = lastEnvelope !== null) {
+        super(`Timed out waiting for PR review ${owner}/${repo}#${prNumber}` +
+            (reviewSeen ? "" : `. ${noPrReviewYetMessage(owner, repo, prNumber, target)}`));
         this.name = "PrReviewPollTimeoutError";
         this.owner = owner;
         this.repo = repo;
         this.prNumber = prNumber;
         this.lastEnvelope = lastEnvelope;
+        this.reviewSeen = reviewSeen;
     }
 }
 function shaMatches(actual, expected) {
@@ -286,6 +299,7 @@ export async function pollPrVortexReview(cfg, owner, repo, prNumber, opts = {})
     applyPrReviewQuery(query, opts);
     let transientFailures = 0;
     let lastEnvelope = null;
+    let apiTimeoutSeen = false;
     const sleepBeforeRetry = async (retryAfterSeconds) => {
         const waitMs = Math.min(transientRetryWaitMs({
             retryAfterSeconds,
@@ -315,6 +329,7 @@ export async function pollPrVortexReview(cfg, owner, repo, prNumber, opts = {})
             if (isCommandErrorCode(err, "api_timeout")) {
                 if (opts.propagateTimeout)
                     throw err;
+                apiTimeoutSeen = true;
                 break;
             }
             if (isTransientReviewPollError(err)) {
@@ -364,7 +379,7 @@ export async function pollPrVortexReview(cfg, owner, repo, prNumber, opts = {})
             return lastEnvelope;
         opts.onTick?.("progress");
     }
-    throw new PrReviewPollTimeoutError(owner, repo, prNumber, lastEnvelope);
+    throw new PrReviewPollTimeoutError(owner, repo, prNumber, lastEnvelope, opts, lastEnvelope !== null || apiTimeoutSeen);
 }
 export async function pollReview(cfg, jobId, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? REVIEW_POLL_DEFAULT_TIMEOUT_MS;

package/dist/commands/settings.d.ts

@@ -3,7 +3,7 @@ import { type SettingsPatch, type SettingsResponse } from "../api.js";
  * CLI flag → Bearer settings key. Boolean flags take on|off. The connected flags are
  * read-only on the API and deliberately have no flag here.
  */
-export declare const SETTINGS_FLAGS: Record<string, "auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check">;
+export declare const SETTINGS_FLAGS: Record<string, "auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check">;
 type IgnoreBotOperation = {
     action: "add" | "remove";
     login: string;

package/dist/commands/settings.js

@@ -46,12 +46,13 @@ export function parseSettingsArgs(args) {
             }
             continue;
         }
-        if ("kind" in row && row.kind === "seconds") {
-            const seconds = value !== undefined && /^\d+$/.test(value) ? Number(value) : Number.NaN;
-            if (!Number.isInteger(seconds) || seconds < row.min || seconds > row.max) {
-                throw new CommandError(`${flag} takes a whole number of seconds from ${row.min} through ${row.max}.`, 2, "usage");
+        if ("kind" in row && (row.kind === "seconds" || row.kind === "count")) {
+            const amount = value !== undefined && /^\d+$/.test(value) ? Number(value) : Number.NaN;
+            if (!Number.isInteger(amount) || amount < row.min || amount > row.max) {
+                const unit = row.kind === "seconds" ? " of seconds" : "";
+                throw new CommandError(`${flag} takes a whole number${unit} from ${row.min} through ${row.max}.`, 2, "usage");
             }
-            Object.assign(patch, { [key]: seconds });
+            Object.assign(patch, { [key]: amount });
             continue;
         }
         if ("kind" in row && row.kind === "enum") {
@@ -85,7 +86,7 @@ export function formatSettingsLines(settings) {
                 : typeof row.value === "string"
                     ? row.value
                     : typeof row.value === "number"
-                        ? `${row.value}s`
+                        ? "kind" in row && row.kind === "seconds" ? `${row.value}s` : String(row.value)
                         : row.writable
                             ? row.value
                                 ? "on"

package/dist/stack-blockers.d.ts

@@ -104,6 +104,14 @@ export type StackRepairHint = {
     branch: string;
     since: string;
     steps: string;
+} | {
+    kind: "ci_unreadable" | "auto_land_waiting";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    since: string;
+    reason: string;
+    steps: string;
 } | {
     kind: "queue_stalled";
     prNumber: number;
@@ -112,6 +120,20 @@ export type StackRepairHint = {
     since: string | null;
     waitReason: string | null;
     steps: string;
+} | {
+    kind: "members_remaining" | "vortex_failed" | "tempest_trigger_failed";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    detail: string | null;
+    steps: string;
+} | {
+    kind: "land_pr_unavailable";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    detail: string | null;
+    steps: string;
 } | {
     kind: "vortex_skipped";
     prNumber: number;
@@ -152,10 +174,18 @@ export declare const VORTEX_FINDINGS_NEED_PERSON = "Vortex findings need a perso
 export declare const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
 export declare const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
 export declare const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";
+export declare const VORTEX_IGNORED_AUTHOR = "Vortex skipped this head: the PR author is on the ignored authors list";
+export declare const VORTEX_REPO_DISABLED = "Vortex skipped this head: reviews are turned off for this repository";
+export declare const VORTEX_RETRY_SCHEDULED = "Vortex hit a temporary error on this head and will retry by itself";
+export declare const VORTEX_REVIEW_FAILED = "Review failed";
+export declare function vortexRetryScheduled(layer: StackLayerDto): boolean;
 export declare const AUTO_LAND_CI_PENDING_ATTENTION_MS: number;
 export declare const AUTO_LAND_VORTEX_WAIT_ATTENTION_MS: number;
 export declare const AUTO_LAND_PROMOTE_FAILED_ATTEMPTS = 3;
 export declare const AUTO_LAND_CI_FAILED_BLOCKER = "CI failed \u2014 Auto land reads a failing check on GitHub at this head";
+export declare const AUTO_LAND_WAIT_ATTENTION_MS: number;
+export declare const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS: number;
+export declare function autoLandWaitLayer(stack: StackDto): StackLayerDto | undefined;
 export declare function autoLandWaitBlocker(stack: StackDto, layer: StackLayerDto, nowMs: number): string | null;
 export declare const MERGE_QUEUE_STALL_ATTENTION_MS: number;
 export type StackQueueWait = {
@@ -168,6 +198,7 @@ export type StackQueueWait = {
 export type MergeQueueWait = {
     text: string;
     stalled: boolean;
+    notPickedUp?: boolean;
     since: string | null;
     waitReason: string | null;
     aheadStackId: string | null;
@@ -182,6 +213,7 @@ export declare function restackFailedRepairSteps(branch: string, liveParent: str
 }): string;
 export declare function agentsCannotClear(blocker: string): boolean;
 export declare function stackRepair(stack: StackDto, attention: StackBlocker | null, layer: StackLayerDto | undefined, bounce: MergeQueueEntryDto | undefined, queueWait?: MergeQueueWait | null): StackRepairHint | null;
+export declare const LAND_PR_MISSING_PREFIX = "No open land PR for ";
 /** Pair-gate attention plus live hard blocks on every other open layer. */
 export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntryDto[], cursor?: Pick<StackWatchCursor, "bounceId" | "afterFinishedAt">, nowMs?: number): {
     attention: null;

package/dist/stack-blockers.js

@@ -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.`;
     }
@@ -199,8 +222,10 @@ function layerAttention(stack, layer, queue, cursor) {
             run.status === "findings" && sameHead(run.sha, layer.headSha));
         if (tempest)
             return hardBlock(`Tempest ${tempest.status}`);
-        if (layer.vortexStatus === "failed")
-            return hardBlock("Review failed");
+        if (layer.vortexStatus === "failed" && !vortexRetryScheduled(layer) &&
+            (!layer.vortexReview?.head_sha || sameHead(layer.vortexReview.head_sha, layer.headSha))) {
+            return hardBlock(VORTEX_REVIEW_FAILED);
+        }
         if (quotaSkippedReview(layer))
             return hardBlock(VORTEX_REVIEW_OUT_OF_QUOTA);
         const vortexSkip = vortexIdleSkipBlocker(layer);
@@ -271,17 +296,84 @@ export const AUTO_LAND_CI_FAILED_BLOCKER = "CI failed — Auto land reads a fail
 const AUTO_LAND_CI_PENDING_PREFIX = "CI pending for ";
 const AUTO_LAND_VORTEX_WAIT_PREFIX = "No green Vortex review for ";
 const AUTO_LAND_PROMOTE_FAILED_PREFIX = "Promote failed ";
+export const AUTO_LAND_WAIT_ATTENTION_MS = 45 * 60_000;
+export const AUTO_LAND_CI_UNREADABLE_ATTENTION_MS = 10 * 60_000;
+const AUTO_LAND_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",
+    ci_unreadable: "the check runs and commit statuses",
+};
+const CI_UNREADABLE_PERMISSION = {
+    check_runs_unreadable: "Checks: read",
+    commit_statuses_unreadable: "Commit statuses: read",
+    ci_unreadable: "Checks: read and Commit statuses: read",
+};
+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",
+    pr_draft: "this PR is a draft",
+    trunk_in_land_target_without_land_pr: "the stack's commits are already in the land target, but no merged land PR was found",
+    conflict_unchanged: "the merge queue bounced this PR for a conflict, and neither the PR nor its base has changed since",
+    land_pr_unavailable: "the land PR cannot be opened or found",
+    github_unreadable: "Mergestorm cannot read this PR from GitHub",
+    land_gate_failed: "the check before landing keeps failing with an error",
+    readiness_check_failed: "the readiness check for this PR keeps failing with an error",
+    layer_without_pr: "a layer of this stack has no pull request",
+    parked_base: "this PR's base is a parked branch (mg-park-*) and has not been moved back",
+    pr_not_open: "GitHub shows this PR merged or closed, but the stack still lists it as open",
+    stack_without_unit: "the stack has more than one open layer but no review unit to promote them into",
+    ci_error: "CI reported an error on this head",
+    ci_unknown: "CI on this head is in a state Mergestorm cannot read",
+    ci_missing: "no CI run exists for this head",
+};
+function autoLandWaitWords(reason) {
+    return AUTO_LAND_WAIT_WORDS[reason] ?? reason.replaceAll("_", " ");
+}
+function ciUnreadableForGood(wait) {
+    return /\bHTTP 40[34]\b/.test(wait.detail ?? "");
+}
 function waitedMs(since, nowMs) {
     const sinceMs = Date.parse(since);
     return Number.isFinite(sinceMs) ? Math.max(0, nowMs - sinceMs) : null;
 }
-function autoLandWaitOn(stack, layer) {
+function armedAutoLandWait(stack) {
     const wait = stack.autoLandWait;
-    if (!wait || stack.archivedAt || stack.autoEnqueueWhenReady !== true)
-        return null;
-    if (wait.prNumber !== layer.prNumber || !sameHead(wait.headSha, layer.headSha))
-        return null;
-    return wait;
+    return wait && !stack.archivedAt && stack.autoEnqueueWhenReady === true ? wait : null;
+}
+function lastPrLayer(stack) {
+    const land = stack.unit?.landPr;
+    if (land && land.prNumber > 0)
+        return land;
+    return stack.layers.filter((layer) => layer.prNumber > 0).sort((a, b) => b.position - a.position)[0];
+}
+export function autoLandWaitLayer(stack) {
+    const wait = armedAutoLandWait(stack);
+    if (!wait)
+        return undefined;
+    const candidate = currentLayer(stack);
+    if (wait.prNumber == null)
+        return candidate ?? lastPrLayer(stack);
+    const named = candidate?.prNumber === wait.prNumber
+        ? candidate
+        : stack.layers.find((layer) => layer.prNumber === wait.prNumber && !isTerminalLayer(layer));
+    return named && (!wait.headSha || sameHead(wait.headSha, named.headSha)) ? named : undefined;
+}
+function autoLandWaitOn(stack, layer) {
+    return autoLandWaitLayer(stack)?.prNumber === layer.prNumber ? armedAutoLandWait(stack) : null;
 }
 export function autoLandWaitBlocker(stack, layer, nowMs) {
     const wait = autoLandWaitOn(stack, layer);
@@ -298,8 +390,10 @@ export function autoLandWaitBlocker(stack, layer, nowMs) {
             return waited >= AUTO_LAND_CI_PENDING_ATTENTION_MS
                 ? `${AUTO_LAND_CI_PENDING_PREFIX}${minutes}m — a check on this head has not finished, so Auto land will not queue it`
                 : null;
+        case "members_remaining":
+            return `${AUTO_LAND_MEMBERS_REMAINING_PREFIX}${wait.detail ?? AUTO_LAND_WAIT_WORDS.members_remaining}`;
         case "vortex_not_green":
-            return waited >= AUTO_LAND_VORTEX_WAIT_ATTENTION_MS
+            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`
                 : null;
         case "promote_merge_failed":
@@ -307,8 +401,17 @@ export function autoLandWaitBlocker(stack, layer, nowMs) {
                 ? `${AUTO_LAND_PROMOTE_FAILED_PREFIX}${wait.attempts} times (merge_failed) — Auto land stopped retrying this head${wait.detail ? `: ${wait.detail}` : ""}`
                 : null;
         default:
-            return null;
+            break;
+    }
+    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`
+            : null;
     }
+    return waited >= AUTO_LAND_WAIT_ATTENTION_MS
+        ? `${AUTO_LAND_WAITED_PREFIX}${minutes}m: ${autoLandWaitWords(wait.reason)}`
+        : null;
 }
 export const MERGE_QUEUE_STALL_ATTENTION_MS = 45 * 60_000;
 const MERGE_QUEUE_STALLED_PREFIX = "Merge queue stuck: ";
@@ -322,12 +425,14 @@ export function mergeQueueWait(queue, nowMs) {
         return null;
     const reason = entry.waitReason?.trim() || null;
     if (entry.state === "queued") {
-        const queuedFor = minutesOf(waitedMs(entry.enqueuedAt, nowMs));
+        const queuedMs = waitedMs(entry.enqueuedAt, nowMs);
+        const queuedFor = minutesOf(queuedMs);
         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,
+                stalled: queuedMs != null && queuedMs >= MERGE_QUEUE_STALL_ATTENTION_MS,
+                notPickedUp: true,
                 since: entry.enqueuedAt, waitReason: reason, aheadStackId: null, aheadOther: false,
             };
         }
@@ -357,6 +462,9 @@ function queueStalledSteps(stack, layer, wait) {
             : "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.`;
     }
+    if (wait.notPickedUp) {
+        return `#${layer.prNumber} has been queued in the merge queue for ${stack.owner}/${stack.repo} since ${wait.since ?? "it was enqueued"} and nothing is working on it or on an entry ahead of it${wait.waitReason ? `; its last note is: ${wait.waitReason}` : ""}. Nothing on ${layer.branch} needs a change: do not patch or push for this. If the note says the base branch keeps moving, the queue is waiting for a quiet moment on it and continues by itself once pushes to that branch pause. Otherwise tell the human: the merge queue is not picking this entry up; 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.`;
+    }
     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) {
@@ -410,11 +518,12 @@ 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_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)\b/i;
+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();
@@ -515,7 +624,8 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
         bounce?.bounceDetail?.message?.trim().match(TEMPEST_RERUN_BLOCKER);
     const rerun = landPr ? rerunBlocker : null;
     if (rerun) {
-        const stoppedByPerson = rerun[1].toLowerCase() === "stopped";
+        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 {
@@ -526,7 +636,29 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             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.`,
+                : 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) {
+        return {
+            kind: "vortex_failed",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            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 vortexSkip = vortexIdleSkipBlocker(layer);
@@ -541,6 +673,16 @@ 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)) {
+        return {
+            kind: "members_remaining",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            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}.`,
+        };
+    }
     if (wait && attention.blocker.startsWith(AUTO_LAND_CI_PENDING_PREFIX)) {
         return {
             kind: "ci_pending",
@@ -561,6 +703,30 @@ 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)) {
+        const what = CI_UNREADABLE_WHAT[wait.reason] ?? "the checks";
+        const permission = CI_UNREADABLE_PERMISSION[wait.reason] ?? "Checks: read and Commit statuses: read";
+        return {
+            kind: "ci_unreadable",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            since: wait.since,
+            reason: wait.reason,
+            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)) {
+        return {
+            kind: "auto_land_waiting",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            since: wait.since,
+            reason: wait.reason,
+            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)) {
         const attempts = wait.attempts ?? AUTO_LAND_PROMOTE_FAILED_ATTEMPTS;
         return {
@@ -599,6 +765,43 @@ 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 {
+        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);
@@ -639,6 +842,9 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
             result = { blocker: `${MERGE_QUEUE_STALLED_PREFIX}${queueWait.text}`, 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)) {
                 issues.push({ prNumber: layer.prNumber, headSha: layer.headSha ?? null,
                     blocker: `Merge state unknown${layer.parentBranch ? ` vs ${layer.parentBranch}` : ""}`, bounceKind: null });
@@ -660,6 +866,14 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
         else if (!candidate || layer.position > candidate.position)
             issues.push(issue);
     }
+    if (!attention) {
+        const unlisted = autoLandWaitLayer(stack);
+        const waiting = unlisted && !open.includes(unlisted) ? autoLandWaitBlocker(stack, unlisted, nowMs) : null;
+        if (unlisted && waiting) {
+            attention = { prNumber: unlisted.prNumber, headSha: unlisted.headSha ?? null, blocker: waiting, bounceKind: null };
+            attentionLayer = unlisted;
+        }
+    }
     const queued = queueWait && candidate && !queueWait.stalled
         ? { prNumber: candidate.prNumber, headSha: candidate.headSha ?? null, text: queueWait.text,
             since: queueWait.since, waitReason: queueWait.waitReason }
@@ -667,6 +881,11 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
     const settleIssue = mergeabilitySettleIssue(stack, open, issues, attention);
     if (settleIssue)
         issues.push(settleIssue);
+    const landMissing = landPrMissing(stack, candidate);
+    if (landMissing) {
+        attention = landMissing.attention;
+        attentionLayer = undefined;
+    }
     const focus = attentionLayer ?? candidate;
     const agents = focus ? layerAgents(focus) : null;
     const busy = [];
@@ -693,7 +912,8 @@ export function stackBlockers(stack, entries = [], cursor = {}, nowMs = Date.now
             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, attention, attentionLayer, bounce, queueWait), landGatePending,
+        queueWait: queued };
 }
 function mergeabilitySettleIssue(stack, open, issues, attention) {
     const settle = stack.autoEnqueueSettle;

package/dist/stack-dto.d.ts

@@ -392,9 +392,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" | "seam_findings" | "restack_conflict" | "pr_draft" | "must_consolidate" | "merge_failed" | "gh_error";
+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";
 /** Every bounce kind understood by the shared contract. */
-export declare const MERGE_QUEUE_BOUNCE_KINDS: readonly ["ci_failure", "ci_timeout", "head_moved", "tempest_findings", "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", "tempest_findings", "tempest_rerun", "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. */

package/dist/stack-dto.js

@@ -56,6 +56,7 @@ export const MERGE_QUEUE_BOUNCE_KINDS = [
     "ci_timeout",
     "head_moved",
     "tempest_findings",
+    "tempest_rerun",
     "seam_findings",
     "restack_conflict",
     "pr_draft",
@@ -68,6 +69,7 @@ export const BOUNCE_KIND_LABELS = {
     ci_timeout: "CI timed out",
     head_moved: "head moved",
     tempest_findings: "Tempest findings",
+    tempest_rerun: "Tempest needs rerun",
     seam_findings: "seam review findings",
     restack_conflict: "restack conflict",
     pr_draft: "draft PR",

package/dist/ui/banner.js

@@ -149,6 +149,12 @@ const WHATS_NEW = {
     "0.3.37": [
         "turning auto-review on reviews skipped heads",
     ],
+    "0.3.39": [
+        "the watch names more waits and what to do",
+    ],
+    "0.3.38": [
+        "mg settings turns merge queue batching on or off",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

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

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

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

package/skill/mergestorm-pr-loop/SKILL.md

@@ -67,7 +67,7 @@ Map these to `mergestorm.pr_review/v1` envelope fields; do not invent statuses.
 - status is `rate_limited`, or `patch_policy.mode` is `"hold"`: surface the findings to the human and stop. Do not patch.
 - status is `failed`: report to the human. Do not keep pushing to retrigger.
 - status is `in_progress` and the envelope has a `head_sha`: the pass is still running; call `review_wait_pr` again with the same `after_sha` and the same `after_pass`.
-- status is `in_progress` and the envelope has no `head_sha`: the wait timed out before Vortex wrote a pass for your SHA. Call `review_wait_pr` once more with the same `after_sha` and the same `after_pass`. If it comes back the same way a second time in a row, stop and tell the human that Vortex did not pick up the push. Do not push again to retrigger.
+- status is `none` (from an older MCP server: status is `in_progress` and the envelope has no `head_sha`): the wait timed out and no Vortex pass exists for your SHA yet. Call `review_wait_pr` once more with the same `after_sha` and the same `after_pass`. If it comes back the same way a second time in a row, stop and tell the human that Vortex did not pick up the push, and that a comment `@mergestorm-vortex review` on the PR runs it. Do not push again to retrigger.
 - status is `quota_exceeded` (or its legacy spelling `trial_expired`): the account's review credits are used up for this period; tell the human calmly and stop. It is not an error and not a lapsed trial. Do not patch or push.
 - status is `skipped`, `stopped`, or `synced`: surface the status and reason to the human and stop. Do not patch or push.