mergestorm 0.3.39 → 0.3.40

package/README.md

@@ -45,7 +45,7 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.39                                             │
+│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.40                                             │
 │ ▀▀▀▀▀▀▀▀▀     ● msk_live_… · maelstrom                                       │
 │  ▀▀▀▀▀▀       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used                      │
 │   ▝▀▀▀▀▀      local reviews + stacked PRs · mergestorm.ai                    │
@@ -137,7 +137,7 @@ Use `mergestorm dismiss` when a Vortex finding is wrong and you have checked it
 
 If the parent branch is already a layer of a **registered** (submitted) stack, `create` and `submit` refuse unless you pass **`--extend`**. That blocks accidentally gluing an unrelated PR onto an open unit. Growing a registered stack on purpose: `mg stack create --onto <tip> --extend` → commit → `mg stack submit --extend`.
 
-`stack submit` walks the **active** local stack: `git push -u origin` each layer, opens a PR with `gh` (`--base` = parent or trunk; adopt then moves the bottom of a 2+ PR stack onto `mg-stack-<n>` — leave it there; skips heads that already have an open PR; body from the tip commit — Summary + Test plan, preserving Fixes/Closes/Resolves), registers the stack with `POST /api/v1/stacks/adopt` internally (Mergestorm API key), then drops that local stack entry so the next create onto trunk is clean. Push is always your local `git` credentials. PRs open as you when `gh` is installed and `gh api user` succeeds; otherwise `stack submit` asks the Mergestorm API (`POST /api/v1/stacks/pulls`) to open them as Cyclone on your behalf, after checking your GitHub account has write access, and assigns you. Without either, submit stops before pushing and links the Cyclone install page.
+`stack submit` walks the **active** local stack: `git push -u origin` each layer, opens a PR with `gh` (`--base` = parent or trunk; adopt then moves the bottom of a 2+ PR stack onto `mg-stack-<n>` — leave it there; skips heads that already have an open PR; body from the tip commit — Summary + Test plan, preserving Fixes/Closes/Resolves), registers the stack with `POST /api/v1/stacks/adopt` internally (Mergestorm API key), then drops that local stack entry so the next create onto trunk is clean. Push is always your local `git` credentials. PRs open as you when `gh` is installed and `gh api user` succeeds; otherwise `stack submit` asks the Mergestorm API (`POST /api/v1/stacks/pulls`) to open them as the Mergestorm infrastructure App on your behalf, after checking your GitHub account has write access, and assigns you. That App is Mergestorm Surge, or Cyclone on accounts not yet moved to Surge; stacks, the merge queue and Auto land run through it, and Cyclone is the auto-patch App. Without either, submit stops before pushing and prints the server's message, which names the App to install and links its install page. `mg settings` prints a `Stacks, merge queue, Auto land` line when the server reports whether that App is ready.
 
 Legacy repo-local `.mergestorm/stack.json` state migrates automatically on the next stack command. If local authoring state is stale or malformed, use `mg stack reset --force`; this clears only pre-submit CLI state and never deletes branches, PRs, or registered stacks.
 

package/dist/api.d.ts

@@ -1,7 +1,8 @@
 import { type Config } from "./config.js";
 import { BEARER_SETTINGS_KEYS as SETTINGS_WRITABLE_KEYS, type BearerSettingsKey as SettingsWritableKey } from "./automation-catalog.js";
+import { CommandError } from "./errors.js";
 import type { MergeQueueEntryDto, StackDto } from "./stack-dto.js";
-export type { MergeQueueBounceDetail, MergeQueueBounceKind, MergeQueueEnqueuedBy, MergeQueueEnqueuedVia, MergeQueueEntryDto, MergeQueueEntryState, StackBranchState, StackCiStatus, StackDto, StackLayerChecks, StackLayerDto, StackReviewStatus, StackTempestStatus, StackUnitDto, StackUnitMemberDto, } from "./stack-dto.js";
+export type { MergeQueueBounceDetail, MergeQueueBounceKind, MergeQueueEnqueuedBy, MergeQueueEnqueuedVia, MergeQueueEntryDto, MergeQueueEntryState, StackBranchState, StackCiStatus, StackDto, StackLayerChecks, StackLayerDto, StackReviewStatus, StackUnitDto, StackUnitMemberDto, } from "./stack-dto.js";
 /** Default per-request timeout so a hung API cannot stall the shell/CI forever. */
 export declare const DEFAULT_API_TIMEOUT_MS = 30000;
 /** Message prefix of the CommandError thrown when a request exceeds its timeout. */
@@ -172,6 +173,7 @@ export type SettingsPatch = Partial<import("./automation-catalog.js").BearerSett
 export type SettingsResponse = import("./automation-catalog.js").BearerSettingsValues & {
     cyclone_connected: boolean;
     github_connected: boolean;
+    stacks_ready?: boolean;
 };
 /**
  * Fetch Bearer /api/v1/settings; null on 404/network/timeouts so panels can
@@ -228,6 +230,9 @@ export type StackPolicyPatch = {
 export declare function stackPolicyBody(policy: StackPolicyPatch | undefined): StackPolicyPatch;
 /** Adopt an open PR chain (Bearer POST /api/v1/stacks/adopt). */
 export declare function adoptStack(owner: string, repo: string, prNumber: number, cfg?: Config, policy?: StackPolicyPatch): Promise<unknown>;
+export declare const SURGE_REFUSAL_FALLBACK = "Mergestorm Surge is not installed or not ready on this repository. Install it from Agents.";
+export declare function surgeRefusal(body: unknown): CommandError | null;
+export declare const GITHUB_UNREADABLE_MESSAGE = "GitHub could not be read just now; try again.";
 /** Mint or reuse the PR3+ park freeze (Bearer POST /api/v1/stacks/:id/ensure-upper-park). */
 export declare function ensureUpperPark(stackId: string, cfg?: Config): Promise<{
     freezeBranch: string;

package/dist/api.js

@@ -1,6 +1,6 @@
 import { apiBase, loadConfig, resolveApiKey } from "./config.js";
 import { BEARER_SETTINGS_KEYS as SETTINGS_WRITABLE_KEYS, } from "./automation-catalog.js";
-import { CommandError, REVIEW_EXIT, rateLimitedMessage, } from "./errors.js";
+import { CommandError, REVIEW_EXIT, rateLimitedMessage, plainServerText, } from "./errors.js";
 /** Default per-request timeout so a hung API cannot stall the shell/CI forever. */
 export const DEFAULT_API_TIMEOUT_MS = 30_000;
 /** Message prefix of the CommandError thrown when a request exceeds its timeout. */
@@ -416,12 +416,53 @@ export async function adoptStack(owner, repo, prNumber, cfg, policy) {
             : code === "supabase_unconfigured"
                 ? "Stacks are not configured on this server."
                 : undefined;
+        const surge = surgeRefusal(body);
+        if (surge)
+            throw surge;
         throw new CommandError(message?.trim()
             ? message
             : fallbackMessage ?? `Failed to import stack (HTTP ${status}): ${JSON.stringify(body)}`, 1, code);
     }
     return body;
 }
+const INFRASTRUCTURE_REFUSAL_CODES = [
+    "cyclone_not_connected",
+    "cyclone_not_installed",
+    "cyclone_permission_missing",
+];
+function refusalReason(body) {
+    const reason = (body && typeof body === "object" ? body.reason : undefined);
+    return typeof reason === "string" && plainServerText(reason).trim() ? plainServerText(reason).trim() : undefined;
+}
+export const SURGE_REFUSAL_FALLBACK = "Mergestorm Surge is not installed or not ready on this repository. Install it from Agents.";
+export function surgeRefusal(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const refusal = body;
+    const reason = refusalReason(body);
+    if (!reason?.startsWith("surge_"))
+        return null;
+    const error = INFRASTRUCTURE_REFUSAL_CODES.find((code) => code === refusal.error);
+    if (!error)
+        return null;
+    const message = serverMessage(refusal.message) ?? SURGE_REFUSAL_FALLBACK;
+    const installUrl = githubAppInstallUrl(refusal.installUrl) ?? "";
+    return new CommandError(installUrl && !message.includes(installUrl) ? `${message} (${installUrl})` : message, 1, error, { reason });
+}
+export const GITHUB_UNREADABLE_MESSAGE = "GitHub could not be read just now; try again.";
+function serverMessage(message) {
+    if (typeof message !== "string")
+        return null;
+    const plain = plainServerText(message).trim();
+    return plain ? plain : null;
+}
+const GITHUB_APP_INSTALL_URL = /https:\/\/github\.com\/apps\/[^\s)]+\/installations\/new/;
+function githubAppInstallUrl(value) {
+    if (typeof value !== "string")
+        return null;
+    const match = GITHUB_APP_INSTALL_URL.exec(plainServerText(value).trim());
+    return match && match.index === 0 ? match[0] : null;
+}
 /** Mint or reuse the PR3+ park freeze (Bearer POST /api/v1/stacks/:id/ensure-upper-park). */
 export async function ensureUpperPark(stackId, cfg) {
     const body = await stackMutation(stackId, "/ensure-upper-park", "POST", {}, "Failed to ensure upper-park freeze", cfg);
@@ -445,10 +486,13 @@ export function cycloneNotInstalledMessage(owner, repo, installUrl = CYCLONE_INS
 function installUrlFrom(message) {
     if (typeof message !== "string")
         return CYCLONE_INSTALL_URL;
-    return message.match(/https:\/\/github\.com\/apps\/[^\s)]+\/installations\/new/)?.[0] ?? CYCLONE_INSTALL_URL;
+    return message.match(GITHUB_APP_INSTALL_URL)?.[0] ?? CYCLONE_INSTALL_URL;
 }
 function stackPullFailure(status, body, owner, repo, failLabel) {
     const rejection = (body && typeof body === "object" ? body : {});
+    const surge = surgeRefusal(body);
+    if (surge)
+        return surge;
     const text = `${String(rejection.error ?? "")} ${String(rejection.message ?? "")}`;
     if (rejection.error === "cyclone_not_installed" ||
         /not installed|installation[^\n]*not found/i.test(text)) {
@@ -500,6 +544,9 @@ async function stackMutation(stackId, pathSuffix, method, json, failLabel, cfg)
         throw new CommandError("Stacks API is not available on this server yet. Deploy the API update or use the dashboard.");
     }
     if (status !== 200) {
+        const surge = surgeRefusal(body);
+        if (surge)
+            throw surge;
         const rejection = body;
         if (method === "PATCH" && rejection?.error === "cyclone_not_connected") {
             throw new CommandError(typeof rejection.message === "string" ? rejection.message : rejection.error, 1, "cyclone_not_connected");
@@ -554,7 +601,7 @@ export async function listMergeQueueEntries(cfg, opts) {
     }
     return entries;
 }
-async function queueMutation(route, failLabel, cfg) {
+async function queueMutation(route, failLabel, cfg, opts = {}) {
     const resolved = cfg ?? (await loadConfig());
     const { status, body } = await apiFetch(resolved, route, {
         method: "POST",
@@ -572,18 +619,27 @@ async function queueMutation(route, failLabel, cfg) {
     }
     if (status === 409) {
         const refusal = body;
-        if (refusal?.error === "conflict_unchanged" && typeof refusal.message === "string") {
+        if ((refusal?.error === "conflict_unchanged" || refusal?.error === "ci_failed") &&
+            typeof refusal.message === "string") {
             throw new CommandError(refusal.message);
         }
     }
+    if (opts.githubUnreadableRefusal &&
+        status === 503 &&
+        body?.error === "github_unreadable") {
+        throw new CommandError(serverMessage(body.message) ?? GITHUB_UNREADABLE_MESSAGE, 1, "github_unreadable");
+    }
     if (status < 200 || status >= 300) {
+        const surge = surgeRefusal(body);
+        if (surge)
+            throw surge;
         throw new CommandError(`${failLabel} (HTTP ${status}): ${JSON.stringify(body)}`);
     }
     return body;
 }
 /** Enqueue a stack for verified landing. */
 export async function enqueueStack(stackId, cfg) {
-    return queueMutation(`/api/v1/stacks/${encodeURIComponent(stackId)}/enqueue`, "Failed to add stack to merge queue", cfg);
+    return queueMutation(`/api/v1/stacks/${encodeURIComponent(stackId)}/enqueue`, "Failed to add stack to merge queue", cfg, { githubUnreadableRefusal: true });
 }
 /** Cancel a live merge-queue entry by entry id. */
 export async function cancelMergeQueueEntry(entryId, cfg) {

package/dist/commands/browse.d.ts

@@ -28,6 +28,11 @@ export declare function buildStatusTabLines(input: StatusTabInput): string[];
 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" | "merge_queue_batch_enabled" | "merge_queue_batch_size" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check", string>;
+export declare const STACKS_READY_LABEL = "Stacks, merge queue, Auto land";
+export declare const STACKS_READY_WORDS: {
+    readonly on: "ready";
+    readonly off: "not ready (install Mergestorm Surge)";
+};
 /** Config rows in a stable order: writable toggles, then connected flags. */
 export declare function buildConfigRows(settings: SettingsResponse): TabsConfigRow[];
 /**

package/dist/commands/browse.js

@@ -121,8 +121,14 @@ export function formatJobDetailLines(row) {
 }
 /** Human labels for the Config tab and the static `settings` printout. */
 export const SETTINGS_LABELS = BEARER_SETTINGS_LABELS;
+export const STACKS_READY_LABEL = "Stacks, merge queue, Auto land";
+export const STACKS_READY_WORDS = {
+    on: "ready",
+    off: "not ready (install Mergestorm Surge)",
+};
 /** Config rows in a stable order: writable toggles, then connected flags. */
 export function buildConfigRows(settings) {
+    const stacksReadyKnown = typeof settings.stacks_ready === "boolean";
     return [
         ...BEARER_BOOLEAN_SETTINGS_KEYS.map((key) => ({
             key,
@@ -130,9 +136,20 @@ export function buildConfigRows(settings) {
             value: settings[key] === true,
             writable: true,
         })),
+        ...(stacksReadyKnown
+            ? [
+                {
+                    key: "stacks_ready",
+                    label: STACKS_READY_LABEL,
+                    value: settings.stacks_ready === true,
+                    writable: false,
+                    readOnlyWords: STACKS_READY_WORDS,
+                },
+            ]
+            : []),
         {
             key: "cyclone_connected",
-            label: "Cyclone",
+            label: stacksReadyKnown ? "Cyclone (auto patch)" : "Cyclone",
             value: settings.cyclone_connected === true,
             writable: false,
         },

package/dist/commands/review.d.ts

@@ -1,4 +1,4 @@
-import { REVIEW_POLL_MAX_TRANSIENT_RETRIES, isTransientReviewPollError, isTransientReviewPollStatus } from "./review-client.js";
+import { REVIEW_POLL_MAX_TRANSIENT_RETRIES, isTransientReviewPollError, isTransientReviewPollStatus, type PollReviewOptions } from "./review-client.js";
 export { REVIEW_POLL_MAX_TRANSIENT_RETRIES, isTransientReviewPollError, isTransientReviewPollStatus, };
 /** Same public specialist allowlist as the API contract and migration 117. */
 export declare const VORTEX_ROUTER_MODES: readonly ["off", "standard", "max", "manual"];
@@ -43,6 +43,7 @@ export type ReviewOptions = {
     interactive?: boolean;
     /** Test seam; production uses the two-second poll interval. */
     pollIntervalMs?: number;
+    pollClock?: Pick<PollReviewOptions, "sleep" | "now" | "random">;
 };
 export declare function reviewStatusHint(jobId: string): string;
 /** Append recovery hint once a job id exists (idempotent). */

package/dist/commands/review.js

@@ -357,6 +357,7 @@ export async function cmdReview(args, opts = {}) {
             row = await pollReview(cfg, jobId, {
                 timeoutMs: parsed.timeoutMs,
                 intervalMs: opts.pollIntervalMs,
+                ...opts.pollClock,
                 signal: opts.signal,
                 propagateTimeout: interactive,
                 onTick(kind) {

package/dist/commands/settings.js

@@ -3,6 +3,7 @@ import { BEARER_SETTINGS, BEARER_SETTINGS_FLAGS } from "../automation-catalog.js
 import { loadConfig } from "../config.js";
 import { CommandError } from "../errors.js";
 import { present } from "../ui/present.js";
+import { readOnlyRowWords } from "../ui/tabs.js";
 import { buildConfigRows, canBrowse, openTabsBrowser } from "./browse.js";
 /**
  * CLI flag → Bearer settings key. Boolean flags take on|off. The connected flags are
@@ -91,9 +92,7 @@ export function formatSettingsLines(settings) {
                             ? row.value
                                 ? "on"
                                 : "off"
-                            : row.value
-                                ? "connected"
-                                : "not connected";
+                            : readOnlyRowWords(row);
         return `  ${row.label.padEnd(labelWidth + 2)}${value}`;
     });
 }

package/dist/commands/stack.js

@@ -1040,8 +1040,7 @@ export async function cmdStackStatus(args, deps = {}) {
         lines.push(`    ${String(layer.position).padStart(2)}  ${pr}${head}  ${layer.state.padEnd(14)}  ${layer.branch}` +
             `  CI: ${layer.ciStatus ?? "unknown"}  review: ${layer.reviewStatus ?? "unknown"}` +
             (layer.vortexStatus ? `  Vortex: ${layer.vortexStatus}` : "") +
-            (layer.cycloneStatus ? `  Cyclone: ${layer.cycloneStatus}` : "") +
-            (layer.tempestStatus ? `  Tempest: ${layer.tempestStatus}` : ""));
+            (layer.cycloneStatus ? `  Cyclone: ${layer.cycloneStatus}` : ""));
     }
     if (queueWait && !attention)
         lines.push(`  Queue: #${queueWait.prNumber} ${queueWait.text}`);

package/dist/errors.d.ts

@@ -2,7 +2,7 @@
  * Stable machine codes for CommandError control flow.
  * UX copy in `message` may change freely; match on `code`, never on message text.
  */
-export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited" | "cyclone_not_installed" | "pr_merged" | "pr_closed" | "not_stacked" | "draft" | "reserved_branch" | "supabase_unconfigured" | "cyclone_not_connected" | "busy" | "adopt_failed" | "stack_attention";
+export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited" | "cyclone_not_installed" | "pr_merged" | "pr_closed" | "not_stacked" | "draft" | "reserved_branch" | "supabase_unconfigured" | "cyclone_not_connected" | "cyclone_permission_missing" | "busy" | "adopt_failed" | "github_unreadable" | "stack_attention";
 /** Stable one-shot exit codes for machine callers of `mergestorm review`. */
 export declare const REVIEW_EXIT: {
     readonly success: 0;
@@ -15,14 +15,17 @@ export declare const REVIEW_EXIT: {
 };
 export type CommandErrorExtras = {
     retryAfterSeconds?: number;
+    reason?: string;
 };
 /** Thrown by command handlers; one-shot mode maps `exitCode` onto process.exitCode. */
 export declare class CommandError extends Error {
     readonly exitCode: number;
     readonly code?: CommandErrorCode;
     readonly retryAfterSeconds?: number;
+    readonly reason?: string;
     constructor(message: string, exitCode?: number, code?: CommandErrorCode, extras?: CommandErrorExtras);
 }
+export declare function plainServerText(text: string): string;
 export declare const RATE_LIMITED_HINT = "Rate limited. Wait for a running review or mergestorm jobs.";
 export declare function rateLimitedMessage(retryAfterSeconds?: number): string;
 export declare function isCommandErrorCode(err: unknown, code: CommandErrorCode): err is CommandError;

package/dist/errors.js

@@ -13,6 +13,7 @@ export class CommandError extends Error {
     exitCode;
     code;
     retryAfterSeconds;
+    reason;
     constructor(message, exitCode = 1, code, extras) {
         super(message);
         this.name = "CommandError";
@@ -21,8 +22,16 @@ export class CommandError extends Error {
         if (extras?.retryAfterSeconds !== undefined) {
             this.retryAfterSeconds = extras.retryAfterSeconds;
         }
+        if (extras?.reason !== undefined) {
+            this.reason = extras.reason;
+        }
     }
 }
+const ANSI_SEQUENCE = /\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b\[[0-?]*[ -/]*[@-~]/g;
+const CONTROL_CHARACTER = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+export function plainServerText(text) {
+    return text.replace(ANSI_SEQUENCE, "").replace(CONTROL_CHARACTER, "");
+}
 export const RATE_LIMITED_HINT = "Rate limited. Wait for a running review or mergestorm jobs.";
 export function rateLimitedMessage(retryAfterSeconds) {
     if (retryAfterSeconds == null || !Number.isFinite(retryAfterSeconds)) {

package/dist/stack-blockers.d.ts

@@ -6,6 +6,10 @@ export type StackBlocker = {
     blocker: string;
     bounceKind: string | null;
 };
+export type StackBlockerReason = "restack_conflict" | "restack_failed" | "draft_pr" | "merge_conflict" | "ci_failed" | "vortex_failed" | "vortex_out_of_quota" | "vortex_skipped" | "vortex_findings_need_person" | "seam_failed" | "seam_findings" | "seam_not_running" | "seam_review_stuck" | "seam_rereview_not_running" | "seam_verdict_stale" | "unit_abandoned" | "land_gate" | "bounce" | "auto_land_off" | "auto_land_ci_pending" | "auto_land_members_remaining" | "auto_land_vortex_wait" | "auto_land_promote_failed" | "auto_land_ci_unreadable" | "auto_land_waited" | "queue_stalled" | "land_pr_missing";
+export type ClassifiedStackBlocker = StackBlocker & {
+    reason: StackBlockerReason;
+};
 export type StackAgentBusy = {
     prNumber: number;
     headSha: string | null;
@@ -47,20 +51,6 @@ export type StackRepairHint = {
     branch: string;
     failingCheck: string | null;
     steps: string;
-} | {
-    kind: "tempest_findings";
-    prNumber: number;
-    headSha: string | null;
-    branch: string;
-    findings: string;
-    steps: string;
-} | {
-    kind: "tempest_rerun";
-    prNumber: number;
-    headSha: string | null;
-    branch: string;
-    stoppedByPerson: boolean;
-    steps: string;
 } | {
     kind: "vortex_findings";
     prNumber: number;
@@ -121,7 +111,7 @@ export type StackRepairHint = {
     waitReason: string | null;
     steps: string;
 } | {
-    kind: "members_remaining" | "vortex_failed" | "tempest_trigger_failed";
+    kind: "members_remaining" | "vortex_failed";
     prNumber: number;
     headSha: string | null;
     branch: string;
@@ -211,8 +201,8 @@ export declare function restackFailedRepairSteps(branch: string, liveParent: str
     kind: string;
     detail?: string | null;
 }): string;
-export declare function agentsCannotClear(blocker: string): boolean;
-export declare function stackRepair(stack: StackDto, attention: StackBlocker | null, layer: StackLayerDto | undefined, bounce: MergeQueueEntryDto | undefined, queueWait?: MergeQueueWait | null): StackRepairHint | null;
+export declare function agentsCannotClear(reason: StackBlockerReason): boolean;
+export declare function stackRepair(stack: StackDto, attention: ClassifiedStackBlocker | 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): {

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. */

package/dist/stack-dto.js

@@ -55,8 +55,6 @@ export const MERGE_QUEUE_BOUNCE_KINDS = [
     "ci_failure",
     "ci_timeout",
     "head_moved",
-    "tempest_findings",
-    "tempest_rerun",
     "seam_findings",
     "restack_conflict",
     "pr_draft",
@@ -68,8 +66,6 @@ export const BOUNCE_KIND_LABELS = {
     ci_failure: "CI failed",
     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

@@ -144,16 +144,19 @@ const WHATS_NEW = {
     "0.3.36": [
         "stack watch names what the merge queue waits on",
         "stack watch names why Vortex skipped a head",
-        "stack watch says how to re-run Tempest",
     ],
     "0.3.37": [
         "turning auto-review on reviews skipped heads",
     ],
+    "0.3.38": [
+        "mg settings turns merge queue batching on or off",
+    ],
     "0.3.39": [
         "the watch names more waits and what to do",
     ],
-    "0.3.38": [
-        "mg settings turns merge queue batching on or off",
+    "0.3.40": [
+        "refusals name Surge when it is the App to install",
+        "mg settings says whether stacks are ready",
     ],
 };
 function densityFromVariant(variant) {

package/dist/ui/tabs.d.ts

@@ -18,7 +18,12 @@ export type TabsConfigRow = {
     label: string;
     value: boolean;
     writable: boolean;
+    readOnlyWords?: {
+        on: string;
+        off: string;
+    };
 };
+export declare function readOnlyRowWords(row: TabsConfigRow): string;
 export type TabsData = {
     /** Prebuilt whoami + credits lines for the Status tab. */
     statusLines: string[];

package/dist/ui/tabs.js

@@ -12,6 +12,10 @@ const TAB_LABELS = {
     jobs: "Jobs",
     config: "Config",
 };
+export function readOnlyRowWords(row) {
+    const words = row.readOnlyWords ?? { on: "connected", off: "not connected" };
+    return row.value ? words.on : words.off;
+}
 export function initialTabsState(tab = "status") {
     return {
         tab,
@@ -180,9 +184,7 @@ function configBody(state, data, bodyRows, width, color) {
             ? row.value
                 ? "on"
                 : "off"
-            : row.value
-                ? "connected"
-                : "not connected";
+            : readOnlyRowWords(row);
         const paintedValue = !color
             ? value
             : row.writable

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.39",
+  "version": "0.3.40",
   "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

@@ -37,8 +37,8 @@ A stack whose layers are all merged into `mg-stack-N` but has no open land PR re
 
 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). 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-*`.
+3. `attention` always means something for you to fix. A land gate that is only waiting (`landGatePending` with `ci_pending` 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. 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). 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, 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. Cyclone patches a land PR when auto-patch is on for that stack, otherwise you do: when `busy[]` shows no Cyclone run on it, fix its blocker 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. For a conflict, 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.
 7. After your successful push, leave a clean worktree and keep watching the named stack. Start a new watch cycle with `enrolled_head_sha` set to the SHA you pushed (in the background: `mg stack watch <stack-id> --head <pushed-sha>`). If you handled a bounce, retain the returned `cursor.afterFinishedAt` as `after_finished_at` and `cursor.bounceId` as `bounce_id` so that attempt is not handled again. Keep these selectors unchanged across subsequent retries. Continue watching; do not enqueue anything. If the bounce you handled turned Auto land off, turn it back on as "Re-arm after a bounce" allows; if that section does not allow it, report and stop.
@@ -68,8 +68,6 @@ The kind list is exactly `MERGE_QUEUE_BOUNCE_KINDS` from stack-dto:
 - `ci_failure`
 - `ci_timeout`
 - `head_moved`
-- `tempest_findings`
-- `tempest_rerun`
 - `seam_findings`
 - `restack_conflict`
 - `pr_draft`

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

@@ -27,7 +27,7 @@ mg skill install --claude --cursor --agents
 ## Loop (in order)
 
 1. Find the PR's stack with `stack_list` (the stack whose `layers` contain this PR's `prNumber` for this owner/repo). If you already have its `stack_id`, `stack_status` is the same payload.
-   - Adoption needs the Cyclone GitHub App on the account; without it `stack_adopt` returns `cyclone_not_connected` — stop and tell the human, do not retry.
+   - Adoption needs the infrastructure GitHub App on the repository: Mergestorm Surge, or Cyclone on accounts not yet moved to Surge. Stacks, the merge queue and Auto land run through that App; Cyclone is the auto-patch App. Without it `stack_adopt` returns `cyclone_not_connected` or `cyclone_not_installed`. The code keeps its name in both cases: the message, and a `reason` starting with `surge_` when Surge is the one to install, say which App is missing. Stop and tell the human what the message says, do not retry.
    - If there is no stack and the human asked you to mute Cyclone or continue the loop: call `stack_adopt` with `{ owner, repo, pr_number, auto_patch: false }` (equivalent to `mg stack adopt … --auto-patch off`). Then call `stack_status` with the returned `result.stack.id`, confirm this PR is in the stack and `autoPatchOverride` is `false`. If adoption or verification fails, refuse the loop. Otherwise continue through the ownership check below and the remaining loop steps; do not stop and ask the human to adopt. Do not turn account auto-patch off.
    - Adoption does not fix installer ≠ key. After adoption, the same `cycloneOwnerMatch` refusal below still applies.
    - After adopting 2+ PRs the bottom PR's GitHub base is `mg-stack-<n>` and PR3+ sit on an `mg-park-*` freeze; a 1-PR stack stays on main. That is expected; leave every base as Mergestorm set it.