mergestorm 0.3.48 → 0.3.49

package/README.md

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

package/dist/api.d.ts

@@ -242,7 +242,15 @@ export declare function ensureUpperPark(stackId: string, cfg?: Config): Promise<
 }>;
 export declare const SURGE_INSTALL_URL = "https://github.com/apps/mergestorm-surge/installations/new";
 export declare function surgeNotInstalledMessage(owner: string, repo: string, installUrl?: string): string;
-export declare function readLandedQueueEntry(cfg: Config, stackId: string): Promise<MergeQueueEntryDto | null>;
+export declare class LandedQueueReadError extends CommandError {
+    readonly status: number;
+    readonly retryAfterSeconds?: number | undefined;
+    constructor(status: number, retryAfterSeconds?: number | undefined);
+}
+export declare function readLandedQueueEntry(cfg: Config, stackId: string, opts?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<MergeQueueEntryDto | null>;
 export declare function findStackPull(cfg: Config, input: {
     owner: string;
     repo: string;

package/dist/api.js

@@ -510,10 +510,19 @@ function stackPullFailure(status, body, owner, repo, failLabel) {
     const detail = typeof rejection.message === "string" ? rejection.message : JSON.stringify(body);
     return new CommandError(`${failLabel} (HTTP ${status}): ${detail}`);
 }
-export async function readLandedQueueEntry(cfg, stackId) {
-    const { status, body } = await apiFetch(cfg, `/api/v1/stacks/queue?stackId=${encodeURIComponent(stackId)}&landed=1`);
+export class LandedQueueReadError extends CommandError {
+    status;
+    retryAfterSeconds;
+    constructor(status, retryAfterSeconds) {
+        super(`Failed to read the landed merge queue entry (HTTP ${status})`);
+        this.status = status;
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+}
+export async function readLandedQueueEntry(cfg, stackId, opts = {}) {
+    const { status, body, retryAfterSeconds } = await apiFetch(cfg, `/api/v1/stacks/queue?stackId=${encodeURIComponent(stackId)}&landed=1`, opts);
     if (status !== 200)
-        throw new CommandError(`Failed to read the landed merge queue entry (HTTP ${status})`);
+        throw new LandedQueueReadError(status, retryAfterSeconds);
     const landed = body?.landed;
     return landed && landed.state === "landed" ? landed : null;
 }

package/dist/commands/stack.js

@@ -16,6 +16,7 @@ import { ansi } from "../ui/ansi.js";
 import { runLineTabsBrowser } from "../ui/line-tabs.js";
 import { present } from "../ui/present.js";
 import { canBrowse } from "./browse.js";
+import { isTransientReviewPollError } from "./review-client.js";
 import { openHelpBrowser } from "./help.js";
 export function stackHeldLine(held) {
     if (!held)
@@ -85,6 +86,16 @@ const STACK_USAGE = `usage:
   otherwise lands the bottom open PR (unit-less stacks).`;
 /** Cap the registered-stack guard's API probe so it cannot stall local authoring. */
 const STACK_GUARD_TIMEOUT_MS = 8_000;
+async function listRegisteredStacksRetryingOnce(list, cfg) {
+    try {
+        return await list(cfg, { timeoutMs: STACK_GUARD_TIMEOUT_MS });
+    }
+    catch (err) {
+        if (!isTransientReviewPollError(err))
+            throw err;
+        return list(cfg, { timeoutMs: STACK_GUARD_TIMEOUT_MS });
+    }
+}
 /** Find a registered stack layer whose branch matches `parentBranch`. */
 export function findRegisteredParent(stacks, parentBranch, owner, repo) {
     const want = parentBranch.trim();
@@ -544,7 +555,7 @@ export async function cmdStackCreate(args, deps = {}) {
     if (origin) {
         try {
             const cfg = await loadConfigFn();
-            const registered = await listStacksFn(cfg, { timeoutMs: STACK_GUARD_TIMEOUT_MS });
+            const registered = await listRegisteredStacksRetryingOnce(listStacksFn, cfg);
             registeredHit = assertMayParentOntoRegistered(parentBranch, registered, extend, "create", origin.owner, origin.repo);
         }
         catch (err) {
@@ -694,7 +705,7 @@ export async function cmdStackSubmit(args, deps = {}) {
     let registered = [];
     try {
         const cfg = await loadConfigFn();
-        registered = await listStacksFn(cfg, { timeoutMs: STACK_GUARD_TIMEOUT_MS });
+        registered = await listRegisteredStacksRetryingOnce(listStacksFn, cfg);
         for (const parent of parents) {
             if (assertMayParentOntoRegistered(parent, registered, extend, "submit", owner, repo)) {
                 registeredHits += 1;

package/dist/stack-blockers.js

@@ -133,7 +133,8 @@ export function autoFixCiActive(stack, layer) {
 }
 export const CI_DID_NOT_FINISH_BLOCKER = "CI did not finish — left for a person";
 export function pendingCiLeftForPerson(stack, layer) {
-    return layer.ciStatus === "pending" && !isLandPrLayer(stack, layer) &&
+    return layer.ciStatus === "pending" && layer.checks?.cancelledOnly === true &&
+        sameHead(layer.checks.namedRunsCompleteHeadSha, layer.headSha) && !isLandPrLayer(stack, layer) &&
         sameHead(layer.cycloneCiHandoff?.headSha, layer.headSha);
 }
 function ciHandoffNote(stack, layer) {
@@ -277,12 +278,12 @@ function layerAttention(stack, layer, queue, cursor) {
             const name = layer.checks?.failingName?.trim();
             return hardBlock(`CI failed${name ? ` — ${name}` : ""}`, "ci_failed");
         }
-        if (pendingCiLeftForPerson(stack, layer))
-            return hardBlock(CI_DID_NOT_FINISH_BLOCKER, "ci_failed");
         if (layer.vortexStatus === "failed" && !vortexRetryScheduled(layer) &&
             (!layer.vortexReview?.head_sha || sameHead(layer.vortexReview.head_sha, layer.headSha))) {
             return hardBlock(VORTEX_REVIEW_FAILED, "vortex_failed");
         }
+        if (pendingCiLeftForPerson(stack, layer))
+            return hardBlock(CI_DID_NOT_FINISH_BLOCKER, "ci_failed");
         if (quotaSkippedReview(layer))
             return hardBlock(VORTEX_REVIEW_OUT_OF_QUOTA, "vortex_out_of_quota");
         const vortexSkip = vortexIdleSkipBlocker(layer);
@@ -788,7 +789,7 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             branch: layer.branch,
             failingCheck,
             steps: pendingCiLeftForPerson(stack, layer)
-                ? `CI on ${layer.branch} at ${layer.headSha ?? "its live head"} ended cancelled or interrupted and did not finish after Cyclone's one re-run. Find the cancelled run (gh run list --branch ${layer.branch}), read why it stopped (gh run view <run-id>), and re-run it (gh run rerun <run-id>) if it was a runner or infrastructure stop. If the job itself cancels, fix that on ${layer.branch} and push. Do not retarget the PR base.`
+                ? `CI on ${layer.branch} at ${layer.headSha ?? "its live head"} has completed cancelled checks with no checks still running after Cyclone's handoff. Find the cancelled run (gh run list --branch ${layer.branch}), read why it stopped (gh run view <run-id>), and re-run it (gh run rerun <run-id>) if it was a runner or infrastructure stop. If the job itself cancels, fix that on ${layer.branch} and push. Do not retarget the PR base.`
                 : `Read the failing ${failingCheck ? `check ${failingCheck}` : "checks"} on ${layer.branch} (gh run list --branch ${layer.branch}, then gh run view <run-id> --log-failed), fix it on ${layer.branch} with the smallest patch, run that check locally, confirm the remote head is still ${layer.headSha ?? "the head you started from"}, then an ordinary git push. Do not retarget the PR base.`,
             ...(note ? { note } : {}),
         };

package/dist/stack-dto.d.ts

@@ -137,6 +137,8 @@ export type StackLayerChecks = {
      * them (#1602).
      */
     namedRunsSeeded?: boolean;
+    cancelledOnly?: boolean;
+    namedRunsCompleteHeadSha?: string;
     /**
      * True when the persisted `namedRuns` carries the reserved synthetic
      * "commit status" run at a pending/failure verdict. Webhook deliveries

package/dist/stack-watch-loop.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from "./config.js";
-import type { MergeQueueEntryDto } from "./stack-dto.js";
+import { readLandedQueueEntry } from "./api.js";
 import { pollStackWatch, type StackWatchCursor, type StackWatchEnvelope } from "./stack-watch.js";
 export declare const STACK_WATCH_MARKER = "MS-WATCH";
 export declare const STACK_WATCH_EXIT: {
@@ -26,7 +26,7 @@ export type RunStackWatchOptions = {
     write?: (line: string) => void;
     writeMarker?: (line: string) => void;
     poll?: typeof pollStackWatch;
-    readLanded?: (cfg: Config, stackId: string) => Promise<MergeQueueEntryDto | null>;
+    readLanded?: typeof readLandedQueueEntry;
     sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
     now?: () => number;
 };

package/dist/stack-watch-loop.js

@@ -1,5 +1,5 @@
 import { setTimeout as sleep } from "node:timers/promises";
-import { API_TIMEOUT_PREFIX, readLandedQueueEntry } from "./api.js";
+import { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, LandedQueueReadError, readLandedQueueEntry } from "./api.js";
 import { isTransientReviewPollError } from "./commands/review-client.js";
 import { pollStackWatch, StackWatchError, StackWatchTimeoutError, } from "./stack-watch.js";
 export const STACK_WATCH_MARKER = "MS-WATCH";
@@ -14,6 +14,8 @@ const TRANSIENT_WATCH_FAILURE = /HTTP (?:408|429|5\d\d)|snapshot missing|fetch f
 export function isTransientWatchFailure(err) {
     if (!(err instanceof Error))
         return false;
+    if (err instanceof LandedQueueReadError)
+        return err.status === 408 || err.status === 429 || (err.status >= 500 && err.status <= 599);
     if (isTransientReviewPollError(err))
         return true;
     if (err.cause !== undefined && isTransientReviewPollError(err.cause))
@@ -79,19 +81,55 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
     const confirmedLanding = async (envelope) => {
         if (envelope.watch.reason !== "not_found")
             return envelope;
+        failures = 0;
+        permanentFailures = 0;
+        transientSince = null;
+        const unconfirmed = (failureMessage) => ({
+            ...envelope,
+            watch: {
+                ...envelope.watch,
+                reason: "landing_unconfirmed",
+                message: `The stack is gone, but its landed merge queue entry could not be read: ${failureMessage}. Landing is unconfirmed. Confirm a matching landed merge queue entry or that the actual land PR merged into its land target before reporting it landed. A layer PR merged into the owned trunk does not confirm landing. The watch is done; do not report it landed.`,
+            },
+        });
         let entry = null;
-        try {
-            entry = await readLanded(cfg, id);
-        }
-        catch {
-            return {
-                ...envelope,
-                watch: {
-                    ...envelope.watch,
-                    reason: "landing_unconfirmed",
-                    message: "The stack is gone, but its landed merge queue entry could not be read. Landing is unconfirmed. Confirm each PR is merged (gh pr view <n> --json state) before reporting it landed. The watch is done; do not report it landed.",
-                },
-            };
+        while (true) {
+            if (now() >= deadline)
+                return unconfirmed("The watch deadline was reached before landing confirmation");
+            if (opts.signal?.aborted)
+                throw new DOMException("The operation was aborted", "AbortError");
+            try {
+                entry = await readLanded(cfg, id, {
+                    signal: opts.signal,
+                    timeoutMs: Math.min(DEFAULT_API_TIMEOUT_MS, deadline - now(), transientSince === null ? STACK_WATCH_TRANSIENT_WINDOW_MS : Math.max(1, STACK_WATCH_TRANSIENT_WINDOW_MS - (now() - transientSince))),
+                });
+                if (opts.signal?.aborted)
+                    throw new DOMException("The operation was aborted", "AbortError");
+                break;
+            }
+            catch (err) {
+                if (isAbort(err, opts.signal))
+                    throw err;
+                let failureMessage = err instanceof Error ? err.message : String(err);
+                if (isTransientWatchFailure(err)) {
+                    failures += 1;
+                    permanentFailures = 0;
+                    transientSince ??= now();
+                    const remaining = STACK_WATCH_TRANSIENT_WINDOW_MS - (now() - transientSince);
+                    if (remaining > 0) {
+                        const retryAfterSeconds = err instanceof LandedQueueReadError ? err.retryAfterSeconds : undefined;
+                        await pause(Math.min(remaining, retryAfterSeconds !== undefined
+                            ? Math.max(1_000, retryAfterSeconds * 1_000)
+                            : Math.min(STACK_WATCH_TRANSIENT_MAX_WAIT_MS, STACK_WATCH_FAILED_RETRY_MS * 2 ** Math.min(failures - 1, 4))));
+                        if (now() < deadline && now() - transientSince < STACK_WATCH_TRANSIENT_WINDOW_MS)
+                            continue;
+                        if (now() >= deadline)
+                            return unconfirmed(`The watch deadline was reached while retrying landing confirmation: ${failureMessage}`);
+                    }
+                    failureMessage = `Transient landing confirmation retry budget exhausted: ${failureMessage}`;
+                }
+                return unconfirmed(failureMessage);
+            }
         }
         const enrolledHead = envelope.cursor?.enrolledHeadSha ?? null;
         const ours = Boolean(entry) && (entry.landedPrNumbers.some((pr) => seenPrs.has(pr)) ||
@@ -165,13 +203,14 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
                     return result;
                 continue;
             }
-            failures = 0;
-            permanentFailures = 0;
-            transientSince = null;
             cursor = envelope.cursor;
             notePrs(envelope);
-            if (envelope.watch.done)
+            if (envelope.watch.done) {
                 return await finished(envelope);
+            }
+            failures = 0;
+            permanentFailures = 0;
+            transientSince = null;
             if (envelope.status === "attention") {
                 const key = stackWatchAttentionKey(envelope);
                 const blocker = (envelope.blocker ?? "").toLowerCase();

package/dist/ui/banner.js

@@ -182,6 +182,9 @@ const WHATS_NEW = {
     "0.3.48": [
         "Watch names CI Cyclone could not finish",
     ],
+    "0.3.49": [
+        "Submit retries a stalled stacks check",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.48",
+  "version": "0.3.49",
   "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-pr-loop/SKILL.md

@@ -47,8 +47,9 @@ mg skill install --claude --cursor --agents
    - Verify it against the current checkout. Do not treat the finding text as proven.
    - Prefer the smallest correct patch. Do not refactor around a finding.
    - Patch concrete bugs. A chat-only explanation is not a dismiss.
-   - If you skip a finding (not reproducible, policy fork, or needs a human), post a public GitHub PR comment before you stop. First line: `mergestorm-loop: dismiss`. Then one line per skipped finding (path, severity, why). That first line is the only dismiss marker Vortex reads.
-   - If you verified a finding is wrong (not merely skipped) and it blocks the PR, for example a seam finding holding `Seam findings`, record the dismissal with `review_dismiss` (CLI: `mg dismiss`):
+   - A finding a human must decide (Decision required, policy fork, needs a human) stays open. Do not dismiss it and do not post the dismiss marker for it: tell the human which finding it is and stop.
+   - A PR comment whose first line is `mergestorm-loop: dismiss` is not a note about one finding. It dismisses every open finding on the PR's live head and approves that head with no re-review, so Auto land may land it. Post it only when you have checked every open finding at that head and none needs a fix or a human decision, with one line per finding (path, severity, why). Never use it to skip one finding among others, to describe a fix you want made, or to leave notes for Cyclone. That first line is the only dismiss marker Vortex reads.
+   - If you verified a single finding is wrong or not reproducible, for example a seam finding holding `Seam findings`, dismiss that finding by id with `review_dismiss` (CLI: `mg dismiss`):
      - First call it with `preview: true`, the PR's live `head_sha` and the review id (review_id) of the Vortex review that raised the finding. It lists that review's finding ids and the seam gate and writes nothing.
      - Then call it with the `finding_ids` you checked (or `scope: "review"` when you checked every finding of that review), a `reason` that says why each is wrong, and an `evidence_url` when you have one.
      - A refusal (stale_head, review_mismatch, unknown_finding, forbidden) means nothing was written. Re-read the pass at the live head; do not retry with another review's ids.