mergestorm 0.3.48 → 0.3.50

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.50                                             │
 │ ▀▀▀▀▀▀▀▀▀     ● msk_live_… · maelstrom                                       │
 │  ▀▀▀▀▀▀       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used                      │
 │   ▝▀▀▀▀▀      local reviews + stacked PRs · mergestorm.ai                    │
@@ -76,6 +76,8 @@ One-shot subcommands work the same inside the shell and from argv (scripts/CI):
 mergestorm                      Interactive shell (TTY only)
 mergestorm shell                Explicit shell entry
 mergestorm login                Sign in via browser; stores an API key in ~/.mergestorm/config.json
+mergestorm login --start        Print a sign-in URL and code, then exit (agents)
+mergestorm login --finish       Store the API key once the code from --start is approved
 mergestorm login --key          Paste an existing API key instead (headless/CI)
 mergestorm logout               Remove the stored API key
 mergestorm review [base] [head] Review git diff base...head (default: origin/HEAD or main or master)
@@ -148,6 +150,8 @@ Runs a browser device-authorization flow: prints a short code, opens `https://me
 
 For headless or CI environments, use `mergestorm login --key` to paste an existing `msk_live_…` key (create one on the dashboard [Settings → API](https://mergestorm.ai/settings#api)). On a TTY the paste is hidden (not echoed); the CLI verifies the key with the API before saving.
 
+For an agent, which cannot sit in a prompt while a person signs in, use two steps. `mergestorm login --start` prints the URL and the short code and exits. Give both to the account owner, who opens [mergestorm.ai/cli/auth](https://mergestorm.ai/cli/auth) on any device, signs in, and approves the code. Then `mergestorm login --finish` stores the API key. The code lasts 10 minutes, and `--finish` can be run again if it is interrupted before the approval.
+
 ### `logout`
 
 Removes `~/.mergestorm/config.json` so the stored key is no longer used.

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/automation-catalog.d.ts

@@ -9,11 +9,11 @@ export declare const BEARER_SETTINGS: readonly [{
 }, {
     readonly key: "auto_resolve_conflicts_enabled";
     readonly flag: "--auto-resolve-conflicts";
-    readonly label: "Auto-resolve merge conflicts";
+    readonly label: "Auto-resolve merge conflicts (alpha)";
 }, {
     readonly key: "auto_fix_ci_enabled";
     readonly flag: "--auto-fix-ci";
-    readonly label: "Auto-fix failing CI";
+    readonly label: "Auto-fix failing CI (alpha)";
 }, {
     readonly key: "vortex_show_thinking_traces";
     readonly flag: "--vortex-thinking";

package/dist/automation-catalog.js

@@ -1,8 +1,8 @@
 export const BEARER_SETTINGS = [
     { key: "auto_review_enabled", flag: "--auto-review", label: "Auto review" },
     { key: "auto_patch_enabled", flag: "--auto-patch", label: "Auto patch" },
-    { key: "auto_resolve_conflicts_enabled", flag: "--auto-resolve-conflicts", label: "Auto-resolve merge conflicts" },
-    { key: "auto_fix_ci_enabled", flag: "--auto-fix-ci", label: "Auto-fix failing CI" },
+    { key: "auto_resolve_conflicts_enabled", flag: "--auto-resolve-conflicts", label: "Auto-resolve merge conflicts (alpha)" },
+    { key: "auto_fix_ci_enabled", flag: "--auto-fix-ci", label: "Auto-fix failing CI (alpha)" },
     { key: "vortex_show_thinking_traces", flag: "--vortex-thinking", label: "Vortex thinking traces" },
     { key: "repo_overview_enabled", flag: "--repo-overview", label: "Repo overview" },
     { key: "cyclone_skip_ci_enabled", flag: "--cyclone-skip-ci", label: "Skip CI on Cyclone commits" },

package/dist/commands/help.js

@@ -40,7 +40,7 @@ export function buildHelpTabs() {
                 cmd("thread <slug>", "jobs in a review thread"),
                 "",
                 rule("Account"),
-                cmd("login", "browser sign-in (or login --key)"),
+                cmd("login", "sign in (--key; agents: --start)"),
                 cmd("whoami", "key · plan · API"),
                 cmd("settings", "automation toggles · Config tab"),
                 cmd("logout", "forget the stored key"),

package/dist/commands/login.d.ts

@@ -5,4 +5,5 @@ import { type MeResponse } from "../api.js";
  * Throws CommandError when the key must not be saved.
  */
 export declare function validateApiKey(cfg: Config): Promise<MeResponse>;
+export declare function pendingLoginPath(): string;
 export declare function cmdLogin(args: string[]): Promise<void>;

package/dist/commands/login.js

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import { platform } from "node:os";
-import { apiBase, configPath, loadConfig, saveConfig } from "../config.js";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { apiBase, configPath, loadConfig, mergestormHome, saveConfig, } from "../config.js";
 import { devicePost, getMe } from "../api.js";
 import { CommandError } from "../errors.js";
 import { ansi } from "../ui/ansi.js";
@@ -52,13 +54,40 @@ async function loginWithKey() {
     const prefix = me.key?.prefix?.trim() || "msk_live_…";
     await present("Login", [`  Verified ${prefix}… · saved to ${configPath()}`]);
 }
-export async function cmdLogin(args) {
-    if (args.includes("--key")) {
-        await loginWithKey();
-        return;
+export function pendingLoginPath() {
+    return path.join(mergestormHome(), "login-pending.json");
+}
+async function savePendingLogin(pending) {
+    await mkdir(mergestormHome(), { recursive: true });
+    await writeFile(pendingLoginPath(), JSON.stringify(pending, null, 2) + "\n", {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+}
+async function loadPendingLogin() {
+    try {
+        const parsed = JSON.parse(await readFile(pendingLoginPath(), "utf8"));
+        if (typeof parsed.deviceCode !== "string" ||
+            typeof parsed.userCode !== "string" ||
+            typeof parsed.openUrl !== "string" ||
+            typeof parsed.apiBase !== "string" ||
+            typeof parsed.pollMs !== "number" ||
+            typeof parsed.expiresAt !== "number") {
+            return null;
+        }
+        return parsed;
     }
-    const cfg = await loadConfig();
-    const base = apiBase(cfg);
+    catch {
+        return null;
+    }
+}
+async function clearPendingLogin(deviceCode) {
+    const pending = await loadPendingLogin();
+    if (pending?.deviceCode !== deviceCode)
+        return;
+    await rm(pendingLoginPath(), { force: true });
+}
+async function startDeviceLogin(base) {
     let start;
     let attempt = 0;
     do {
@@ -87,51 +116,110 @@ export async function cmdLogin(args) {
         throw new CommandError(`Could not start device login (HTTP ${start.status}). The API may be unreachable or misconfigured.\n` +
             `Run \`mergestorm login --key\` to paste an existing API key instead.`);
     }
-    const { device_code, user_code, verification_uri, verification_uri_complete, interval, expires_in, } = start.body;
-    const openUrl = verification_uri_complete || verification_uri;
-    console.log("To sign in, open this URL and confirm the code:\n");
-    console.log(`  ${ansi.brightGreen(openUrl)}`);
-    console.log(`\n  Code: ${ansi.bold(user_code)}\n`);
-    openBrowser(openUrl);
-    console.log("Waiting for approval…");
-    const pollMs = Math.max(interval || 5, 2) * 1000;
-    const deadline = Date.now() + (expires_in || 600) * 1000;
-    while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, pollMs));
+    return start.body;
+}
+function pendingFromStart(base, start) {
+    return {
+        deviceCode: start.device_code,
+        userCode: start.user_code,
+        openUrl: start.verification_uri_complete || start.verification_uri,
+        apiBase: base,
+        pollMs: Math.max(start.interval || 5, 2) * 1000,
+        expiresAt: Date.now() + (start.expires_in || 600) * 1000,
+    };
+}
+async function pollDeviceLogin(pending, retryCommand, recovery) {
+    while (Date.now() < pending.expiresAt) {
         let poll;
         try {
-            poll = await devicePost(base, "/api/v1/cli/device/token", { device_code });
+            poll = await devicePost(pending.apiBase, "/api/v1/cli/device/token", {
+                device_code: pending.deviceCode,
+            });
         }
         catch {
-            throw new CommandError("Login failed: network error. Check your connection and run `mergestorm login` again.");
+            throw new CommandError(`Login failed: network error. Check your connection and run \`${retryCommand}\` again.`);
         }
         if (poll.status === 200 && poll.body?.api_key) {
             const next = await loadConfig();
             next.apiKey = poll.body.api_key;
+            next.apiBase = pending.apiBase;
             await saveConfig(next);
+            await clearPendingLogin(pending.deviceCode);
             await present("Login", [`  Logged in. Key saved to ${configPath()}`]);
             return;
         }
         const err = poll.body?.error;
         if (err === "authorization_pending") {
             process.stdout.write(".");
+            await new Promise((r) => setTimeout(r, pending.pollMs));
             continue;
         }
         if (err === "slow_down" || err === "rate_limited") {
             const backoff = Number(poll.body?.retry_after_seconds);
-            await new Promise((r) => setTimeout(r, Number.isFinite(backoff) && backoff > 0 ? backoff * 1000 : pollMs));
+            await new Promise((r) => setTimeout(r, Number.isFinite(backoff) && backoff > 0 ? backoff * 1000 : pending.pollMs));
             continue;
         }
         if (err === "key_limit_reached") {
             throw new CommandError("You have reached the max active API keys. Revoke one at https://mergestorm.ai/settings#api and try again.");
         }
+        if (err === "expired_token" || err === "already_redeemed" || err === "access_denied") {
+            await clearPendingLogin(pending.deviceCode);
+        }
         if (err === "expired_token") {
-            throw new CommandError("Login code expired. Run `mergestorm login` again.");
+            throw new CommandError(`Login code expired. ${recovery}`);
         }
         if (err === "already_redeemed") {
-            throw new CommandError("This code was already used. Run `mergestorm login` again.");
+            throw new CommandError(`This code was already used. ${recovery}`);
         }
         throw new CommandError(`Login failed: ${typeof err === "string" ? err : JSON.stringify(poll.body)}`);
     }
-    throw new CommandError("Login timed out. Run `mergestorm login` again.");
+    await clearPendingLogin(pending.deviceCode);
+    throw new CommandError(`Login timed out. ${recovery}`);
+}
+async function loginStart() {
+    const cfg = await loadConfig();
+    const base = apiBase(cfg);
+    const pending = pendingFromStart(base, await startDeviceLogin(base));
+    await savePendingLogin(pending);
+    const minutes = Math.max(1, Math.round((pending.expiresAt - Date.now()) / 60_000));
+    console.log("Ask the account owner to open this URL, sign in, and approve the code:\n");
+    console.log(`  ${pending.openUrl}`);
+    console.log(`\n  Code: ${pending.userCode}\n`);
+    console.log(`The code expires in ${minutes} minutes.`);
+    console.log("After they approve, run `mergestorm login --finish` to store the API key.");
+}
+async function loginFinish() {
+    const pending = await loadPendingLogin();
+    if (!pending) {
+        throw new CommandError("No login is waiting. Run `mergestorm login --start` first.");
+    }
+    if (Date.now() >= pending.expiresAt) {
+        await clearPendingLogin(pending.deviceCode);
+        throw new CommandError("Login code expired. Run `mergestorm login --start` again.");
+    }
+    console.log(`Waiting for approval of code ${pending.userCode} at ${pending.openUrl}`);
+    await pollDeviceLogin(pending, "mergestorm login --finish", "Run `mergestorm login --start`, then `mergestorm login --finish`.");
+}
+export async function cmdLogin(args) {
+    if (args.includes("--key")) {
+        await loginWithKey();
+        return;
+    }
+    if (args.includes("--start")) {
+        await loginStart();
+        return;
+    }
+    if (args.includes("--finish")) {
+        await loginFinish();
+        return;
+    }
+    const cfg = await loadConfig();
+    const base = apiBase(cfg);
+    const pending = pendingFromStart(base, await startDeviceLogin(base));
+    console.log("To sign in, open this URL and confirm the code:\n");
+    console.log(`  ${ansi.brightGreen(pending.openUrl)}`);
+    console.log(`\n  Code: ${ansi.bold(pending.userCode)}\n`);
+    openBrowser(pending.openUrl);
+    console.log("Waiting for approval…");
+    await pollDeviceLogin(pending, "mergestorm login", "Run `mergestorm login` again.");
 }

package/dist/commands/registry.js

@@ -25,6 +25,8 @@ export const COMMAND_REGISTRY = [
         summary: "Sign in via browser (or paste a key)",
         usage: [
             "mergestorm login                Sign in via browser and store an API key",
+            "mergestorm login --start        Print a sign-in URL and code, then exit (agents)",
+            "mergestorm login --finish       Store the API key once the code from --start is approved",
             "mergestorm login --key          Paste an existing API key instead (headless/CI)",
         ],
         async run(args, ctx) {

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,12 @@ const WHATS_NEW = {
     "0.3.48": [
         "Watch names CI Cyclone could not finish",
     ],
+    "0.3.49": [
+        "Submit retries a stalled stacks check",
+    ],
+    "0.3.50": [
+        "Agent sign-in: login --start, --finish",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.48",
+  "version": "0.3.50",
   "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.