mergestorm 0.3.24 → 0.3.25

package/README.md

@@ -45,12 +45,12 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│ ▟██▛  mergestorm v0.3.24                                                     │
+│ ▟██▛  mergestorm v0.3.25                                                     │
 │  ▜▙   ● msk_live_…  · maelstrom                                              │
 │       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used · Resets Sep 5, 10:53am (UTC)│
 │                                                                              │
 │       review a diff · usage for tabs · /help for all commands                │
-│       New in v0.3.24: mg settings --auto-land-settle (15-300 seconds)       │
+│       New in v0.3.25: stack wait holds a PR while Cyclone or Vortex works   │
 ╰──────────────────────────────────────────────────────────────────────────────╯
 mergestorm
 ╭──────────────────────────────────────────────────────────────────────────────╮

package/dist/client/index.d.ts

@@ -5,6 +5,6 @@ export { CommandError, DetachedError, RATE_LIMITED_HINT, REVIEW_EXIT, isCommandE
 export { REVIEW_POLL_BACKOFF_MS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_POLL_STRETCH_AFTER_MS, REVIEW_POLL_STRETCH_SPAN_MS, REVIEW_THREAD_SLUG_RE, PrReviewPollTimeoutError, ReviewPollTimeoutError, collectReviewInput, formatReviewSubmitError, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollPrVortexReview, pollReview, stretchedPollIntervalMs, submitReview, transientRetryWaitMs, type PollReviewOptions, type PollPrVortexReviewOptions, type ReviewInput, type SubmitReviewOptions, } from "../commands/review-client.js";
 export { REVIEW_JOB_ENVELOPE_SCHEMA, toReviewJobEnvelope, type ReviewEnvelopeFallbacks, type ReviewJobEnvelope, type ReviewJobRow, } from "../ui/job-envelope.js";
 export { discoverTrunk } from "../git-stack.js";
-export { BOUNCE_KIND_LABELS, mergeQueueBounceLabel } from "../stack-dto.js";
-export { STACK_WATCH_SCHEMA, STACK_WATCH_DEFAULT_TIMEOUT_MS, StackWatchError, StackWatchTimeoutError, pollStackWatch, type PollStackWatchOptions, type StackWatchCursor, type StackWatchEnvelope, } from "../stack-watch.js";
-export { stackBlockers, stackBlockersSummary, sameHead, type StackBlocker } from "../stack-blockers.js";
+export { BOUNCE_KIND_LABELS, deriveStackAgentsBusy, mergeQueueBounceLabel, type StackAgentsBusy } from "../stack-dto.js";
+export { STACK_WATCH_SCHEMA, STACK_WATCH_DEFAULT_TIMEOUT_MS, STACK_WATCH_BUSY_RECHECK_S, StackWatchError, StackWatchTimeoutError, pollStackWatch, type PollStackWatchOptions, type StackWatchCursor, type StackWatchEnvelope, } from "../stack-watch.js";
+export { stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, type StackAgentBusy, type StackBlocker, type StackLayerAgents, } from "../stack-blockers.js";

package/dist/client/index.js

@@ -5,6 +5,6 @@ export { CommandError, DetachedError, RATE_LIMITED_HINT, REVIEW_EXIT, isCommandE
 export { REVIEW_POLL_BACKOFF_MS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_POLL_STRETCH_AFTER_MS, REVIEW_POLL_STRETCH_SPAN_MS, REVIEW_THREAD_SLUG_RE, PrReviewPollTimeoutError, ReviewPollTimeoutError, collectReviewInput, formatReviewSubmitError, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollPrVortexReview, pollReview, stretchedPollIntervalMs, submitReview, transientRetryWaitMs, } from "../commands/review-client.js";
 export { REVIEW_JOB_ENVELOPE_SCHEMA, toReviewJobEnvelope, } from "../ui/job-envelope.js";
 export { discoverTrunk } from "../git-stack.js";
-export { BOUNCE_KIND_LABELS, mergeQueueBounceLabel } from "../stack-dto.js";
-export { STACK_WATCH_SCHEMA, STACK_WATCH_DEFAULT_TIMEOUT_MS, StackWatchError, StackWatchTimeoutError, pollStackWatch, } from "../stack-watch.js";
-export { stackBlockers, stackBlockersSummary, sameHead } from "../stack-blockers.js";
+export { BOUNCE_KIND_LABELS, deriveStackAgentsBusy, mergeQueueBounceLabel } from "../stack-dto.js";
+export { STACK_WATCH_SCHEMA, STACK_WATCH_DEFAULT_TIMEOUT_MS, STACK_WATCH_BUSY_RECHECK_S, StackWatchError, StackWatchTimeoutError, pollStackWatch, } from "../stack-watch.js";
+export { stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, } from "../stack-blockers.js";

package/dist/commands/queue.js

@@ -144,8 +144,12 @@ async function removeQueue(args, asJson) {
         console.log(JSON.stringify(body, null, 2));
         return;
     }
+    const cancelRequested = typeof body === "object" && body !== null &&
+        body.cancelRequested === true;
     await present("Merge queue", [
-        ansi.brightGreen(`  Removed ${entryId} from the merge queue`),
+        cancelRequested
+            ? ansi.brightGreen(`  Cancel requested for ${entryId}: it is merging, and the queue cancels it before the merge call unless the merge already started`)
+            : ansi.brightGreen(`  Removed ${entryId} from the merge queue`),
     ]);
 }
 export async function cmdQueue(args, deps = {}) {

package/dist/commands/stack.js

@@ -868,7 +868,7 @@ export async function cmdStackWait(args, deps = {}) {
             ...envelope,
             ...(retryAfterSeconds !== undefined ? { retry_after_seconds: retryAfterSeconds } : {}),
         }, null, 2)
-        : `Stack ${envelope.stackId} · ${envelope.status}${stackBlockersSummary(envelope.blocker && envelope.prNumber != null ? { prNumber: envelope.prNumber, blocker: envelope.blocker } : null, envelope.issues)}${envelope.assessment === "unavailable" ? " · assessment unavailable" : ""}`);
+        : `Stack ${envelope.stackId} · ${envelope.status}${stackBlockersSummary(envelope.blocker && envelope.prNumber != null ? { prNumber: envelope.prNumber, blocker: envelope.blocker } : null, envelope.issues, envelope.busy)}${envelope.assessment === "unavailable" ? " · assessment unavailable" : ""}`);
     try {
         print(await (deps.pollStackWatch ?? pollStackWatch)(cfg, stackId, {
             timeoutMs: timeoutS * 1000,

package/dist/stack-blockers.d.ts

@@ -1,4 +1,4 @@
-import { type MergeQueueEntryDto, type StackDto, type StackLayerDto } from "./stack-dto.js";
+import { type MergeQueueEntryDto, type StackAgentsBusy, type StackDto, type StackLayerDto } from "./stack-dto.js";
 import type { StackWatchCursor } from "./stack-watch.js";
 export type StackBlocker = {
     prNumber: number;
@@ -6,6 +6,29 @@ export type StackBlocker = {
     blocker: string;
     bounceKind: string | null;
 };
+export type StackAgentBusy = {
+    prNumber: number;
+    headSha: string | null;
+    agent: "vortex" | "cyclone";
+    blocker: string;
+};
+export type StackLayerAgents = {
+    prNumber: number;
+    headSha: string | null;
+    vortexStatus: StackLayerDto["vortexStatus"];
+    cycloneStatus: StackLayerDto["cycloneStatus"];
+    vortexReview: {
+        status: string;
+        headSha: string | null;
+        pass: number | null;
+    } | null;
+    busy: {
+        vortex: boolean;
+        cyclone: boolean;
+    };
+};
+export declare function layerAgentsBusy(layer: StackLayerDto): StackAgentsBusy;
+export declare function layerAgents(layer: StackLayerDto): StackLayerAgents;
 export declare function isMgParkBase(branch: string | null | undefined): boolean;
 /** GitHub DIRTY vs an mg-park-* freeze is not a merge conflict, verified or not. */
 export declare function boundDirty(layer: StackLayerDto): boolean;
@@ -20,6 +43,8 @@ export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntry
         headSha: string | null;
     } | null;
     bounce: MergeQueueEntryDto | undefined;
+    busy: StackAgentBusy[];
+    agents: StackLayerAgents | null;
 };
 /** Compact contract text shared by status and wait summaries. */
-export declare function stackBlockersSummary(attention: Pick<StackBlocker, "prNumber" | "blocker"> | null, issues: StackBlocker[]): string;
+export declare function stackBlockersSummary(attention: Pick<StackBlocker, "prNumber" | "blocker"> | null, issues: StackBlocker[], busy?: readonly StackAgentBusy[]): string;

package/dist/stack-blockers.js

@@ -1,4 +1,19 @@
-import { mergeQueueBounceLabel, restackRetryPending } from "./stack-dto.js";
+import { deriveStackAgentsBusy, mergeQueueBounceLabel, restackRetryPending, } from "./stack-dto.js";
+export function layerAgentsBusy(layer) {
+    return layer.agentsBusy ?? deriveStackAgentsBusy(layer);
+}
+export function layerAgents(layer) {
+    const busy = layerAgentsBusy(layer);
+    const review = layer.vortexReview;
+    return {
+        prNumber: layer.prNumber,
+        headSha: layer.headSha ?? null,
+        vortexStatus: layer.vortexStatus ?? null,
+        cycloneStatus: layer.cycloneStatus ?? null,
+        vortexReview: review ? { status: review.status, headSha: review.head_sha, pass: review.pass } : null,
+        busy: { vortex: busy.vortex, cyclone: busy.cyclone },
+    };
+}
 export function isMgParkBase(branch) {
     return (branch ?? "").trim().toLowerCase().startsWith("mg-park-");
 }
@@ -26,6 +41,22 @@ export function currentLayer(stack) {
     return promote[0] ?? open.find((layer) => layer.prNumber === stack.unit?.landPrNumber) ??
         (land && land.prNumber > 0 && land.state !== "merged" && land.state !== "closed" ? land : undefined);
 }
+function seamGateBlocker(stack, layer) {
+    const members = stack.unit?.members ?? [];
+    if (layer.prNumber === stack.unit?.landPrNumber)
+        return null;
+    if (!members.some((member) => member.promotedHeadSha?.trim()))
+        return null;
+    const member = members.find((entry) => entry.prNumber === layer.prNumber);
+    if (!member || member.promotedHeadSha?.trim())
+        return null;
+    const seamState = member.seamState?.trim().toLowerCase();
+    if (seamState === "failed")
+        return "Seam review failed";
+    if (seamState === "findings" && sameHead(member.seamReviewedSha, layer.headSha))
+        return "Seam findings";
+    return null;
+}
 /** Shared live-fact precedence; bounce history is only passed for the candidate. */
 function layerAttention(stack, layer, queue, cursor) {
     const none = { blocker: null, bounceKind: null };
@@ -63,6 +94,9 @@ function layerAttention(stack, layer, queue, cursor) {
             return hardBlock(`Tempest ${tempest.status}`);
         if (layer.vortexStatus === "failed")
             return hardBlock("Review failed");
+        const seam = seamGateBlocker(stack, layer);
+        if (seam)
+            return hardBlock(seam);
         if (stack.unit?.landPrNumber === layer.prNumber) {
             if (stack.unit.landingBlockReason?.trim())
                 return hardBlock(stack.unit.landingBlockReason.trim());
@@ -94,6 +128,7 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
         (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 attentionLayer;
     let bounce;
     const issues = [];
     for (const layer of open) {
@@ -105,16 +140,31 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
             blocker: result.blocker, bounceKind: result.bounceKind };
         if (selected || (!attention && layer === child)) {
             attention = issue;
+            attentionLayer = layer;
             bounce = result.bounce;
         }
         else if (!candidate || layer.position > candidate.position)
             issues.push(issue);
     }
-    return { attention, issues, currentCandidate, bounce };
+    const focus = attentionLayer ?? candidate;
+    const agents = focus ? layerAgents(focus) : null;
+    const busy = [];
+    if (attention && agents) {
+        for (const agent of ["cyclone", "vortex"]) {
+            if (agents.busy[agent])
+                busy.push({ prNumber: attention.prNumber, headSha: attention.headSha, agent, blocker: attention.blocker });
+        }
+    }
+    if (busy.length)
+        return { attention: null, issues, currentCandidate, bounce: undefined, busy, agents };
+    return { attention, issues, currentCandidate, bounce, busy, agents };
 }
 /** Compact contract text shared by status and wait summaries. */
-export function stackBlockersSummary(attention, issues) {
+export function stackBlockersSummary(attention, issues, busy = []) {
     const blocked = attention ? ` · blocked: #${attention.prNumber} ${attention.blocker}` : "";
+    const working = busy.length
+        ? ` · held: #${busy[0].prNumber} ${busy[0].blocker} while ${busy.map((entry) => entry.agent === "cyclone" ? "Cyclone patches" : "Vortex reviews").join(" and ")}`
+        : "";
     const labels = issues.slice(0, 3).map(issue => `#${issue.prNumber} ${issue.blocker}`).join("; ");
-    return blocked + (issues.length ? ` · issues: ${labels}${issues.length > 3 ? `; +${issues.length - 3} more` : ""}` : "");
+    return blocked + working + (issues.length ? ` · issues: ${labels}${issues.length > 3 ? `; +${issues.length - 3} more` : ""}` : "");
 }

package/dist/stack-dto.d.ts

@@ -98,6 +98,16 @@ export type StackAgentRun = {
         total: number;
     } | null;
 };
+export type StackAgentsBusy = {
+    vortex: boolean;
+    cyclone: boolean;
+    headSha: string | null;
+};
+export declare const STACK_AGENT_QUEUED_STALE_MS: number;
+export declare function deriveStackAgentsBusy(layer: Pick<StackLayerDto, "headSha" | "vortexStatus" | "cycloneStatus" | "agentRuns" | "vortexReview">, opts?: {
+    cycloneClaimed?: boolean;
+    nowMs?: number;
+}): StackAgentsBusy;
 export type StackLayerChecks = {
     total: number;
     success: number;
@@ -182,6 +192,7 @@ export type StackLayerDto = {
      * detail once it says `done`. Undefined = producer predates the viewer.
      */
     vortexReview?: StackVortexReviewView;
+    agentsBusy?: StackAgentsBusy | null;
     conflictDetail: string | null;
     restackError?: RestackError | null;
     lastRestackedSha: string | null;
@@ -357,6 +368,7 @@ export type MergeQueueBounceDetail = {
     failingCheck?: string;
     conflictBranch?: string;
     conflictDetail?: string;
+    conflictPaths?: string[];
     message?: string;
 };
 export type MergeQueueEntryDto = {
@@ -379,5 +391,6 @@ export type MergeQueueEntryDto = {
     verifyHeadSha: string | null;
     /** Target tip included in the verified PR head. Null until recorded. */
     verifyBaseSha: string | null;
+    cancelRequestedAt?: string | null;
     finishedAt: string | null;
 };

package/dist/stack-dto.js

@@ -16,6 +16,33 @@ export function restackRetryPending(error, layer) {
         return false;
     return !/\(origin\/\S+ moved to /.test(error.detail) && pushRejectionIsRetryable(error.detail);
 }
+export const STACK_AGENT_QUEUED_STALE_MS = 15 * 60 * 1000;
+function agentShaMayBeHead(sha, head) {
+    const left = sha?.trim().toLowerCase();
+    const right = head?.trim().toLowerCase();
+    if (!left || !right)
+        return false;
+    return left.startsWith(right) || right.startsWith(left);
+}
+export function deriveStackAgentsBusy(layer, opts = {}) {
+    const headSha = layer.headSha?.trim() || null;
+    const nowMs = opts.nowMs ?? Date.now();
+    const runs = (layer.agentRuns ?? []).filter((run) => !run.finishedAt);
+    const vortexRuns = runs.filter((run) => run.agent === "vortex" && agentShaMayBeHead(run.sha, headSha));
+    const freshQueued = vortexRuns.some((run) => {
+        const queuedAt = Date.parse(run.startedAt ?? "");
+        return run.status === "queued" && Number.isFinite(queuedAt) && nowMs - queuedAt <= STACK_AGENT_QUEUED_STALE_MS;
+    });
+    const review = layer.vortexReview;
+    const reviewOnHead = !!review && agentShaMayBeHead(review.head_sha, headSha);
+    const vortex = (reviewOnHead && review.status === "reviewing") ||
+        vortexRuns.some((run) => run.status === "reviewing") ||
+        freshQueued ||
+        (layer.agentRuns === undefined && review === undefined && layer.vortexStatus === "reviewing");
+    const cyclone = opts.cycloneClaimed === true || layer.cycloneStatus === "patching" ||
+        runs.some((run) => run.agent === "cyclone" && run.status === "patching");
+    return { vortex, cyclone, headSha };
+}
 /** Every bounce kind understood by the shared contract. */
 export const MERGE_QUEUE_BOUNCE_KINDS = [
     "ci_failure",
@@ -47,6 +74,7 @@ export function mergeQueueBounceLabel(entry) {
     if (kindLabel) {
         const specifics = detail?.failingCheck ??
             detail?.conflictBranch ??
+            (detail?.conflictPaths?.length ? detail.conflictPaths.join(", ") : null) ??
             detail?.message ??
             (detail?.prNumber != null ? `PR #${detail.prNumber}` : null);
         return specifics ? `${kindLabel} — ${specifics}` : kindLabel;

package/dist/stack-watch.d.ts

@@ -1,8 +1,9 @@
-import { type StackBlocker } from "./stack-blockers.js";
+import { type StackAgentBusy, type StackBlocker, type StackLayerAgents } from "./stack-blockers.js";
 import { apiFetch } from "./api.js";
 import type { Config } from "./config.js";
 export declare const STACK_WATCH_SCHEMA: "mergestorm.stack_watch/v1";
 export declare const STACK_WATCH_DEFAULT_TIMEOUT_MS = 45000;
+export declare const STACK_WATCH_BUSY_RECHECK_S = 15;
 /** Resume selectors are fixed for the entire wait, including transient retries. */
 export type StackWatchCursor = {
     readonly stackId: string;
@@ -25,6 +26,8 @@ export type StackWatchEnvelope = {
         headSha: string | null;
     } | null;
     assessment: "available" | "unavailable";
+    busy: StackAgentBusy[];
+    agents: StackLayerAgents | null;
 };
 export type PollStackWatchOptions = {
     timeoutMs?: number;

package/dist/stack-watch.js

@@ -1,9 +1,10 @@
-import { currentLayer, stackBlockers } from "./stack-blockers.js";
+import { currentLayer, layerAgents, stackBlockers, } from "./stack-blockers.js";
 import { setTimeout as sleep } from "node:timers/promises";
 import { apiFetch } from "./api.js";
 import { REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, isTransientReviewPollError, isTransientReviewPollStatus, transientRetryWaitMs, } from "./commands/review-client.js";
 export const STACK_WATCH_SCHEMA = "mergestorm.stack_watch/v1";
 export const STACK_WATCH_DEFAULT_TIMEOUT_MS = 45_000;
+export const STACK_WATCH_BUSY_RECHECK_S = 15;
 export class StackWatchTimeoutError extends Error {
     lastEnvelope;
     constructor(lastEnvelope) {
@@ -46,7 +47,7 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
     let lastEnvelope = {
         schema: STACK_WATCH_SCHEMA, status: "failed", stackId: id, blocker: null,
         bounceKind: null, prNumber: null, headSha: null, cursor,
-        issues: [], currentCandidate: null, assessment: "unavailable",
+        issues: [], currentCandidate: null, assessment: "unavailable", busy: [], agents: null,
     };
     let transientFailures = 0;
     const timeout = () => new StackWatchTimeoutError(lastEnvelope);
@@ -122,15 +123,16 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         };
     };
     const evaluate = (stack, entries) => {
-        const { attention, issues, currentCandidate, bounce } = stackBlockers(stack, entries, cursor);
+        const { attention, issues, currentCandidate, bounce, busy, agents } = stackBlockers(stack, entries, cursor);
         if (bounce)
             cursor = Object.freeze({ ...cursor, bounceId: bounce.id,
                 ...(bounce.finishedAt !== undefined ? { afterFinishedAt: bounce.finishedAt } : {}) });
-        lastEnvelope = { ...lastEnvelope, cursor, issues, currentCandidate, assessment: "available",
+        const held = busy[0];
+        lastEnvelope = { ...lastEnvelope, cursor, issues, currentCandidate, assessment: "available", busy, agents,
             blocker: attention?.blocker ?? null, bounceKind: attention?.bounceKind ?? null,
-            prNumber: attention?.prNumber ?? currentCandidate?.prNumber ?? null,
-            headSha: attention ? attention.headSha : currentCandidate?.headSha ?? null,
-            status: attention ? "attention" : entries.some((entry) => ["queued", "running", "waiting"].includes(entry.state))
+            prNumber: attention?.prNumber ?? held?.prNumber ?? currentCandidate?.prNumber ?? null,
+            headSha: attention ? attention.headSha : held ? held.headSha : currentCandidate?.headSha ?? null,
+            status: attention ? "attention" : busy.length || entries.some((entry) => ["queued", "running", "waiting"].includes(entry.state))
                 ? "in_progress" : "waiting" };
     };
     let stack = await enrich(timeoutMs === 0);
@@ -139,14 +141,15 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         cursor = Object.freeze({ stackId: id, enrolledHeadSha: layer?.headSha ?? null });
         enrolled = true;
     }
-    lastEnvelope = { ...lastEnvelope, cursor, prNumber: layer?.prNumber ?? null, headSha: layer?.headSha ?? null };
+    lastEnvelope = { ...lastEnvelope, cursor, prNumber: layer?.prNumber ?? null, headSha: layer?.headSha ?? null,
+        agents: layer ? layerAgents(layer) : null };
     let queue = await readQueue(queueRoute, timeoutMs === 0);
     evaluate(stack, queue.entries);
     if (lastEnvelope.status === "attention" || timeoutMs === 0)
         return lastEnvelope;
     while (now() < deadline) {
         const heldAt = now();
-        const seconds = Math.min(45, Math.max(1, Math.ceil((deadline - heldAt) / 1000)));
+        const seconds = Math.min(lastEnvelope.busy.length ? STACK_WATCH_BUSY_RECHECK_S : 45, Math.max(1, Math.ceil((deadline - heldAt) / 1000)));
         const seen = queue.fingerprint ? `&seen=${encodeURIComponent(queue.fingerprint)}` : "";
         const held = await readQueue(`${queueRoute}&wait=${seconds}${seen}`);
         if (JSON.stringify(held.entries) === JSON.stringify(queue.entries)) {
@@ -155,7 +158,8 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         queue = held;
         stack = await enrich(true);
         const refreshed = currentLayer(stack);
-        lastEnvelope = { ...lastEnvelope, prNumber: refreshed?.prNumber ?? null, headSha: refreshed?.headSha ?? null };
+        lastEnvelope = { ...lastEnvelope, prNumber: refreshed?.prNumber ?? null, headSha: refreshed?.headSha ?? null,
+            agents: refreshed ? layerAgents(refreshed) : null };
         transientFailures = 0;
         evaluate(stack, queue.entries);
         if (lastEnvelope.status === "attention")

package/dist/ui/banner.js

@@ -105,6 +105,9 @@ const WHATS_NEW = {
     "0.3.24": [
         "mg settings --auto-land-settle (15-300 seconds)",
     ],
+    "0.3.25": [
+        "stack wait holds a PR while Cyclone or Vortex works",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

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

package/skill/SKILL.md

@@ -68,12 +68,12 @@ Call `review_submit` with `wait: false` (the default) on the repo cwd (git colle
 
 Optional: `thread`, `idempotency_key`, `wait`, `timeout_s`. Submit returns without waiting. Record `job_id` as soon as it returns, then loop `review_wait` with that `job_id` and `timeout_s: 45` until the job finishes. Each call is one 45s slice. On timeout, call `review_wait` again with the same `job_id`. Do not pass 300; hosts drop long MCP calls. Explicit `wait: true` also defaults to one 45s slice.
 
-Call `review_list` before any resubmit, including when a submit or wait call is interrupted. Resume the existing job with `review_get` or `review_wait`; do not create a second job because a slice died or the submit response was lost.
+Call `review_list` before any resubmit, including when a submit or wait call is interrupted. Resume the existing job with `review_wait` (`timeout_s: 0` reads it once without waiting); do not create a second job because a slice died or the submit response was lost.
 
 Status handling:
 
 - status is `no_changes`: success. The branch matches the selected base, no review job was submitted, and no review credit was used. Stop unless the user expected a different base.
-- status is `rate_limited`: wait `retry_after_seconds`. Use `review_list`, `review_get`, or `review_wait` for an existing in-flight job before resubmitting. Do not immediately resubmit the same diff.
+- status is `rate_limited`: wait `retry_after_seconds`. Use `review_list` or `review_wait` for an existing in-flight job before resubmitting. Do not immediately resubmit the same diff.
 
 ## Apply findings
 

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

@@ -17,9 +17,9 @@ Call `stack_status` with `stack_id`. Require that stack's `autoEnqueueWhenReady`
 
 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.
 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. 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, stop and report the reason. `queue_status` returning `queue_entry_not_found` is not a failure: an empty queue for the stack is a normal wait.
-3. 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. A bounce is the reason to look, not the moment to commit. For a red CI failure (`ci_failure`) or a merge conflict, if Vortex or Cyclone is still working on that PR, do not patch yet: keep calling `stack_wait` with the same cursor until that work has finished, then make the follow-up commit. Still working means, from `stack_status` on that stack for that PR: `vortexStatus` is `queued`, `reviewing`, or `seam_pending`; or `cycloneStatus` is `patching`; or an `agentRuns` row for vortex or cyclone has no `finishedAt` and its status is one of those in-flight values. `all_clear`, `findings`, `skipped`, `failed`, `throttled`, `awaiting_fix`, and a null status are finished. Do not turn Cyclone off, and do not turn Auto land off or on, to end the wait. If the remote head moves while you wait, stop and tell the human.
+3. 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. 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. While `busy[]` holds a PR it can hide a blocker no agent will clear, such as a Draft PR. If a hold looks stuck, refresh `stack_status` and tell the human. Do not turn Cyclone off, and do not turn Auto land off or on, to end the wait. 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. Otherwise prefer merging that live parent into the PR branch, resolving locally, then an ordinary push. Never use Dashboard Continue. When the live parent is a sibling, never rebase onto trunk or `mg-stack-N` instead. Parked-freeze DIRTY alone needs no conflict patch. Leave GitHub bases as Mergestorm set them: the bottom of a 2+ PR stack is based on `mg-stack-N`, layer 2 on layer 1, PR3+ on `mg-park-*`.
-5. CI-only fixes may run while Cyclone auto-patch is still on for the stack. Auto-patch may stay on, and you still wait until the current Vortex run and the current Cyclone run on that PR have finished before the follow-up commit. When the gate is clean, inspect `issues[]` and fix a live upstack CI failure one PR at a time, refreshing the gate before the next PR. Do not use higher-layer bounce history as a patch target. Do not fight Cyclone: if the remote head moved, stop and tell the human. Do not take over Cyclone's review-finding work while it is active; if the blocker requires that or a policy/queue action rather than a concrete patch, stop and explain what needs human attention.
+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. On `Seam review failed`, do not patch; tell the human, unless a new push already has a seam re-review held in `busy[]`.
 6. Recheck Auto land 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. 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 or re-arm anything. If further progress requires re-arming, stop and tell the human.
 

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

@@ -41,7 +41,7 @@ mg skill install --claude --cursor --agents
      - If the override is not `false` and the human asked you to turn Cyclone off for this PR: call `stack_set` with `{ stack_id, auto_patch: false }` on that stack, call `stack_status` with that `stack_id`, and confirm `autoPatchOverride` now reads `false`. Leave the account `auto_patch_enabled` unchanged; other PRs keep their own policy.
      - Otherwise: refuse the loop. Do not wait, patch, or push; tell the human Cyclone auto-patch is still on for this PR and that `stack_set` with `auto_patch: false` on its stack turns it off for this PR only.
    - Never set `auto_patch_enabled` with `settings_set` from this skill, in either direction, and never set `auto_patch: true` on a stack.
-3. Call `review_wait_pr` with the PR's owner, repo, pr_number, and `timeout_s` 45 (`review_get_pr` works for a first look at the resting state). A Vortex pass often takes several minutes. If status is `in_progress`, call `review_wait_pr` again with the same args. Do not pass a 300s timeout; hosts drop long MCP calls. Review identity is SHA + pass: every envelope carries `head_sha` and `pass` (1 for the first review on a head; a re-review on the same head is the next pass, its own row). Save the `pass` of every resting envelope you act on together with its `head_sha`.
+3. Call `review_wait_pr` with the PR's owner, repo, pr_number, and `timeout_s` 45 (`timeout_s` 0 reads the current state once without waiting). A Vortex pass often takes several minutes. If status is `in_progress`, call `review_wait_pr` again with the same args. Do not pass a 300s timeout; hosts drop long MCP calls. Review identity is SHA + pass: every envelope carries `head_sha` and `pass` (1 for the first review on a head; a re-review on the same head is the next pass, its own row). Save the `pass` of every resting envelope you act on together with its `head_sha`.
 4. Confirm the envelope's `head_sha` is the commit you have checked out as the PR head (compare its leading 7+ hex characters with `git rev-parse HEAD`). If it is not, someone else pushed after this pass and its findings are not yours to patch: do not edit. Fetch and check out the PR head, then go to step 8 with `after_sha` set to that head.
 5. Read `findings.inline` and `findings.offDiff` (or `off_diff`) sorted by severity. For each finding:
    - Verify it against the current checkout. Do not treat the finding text as proven.
@@ -50,7 +50,7 @@ mg skill install --claude --cursor --agents
    - 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.
 6. Patch on the PR head branch only.
 7. Push that head branch with an ordinary push. If the push is rejected because the remote branch moved, another patcher already pushed for this pass. Do not rebase, do not force, do not retry the push: stop and tell the human that a second patcher is active on this PR.
-8. Call `review_wait_pr` again with `after_sha` set to the SHA you just pushed (7+ hex) and `timeout_s` 45. If the last envelope you acted on has that same `head_sha` (no new commit, for example a re-review requested on the same head), also pass `after_pass` set to that envelope's saved `pass`, so the wait cannot hand you that attempt again. For a freshly pushed SHA omit `after_pass`; its first pass is 1. Keep `after_sha` and `after_pass` unchanged across 45s timeout retries; never replace `after_pass` with the `pass` of an in-progress envelope. `review_get_pr` accepts the same `after_sha`, `pass`, and `after_pass` filters. An envelope whose `head_sha` is an older commit is a previous pass, not yours; keep waiting.
+8. Call `review_wait_pr` again with `after_sha` set to the SHA you just pushed (7+ hex) and `timeout_s` 45. If the last envelope you acted on has that same `head_sha` (no new commit, for example a re-review requested on the same head), also pass `after_pass` set to that envelope's saved `pass`, so the wait cannot hand you that attempt again. For a freshly pushed SHA omit `after_pass`; its first pass is 1. Keep `after_sha` and `after_pass` unchanged across 45s timeout retries; never replace `after_pass` with the `pass` of an in-progress envelope. `pass` reads one exact attempt; `timeout_s` 0 reads once without waiting. An envelope whose `head_sha` is an older commit is a previous pass, not yours; keep waiting.
 9. Repeat from step 4 until a stop rule fires.
 
 ## Stop rules
@@ -68,7 +68,7 @@ Map these to `mergestorm.pr_review/v1` envelope fields; do not invent statuses.
 
 ## Never
 
-- submit a local review job, or call the job-id tools `review_wait` / `review_get` here. Local jobs are `mergestorm-review`'s world: they cost credits and do not fire Vortex on the PR.
+- submit a local review job, or call the job-id tool `review_wait` here. Local jobs are `mergestorm-review`'s world: they cost credits and do not fire Vortex on the PR.
 - land, merge, enqueue, or touch stack authoring beyond adopting the existing PR, or the merge queue
 - change the account `auto_patch_enabled` from this skill, for any reason; Cyclone is muted per stack with `stack_adopt` or `stack_set`, never per account
 - treat the key user's mute or `auto_patch_enabled` as covering a different Cyclone install user