mergestorm 0.3.26 → 0.3.28

package/README.md

@@ -45,12 +45,12 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.26                                             │
+│  ▀▀▀▀▀▀▀▀▀▀▘  mergestorm v0.3.28                                             │
 │ ▀▀▀▀▀▀▀▀▀     ● msk_live_… · maelstrom                                       │
 │  ▀▀▀▀▀▀       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used                      │
 │   ▝▀▀▀▀▀      local reviews + stacked PRs · mergestorm.ai                    │
 │     ▝▀▀▘      review a diff · usage for tabs · /help for all commands        │
-│       ▀       New: stack results say the watch ends only at land             │
+│       ▀       New: mg dismiss records an audited finding dismissal           │
 ╰──────────────────────────────────────────────────────────────────────────────╯
 mergestorm
 ╭──────────────────────────────────────────────────────────────────────────────╮
@@ -96,8 +96,21 @@ mergestorm stack restack <stack-id>  Restack descendants
 mergestorm stack land <stack-id>     Land / promote (into review unit when present)
 mergestorm stack wait <stack-id> [--timeout <s>]  Wait for stack attention (default 45s, max 300s; 0 = one snapshot, no wait)
 mergestorm stack reset --force  Clear local authoring state (not branches/PRs)
+mergestorm dismiss <owner/repo>#<n> --head <sha> --review <id> --preview   List a Vortex review's finding ids and the seam gate
+mergestorm dismiss <owner/repo>#<n> --head <sha> --review <id> --finding <id> --reason <text>  Dismiss verified-wrong findings (`--all` for the whole review, `--evidence <url>`, `--json`)
 ```
 
+### Dismissing a finding
+
+Use `mergestorm dismiss` when a Vortex finding is wrong and you have checked it against the code. It is recorded server side with your GitHub login, the reason, the evidence URL, the scope and the time. Rules:
+
+- You need write access to the repository on GitHub, and the repository must be monitored by your Mergestorm account or the PR must be in one of your stacks.
+- `--head` must be the PR's live head and `--review` a Vortex review made at that head. A moved head, another review, or a finding id that is not in that review is refused, and nothing is written.
+- Retrying the same dismissal is safe; it reports the earlier record.
+- The seam gate clears only when every finding of that integration review is dismissed and the review is still the current seam verdict. CI, other reviews and Auto land policy still apply.
+- Vortex does not raise a dismissed finding again on the same diff (the same head, or a restack with an unchanged diff).
+- With `--json`, the result carries `gate` and, for a stack PR, `watch.next` (the next `stack_wait` call).
+
 `mg` is a short alias for `mergestorm` (same binary), e.g. `mg stack create`. Happy path: **create → commit → submit → restack → land**. On review-unit stacks, `stack land` **promotes** the tip into the unit (same gates as the dashboard); otherwise it lands the bottom open PR. `stack adopt` is for importing a chain that already exists on GitHub (legacy / Graphite). Restack/land use the same login key (`/api/v1/stacks`). Unattended landing is `mg queue add`.
 
 `stack create` checks out a new branch from the current tip (or `--onto <branch>`), discovers trunk (`main` / `master` / `origin/HEAD`, overridable with `--trunk`), and records `{ branch, parentBranch }` in CLI-managed state under **`~/.mergestorm/stacks/<repo-id>/stack.json`**. The CLI updates this automatically; never edit it. Each worktree has its own authoring state; independent clones stay isolated too. Creating onto trunk with a non-empty active stack starts a new one. `--trunk` only sets trunk metadata — it does **not** change the parent; use `--onto main` (etc.) for a fresh stack from trunk.

package/dist/api.d.ts

@@ -267,3 +267,62 @@ export declare function enqueueStack(stackId: string, cfg?: Config): Promise<unk
 export declare function cancelMergeQueueEntry(entryId: string, cfg?: Config): Promise<unknown>;
 /** Recently reviewed branches/threads (Bearer GET /api/v1/threads). */
 export declare function listThreads(limit?: number, cfg?: Config): Promise<ThreadListItem[]>;
+export type PrFindingDismissInput = {
+    owner: string;
+    repo: string;
+    prNumber: number;
+    headSha: string;
+    reviewId: number;
+    findingIds?: string[];
+    scope?: "findings" | "review";
+    reason?: string;
+    evidenceUrl?: string;
+    preview?: boolean;
+};
+export type PrDismissedFinding = {
+    finding_id: string;
+    finding_key: string;
+    path: string | null;
+    line: number | null;
+    title: string;
+};
+export type PrFindingDismissResult = {
+    status: "dismissed" | "preview";
+    owner: string;
+    repo: string;
+    pr_number: number;
+    head_sha: string;
+    review_id: number;
+    review_kind: "seam" | "core";
+    scope: "findings" | "review";
+    dismissed: PrDismissedFinding[];
+    already_dismissed: Array<PrDismissedFinding & {
+        actor_login: string;
+        dismissed_at: string;
+    }>;
+    remaining: PrDismissedFinding[];
+    all_dismissed: boolean;
+    gate: {
+        seam: {
+            state: string;
+            reviewed_sha: string | null;
+            review_id: number | null;
+            cleared: boolean;
+            blocking: boolean;
+        } | null;
+        other_gates: "unchanged";
+    };
+    stack_id: string | null;
+};
+export type PrFindingDismissOutcome = {
+    ok: true;
+    result: PrFindingDismissResult;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+    message: string;
+};
+export declare function dismissPrFindings(input: PrFindingDismissInput, cfg?: Config, opts?: {
+    signal?: AbortSignal;
+}): Promise<PrFindingDismissOutcome>;

package/dist/api.js

@@ -597,3 +597,43 @@ export async function listThreads(limit = 20, cfg) {
     const items = body.items;
     return Array.isArray(items) ? items : [];
 }
+export async function dismissPrFindings(input, cfg, opts) {
+    const resolved = cfg ?? (await loadConfig());
+    const json = {
+        owner: input.owner.trim(),
+        repo: input.repo.trim(),
+        pr_number: input.prNumber,
+        head_sha: input.headSha.trim(),
+        review_id: input.reviewId,
+        ...(input.scope ? { scope: input.scope } : {}),
+        ...(input.findingIds && input.findingIds.length > 0 ? { finding_ids: input.findingIds } : {}),
+        ...(input.reason !== undefined ? { reason: input.reason } : {}),
+        ...(input.evidenceUrl ? { evidence_url: input.evidenceUrl } : {}),
+        ...(input.preview ? { preview: true } : {}),
+    };
+    const { status, body, retryAfterSeconds } = await apiFetch(resolved, "/api/v1/stacks/pr-review/dismiss", {
+        method: "POST",
+        json,
+        signal: opts?.signal,
+    });
+    if (status === 429) {
+        throw new CommandError(rateLimitedMessage(retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", {
+            retryAfterSeconds,
+        });
+    }
+    if (status === 200)
+        return { ok: true, result: body };
+    const rejection = (body ?? {});
+    if (status === 404 && typeof rejection.error !== "string") {
+        throw new CommandError("Finding dismissal is not available on this server yet. Deploy the API update.", REVIEW_EXIT.failed, "not_found");
+    }
+    if (typeof rejection.error === "string") {
+        return {
+            ok: false,
+            status,
+            error: rejection.error,
+            message: typeof rejection.message === "string" ? rejection.message : rejection.error,
+        };
+    }
+    throw new CommandError(`Failed to dismiss findings (HTTP ${status}): ${JSON.stringify(body)}`, REVIEW_EXIT.failed, "review_failed");
+}

package/dist/automation-catalog.d.ts

@@ -18,10 +18,6 @@ export declare const BEARER_SETTINGS: readonly [{
     readonly key: "review_unit_land_prs_enabled";
     readonly flag: "--review-unit-land";
     readonly label: "Review Unit land PRs";
-}, {
-    readonly key: "cyclone_review_unit_land_prs_enabled";
-    readonly flag: "--cyclone-review-unit-land";
-    readonly label: "Cyclone Review Unit land PRs";
 }, {
     readonly key: "cyclone_skip_ci_enabled";
     readonly flag: "--cyclone-skip-ci";
@@ -91,4 +87,4 @@ export type BearerSettingsValues = {
         values: readonly (infer Value)[];
     } ? Value : boolean;
 };
-export declare const BEARER_BOOLEAN_SETTINGS_KEYS: ("auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check")[];
+export declare const BEARER_BOOLEAN_SETTINGS_KEYS: ("auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check")[];

package/dist/automation-catalog.js

@@ -4,7 +4,6 @@ export const BEARER_SETTINGS = [
     { key: "vortex_show_thinking_traces", flag: "--vortex-thinking", label: "Vortex thinking traces" },
     { key: "repo_overview_enabled", flag: "--repo-overview", label: "Repo overview" },
     { key: "review_unit_land_prs_enabled", flag: "--review-unit-land", label: "Review Unit land PRs" },
-    { key: "cyclone_review_unit_land_prs_enabled", flag: "--cyclone-review-unit-land", label: "Cyclone Review Unit land PRs" },
     { key: "cyclone_skip_ci_enabled", flag: "--cyclone-skip-ci", label: "Skip CI on Cyclone commits" },
     { key: "cyclone_patch_unverified_languages", flag: "--cyclone-patch-unverified", label: "Patch languages we cannot typecheck" },
     { key: "vortex_auto_overflow_enabled", flag: "--vortex-auto-overflow", label: "Vortex auto overflow" },

package/dist/client/index.d.ts

@@ -1,11 +1,11 @@
 export { DEFAULT_API, apiBase, clearConfig, configPath, keyDisplay, loadConfig, mergestormHome, resolveApiKey, saveConfig, type Config, } from "../config.js";
 export { BEARER_SETTINGS, BEARER_BOOLEAN_SETTINGS_KEYS, BEARER_SETTINGS_FLAGS, BEARER_SETTINGS_KEYS, BEARER_SETTINGS_LABELS, type BearerSettingsKey, } from "../automation-catalog.js";
-export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, setStackAutoLand, setStackPolicy, stackPolicyBody, type ApiFetchInit, type ApiFetchResult, type JobListItem, type MeResponse, type MergeQueueBounceDetail, type MergeQueueBounceKind, type MergeQueueEnqueuedBy, type MergeQueueEnqueuedVia, type MergeQueueEntryDto, type MergeQueueEntryState, type PrReviewFinding, type PrReviewFindings, type PrVortexReview, type SettingsPatch, type SettingsResponse, type SettingsWritableKey, type StackDto, type StackPolicyPatch, type ThreadDetail, type ThreadListItem, } from "../api.js";
+export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, dismissPrFindings, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, setStackAutoLand, setStackPolicy, stackPolicyBody, type ApiFetchInit, type ApiFetchResult, type JobListItem, type MeResponse, type MergeQueueBounceDetail, type MergeQueueBounceKind, type MergeQueueEnqueuedBy, type MergeQueueEnqueuedVia, type MergeQueueEntryDto, type MergeQueueEntryState, type PrDismissedFinding, type PrFindingDismissInput, type PrFindingDismissOutcome, type PrFindingDismissResult, type PrReviewFinding, type PrReviewFindings, type PrVortexReview, type SettingsPatch, type SettingsResponse, type SettingsWritableKey, type StackDto, type StackPolicyPatch, type ThreadDetail, type ThreadListItem, } from "../api.js";
 export { CommandError, DetachedError, RATE_LIMITED_HINT, REVIEW_EXIT, isCommandErrorCode, rateLimitedMessage, type CommandErrorCode, type CommandErrorExtras, } from "../errors.js";
 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, 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, conflictLiveParent, stackRepair, type StackAgentBusy, type StackBlocker, type StackLandGatePending, type StackLayerAgents, type StackRepairHint, } from "../stack-blockers.js";
+export { stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, conflictLiveParent, stackRepair, agentsCannotClear, type StackAgentBusy, type StackBlocker, type StackBusyAgent, type StackHeldBlocker, type StackLandGatePending, type StackLayerAgents, type StackRepairHint, } from "../stack-blockers.js";
 export { STACK_WATCH_NOT_DONE_SENTENCE, stackTerminalReason, stackWatchNextArgs, stackWatchObligation, type StackWatchDoneReason, type StackWatchNext, type StackWatchNextArgs, type StackWatchObligation, type StackWatchObligationInput, type StackWatchReason, } from "../stack-watch-obligation.js";

package/dist/client/index.js

@@ -1,11 +1,11 @@
 export { DEFAULT_API, apiBase, clearConfig, configPath, keyDisplay, loadConfig, mergestormHome, resolveApiKey, saveConfig, } from "../config.js";
 export { BEARER_SETTINGS, BEARER_BOOLEAN_SETTINGS_KEYS, BEARER_SETTINGS_FLAGS, BEARER_SETTINGS_KEYS, BEARER_SETTINGS_LABELS, } from "../automation-catalog.js";
-export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, setStackAutoLand, setStackPolicy, stackPolicyBody, } from "../api.js";
+export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, dismissPrFindings, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, setStackAutoLand, setStackPolicy, stackPolicyBody, } from "../api.js";
 export { CommandError, DetachedError, RATE_LIMITED_HINT, REVIEW_EXIT, isCommandErrorCode, rateLimitedMessage, } from "../errors.js";
 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, 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, conflictLiveParent, stackRepair, } from "../stack-blockers.js";
+export { stackBlockers, stackBlockersSummary, sameHead, layerAgents, layerAgentsBusy, conflictLiveParent, stackRepair, agentsCannotClear, } from "../stack-blockers.js";
 export { STACK_WATCH_NOT_DONE_SENTENCE, stackTerminalReason, stackWatchNextArgs, stackWatchObligation, } from "../stack-watch-obligation.js";

package/dist/commands/browse.d.ts

@@ -27,7 +27,7 @@ export declare function buildStatusTabLines(input: StatusTabInput): string[];
 /** In-place job detail for the Jobs tab (same envelope as `status <id>`). */
 export declare function formatJobDetailLines(row: ReviewJobRow): string[];
 /** Human labels for the Config tab and the static `settings` printout. */
-export declare const SETTINGS_LABELS: Record<"auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check", string>;
+export declare const SETTINGS_LABELS: Record<"auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check", string>;
 /** Config rows in a stable order: writable toggles, then connected flags. */
 export declare function buildConfigRows(settings: SettingsResponse): TabsConfigRow[];
 /**

package/dist/commands/dismiss.d.ts

@@ -0,0 +1,15 @@
+import { type PrFindingDismissInput, type PrFindingDismissOutcome, type PrFindingDismissResult } from "../api.js";
+import { type Config } from "../config.js";
+import { type StackWatchObligation } from "../stack-watch-obligation.js";
+export declare const DISMISS_USAGE: string;
+export type ParsedDismissArgs = PrFindingDismissInput & {
+    json: boolean;
+};
+export declare function parseDismissArgs(args: string[]): ParsedDismissArgs;
+export declare function dismissWatch(result: PrFindingDismissResult): StackWatchObligation | null;
+export declare function formatDismissResult(result: PrFindingDismissResult, watch: StackWatchObligation | null): string;
+export type DismissDeps = {
+    loadConfig?: () => Promise<Config>;
+    dismiss?: (input: PrFindingDismissInput, cfg: Config) => Promise<PrFindingDismissOutcome>;
+};
+export declare function cmdDismiss(args: string[], deps?: DismissDeps): Promise<void>;

package/dist/commands/dismiss.js

@@ -0,0 +1,145 @@
+import { dismissPrFindings, } from "../api.js";
+import { loadConfig } from "../config.js";
+import { CommandError, REVIEW_EXIT } from "../errors.js";
+import { stackWatchObligation } from "../stack-watch-obligation.js";
+import { parseAdoptTarget, withWatch } from "./stack.js";
+export const DISMISS_USAGE = [
+    "usage: mergestorm dismiss <owner/repo>#<n> --head <sha> --review <id>",
+    "         (--finding <id> [--finding <id>…] | --all) --reason <text> [--evidence <url>] [--json]",
+    "       mergestorm dismiss <owner/repo>#<n> --head <sha> --review <id> --preview [--json]",
+].join("\n");
+function usage(message) {
+    return new CommandError(message ? `${message}\n${DISMISS_USAGE}` : DISMISS_USAGE, REVIEW_EXIT.usage, "usage");
+}
+export function parseDismissArgs(args) {
+    const target = [];
+    const findingIds = [];
+    let headSha = "";
+    let reviewId;
+    let reason;
+    let evidenceUrl;
+    let all = false;
+    let preview = false;
+    let json = false;
+    const value = (flag, raw) => {
+        if (raw === undefined || raw.startsWith("--"))
+            throw usage(`${flag} needs a value`);
+        return raw;
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--head")
+            headSha = value(arg, args[++i]).trim().toLowerCase();
+        else if (arg === "--review") {
+            const raw = value(arg, args[++i]).trim();
+            if (!/^[1-9]\d*$/.test(raw) || !Number.isSafeInteger(Number(raw)))
+                throw usage("--review needs the numeric GitHub review id");
+            reviewId = Number(raw);
+        }
+        else if (arg === "--finding")
+            findingIds.push(...value(arg, args[++i]).split(",").map((id) => id.trim()).filter(Boolean));
+        else if (arg === "--all")
+            all = true;
+        else if (arg === "--reason")
+            reason = value(arg, args[++i]);
+        else if (arg === "--evidence")
+            evidenceUrl = value(arg, args[++i]).trim();
+        else if (arg === "--preview")
+            preview = true;
+        else if (arg === "--json")
+            json = true;
+        else if (arg.startsWith("--"))
+            throw usage(`unknown flag ${arg}`);
+        else
+            target.push(arg);
+    }
+    let parsedTarget;
+    try {
+        parsedTarget = parseAdoptTarget(target);
+    }
+    catch {
+        throw usage("name the PR as <owner/repo>#<n>");
+    }
+    if (!/^[0-9a-f]{40}$/.test(headSha))
+        throw usage("--head needs the full 40-character PR head SHA");
+    if (reviewId === undefined)
+        throw usage("--review is required");
+    if (!preview) {
+        if (all && findingIds.length > 0)
+            throw usage("pass --finding or --all, not both");
+        if (!all && findingIds.length === 0)
+            throw usage("pass --finding <id> for each finding, or --all for the whole review");
+        if (!reason?.trim())
+            throw usage("--reason is required: say why the finding is wrong or not actionable");
+    }
+    return {
+        ...parsedTarget,
+        headSha,
+        reviewId,
+        findingIds: all ? [] : findingIds,
+        scope: all ? "review" : "findings",
+        ...(reason !== undefined ? { reason } : {}),
+        ...(evidenceUrl ? { evidenceUrl } : {}),
+        preview,
+        json,
+    };
+}
+export function dismissWatch(result) {
+    if (!result.stack_id)
+        return null;
+    return stackWatchObligation({ stackId: result.stack_id, terminal: null, unread: true, freshCursor: true });
+}
+function findingLine(finding) {
+    const where = finding.path ? `${finding.path}${finding.line ? `:${finding.line}` : ""}` : "review body";
+    return `  ${finding.finding_id}  ${where}  ${finding.title}`;
+}
+export function formatDismissResult(result, watch) {
+    const lines = [];
+    const pr = `${result.owner}/${result.repo}#${result.pr_number}`;
+    const kind = result.review_kind === "seam" ? "seam review" : "Vortex review";
+    if (result.status === "preview") {
+        lines.push(`${pr} ${kind} ${result.review_id} at ${result.head_sha.slice(0, 7)}: ${result.remaining.length} open finding(s)`);
+        lines.push(...result.remaining.map(findingLine));
+    }
+    else {
+        lines.push(`${pr} ${kind} ${result.review_id} at ${result.head_sha.slice(0, 7)}`);
+        if (result.dismissed.length)
+            lines.push("Dismissed:", ...result.dismissed.map(findingLine));
+        if (result.already_dismissed.length) {
+            lines.push("Already dismissed:", ...result.already_dismissed.map((f) => `${findingLine(f)}  (by @${f.actor_login})`));
+        }
+        if (result.remaining.length)
+            lines.push("Still open:", ...result.remaining.map(findingLine));
+    }
+    const seam = result.gate.seam;
+    if (seam) {
+        lines.push(seam.cleared
+            ? "Seam gate: cleared (approved at this head). CI, other reviews and Auto land policy still apply."
+            : seam.blocking
+                ? `Seam gate: still blocking (seam_state=${seam.state}).`
+                : `Seam gate: not blocking (seam_state=${seam.state}).`);
+    }
+    if (watch?.next)
+        lines.push(`Next: ${watch.next.command}`);
+    return lines.join("\n");
+}
+export async function cmdDismiss(args, deps = {}) {
+    const parsed = parseDismissArgs(args);
+    const cfg = await (deps.loadConfig ?? loadConfig)();
+    const { json, ...input } = parsed;
+    const outcome = await (deps.dismiss ?? ((i, c) => dismissPrFindings(i, c)))(input, cfg);
+    if (!outcome.ok) {
+        if (json) {
+            console.log(JSON.stringify({ error: { code: outcome.error, message: outcome.message } }, null, 2));
+            process.exitCode = REVIEW_EXIT.failed;
+            return;
+        }
+        throw new CommandError(`Dismissal refused (${outcome.error}): ${outcome.message}`, REVIEW_EXIT.failed, "review_failed");
+    }
+    const watch = dismissWatch(outcome.result);
+    if (json) {
+        console.log(JSON.stringify(withWatch(outcome.result, watch), null, 2));
+        return;
+    }
+    console.log(formatDismissResult(outcome.result, watch));
+}

package/dist/commands/registry.js

@@ -3,6 +3,7 @@ import { CommandError } from "../errors.js";
 import { cmdBranches, cmdChain } from "./branches.js";
 import { canBrowse, openTabsBrowser } from "./browse.js";
 import { cmdCredits } from "./credits.js";
+import { cmdDismiss } from "./dismiss.js";
 import { cmdJobs, cmdThread } from "./jobs.js";
 import { cmdLogin } from "./login.js";
 import { cmdLogout } from "./logout.js";
@@ -79,6 +80,21 @@ export const COMMAND_REGISTRY = [
             });
         },
     },
+    {
+        name: "dismiss",
+        summary: "Dismiss Vortex findings you verified are wrong (audited)",
+        usage: [
+            "mergestorm dismiss <owner/repo>#<n> --head <sha> --review <id> --preview",
+            "  Lists the review's findings (ids) and the seam gate; writes nothing",
+            "mergestorm dismiss <owner/repo>#<n> --head <sha> --review <id> --finding <id> --reason <text>",
+            "  [--finding <id>]… | --all (every finding of that review)  [--evidence <url>] [--json]",
+            "  Needs write access on GitHub; refuses a moved head, another review or an unknown id",
+            "  Clears the seam gate only when every finding of that seam review is dismissed",
+        ],
+        async run(args) {
+            await cmdDismiss(args);
+        },
+    },
     {
         name: "status",
         summary: "Job panel (id) or Status / Usage / Jobs tabs",
@@ -165,7 +181,7 @@ export const COMMAND_REGISTRY = [
             "mergestorm settings [--json]    Read the automation toggles (Config tab on a TTY)",
             "  [--auto-review on|off] [--auto-patch on|off] [--vortex-thinking on|off]",
             "  [--repo-overview on|off] [--review-unit-land on|off]",
-            "  [--cyclone-review-unit-land on|off] [--cyclone-skip-ci on|off]",
+            "  [--cyclone-skip-ci on|off]",
             "  [--cyclone-patch-unverified on|off]  Patch languages we cannot typecheck",
             "  [--vortex-seam on|off] [--vortex-skip-all-clear on|off]",
             "  [--auto-land on|off]  Auto land default for new stacks",

package/dist/commands/settings.d.ts

@@ -3,7 +3,7 @@ import { type SettingsPatch, type SettingsResponse } from "../api.js";
  * CLI flag → Bearer settings key. Boolean flags take on|off. The connected flags are
  * read-only on the API and deliberately have no flag here.
  */
-export declare const SETTINGS_FLAGS: Record<string, "auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check">;
+export declare const SETTINGS_FLAGS: Record<string, "auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_skip_ci_enabled" | "cyclone_patch_unverified_languages" | "vortex_auto_overflow_enabled" | "vortex_skip_all_clear_comments" | "vortex_seam_specialist_enabled" | "auto_land_default" | "auto_land_settle_seconds" | "ignored_bot_logins" | "vortex_bot_skip_check" | "vortex_findings_check" | "cyclone_patch_failure_check">;
 type IgnoreBotOperation = {
     action: "add" | "remove";
     login: string;

package/dist/commands/stack.d.ts

@@ -1,4 +1,4 @@
-import { type StackRepairHint } from "../stack-blockers.js";
+import { type StackHeldBlocker, type StackRepairHint } from "../stack-blockers.js";
 import { type StackWatchObligation } from "../stack-watch-obligation.js";
 import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, listStacks, openStackPull, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
 import { loadConfig } from "../config.js";
@@ -9,6 +9,7 @@ import { buildPrBodyFromCommit } from "../pr-body.js";
 import { gitTopLevel } from "../repo-identity.js";
 import { loadStackMeta, saveStackMeta } from "../stack-meta.js";
 import { pollStackWatch } from "../stack-watch.js";
+export declare function stackHeldLine(held: StackHeldBlocker | null | undefined): string[];
 export declare function stackRepairLine(repair: StackRepairHint | null | undefined): string[];
 export declare function stackWatchTextLines(watch: StackWatchObligation | null | undefined): string[];
 export declare function openStackWatch(stackId: string, opts?: {

package/dist/commands/stack.js

@@ -16,6 +16,12 @@ import { runLineTabsBrowser } from "../ui/line-tabs.js";
 import { present } from "../ui/present.js";
 import { canBrowse } from "./browse.js";
 import { openHelpBrowser } from "./help.js";
+export function stackHeldLine(held) {
+    if (!held)
+        return [];
+    const agents = held.waitingOn.map((agent) => agent === "cyclone" ? "Cyclone" : "Vortex").join(" and ");
+    return [`Held: #${held.prNumber} ${held.blocker}. Plan the fix; act once ${agents} ${held.waitingOn.length > 1 ? "are" : "is"} idle and the watch returns attention.`];
+}
 export function stackRepairLine(repair) {
     if (!repair)
         return [];
@@ -895,7 +901,7 @@ export async function cmdStackWait(args, deps = {}) {
             ...(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.busy, envelope.landGatePending ?? null)}${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.landGatePending ?? null, envelope.actAfter ?? null)}${envelope.assessment === "unavailable" ? " · assessment unavailable" : ""}`,
             ...stackRepairLine(envelope.repair),
             ...stackWatchTextLines(envelope.watch),
         ].join("\n"));
@@ -939,7 +945,7 @@ export async function cmdStackStatus(args, deps = {}) {
         console.log(watch.message);
         throw new CommandError(`Stack not found or not owned by the current user: ${stackId}`, 1, "not_found");
     }
-    const { attention, currentCandidate, repair } = stackBlockers(stack);
+    const { attention, held, currentCandidate, repair } = stackBlockers(stack);
     const watch = stackWatchObligation({
         stackId: stack.id,
         terminal: stackTerminalReason(stack),
@@ -948,7 +954,7 @@ export async function cmdStackStatus(args, deps = {}) {
         freshCursor: true,
     });
     if (asJson) {
-        console.log(JSON.stringify({ ...stack, repair, watch }, null, 2));
+        console.log(JSON.stringify({ ...stack, held, repair, watch }, null, 2));
         return;
     }
     const lines = formatStackHuman(stack, false);
@@ -961,7 +967,7 @@ export async function cmdStackStatus(args, deps = {}) {
             (layer.cycloneStatus ? `  Cyclone: ${layer.cycloneStatus}` : "") +
             (layer.tempestStatus ? `  Tempest: ${layer.tempestStatus}` : ""));
     }
-    lines.push(...[...stackRepairLine(repair), ...stackWatchTextLines(watch)].map((line) => `  ${line}`));
+    lines.push(...[...stackHeldLine(held), ...stackRepairLine(repair), ...stackWatchTextLines(watch)].map((line) => `  ${line}`));
     await present("Stack status", lines);
 }
 /** Human summary lines for a `stack set` write, one per flag. */

package/dist/stack-blockers.d.ts

@@ -12,6 +12,11 @@ export type StackAgentBusy = {
     agent: "vortex" | "cyclone";
     blocker: string;
 };
+export type StackBusyAgent = StackAgentBusy["agent"];
+export type StackHeldBlocker = StackBlocker & {
+    actAfter: "agents_idle";
+    waitingOn: StackBusyAgent[];
+};
 export type StackLayerAgents = {
     prNumber: number;
     headSha: string | null;
@@ -42,6 +47,20 @@ export type StackRepairHint = {
     branch: string;
     failingCheck: string | null;
     steps: string;
+} | {
+    kind: "tempest_findings";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    findings: string;
+    steps: string;
+} | {
+    kind: "auto_land_off";
+    prNumber: number;
+    headSha: string | null;
+    branch: string;
+    bounceKind: string;
+    steps: string;
 };
 export type StackLandGatePending = {
     prNumber: number;
@@ -54,14 +73,32 @@ 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;
+export declare function mergeabilityPending(layer: StackLayerDto): boolean;
 export declare function sameHead(a: string | null | undefined, b: string | null | undefined): boolean;
 export declare function currentLayer(stack: StackDto): StackLayerDto | undefined;
+export declare const SEAM_REVIEW_NOT_RUNNING = "Seam review pending, no review running";
+export declare const VORTEX_REVIEW_OUT_OF_QUOTA = "Review skipped, out of review quota";
 export declare function conflictLiveParent(stack: StackDto, layer: StackLayerDto): string | null;
 export declare function conflictRepairSteps(branch: string, liveParent: string | null): string;
+export declare function agentsCannotClear(blocker: string): boolean;
 export declare function stackRepair(stack: StackDto, attention: StackBlocker | null, layer: StackLayerDto | undefined, bounce: MergeQueueEntryDto | undefined): StackRepairHint | null;
 /** Pair-gate attention plus live hard blocks on every other open layer. */
 export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntryDto[], cursor?: Pick<StackWatchCursor, "bounceId" | "afterFinishedAt">): {
+    attention: null;
+    held: StackHeldBlocker;
+    issues: StackBlocker[];
+    currentCandidate: {
+        prNumber: number;
+        headSha: string | null;
+    } | null;
+    bounce: undefined;
+    busy: StackAgentBusy[];
+    agents: StackLayerAgents | null;
+    repair: StackRepairHint | null;
+    landGatePending: StackLandGatePending | null;
+} | {
     attention: StackBlocker | null;
+    held: null;
     issues: StackBlocker[];
     currentCandidate: {
         prNumber: number;
@@ -74,4 +111,4 @@ export declare function stackBlockers(stack: StackDto, entries?: MergeQueueEntry
     landGatePending: StackLandGatePending | null;
 };
 /** Compact contract text shared by status and wait summaries. */
-export declare function stackBlockersSummary(attention: Pick<StackBlocker, "prNumber" | "blocker"> | null, issues: StackBlocker[], busy?: readonly StackAgentBusy[], landGatePending?: Pick<StackLandGatePending, "prNumber" | "reason"> | null): string;
+export declare function stackBlockersSummary(attention: Pick<StackBlocker, "prNumber" | "blocker"> | null, issues: StackBlocker[], busy?: readonly StackAgentBusy[], landGatePending?: Pick<StackLandGatePending, "prNumber" | "reason"> | null, actAfter?: StackHeldBlocker["actAfter"] | null): string;

package/dist/stack-blockers.js

@@ -30,6 +30,12 @@ export function boundDirty(layer) {
     return (!layer.headSha || layer.mergeableHeadSha === layer.headSha) &&
         (layer.mergeable === false || layer.mergeableState?.toLowerCase() === "dirty");
 }
+export function mergeabilityPending(layer) {
+    if (isMgParkBase(layer.parentBranch))
+        return false;
+    return layer.mergeable == null && !!layer.headSha && layer.mergeableHeadSha === layer.headSha &&
+        layer.mergeableState?.toLowerCase() === "pending";
+}
 export function sameHead(a, b) {
     const left = a?.trim().toLowerCase();
     const right = b?.trim().toLowerCase();
@@ -45,6 +51,13 @@ 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);
 }
+export const SEAM_REVIEW_NOT_RUNNING = "Seam review pending, no review running";
+export const VORTEX_REVIEW_OUT_OF_QUOTA = "Review skipped, out of review quota";
+function quotaSkippedReview(layer) {
+    const review = layer.vortexReview;
+    return review?.status === "skipped" && review.skip_reason === "quota_exceeded" &&
+        sameHead(review.head_sha, layer.headSha);
+}
 function seamGateBlocker(stack, layer) {
     const members = stack.unit?.members ?? [];
     if (layer.prNumber === stack.unit?.landPrNumber)
@@ -59,6 +72,8 @@ function seamGateBlocker(stack, layer) {
         return "Seam review failed";
     if (seamState === "findings" && sameHead(member.seamReviewedSha, layer.headSha))
         return "Seam findings";
+    if (seamState === "pending" && !layerAgentsBusy(layer).vortex)
+        return SEAM_REVIEW_NOT_RUNNING;
     return null;
 }
 /** Shared live-fact precedence; bounce history is only passed for the candidate. */
@@ -92,12 +107,17 @@ function layerAttention(stack, layer, queue, cursor) {
             const name = layer.checks?.failingName?.trim();
             return hardBlock(`CI failed${name ? ` — ${name}` : ""}`);
         }
+        if (layer.agentRuns?.some((run) => run.agent === "cyclone" && run.status === "failed" &&
+            sameHead(run.sha, layer.headSha)))
+            return hardBlock("Cyclone failed");
         const tempest = layer.agentRuns?.find((run) => run.agent === "tempest" &&
             ["findings", "failed"].includes(run.status) && sameHead(run.sha, layer.headSha));
         if (tempest)
             return hardBlock(`Tempest ${tempest.status}`);
         if (layer.vortexStatus === "failed")
             return hardBlock("Review failed");
+        if (quotaSkippedReview(layer))
+            return hardBlock(VORTEX_REVIEW_OUT_OF_QUOTA);
         const seam = seamGateBlocker(stack, layer);
         if (seam)
             return hardBlock(seam);
@@ -120,6 +140,27 @@ function layerAttention(stack, layer, queue, cursor) {
         return none;
     return { blocker: mergeQueueBounceLabel(bounce), bounceKind: kind, bounce };
 }
+const AUTO_LAND_DISARMING_BOUNCE_KINDS = ["merge_failed", "gh_error", "ci_timeout"];
+const AUTO_LAND_OFF_BLOCKER_PREFIX = "Auto land off after ";
+function isDisarmingBounce(entry) {
+    const kind = entry?.bounceDetail?.kind;
+    return entry?.state === "bounced" && !!kind && AUTO_LAND_DISARMING_BOUNCE_KINDS.includes(kind);
+}
+function disarmingBounce(stack, queue) {
+    if (stack.archivedAt || stack.autoEnqueueWhenReady !== false)
+        return undefined;
+    const byRecency = [...queue].sort((a, b) => (Date.parse(b.enqueuedAt) || 0) - (Date.parse(a.enqueuedAt) || 0) ||
+        (Date.parse(b.finishedAt ?? "") || 0) - (Date.parse(a.finishedAt ?? "") || 0));
+    if (stack.autoLandOff === undefined) {
+        return isDisarmingBounce(byRecency[0]) ? byRecency[0] : undefined;
+    }
+    if (stack.autoLandOff?.reason !== "bounced")
+        return undefined;
+    const recorded = queue.find((entry) => entry.id === stack.autoLandOff?.entryId);
+    if (isDisarmingBounce(recorded))
+        return recorded;
+    return undefined;
+}
 function isTerminalLayer(layer) {
     return layer.state === "merged" || layer.state === "closed";
 }
@@ -156,15 +197,27 @@ export function conflictRepairSteps(branch, liveParent) {
     }
     return `Merge ${liveParent} into ${branch}: git fetch origin, check out ${branch} at its live remote head, git merge origin/${liveParent}, resolve the conflicts, run the tests, then an ordinary git push (no force). Do not rebase onto trunk, main, or mg-park-*, and do not retarget the PR base.`;
 }
+function landPrLiveParent(stack, layer) {
+    const base = stack.unit?.landTarget?.trim() || layer.parentBranch?.trim();
+    return base && !isMgParkBase(base) && base !== layer.branch ? base : null;
+}
+export function agentsCannotClear(blocker) {
+    return blocker === "Conflict" || blocker === "Restack failed" || blocker === "Draft PR" ||
+        blocker === SEAM_REVIEW_NOT_RUNNING || blocker === VORTEX_REVIEW_OUT_OF_QUOTA || blocker.startsWith("Merge conflicts");
+}
+function isTempestFindingsBlocker(attention) {
+    const blocker = attention.blocker.trim();
+    return attention.bounceKind === "tempest_findings" || /^Tempest findings\b/i.test(blocker) ||
+        /^(?:landing blocked:\s*)?tempest_findings\b/i.test(blocker);
+}
 export function stackRepair(stack, attention, layer, bounce) {
     if (!attention || !layer || attention.prNumber !== layer.prNumber)
         return null;
-    if (stack.unit && layer.prNumber === stack.unit.landPrNumber && layer.branch === stack.unit.branch)
-        return null;
+    const landPr = !!stack.unit?.branch && layer.prNumber === stack.unit.landPrNumber && layer.branch === stack.unit.branch;
     const restackConflict = attention.blocker === "Conflict" || attention.bounceKind === "restack_conflict";
     const mergeConflict = attention.blocker.startsWith("Merge conflicts");
     if (restackConflict || mergeConflict) {
-        const liveParent = conflictLiveParent(stack, layer);
+        const liveParent = landPr ? landPrLiveParent(stack, layer) : conflictLiveParent(stack, layer);
         return {
             kind: restackConflict ? "restack_conflict" : "merge_conflict",
             prNumber: layer.prNumber,
@@ -175,6 +228,27 @@ export function stackRepair(stack, attention, layer, bounce) {
             steps: conflictRepairSteps(layer.branch, liveParent),
         };
     }
+    if (attention.blocker.startsWith(AUTO_LAND_OFF_BLOCKER_PREFIX) && attention.bounceKind) {
+        return {
+            kind: "auto_land_off",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            bounceKind: attention.bounceKind,
+            steps: `The ${attention.bounceKind} bounce turned Auto land off, so nothing will enqueue this stack. Fix the cause of the bounce on ${layer.branch}, then turn Auto land back on (mg stack set ${stack.id} --auto-land on) or enqueue the stack.`,
+        };
+    }
+    if (landPr && isTempestFindingsBlocker(attention)) {
+        const findings = `gh api repos/${stack.owner}/${stack.repo}/issues/${layer.prNumber}/comments`;
+        return {
+            kind: "tempest_findings",
+            prNumber: layer.prNumber,
+            headSha: layer.headSha ?? null,
+            branch: layer.branch,
+            findings,
+            steps: `Tempest never patches, and Cyclone is not patching this land PR. Read the Tempest report on it (${findings}), verify each finding against ${layer.branch} at its live remote head, fix the real ones with the smallest patch on ${layer.branch}, run the tests, confirm the remote head is still ${layer.headSha ?? "the head you started from"}, then an ordinary git push (no force). Do not retarget the PR base.`,
+        };
+    }
     if (attention.blocker.startsWith("CI failed") || attention.bounceKind === "ci_failure") {
         const failingCheck = bounce?.bounceDetail?.failingCheck?.trim() || layer.checks?.failingName?.trim() || null;
         return {
@@ -206,15 +280,31 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
     const issues = [];
     for (const layer of open) {
         const selected = layer.prNumber === candidate?.prNumber;
-        const result = layerAttention(stack, layer, selected ? queue : [], cursor);
-        if (!result.blocker)
+        let result = layerAttention(stack, layer, selected ? queue : [], cursor);
+        let disarmed;
+        if (!result.blocker && selected) {
+            disarmed = disarmingBounce(stack, queue);
+            if (disarmed) {
+                const kind = disarmed.bounceDetail.kind;
+                result = { blocker: `${AUTO_LAND_OFF_BLOCKER_PREFIX}${kind} bounce`, bounceKind: kind, bounce: disarmed };
+            }
+        }
+        if (!result.blocker) {
+            if (mergeabilityPending(layer) && (selected || !candidate || layer.position > candidate.position)) {
+                issues.push({ prNumber: layer.prNumber, headSha: layer.headSha ?? null,
+                    blocker: `Merge state unknown${layer.parentBranch ? ` vs ${layer.parentBranch}` : ""}`, bounceKind: null });
+            }
             continue;
+        }
         const issue = { prNumber: layer.prNumber, headSha: layer.headSha ?? null,
             blocker: result.blocker, bounceKind: result.bounceKind };
         if (selected || (!attention && layer === child)) {
             attention = issue;
             attentionLayer = layer;
             bounce = result.bounce;
+            if (disarmed)
+                issues.push({ prNumber: disarmed.bounceDetail?.prNumber ?? layer.prNumber,
+                    headSha: disarmed.bounceDetail?.headSha ?? null, blocker: mergeQueueBounceLabel(disarmed), bounceKind: result.bounceKind });
         }
         else if (!candidate || layer.position > candidate.position)
             issues.push(issue);
@@ -235,19 +325,28 @@ export function stackBlockers(stack, entries = [], cursor = {}) {
     const landGatePending = landLayer && landing && landGateIsPending(landing)
         ? { prNumber: landLayer.prNumber, headSha: landLayer.headSha ?? null, reason: landing }
         : null;
+    if (busy.length && attention && agentsCannotClear(attention.blocker)) {
+        const held = { ...attention, actAfter: "agents_idle", waitingOn: busy.map((entry) => entry.agent) };
+        return { attention: null, held, issues: [attention, ...issues], currentCandidate, bounce: undefined, busy, agents,
+            repair: stackRepair(stack, attention, attentionLayer, undefined), landGatePending };
+    }
     if (busy.length)
-        return { attention: null, issues, currentCandidate, bounce: undefined, busy, agents, repair: null, landGatePending };
-    return { attention, issues, currentCandidate, bounce, busy, agents, repair: stackRepair(stack, attention, attentionLayer, bounce), landGatePending };
+        return { attention: null, held: null, issues, currentCandidate, bounce: undefined, busy, agents, repair: null, landGatePending };
+    return { attention, held: null, issues, currentCandidate, bounce, busy, agents, repair: stackRepair(stack, attention, attentionLayer, bounce), landGatePending };
 }
 /** Compact contract text shared by status and wait summaries. */
-export function stackBlockersSummary(attention, issues, busy = [], landGatePending = null) {
-    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 ")}`
+export function stackBlockersSummary(attention, issues, busy = [], landGatePending = null, actAfter = null) {
+    const agentWork = (entry) => entry.agent === "cyclone" ? "Cyclone patches" : "Vortex reviews";
+    const blocked = attention && actAfter && busy.length
+        ? ` · blocked after the agents: #${attention.prNumber} ${attention.blocker} (plan the fix; act once ${busy.map(agentWork).join(" and ")} finish and the watch returns attention)`
+        : attention ? ` · blocked: #${attention.prNumber} ${attention.blocker}` : "";
+    const working = busy.length && !actAfter
+        ? ` · held: #${busy[0].prNumber} ${busy[0].blocker} while ${busy.map(agentWork).join(" and ")}`
         : "";
-    const labels = issues.slice(0, 3).map(issue => `#${issue.prNumber} ${issue.blocker}`).join("; ");
+    const listed = actAfter && attention ? issues.filter((issue) => issue.prNumber !== attention.prNumber || issue.blocker !== attention.blocker) : issues;
+    const labels = listed.slice(0, 3).map(issue => `#${issue.prNumber} ${issue.blocker}`).join("; ");
     const gate = landGatePending && !attention
         ? ` · land gate: #${landGatePending.prNumber} ${landGatePending.reason} (nothing to fix; wait)`
         : "";
-    return blocked + working + gate + (issues.length ? ` · issues: ${labels}${issues.length > 3 ? `; +${issues.length - 3} more` : ""}` : "");
+    return blocked + working + gate + (listed.length ? ` · issues: ${labels}${listed.length > 3 ? `; +${listed.length - 3} more` : ""}` : "");
 }

package/dist/stack-dto.d.ts

@@ -27,6 +27,8 @@ export declare function restackRetryPending(error: {
  * `api/src/stacks.ts#loadStackDtos` is the producer. Keep this file
  * dependency-free and byte-for-byte aligned with the canonical wire contract.
  */
+export declare const AUTO_LAND_OFF_REASONS: readonly ["user", "archive", "watcher", "cancelled", "landed", "bounced"];
+export type AutoLandOffReason = (typeof AUTO_LAND_OFF_REASONS)[number];
 export type StackBranchState = "clean" | "needs_restack" | "restacking" | "conflict" | "merged" | "closed";
 export type StackCiStatus = "success" | "pending" | "failure" | "neutral" | "none" | "unknown";
 export type StackReviewStatus = "approved" | "changes_requested" | "reviewed" | "failed" | "none" | "unknown";
@@ -118,6 +120,7 @@ export type StackLayerChecks = {
     pending: number;
     failure: number;
     failingName: string | null;
+    selfHosted?: number;
     /**
      * True when the persisted `ci_checks` carries a `namedRuns` seed (enrich
      * writes it so CI webhook deliveries fold into the snapshot). Pre-seeding
@@ -158,6 +161,14 @@ export type StackLayerConflictResolution = {
      */
     dispatchId: string | null;
 };
+export type StackLayerCiFixStatus = "verified" | "unverified" | "no_changes" | "failed";
+export type StackLayerCiFix = {
+    status: StackLayerCiFixStatus;
+    failingCheck: string | null;
+    resultSha: string | null;
+    reason: string | null;
+    at: string;
+};
 export type StackLayerDto = {
     branch: string;
     parentBranch: string | null;
@@ -232,6 +243,7 @@ export type StackLayerDto = {
      * layers and when the specialist never ran.
      */
     conflictResolution?: StackLayerConflictResolution | null;
+    ciFix?: StackLayerCiFix | null;
 };
 export type StackUnitMemberDto = {
     prNumber: number;
@@ -306,6 +318,11 @@ export type StackDto = {
      * Missing on older payloads is off.
      */
     autoEnqueueWhenReady?: boolean;
+    autoLandOff?: {
+        reason: AutoLandOffReason;
+        entryId: string | null;
+        at: string;
+    } | null;
     /**
      * Auto land Settling certificate. The stacks watcher publishes the identity
      * of the settle clock it actually started (action, exact PR and head, server
@@ -374,6 +391,7 @@ export type MergeQueueBounceDetail = {
     conflictDetail?: string;
     conflictPaths?: string[];
     message?: string;
+    warning?: string;
 };
 export type MergeQueueEntryDto = {
     id: string;

package/dist/stack-dto.js

@@ -16,6 +16,13 @@ export function restackRetryPending(error, layer) {
         return false;
     return !/\(origin\/\S+ moved to /.test(error.detail) && pushRejectionIsRetryable(error.detail);
 }
+/**
+ * Wire types returned by the stack list/enrich HTTP endpoints.
+ *
+ * `api/src/stacks.ts#loadStackDtos` is the producer. Keep this file
+ * dependency-free and byte-for-byte aligned with the canonical wire contract.
+ */
+export const AUTO_LAND_OFF_REASONS = ["user", "archive", "watcher", "cancelled", "landed", "bounced"];
 export const STACK_AGENT_QUEUED_STALE_MS = 15 * 60 * 1000;
 function agentShaMayBeHead(sha, head) {
     const left = sha?.trim().toLowerCase();

package/dist/stack-watch.d.ts

@@ -1,4 +1,4 @@
-import { type StackAgentBusy, type StackBlocker, type StackLayerAgents, type StackLandGatePending, type StackRepairHint } from "./stack-blockers.js";
+import { type StackAgentBusy, type StackBlocker, type StackBusyAgent, type StackHeldBlocker, type StackLayerAgents, type StackLandGatePending, type StackRepairHint } from "./stack-blockers.js";
 import { type StackWatchObligation } from "./stack-watch-obligation.js";
 import { apiFetch } from "./api.js";
 import type { Config } from "./config.js";
@@ -28,6 +28,8 @@ export type StackWatchEnvelope = {
     } | null;
     assessment: "available" | "unavailable";
     busy: StackAgentBusy[];
+    actAfter: StackHeldBlocker["actAfter"] | null;
+    waitingOn: StackBusyAgent[];
     agents: StackLayerAgents | null;
     repair: StackRepairHint | null;
     landGatePending: StackLandGatePending | null;

package/dist/stack-watch.js

@@ -48,7 +48,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", busy: [], agents: null, repair: null,
+        issues: [], currentCandidate: null, assessment: "unavailable", busy: [], actAfter: null, waitingOn: [], agents: null, repair: null,
         landGatePending: null,
     };
     let terminal = null;
@@ -119,7 +119,7 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
             : undefined;
         if (snapshot && Array.isArray(snapshot.stacks) && !stack) {
             terminal = "not_found";
-            throw new StackWatchError("Stack not found or not owned by the current user", seal({ ...lastEnvelope, status: "failed", assessment: "unavailable", blocker: null, issues: [], busy: [],
+            throw new StackWatchError("Stack not found or not owned by the current user", seal({ ...lastEnvelope, status: "failed", assessment: "unavailable", blocker: null, issues: [], busy: [], actAfter: null, waitingOn: [],
                 prNumber: null, headSha: null, repair: null, agents: null, currentCandidate: null, landGatePending: null }));
         }
         if (!stack || !Array.isArray(stack.layers)) {
@@ -140,15 +140,17 @@ export async function pollStackWatch(cfg, stackId, opts = {}) {
         };
     };
     const evaluate = (stack, entries) => {
-        const { attention, issues, currentCandidate, bounce, busy, agents, repair, landGatePending } = stackBlockers(stack, entries, cursor);
+        const { attention, held: named, issues, currentCandidate, bounce, busy, agents, repair, landGatePending } = stackBlockers(stack, entries, cursor);
         if (bounce)
             cursor = Object.freeze({ ...cursor, bounceId: bounce.id,
                 ...(bounce.finishedAt !== undefined ? { afterFinishedAt: bounce.finishedAt } : {}) });
         const held = busy[0];
+        const shown = attention ?? named;
         lastEnvelope = { ...lastEnvelope, cursor, issues, currentCandidate, assessment: "available", busy, agents, repair, landGatePending,
-            blocker: attention?.blocker ?? null, bounceKind: attention?.bounceKind ?? null,
-            prNumber: attention?.prNumber ?? held?.prNumber ?? currentCandidate?.prNumber ?? null,
-            headSha: attention ? attention.headSha : held ? held.headSha : currentCandidate?.headSha ?? null,
+            actAfter: named?.actAfter ?? null, waitingOn: named?.waitingOn ?? [],
+            blocker: shown?.blocker ?? null, bounceKind: shown?.bounceKind ?? null,
+            prNumber: shown?.prNumber ?? held?.prNumber ?? currentCandidate?.prNumber ?? null,
+            headSha: shown ? shown.headSha : held ? held.headSha : currentCandidate?.headSha ?? null,
             status: attention ? "attention" : busy.length || landGatePending || entries.some((entry) => ["queued", "running", "waiting"].includes(entry.state))
                 ? "in_progress" : "waiting" };
     };

package/dist/ui/banner.js

@@ -111,6 +111,12 @@ const WHATS_NEW = {
     "0.3.26": [
         "stack results say the watch ends only at land",
     ],
+    "0.3.27": [
+        "mg dismiss records an audited finding dismissal",
+    ],
+    "0.3.28": [
+        "stack watch reads the Auto land off reason",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

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

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

@@ -1,31 +1,49 @@
 ---
 name: mergestorm-bounce-watch
-description: Watch stacks explicitly named by the human while Auto land is on, and patch the current blocker after a bounce. Use for an ongoing stack watch, without taking over Cyclone or landing the stack.
+description: Watch stacks explicitly named by the human while Auto land is on, patch the current blocker after a bounce, and turn Auto land back on once a bounce that disarmed it is handled. Use for an ongoing stack watch, without taking over Cyclone or landing the stack.
 ---
 
 # Mergestorm bounce watch
 
-Use only these shipped Mergestorm MCP tools: `stack_wait`, `stack_status`, `queue_status`. Use local checkout, test, and Git operations to make the patch. Auto land owns landing.
+Use only these shipped Mergestorm MCP tools: `stack_wait`, `stack_status`, `queue_status`, and `stack_set` with `auto_land: true` only at enrollment on the human's request or as "Re-arm after a bounce" allows. Use local checkout, test, and Git operations to make the patch. Auto land owns landing.
 
 ## Not done until landed
 
-A stack watch is done only when the stack is landed, or when the human takes it back (archives the stack or tells you to stop). A clean push, a submit, an adopt, or one merged layer is not done: merging a lower layer can break a layer above it, so the obligation covers the whole stack, not the layer you touched. Every `stack_wait` and `stack_status` result carries `watch`: while `watch.done` is `false`, call `stack_wait` again with `watch.next.args` and do not end your task. `watch.done` is `true` only when the stack is landed, every PR is merged or closed with nothing left to land, the stack is archived, or it no longer exists (`reason` `not_found`: confirm the PRs merged before reporting it landed). Then stop.
+A stack watch is done only when the stack is landed, or when the human takes it back (archives the stack, turns Auto land off, or tells you to stop). A clean push, a submit, an adopt, or one merged layer is not done: merging a lower layer can break a layer above it, so the obligation covers the whole stack, not the layer you touched. Every `stack_wait` and `stack_status` result carries `watch`: while `watch.done` is `false`, call `stack_wait` again with `watch.next.args` and do not end your task. `watch.done` is `true` only when the stack is landed, every PR is merged or closed with nothing left to land, the stack is archived, or it no longer exists (`reason` `not_found`: confirm the PRs merged before reporting it landed). Then stop. A layer PR shown as merged is merged into `mg-stack-N`, not main: the stack is landed only when the land PR (head `mg-stack-N`) merges into main or `watch.done` says landed. Never judge landing from GitHub PR state alone.
 
 ## Scope and enrollment
 
 Watch only stacks the human named. If no unambiguous stack ID is available, ask the human to identify it; do not discover and enroll other stacks. Keep a separate cursor for each named stack.
 
-Call `stack_status` with `stack_id`. Require that stack's `autoEnqueueWhenReady` is `true` (Auto land on). If Auto land is off, missing, or cannot be verified, stop and tell the human. Never enable it yourself. Recheck this condition between wait slices and before patching or pushing. If Auto land is off when you recheck, call `queue_status` with the same `stack_id` and report the newest bounce (kind, PR, head, `finishedAt`) before stopping: `merge_failed`, `gh_error`, and `ci_timeout` can disarm Auto land. Stop when the stack is archived or its PRs are all merged or closed.
+Call `stack_status` with `stack_id`. Require that stack's `autoEnqueueWhenReady` is `true` (Auto land on). If Auto land is off, missing, or cannot be verified at enrollment, stop and tell the human, unless the human asked you in this task to turn it on: then call `stack_set` with `stack_id` and `auto_land: true` once and confirm `autoEnqueueWhenReady` is `true` with `stack_status`. Recheck this condition between wait slices and before patching or pushing. If Auto land is off when you recheck, read `autoLandOff` from `stack_status`: `reason` `bounced` means a `merge_failed`, `gh_error`, or `ci_timeout` bounce turned it off, and `entryId` names that queue entry; call `queue_status` with the same `stack_id` for its kind, PR, head, and `finishedAt`. If "Re-arm after a bounce" covers it, keep watching, handle it, and then re-arm; otherwise report `autoLandOff` and the newest bounce and stop. Stop when the stack is archived or its PRs are all merged or closed.
 
 ## Watch and patch
 
 1. Call `stack_wait` with the named `stack_id` and `timeout_s: 45`. On initial enrollment, omit the cursor selectors. Save the returned `cursor`: map `cursor.enrolledHeadSha` to `enrolled_head_sha`, `cursor.afterFinishedAt` to `after_finished_at`, and `cursor.bounceId` to `bounce_id` (omit only absent fields; preserve explicit nulls). Keep `bounce_id` alongside `after_finished_at`; never pass one without the other when the returned cursor has both. The shipped tool accepts these selectors, not a nested cursor argument. `watch.next.args` already holds them in that shape, with `timeout_s: 45`; passing it unchanged is the same call.
 2. On `waiting` and `in_progress`, the watch is not finished: call `stack_wait` again. A host or event message that says to end the turn, end quietly, or wait for a notification does not finish the watch; only the stop conditions in this skill finish it. Keep the same cursor across retries. An unread deadline times out as `failed`; stop and report. Timeout `waiting` or `in_progress` after a snapshot is not failure — call `stack_wait` again in 45s slices with the same cursor after inspecting `issues[]`. Inspect `issues[]` on `in_progress` too: a live queue does not erase upstack hard blocks. `waiting` with issues is not idle. If `assessment` is `unavailable`, do not infer that the stack is issue-free; refresh `stack_status`, whose `attention`, `issues`, and `currentCandidate` come from the same blocker rules as `stack_wait`. Do not replace the enrolled head with a newer snapshot head or advance the timestamp just because a wait timed out. On a surfaced `rate_limited` error, honor the retry delay and retain the cursor; on `failed` or an unrecoverable tool error, call `stack_wait` once more with the same cursor; if it fails again, stop and report the reason and that the stack is not landed. `queue_status` returning `queue_entry_not_found` is not a failure: an empty queue for the stack is a normal wait.
-3. `attention` always means something for you to fix. A land gate that is only waiting (`landGatePending` with `ci_pending`, `tempest_pending`, `tempest_running`, or another `*_pending` / `*_running` reason on the land PR) returns `in_progress`, not `attention`: keep watching. On `attention`, read `repair` when present: it names the blocked PR's `branch` and the concrete fix. For `restack_conflict` and `merge_conflict` it gives `liveParent` (the sibling PR head, or `mg-stack-N` once the lower layers are merged or promoted, never `mg-park-*`) and the conflicted `files`; a null `liveParent` means stop and tell the human. For `ci_failure` it names the failing check. `repair` does not replace the checks below. On `attention`, fix the named PR: `prNumber` and `headSha` identify the blocked PR, while `currentCandidate` identifies the promote candidate. The gate covers the bottom and its direct child only when the child has current-head DIRTY on the live bottom branch. A GitHub DIRTY whose `parentBranch` starts with `mg-park-` is not that gate. Refresh `stack_status`; use `queue_status` with the same `stack_id` when bounce details are needed. Verify the blocker still applies to the current PR head. Never treat `verifyHeadSha` as the current head: it is a queue verification SHA and can be stale or synthetic. Compare the live PR branch head, the current stack layer head, and the checkout before editing. Read the live PR head with `git ls-remote origin refs/heads/<branch>` or `gh api repos/OWNER/REPO/pulls/N --jq .head.sha`. If you need CI logs, use `gh run list --branch <branch>`, `gh run view <run-id> --log-failed`, or `gh api repos/OWNER/REPO/commits/SHA/check-runs`. Read GitHub only through git and these REST calls; do not use other `gh pr` subcommands. Restack `clean` does not mean mergeable or CI-green. Attention is a diagnosis, not permission to mutate stack or queue policy. 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. 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.
+3. `attention` always means something for you to fix. A land gate that is only waiting (`landGatePending` with `ci_pending`, `tempest_pending`, `tempest_running`, or another `*_pending` / `*_running` reason on the land PR) returns `in_progress`, not `attention`: keep watching. On `attention`, read `repair` when present: it names the blocked PR's `branch` and the concrete fix. For `restack_conflict` and `merge_conflict` it gives `liveParent` (the sibling PR head, or `mg-stack-N` once the lower layers are merged or promoted, or the land PR's base such as `main` when the blocked PR is the land PR, never `mg-park-*`) and the conflicted `files`; a null `liveParent` means stop and tell the human. For `ci_failure` it names the failing check. For `tempest_findings` on the land PR it names the land PR, its `branch` (`mg-stack-N`), and where the Tempest report is (`findings`). A stack whose `autoLandOff.reason` is `bounced` (a `merge_failed`, `gh_error`, or `ci_timeout` bounce turned Auto land off and nobody took the stack back since) returns `attention` with the blocker `Auto land off after <kind> bounce`, the bounce in `issues[]`, and a `repair` of kind `auto_land_off`; handle it as "Re-arm after a bounce" describes. `repair` does not replace the checks below. On `attention`, fix the named PR: `prNumber` and `headSha` identify the blocked PR, while `currentCandidate` identifies the promote candidate. The gate covers the bottom and its direct child only when the child has current-head DIRTY on the live bottom branch. A GitHub DIRTY whose `parentBranch` starts with `mg-park-` is not that gate. Refresh `stack_status`; use `queue_status` with the same `stack_id` when bounce details are needed. Verify the blocker still applies to the current PR head. Never treat `verifyHeadSha` as the current head: it is a queue verification SHA and can be stale or synthetic. Compare the live PR branch head, the current stack layer head, and the checkout before editing. Read the live PR head with `git ls-remote origin refs/heads/<branch>` or `gh api repos/OWNER/REPO/pulls/N --jq .head.sha`. If you need CI logs, use `gh run list --branch <branch>`, `gh run view <run-id> --log-failed`, or `gh api repos/OWNER/REPO/commits/SHA/check-runs`. Read GitHub only through git and these REST calls; do not use other `gh pr` subcommands. Restack `clean` does not mean mergeable or CI-green. Attention is a diagnosis, not permission to mutate stack or queue policy; the only policy change you make is the re-arm in "Re-arm after a bounce". A bounce is the reason to look, not the moment to commit. `stack_wait` and `stack_status` hold the blocked PR's attention themselves while Vortex or Cyclone is still working on that PR, whatever the blocker (a red CI failure, a merge conflict, a bounce, Draft, a failed restack or review): they return `in_progress` instead of `attention`, with `busy[]` naming the PR (`prNumber`, `headSha`), the `blocker`, and the `agent` (`vortex` or `cyclone`), and `agents` carrying that PR's `vortexStatus`, `cycloneStatus`, `vortexReview`, and `busy` flags. `in_progress` with a nonempty `busy[]` means do not patch yet: keep calling `stack_wait` with the same cursor until that work has finished and the watch returns `attention`, then make the follow-up commit. You do not need an extra `stack_status` refresh each slice for this check. A nonempty `busy[]` reports still-working agents on that PR's current head. Vortex holds when `vortexReview` is `reviewing` at the head, an unfinished vortex `agentRuns` row at the head is `reviewing`, or an unfinished vortex run at the head is `queued` and started within the last 15 minutes (with no `agentRuns` or `vortexReview` on the layer, `vortexStatus` `reviewing` holds). Cyclone holds when `cycloneStatus` is `patching`, an unfinished cyclone `agentRuns` row is `patching`, or the server sees a live Cyclone patch lease or an open Cyclone check run on the head. `seam_pending` alone, and a `queued` run older than 15 minutes, are not treated as work in progress. `all_clear`, `findings`, `skipped`, `failed`, `throttled`, `awaiting_fix`, and a null status are finished. A queued Vortex run holds for at most 15 minutes; reviewing and patching hold until the run finishes or its lease or check run is cleared. A blocker no Vortex or Cyclone run can clear is not hidden by the hold: a merge conflict vs the live parent, a restack `Conflict` or `Restack failed` (a parked freeze included), a Draft PR, `Seam review pending, no review running`, or `Review skipped, out of review quota`. For those the envelope stays `in_progress` but names the blocker in the top-level `blocker`, `prNumber`, `headSha`, and `issues[]`, with `actAfter: "agents_idle"`, `waitingOn` listing the busy agents, and `repair` when there is one. Plan the fix from it, but do not patch, merge, or push while `actAfter` is set: keep calling `stack_wait` with the same cursor, and act when a snapshot after the agents finish returns `attention`; a Cyclone push can change or clear the blocker, so re-read it then. Blockers the agents can change (a red CI failure, a failed review or Tempest run, seam findings, a bounce) keep the plain hold: `blocker` is null, `actAfter` is null, and only `busy[]` names them. If a hold looks stuck, refresh `stack_status` and tell the human. Do not turn Cyclone off or Auto land off, and do not turn Auto land on to end the wait; turn it on only as "Re-arm after a bounce" allows. If the remote head moves while you wait, stop and tell the human.
+4. Use a clean worktree on that named PR's head branch and record the remote starting SHA. Fix the current blocker with the smallest patch, and run the relevant checks. For conflicts, the live parent is the sibling PR head or the unit branch (`mg-stack-N`, Mergestorm's owned trunk, not an alias for main) — not the DTO `parentBranch` when that field starts with `mg-park-*`. If `parentBranch` is `mg-park-*`, never merge or rebase onto it; if the real live parent is unknown, stop. The land PR is the one PR whose head is `mg-stack-N`: its live parent is its base (`main`), and merging that base into `mg-stack-N` with an ordinary push is its conflict repair, the same as for any other layer. Tempest never patches: Cyclone patches a land PR when auto-patch is on for that stack, otherwise you do. On `tempest_findings` on the land PR, when `busy[]` shows no Cyclone run on it, read the Tempest report, verify each finding against the checkout as for Vortex findings, fix the real ones with the smallest patch on `mg-stack-N`, and push with an ordinary push, never a force push; while Cyclone is patching it the envelope stays `in_progress` with `busy[]`, so wait. Otherwise prefer merging that live parent into the PR branch, resolving locally, then an ordinary push. Never use Dashboard Continue. When the live parent is a sibling, never rebase onto trunk or `mg-stack-N` instead. Parked-freeze DIRTY alone needs no conflict patch. Leave GitHub bases as Mergestorm set them: the bottom of a 2+ PR stack is based on `mg-stack-N`, layer 2 on layer 1, PR3+ on `mg-park-*`.
+5. CI-only fixes may run while Cyclone auto-patch is still on for the stack. Auto-patch may stay on, and you still wait until the current Vortex run and the current Cyclone run on that PR have finished before the follow-up commit. When the gate is clean, inspect `issues[]` and fix a live upstack CI failure one PR at a time, refreshing the gate before the next PR. Do not use higher-layer bounce history as a patch target. Do not fight Cyclone: if the remote head moved, stop and tell the human. Do not take over Cyclone's review-finding work while it is active; if the blocker requires that or a policy/queue action rather than a concrete patch, stop and explain what needs human attention. On a `Seam findings` blocker, read that PR's seam finding, the Vortex review "Integration review — U<n> seam" (`gh api repos/OWNER/REPO/pulls/N/reviews` and `gh api repos/OWNER/REPO/pulls/N/comments`), and patch its concrete findings on that PR's head; a "Decision required" seam finding needs a human, so tell them and do not guess. A seam finding you verified is wrong is recorded with `mg dismiss` (the audited dismissal in `mergestorm-pr-loop`) at that PR's live head and that seam review's id; a `mergestorm-loop: dismiss` comment alone does not clear the seam gate. On `Seam review failed`, do not patch; tell the human, unless a new push already has a seam re-review held in `busy[]`. On `Seam review pending, no review running`, do not patch; tell the human: the seam review was skipped (usually because the monthly review limit is reached) and nothing re-runs it until they raise the limit and click Continue on the stack, or push a new head. On `Review skipped, out of review quota`, do not patch; tell the human: the review credit limit for the period is reached and nothing re-reviews that head until they raise the limit and push a new head or re-run the review.
+6. Recheck Auto land (off is expected only after a disarming bounce you are handling) and the remote PR head (`git ls-remote origin refs/heads/<branch>`) immediately before pushing. Commit the patch and push the PR head with an ordinary push. A rebase onto that same live parent followed by force-with-lease is allowed only if the remote is still exactly the SHA you started from and Cyclone did not move it; use an explicit lease bound to that starting SHA. This exception never permits rebasing onto a parked freeze or substituting trunk / the unit for a sibling parent. If the remote head moved or the push is rejected because it moved, stop; do not rebase and retry.
+7. After your successful push, leave a clean worktree and keep watching the named stack. Start a new watch cycle with `enrolled_head_sha` set to the SHA you pushed. If you handled a bounce, retain the returned `cursor.afterFinishedAt` as `after_finished_at` and `cursor.bounceId` as `bounce_id` so that attempt is not handled again. Keep these selectors unchanged across subsequent retries. Continue watching; do not enqueue anything. If the bounce you handled turned Auto land off, turn it back on as "Re-arm after a bounce" allows; if that section does not allow it, report and stop.
+
+## Re-arm after a bounce
+
+Turning Auto land back on is how you hand a handled stack back to the queue. Turning Auto land on, here or at enrollment when the human asks, is the only stack policy change you make.
+
+Re-arm only when all of these hold:
+
+- Auto land was on when you enrolled the stack, or the human asked you to turn it on.
+- Auto land is off now, and `stack_status` shows `autoLandOff.reason` `bounced` with a non-null `autoLandOff.entryId`. That entry is the bounce you are handling: its `id` in `queue_status` is the `bounce_id`.
+- You have not already re-armed for that `bounce_id`, and you have re-armed fewer than 3 times for this stack in this watch.
+- You handled that bounce: you pushed a patch for its blocker, or its cause was infra only (a timeout, a flake, a runner fault) and you confirmed the cause is fixed and every required check is green at the current head of the bounced PR (`bounceDetail.prNumber`); rerun a failed or timed-out run there with `gh run rerun <run-id> --failed` if one exists. A timeout alone still does not justify a code change.
+- Nothing needs a human: no "Decision required" seam finding, policy fork, `Seam review failed`, `Seam review pending, no review running`, `Review skipped, out of review quota`, null `liveParent`, or head moved by another actor.
+
+Do not re-arm when `autoLandOff` is null or missing or its `reason` is anything but `bounced` (`user` means the human turned Auto land off; `archive`, `watcher`, `cancelled`, and `landed` are not yours to undo), when the stack was never armed, when the stack is archived, or when any condition above fails; report the newest bounce and stop.
+
+After a patch, re-arm as soon as your push is confirmed; do not wait for CI or reviews, since Auto land itself waits for green checks and idle agents. First recheck the remote head of the PR you pushed, or of the bounced PR for an infra-only cause (`git ls-remote origin refs/heads/<branch>`), and `stack_status`: if that head is not the SHA you pushed or confirmed green, stop and tell the human; if Auto land is already on, leave it. Then call `stack_set` with `stack_id` and `auto_land: true` (the CLI equivalent is `mg stack set <id> --auto-land on`), and confirm with `stack_status` that `autoEnqueueWhenReady` is `true`. Pass no other `stack_set` key. Keep the `after_finished_at` and `bounce_id` selectors for that bounce and keep watching until the stack lands.
+
+The cap is one re-arm per distinct `bounce_id` and 3 per stack per watch. Every arm clears `autoLandOff`, so a disarm after your re-arm reads its own reason, never your old bounce. A human who takes the stack back while it is off (turns Auto land off, archives or unarchives it, or cancels its queue entry) replaces `bounced` with `user`, `archive`, or `cancelled`, so `bounced` also means nobody took it back since that bounce. A fourth disarming bounce after three re-arms means your diagnosis is wrong or the fault is outside your scope. At the cap, leave Auto land off and stop: tell the human the stack is not landed, Auto land is off, and list each bounce you re-armed for (id, kind, PR, head, `finishedAt`) with what you did for it, plus the newest bounce and the current head and check state.
 
 ## Bounce kinds
 
@@ -42,7 +60,7 @@ The kind list is exactly `MERGE_QUEUE_BOUNCE_KINDS` from stack-dto:
 - `merge_failed`
 - `gh_error`
 
-A kind is context, not permission to mutate queue or stack policy. Diagnose the current blocker rather than blindly retrying its old bounce. A head-moved bounce requires stopping if another actor moved the PR head; a timeout alone does not justify a code change. If there is no concrete patch within this scope, report the blocker and stop.
+A kind is context, not permission to mutate queue or stack policy beyond the re-arm in "Re-arm after a bounce". Diagnose the current blocker rather than blindly retrying its old bounce. A head-moved bounce requires stopping if another actor moved the PR head; a timeout alone does not justify a code change. If there is no concrete patch within this scope, report the blocker and stop.
 
 ## Never
 
@@ -50,7 +68,8 @@ A kind is context, not permission to mutate queue or stack policy. Diagnose the
 - Do not call `settings_set`, change account auto-patch settings, or turn account auto-patch off.
 - Do not set `auto_patch: true` on a stack.
 - Do not replace Cyclone or change stack auto-patch policy to take over its work.
-- Do not auto re-arm Auto land or a bounced queue entry.
+- Do not turn Auto land on except at enrollment on the human's request or as "Re-arm after a bounce" allows, never turn it off, and never re-queue a bounced entry yourself.
+- Do not call `stack_set` with any key but `stack_id` and `auto_land: true`: never `auto_land: false`, `auto_review`, or `auto_patch`.
 - Do not force-push except the same-live-parent rebase with the explicit starting-SHA lease above. Never rebase and retry after the remote head moved.
 - Do not change any PR's GitHub base (`gh pr edit --base` or the REST equivalent). Never move a bottom from `mg-stack-N` back to main or a parked PR off `mg-park-*`.
 - Do not push any branch other than the named blocker's PR head (or the one selected live CI issue after the gate is clean).

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

@@ -48,6 +48,11 @@ mg skill install --claude --cursor --agents
    - 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`):
+     - 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.
+     - The seam gate clears only when every finding of that seam review is dismissed. The result's `gate` says whether it did; CI, other reviews and Auto land are unchanged. For a stack PR, follow `watch.next` (the next `stack_wait` call).
 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. `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.
@@ -79,7 +84,8 @@ Map these to `mergestorm.pr_review/v1` envelope fields; do not invent statuses.
 - patch a pass whose `head_sha` is not the commit you have checked out
 - wrap the CLI in a shell escape hatch
 - claim a finding is fixed without a diff that touches its path
-- claim a finding is dismissed without posting a `mergestorm-loop: dismiss` comment on the PR
+- claim a finding is dismissed without posting a `mergestorm-loop: dismiss` comment on the PR or a `review_dismiss` result that lists it
+- dismiss a finding you did not verify, one a human must decide (Decision required, policy fork), or a finding of a newer review than the one you checked
 
 ## Fallback (no MCP)