mergestorm 0.3.46 → 0.3.48

package/README.md

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

package/dist/api.d.ts

@@ -242,11 +242,17 @@ 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 function findStackPull(cfg: Config, input: {
     owner: string;
     repo: string;
     head: string;
 }): Promise<number | null>;
+export declare function claimStackPulls(cfg: Config, input: {
+    owner: string;
+    repo: string;
+    heads: string[];
+}): Promise<void>;
 export declare function openStackPull(cfg: Config, input: {
     owner: string;
     repo: string;

package/dist/api.js

@@ -510,6 +510,13 @@ 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`);
+    if (status !== 200)
+        throw new CommandError(`Failed to read the landed merge queue entry (HTTP ${status})`);
+    const landed = body?.landed;
+    return landed && landed.state === "landed" ? landed : null;
+}
 export async function findStackPull(cfg, input) {
     const query = new URLSearchParams(input).toString();
     const { status, body } = await apiFetch(cfg, `/api/v1/stacks/pulls?${query}`);
@@ -519,6 +526,18 @@ export async function findStackPull(cfg, input) {
     const n = body?.number;
     return typeof n === "number" && n > 0 ? n : null;
 }
+export async function claimStackPulls(cfg, input) {
+    const { status, body } = await apiFetch(cfg, "/api/v1/stacks/pull-claims", {
+        method: "POST",
+        json: input,
+    });
+    if (status !== 200) {
+        const detail = body?.message
+            ?? body?.error
+            ?? `HTTP ${status}`;
+        throw new CommandError(`Could not claim ${input.heads.join(", ")}: ${String(detail)}`);
+    }
+}
 export async function openStackPull(cfg, input) {
     const { status, body } = await apiFetch(cfg, "/api/v1/stacks/pulls", {
         method: "POST",

package/dist/commands/stack.d.ts

@@ -1,6 +1,6 @@
 import { type StackHeldBlocker, type StackRepairHint } from "../stack-blockers.js";
 import { type StackWatchObligation } from "../stack-watch-obligation.js";
-import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, listMergeQueueEntries, listStacks, openStackPull, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
+import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, listMergeQueueEntries, listStacks, openStackPull, claimStackPulls, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
 import { loadConfig } from "../config.js";
 import { createPrs, findOpenPrNumber } from "../gh.js";
 import { parseGithubOriginRepo } from "../git.js";
@@ -137,6 +137,7 @@ export type StackSubmitDeps = {
     createPrs?: typeof createPrs;
     findStackPull?: typeof findStackPull;
     openStackPull?: typeof openStackPull;
+    claimStackPulls?: typeof claimStackPulls;
     loadConfig?: typeof loadConfig;
     listStacks?: typeof listStacks;
     adoptStack?: typeof adoptStack;

package/dist/commands/stack.js

@@ -1,6 +1,6 @@
 import { stackBlockers, stackBlockersSummary } from "../stack-blockers.js";
 import { STACK_WATCH_NOT_DONE_SENTENCE, STACK_WATCH_NOTIFY_PATTERN, stackTerminalReason, stackWatchObligation, } from "../stack-watch-obligation.js";
-import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, landNextStack, listMergeQueueEntries, listStacks, openStackPull, restackStack, setStackPolicy, } from "../api.js";
+import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, landNextStack, listMergeQueueEntries, listStacks, openStackPull, claimStackPulls, restackStack, setStackPolicy, } from "../api.js";
 import { loadConfig } from "../config.js";
 import { rateLimitedMessage, REVIEW_EXIT, CommandError } from "../errors.js";
 import { createPrs, findOpenPrNumber, ghReady, githubApiFromEnv, } from "../gh.js";
@@ -58,8 +58,9 @@ const STACK_USAGE = `usage:
     (exit 5 on timeout), so do not merge the streams (2>&1) before parsing stdout.
   mergestorm stack watch <stack-id> [--until attention|landed] [--ignore <blocker-substring>] [--max <minutes>] [--head <sha>] [--json]
     Loops stack wait with the cursor and stays silent while the stack is waiting or in progress.
-    Prints one MS-WATCH ATTENTION line and exits 3 on attention or a repeated failed read; prints
-    MS-WATCH LANDED and exits 0 only for a confirmed landing. Other terminal reasons exit 3 with ATTENTION. Run it as a background command.
+    Prints one MS-WATCH ATTENTION line and exits 3 on attention or on reads that keep failing (a permanent
+    error twice, or 15 minutes of timeouts and 5xx, which it retries with backoff); prints MS-WATCH LANDED
+    and exits 0 only for a confirmed landing, including a stack Mergestorm deleted after its queue entry landed. Other terminal reasons exit 3 with ATTENTION. Run it as a background command.
     --json writes exactly one JSON document to stdout and sends the MS-WATCH lines to stderr.
   mergestorm stack set <stack-id> [--auto-land on|off] [--auto-review on|off|default] [--auto-patch on|off|default] [--auto-resolve-conflicts on|off|default] [--auto-fix-ci on|off|default] [--json]
   mergestorm stack adopt <owner/repo>#<pr> [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off] [--auto-resolve-conflicts on|off] [--auto-fix-ci on|off] [--json]
@@ -640,6 +641,7 @@ export async function cmdStackSubmit(args, deps = {}) {
     const createPrsFn = deps.createPrs ?? createPrs;
     const findStackPullFn = deps.findStackPull ?? findStackPull;
     const openStackPullFn = deps.openStackPull ?? openStackPull;
+    const claimStackPullsFn = deps.claimStackPulls ?? claimStackPulls;
     const loadConfigFn = deps.loadConfig ?? loadConfig;
     const listStacksFn = deps.listStacks ?? listStacks;
     const adoptStackFn = deps.adoptStack ?? adoptStack;
@@ -736,6 +738,20 @@ export async function cmdStackSubmit(args, deps = {}) {
     for (const plan of plans) {
         existingPrs.set(plan.branch, await opener.findOpen(plan.branch));
     }
+    const newHeads = plans
+        .filter((plan) => existingPrs.get(plan.branch) == null)
+        .map((plan) => plan.branch);
+    if (newHeads.length > 0) {
+        try {
+            const config = await loadConfigFn();
+            for (let i = 0; i < newHeads.length; i += 20) {
+                await claimStackPullsFn(config, { owner, repo, heads: newHeads.slice(i, i + 20) });
+            }
+        }
+        catch (err) {
+            progress(ansi.dim(`  Could not hold the new PRs off the dashboard until adopt (${err instanceof Error ? err.message : String(err)}); continuing.`));
+        }
+    }
     for (const layer of layers) {
         if (!branchExistsFn(layer.branch, cwd)) {
             throw new CommandError(`Stack layer branch missing locally: ${layer.branch}`);
@@ -1042,7 +1058,9 @@ export async function cmdStackWatch(args, deps = {}) {
             ? `Stopped watching stack ${stackId}; it is not landed.`
             : result.envelope?.watch.reason === "not_found"
                 ? `Stack ${stackId} was not found; landing is unconfirmed. Verify each PR before reporting it landed.`
-                : `Stack ${stackId} needs attention; it is not landed.`;
+                : result.envelope?.watch.reason === "landing_unconfirmed"
+                    ? `Stack ${stackId} is gone, but landing is unconfirmed. Verify each PR before reporting it landed.`
+                    : `Stack ${stackId} needs attention; it is not landed.`;
     throw new CommandError(reason, result.exitCode, result.outcome === "timeout" ? "review_timeout" : "stack_attention");
 }
 export async function cmdStackStatus(args, deps = {}) {

package/dist/stack-blockers.d.ts

@@ -165,6 +165,8 @@ export declare const SEAM_VERDICT_STALE = "Seam verdict is for an older head, no
 export declare const VORTEX_FINDINGS_NEED_PERSON = "Vortex findings need a person";
 export declare function autoResolveActive(stack: StackDto, layer: StackLayerDto): boolean;
 export declare function autoFixCiActive(stack: StackDto, layer: StackLayerDto): boolean;
+export declare const CI_DID_NOT_FINISH_BLOCKER = "CI did not finish \u2014 left for a person";
+export declare function pendingCiLeftForPerson(stack: StackDto, layer: StackLayerDto): boolean;
 export declare const VORTEX_AUTO_REVIEW_OFF = "Vortex auto-review is off, so this head was not reviewed";
 export declare const VORTEX_BILLING_SKIPPED = "Vortex skipped this head: it could not confirm billing";
 export declare const VORTEX_REVIEW_INCOMPLETE = "Vortex reviewed only part of this PR";

package/dist/stack-blockers.js

@@ -131,6 +131,11 @@ export function autoFixCiActive(stack, layer) {
     return !stack.cycloneCiOff && !isLandPrLayer(stack, layer) &&
         !sameHead(layer.cycloneCiHandoff?.headSha, layer.headSha);
 }
+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) &&
+        sameHead(layer.cycloneCiHandoff?.headSha, layer.headSha);
+}
 function ciHandoffNote(stack, layer) {
     if (isLandPrLayer(stack, layer))
         return null;
@@ -272,6 +277,8 @@ 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");
@@ -780,7 +787,9 @@ export function stackRepair(stack, attention, layer, bounce, queueWait = null) {
             headSha: layer.headSha ?? null,
             branch: layer.branch,
             failingCheck,
-            steps: `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.`,
+            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.`
+                : `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

@@ -427,12 +427,25 @@ export type MergeQueueBounceBatch = {
     withPrNumbers: number[];
 };
 export type MergeQueueBatchState = "verifying" | "landing" | "landed" | "stopped" | "bounced" | "abandoned";
+export type MergeQueueBatchCiCheckState = "passed" | "skipped" | "failed" | "running" | "queued";
+export type MergeQueueBatchCiCheckDto = {
+    name: string;
+    state: MergeQueueBatchCiCheckState;
+    startedAt: string | null;
+    completedAt: string | null;
+};
+export type MergeQueueBatchCiDto = {
+    sha: string;
+    observedAt: string;
+    checks: MergeQueueBatchCiCheckDto[];
+};
 export type MergeQueueEntryBatchDto = {
     id: string;
     position: number;
     size: number;
     state: MergeQueueBatchState;
     landedCount: number;
+    ci?: MergeQueueBatchCiDto | null;
 };
 export type MergeQueueAheadDto = {
     stackId: string | null;

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

@@ -1,4 +1,5 @@
 import type { Config } from "./config.js";
+import type { MergeQueueEntryDto } from "./stack-dto.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: {
@@ -10,6 +11,9 @@ export declare const STACK_WATCH_SLICE_MS = 300000;
 export declare const STACK_WATCH_RECHECK_MS = 30000;
 export declare const STACK_WATCH_FAILED_RETRY_MS = 15000;
 export declare const STACK_WATCH_RATE_LIMIT_WAIT_MS = 30000;
+export declare const STACK_WATCH_TRANSIENT_WINDOW_MS: number;
+export declare const STACK_WATCH_TRANSIENT_MAX_WAIT_MS = 60000;
+export declare function isTransientWatchFailure(err: unknown): boolean;
 export type StackWatchUntil = "attention" | "landed";
 export type StackWatchOutcome = "attention" | "landed" | "failed" | "timeout" | "aborted";
 export type RunStackWatchOptions = {
@@ -22,6 +26,7 @@ export type RunStackWatchOptions = {
     write?: (line: string) => void;
     writeMarker?: (line: string) => void;
     poll?: typeof pollStackWatch;
+    readLanded?: (cfg: Config, stackId: string) => Promise<MergeQueueEntryDto | null>;
     sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
     now?: () => number;
 };

package/dist/stack-watch-loop.js

@@ -1,4 +1,6 @@
 import { setTimeout as sleep } from "node:timers/promises";
+import { API_TIMEOUT_PREFIX, 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";
 export const STACK_WATCH_EXIT = { landed: 0, attention: 3, timeout: 5 };
@@ -6,6 +8,18 @@ export const STACK_WATCH_SLICE_MS = 300_000;
 export const STACK_WATCH_RECHECK_MS = 30_000;
 export const STACK_WATCH_FAILED_RETRY_MS = 15_000;
 export const STACK_WATCH_RATE_LIMIT_WAIT_MS = 30_000;
+export const STACK_WATCH_TRANSIENT_WINDOW_MS = 15 * 60_000;
+export const STACK_WATCH_TRANSIENT_MAX_WAIT_MS = 60_000;
+const TRANSIENT_WATCH_FAILURE = /HTTP (?:408|429|5\d\d)|snapshot missing|fetch failed|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket hang up|network|connection/i;
+export function isTransientWatchFailure(err) {
+    if (!(err instanceof Error))
+        return false;
+    if (isTransientReviewPollError(err))
+        return true;
+    if (err.cause !== undefined && isTransientReviewPollError(err.cause))
+        return true;
+    return err.message.startsWith(API_TIMEOUT_PREFIX) || TRANSIENT_WATCH_FAILURE.test(err.message);
+}
 const ELAPSED_MINUTES = /\b\d+m\b/g;
 export function blockerWithoutElapsedMinutes(blocker) {
     return (blocker ?? "").replace(ELAPSED_MINUTES, "Nm");
@@ -35,6 +49,7 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
     const write = opts.write ?? ((line) => console.log(line));
     const writeMarker = opts.json ? opts.writeMarker ?? ((line) => console.error(line)) : write;
     const poll = opts.poll ?? pollStackWatch;
+    const readLanded = opts.readLanded ?? readLandedQueueEntry;
     const now = opts.now ?? Date.now;
     const wait = opts.sleep ?? ((ms, signal) => sleep(ms, undefined, { signal }));
     const deadline = opts.maxMs !== undefined ? now() + opts.maxMs : Number.POSITIVE_INFINITY;
@@ -50,9 +65,43 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
     };
     let cursor = opts.cursor;
     let failures = 0;
+    let permanentFailures = 0;
+    const seenPrs = new Set();
+    const notePrs = (envelope) => {
+        if (envelope.prNumber)
+            seenPrs.add(envelope.prNumber);
+        if (envelope.currentCandidate?.prNumber)
+            seenPrs.add(envelope.currentCandidate.prNumber);
+    };
+    let transientSince = null;
     const ignoredKeys = new Map();
     let reportedKey = null;
-    const finished = (envelope) => {
+    const confirmedLanding = async (envelope) => {
+        if (envelope.watch.reason !== "not_found")
+            return envelope;
+        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.",
+                },
+            };
+        }
+        const enrolledHead = envelope.cursor?.enrolledHeadSha ?? null;
+        const ours = Boolean(entry) && (entry.landedPrNumbers.some((pr) => seenPrs.has(pr)) ||
+            (enrolledHead !== null && entry.verifyHeadSha === enrolledHead));
+        if (!entry || !ours)
+            return envelope;
+        return { ...envelope, watch: { ...envelope.watch, reason: "landed", message: `This stack is landed (merge queue landed #${entry.landedPrNumbers.join(", #")}). The watch is done; stop calling stack_wait for it.` } };
+    };
+    const finished = async (seen) => {
+        const envelope = await confirmedLanding(seen);
         const landed = envelope.watch.reason === "landed";
         const outcome = landed ? "landed" : "attention";
         emit(landed ? stackWatchLandedLine(envelope)
@@ -61,9 +110,20 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
             write(envelope.watch.message);
         return { outcome, exitCode: landed ? STACK_WATCH_EXIT.landed : STACK_WATCH_EXIT.attention, envelope };
     };
-    const failed = async (message, envelope) => {
+    const failed = async (message, envelope, transient) => {
         failures += 1;
-        if (failures >= 2) {
+        if (transient) {
+            permanentFailures = 0;
+            transientSince ??= now();
+            if (now() - transientSince < STACK_WATCH_TRANSIENT_WINDOW_MS) {
+                await pause(Math.min(STACK_WATCH_TRANSIENT_MAX_WAIT_MS, STACK_WATCH_FAILED_RETRY_MS * 2 ** Math.min(failures - 1, 4)));
+                return null;
+            }
+        }
+        else {
+            permanentFailures += 1;
+        }
+        if (permanentFailures >= 2 || transient) {
             emit(stackWatchFailedLine(id, message), envelope, "failed");
             return { outcome: "failed", exitCode: STACK_WATCH_EXIT.attention, envelope };
         }
@@ -84,25 +144,34 @@ export async function runStackWatch(cfg, stackId, opts = {}) {
                 if (isAbort(err, opts.signal))
                     throw err;
                 if (err instanceof StackWatchTimeoutError) {
+                    notePrs(err.lastEnvelope);
                     cursor = err.lastEnvelope.cursor;
                     failures = 0;
+                    permanentFailures = 0;
+                    if (err.lastEnvelope.assessment === "available")
+                        transientSince = null;
                     continue;
                 }
-                if (err instanceof StackWatchError && err.lastEnvelope.watch.done)
-                    return finished(err.lastEnvelope);
+                if (err instanceof StackWatchError && err.lastEnvelope.watch.done) {
+                    notePrs(err.lastEnvelope);
+                    return await finished(err.lastEnvelope);
+                }
                 if (err instanceof StackWatchError && err.lastEnvelope.status === "rate_limited") {
                     await pause(err.retryAfterSeconds !== undefined ? Math.max(1_000, err.retryAfterSeconds * 1000) : STACK_WATCH_RATE_LIMIT_WAIT_MS);
                     continue;
                 }
-                const result = await failed(err instanceof Error ? err.message : String(err), err instanceof StackWatchError ? err.lastEnvelope : null);
+                const result = await failed(err instanceof Error ? err.message : String(err), err instanceof StackWatchError ? err.lastEnvelope : null, isTransientWatchFailure(err));
                 if (result)
                     return result;
                 continue;
             }
             failures = 0;
+            permanentFailures = 0;
+            transientSince = null;
             cursor = envelope.cursor;
+            notePrs(envelope);
             if (envelope.watch.done)
-                return finished(envelope);
+                return await finished(envelope);
             if (envelope.status === "attention") {
                 const key = stackWatchAttentionKey(envelope);
                 const blocker = (envelope.blocker ?? "").toLowerCase();

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

@@ -3,7 +3,7 @@ export declare const STACK_WATCH_NOT_DONE_SENTENCE = "This stack is not landed.
 export declare const STACK_WATCH_NOTIFY_PATTERN = "MS-WATCH (ATTENTION|LANDED)";
 export declare function stackWatchBackgroundCommand(stackId: string): string;
 export type StackWatchDoneReason = "landed" | "closed" | "archived" | "not_found";
-export type StackWatchReason = StackWatchDoneReason | "open" | "attention" | "unread" | "rate_limited" | "failed";
+export type StackWatchReason = StackWatchDoneReason | "open" | "attention" | "unread" | "rate_limited" | "failed" | "landing_unconfirmed";
 export type StackWatchNextArgs = {
     stack_id: string;
     enrolled_head_sha?: string | null;

package/dist/stack-watch.js

@@ -83,6 +83,7 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
             catch (err) {
                 if (opts.signal?.aborted || (err instanceof Error && err.name === "AbortError"))
                     throw err;
+                lastEnvelope = { ...lastEnvelope, assessment: "unavailable" };
                 if (now() >= deadline && timeoutMs !== 0)
                     throw timeout();
                 if (timeoutMs !== 0 && isTransientReviewPollError(err) && transientFailures < REVIEW_POLL_MAX_TRANSIENT_RETRIES) {
@@ -95,6 +96,7 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
             }
             if (response.status === 200)
                 return response.body;
+            lastEnvelope = { ...lastEnvelope, assessment: "unavailable" };
             const retryWaitMs = transientRetryWaitMs({
                 failureCount: transientFailures + 1, retryAfterSeconds: response.retryAfterSeconds, random: opts.random,
             });

package/dist/ui/banner.js

@@ -176,6 +176,12 @@ const WHATS_NEW = {
     "0.3.46": [
         "Watch waits while GitHub delays a review",
     ],
+    "0.3.47": [
+        "New stack PRs are adopted on Work at submit",
+    ],
+    "0.3.48": [
+        "Watch names CI Cyclone could not finish",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

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