mergestorm 0.3.15 → 0.3.17

package/dist/stack-dto.d.ts

@@ -1,3 +1,11 @@
+export type RestackError = {
+    kind: "rebase_conflict" | "checkout_failed" | "head_unresolved" | "push_failed";
+    detail: string;
+    headSha: string;
+    attemptedAt: string;
+    attempts: number;
+    backupRef: string | null;
+};
 /**
  * Wire types returned by the stack list/enrich HTTP endpoints.
  *
@@ -7,8 +15,12 @@
 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";
-/** `failed` is the newest Vortex `pr_reviews` row. Work paints Review failed. */
-export type StackVortexStatus = "reviewing" | "seam_pending" | "all_clear" | "findings" | "throttled" | "failed";
+/**
+ * `failed` is the newest Vortex `pr_reviews` row. Work paints Review failed.
+ * `incomplete` is a posted verdict whose head still has unreviewed files
+ * (#1947): Work paints Incomplete, never Reviewed or all clear.
+ */
+export type StackVortexStatus = "reviewing" | "seam_pending" | "all_clear" | "findings" | "throttled" | "failed" | "incomplete";
 export type StackCycloneStatus = "patching" | "awaiting_fix";
 export type StackTempestStatus = "reviewing" | "findings" | "clear" | "failed" | "stale";
 export type StackAgentName = "vortex" | "cyclone" | "tempest";
@@ -38,6 +50,15 @@ export type StackAgentRun = {
      * Only on resting Vortex `findings` runs.
      */
     findingCount?: number | null;
+    /**
+     * File coverage at the posted head from `vortex_pr_review_state.file_states`
+     * (#1947): files reviewed at this head over all changed files. Only on
+     * resting Vortex `incomplete` runs, so the chip tooltip can say 21/32.
+     */
+    coverage?: {
+        reviewed: number;
+        total: number;
+    } | null;
 };
 export type StackLayerChecks = {
     total: number;
@@ -118,6 +139,7 @@ export type StackLayerDto = {
      */
     agentRuns?: StackAgentRun[];
     conflictDetail: string | null;
+    restackError?: RestackError | null;
     lastRestackedSha: string | null;
     /** GitHub PR mergeability from enrich; null when unknown. */
     mergeable: boolean | null;
@@ -207,6 +229,7 @@ export type StackUnitDto = {
      */
     landPr: StackLayerDto | null;
 };
+export type CycloneOwnerMatch = "same" | "different" | "none" | "lookup_failed";
 export type StackDto = {
     id: string;
     owner: string;
@@ -224,6 +247,36 @@ export type StackDto = {
      * Missing on older payloads is off.
      */
     autoEnqueueWhenReady?: boolean;
+    /**
+     * Per-stack Vortex auto-review override. `null` (or missing) follows the
+     * account `auto_review_enabled` flag; a boolean wins in both directions.
+     */
+    autoReviewOverride?: boolean | null;
+    /**
+     * Per-stack Cyclone auto-patch override. `null` (or missing) follows the
+     * account `auto_patch_enabled` flag; a boolean wins in both directions.
+     */
+    autoPatchOverride?: boolean | null;
+    /**
+     * Bearer / stack-row user. Cyclone apply follows this user's auto-patch
+     * policy and credits for an adopted stack (HOUSE-1), even when
+     * `cycloneInstallUserId` is a different Mergestorm account on a shared repo
+     * (LOOP-5).
+     */
+    keyUserId?: string;
+    /**
+     * Cyclone GitHub App install user for this owner/repo, when resolved. Its
+     * installation clones and pushes; it does not decide auto-patch for another
+     * user's stack.
+     */
+    cycloneInstallUserId?: string | null;
+    /**
+     * `same`: the only Cyclone install user is the key user.
+     * `different`: a Cyclone install user is not the key user (or more than one).
+     * `none`: no Cyclone install monitors this repo.
+     * `lookup_failed`: the comparison could not be loaded. Fail closed.
+     */
+    cycloneOwnerMatch?: CycloneOwnerMatch;
     layers: StackLayerDto[];
     /** Present when a review-unit row exists for this stack. */
     unit?: StackUnitDto;

package/dist/stack-dto.js

@@ -1,7 +1 @@
-/**
- * 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 {};

package/dist/stack-meta.d.ts

@@ -5,6 +5,10 @@ export type StackLayerMeta = {
 };
 export type LocalStack = {
     layers: StackLayerMeta[];
+    autoEnqueueWhenReady?: boolean;
+    /** Per-open override carried from `stack create` to `stack submit`; absent = account flag. */
+    autoReviewOverride?: boolean;
+    autoPatchOverride?: boolean;
 };
 export type StackMeta = {
     version: 2;
@@ -20,6 +24,14 @@ export declare function loadStackMeta(cwd?: string, stacksRoot?: string): Promis
 export declare function emptyStackMeta(trunk: string): StackMeta;
 export declare function activeStack(meta: StackMeta): LocalStack;
 export declare function activeLayers(meta: StackMeta): StackLayerMeta[];
+export declare function setActiveAutoEnqueue(meta: StackMeta, enabled: boolean | undefined): StackMeta;
+/** Per-open automation flags remembered on the active local stack until submit. */
+export type LocalStackPolicy = {
+    autoEnqueueWhenReady?: boolean;
+    autoReviewOverride?: boolean;
+    autoPatchOverride?: boolean;
+};
+export declare function setActivePolicy(meta: StackMeta, policy: LocalStackPolicy): StackMeta;
 export declare function saveStackMeta(meta: StackMeta, cwd?: string, stacksRoot?: string): Promise<void>;
 /** Explicit recovery. Does not touch branches, PRs, or registered server stacks. */
 export declare function resetStackMeta(cwd?: string, stacksRoot?: string): Promise<void>;

package/dist/stack-meta.js

@@ -8,6 +8,11 @@ import path from "node:path";
 import { CommandError, isCommandErrorCode } from "./errors.js";
 import { git } from "./git.js";
 import { cliStacksRoot, gitTopLevel, LEGACY_STACK_META_REL, legacyStackMetaPath, repoStateDir, stackMetaPath as resolveStackMetaPath, } from "./repo-identity.js";
+const LOCAL_STACK_FLAGS = [
+    "autoEnqueueWhenReady",
+    "autoReviewOverride",
+    "autoPatchOverride",
+];
 /** Exported only for legacy migration/tests. New state never uses this path. */
 export const STACK_META_REL = LEGACY_STACK_META_REL;
 export function stackMetaPath(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
@@ -35,10 +40,18 @@ function normalizeMeta(raw) {
             if (!stack ||
                 typeof stack !== "object" ||
                 !Array.isArray(stack.layers) ||
-                !stack.layers.every(isLayer)) {
+                !stack.layers.every(isLayer) ||
+                LOCAL_STACK_FLAGS.some((flag) => stack[flag] !== undefined &&
+                    typeof stack[flag] !== "boolean")) {
                 throw new Error("Stack authoring state has a malformed stack entry; run `mg stack reset --force` to clear it.");
             }
-            stacks.push({ layers: stack.layers });
+            const entry = { layers: stack.layers };
+            for (const flag of LOCAL_STACK_FLAGS) {
+                const value = stack[flag];
+                if (typeof value === "boolean")
+                    entry[flag] = value;
+            }
+            stacks.push(entry);
         }
         const active = obj.active;
         if (typeof active !== "number" ||
@@ -165,6 +178,22 @@ export function activeStack(meta) {
 export function activeLayers(meta) {
     return activeStack(meta).layers;
 }
+export function setActiveAutoEnqueue(meta, enabled) {
+    return setActiveStackFlag(meta, "autoEnqueueWhenReady", enabled);
+}
+export function setActivePolicy(meta, policy) {
+    let next = meta;
+    for (const flag of LOCAL_STACK_FLAGS) {
+        next = setActiveStackFlag(next, flag, policy[flag]);
+    }
+    return next;
+}
+function setActiveStackFlag(meta, flag, value) {
+    if (value === undefined)
+        return meta;
+    const stacks = meta.stacks.map((stack, index) => index === meta.active ? { ...stack, [flag]: value } : stack);
+    return { ...meta, stacks };
+}
 export async function saveStackMeta(meta, cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
     const file = stackMetaPath(cwd, stacksRoot);
     const dir = path.dirname(file);
@@ -229,7 +258,7 @@ export function appendLayer(meta, layer) {
         }
     }
     const stacks = meta.stacks.map((stack, index) => index === meta.active
-        ? { layers: [...stack.layers, layer] }
+        ? { ...stack, layers: [...stack.layers, layer] }
         : stack);
     return { ...meta, stacks };
 }

package/dist/ui/banner.js

@@ -81,6 +81,12 @@ const WHATS_NEW = {
         "mg pr --wait --after-sha, mg settings, mergestorm-pr-loop skill on npm",
         "mg skill install copies review + pr-loop from the packed tarball",
     ],
+    "0.3.16": [
+        "PR loop: verify each finding, prefer a small diff, post mergestorm-loop: dismiss on skip",
+    ],
+    "0.3.17": [
+        "nginx 413 names the upload limit instead of Failed: {}",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/dist/ui/human-summary.d.ts

@@ -0,0 +1,2 @@
+/** Remove tool/LLM JSON that is unsafe to show in human summary output. */
+export declare function humanSummary(summary: string): string | null;

package/dist/ui/human-summary.js

@@ -0,0 +1,153 @@
+const TOOL_PAYLOAD_KEYS = new Set([
+    "function_call",
+    "tool",
+    "tool_call",
+    "tool_calls",
+]);
+function parseJsonContainer(value) {
+    const trimmed = value.trim();
+    if (!((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]")))) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function looksLikeToolPayload(value) {
+    if (Array.isArray(value))
+        return value.some(looksLikeToolPayload);
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    const keys = Object.keys(record);
+    if (keys.some((key) => TOOL_PAYLOAD_KEYS.has(key.toLowerCase())))
+        return true;
+    const lower = new Set(keys.map((key) => key.toLowerCase()));
+    if (record.type === "tool_use" && lower.has("name") && lower.has("input"))
+        return true;
+    if (lower.has("verdict") && lower.has("comments"))
+        return true;
+    return Object.values(record).some(looksLikeToolPayload);
+}
+function matchingJsonEnd(text, start) {
+    const open = text[start];
+    if (open !== "{" && open !== "[")
+        return null;
+    const stack = [open];
+    let quoted = false;
+    let escaped = false;
+    for (let i = start + 1; i < text.length; i += 1) {
+        const char = text[i];
+        if (quoted) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === '"')
+                quoted = false;
+            continue;
+        }
+        if (char === '"') {
+            quoted = true;
+            continue;
+        }
+        if (char === "{" || char === "[")
+            stack.push(char);
+        else if (char === "}" || char === "]") {
+            const expected = char === "}" ? "{" : "[";
+            if (stack.pop() !== expected)
+                return null;
+            if (stack.length === 0)
+                return i + 1;
+        }
+    }
+    return null;
+}
+function fencedLines(text) {
+    const lines = text.split("\n");
+    const protectedLines = new Set();
+    const openFences = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        if (/^\s*```[a-z0-9_-]+\s*$/i.test(lines[i])) {
+            openFences.push(i);
+        }
+        else if (/^\s*```\s*$/.test(lines[i])) {
+            if (openFences.length > 0) {
+                const start = openFences.pop();
+                for (let line = start; line <= i; line += 1)
+                    protectedLines.add(line);
+            }
+            else {
+                openFences.push(i);
+            }
+        }
+    }
+    return protectedLines;
+}
+function stripBoundaryPayload(text) {
+    let result = text;
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const protectedLines = fencedLines(result);
+        for (let start = 0; start < result.length; start += 1) {
+            if (result[start] !== "{" && result[start] !== "[")
+                continue;
+            if (protectedLines.has(result.slice(0, start).split("\n").length - 1))
+                continue;
+            const end = matchingJsonEnd(result, start);
+            if (end == null)
+                continue;
+            const parsed = parseJsonContainer(result.slice(start, end));
+            if (parsed !== undefined &&
+                looksLikeToolPayload(parsed)) {
+                const before = result.slice(0, start);
+                const after = result.slice(end);
+                result = `${before}${before.endsWith("\n") && after.startsWith("\n") ? after.slice(1) : after}`;
+                changed = true;
+                break;
+            }
+        }
+    }
+    return result;
+}
+function stripOrphanLines(text) {
+    const lines = text.split("\n");
+    const keptLines = new Set();
+    const protectedLines = fencedLines(text);
+    for (const line of protectedLines)
+        keptLines.add(line);
+    for (let start = 0; start < text.length; start += 1) {
+        if (text[start] !== "{" && text[start] !== "[")
+            continue;
+        const end = matchingJsonEnd(text, start);
+        if (end == null || parseJsonContainer(text.slice(start, end)) === undefined)
+            continue;
+        const i = text.slice(0, start).split("\n").length - 1;
+        const lastLine = text.slice(0, end).split("\n").length - 1;
+        for (let line = i; line <= lastLine; line += 1) {
+            keptLines.add(line);
+            if (i !== lastLine)
+                protectedLines.add(line);
+        }
+    }
+    return lines
+        .filter((line, i) => protectedLines.has(i) ||
+        (parseJsonContainer(line) === undefined &&
+            (keptLines.has(i) || !/^\s*(?:```|[{}])\s*$/.test(line))))
+        .join("\n");
+}
+/** Remove tool/LLM JSON that is unsafe to show in human summary output. */
+export function humanSummary(summary) {
+    let result = summary.replace(/\r\n?/g, "\n");
+    result = result.replace(/```json[ \t]*\n([\s\S]*?)```/gi, (block, body) => parseJsonContainer(body) === undefined ? block : "");
+    result = stripBoundaryPayload(result);
+    result = stripOrphanLines(result)
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    return result || null;
+}

package/dist/ui/usage.d.ts

@@ -22,8 +22,6 @@ export declare function nextUtcMonthStart(now?: Date): string;
 export declare function formatResetLabel(iso: string | null | undefined, now?: Date): string;
 /** How long until `iso` (the API `resets_at`). Empty when the date is unusable. */
 export declare function formatDaysLeft(iso: string | null | undefined, now?: Date): string;
-/** Alias kept for callers that still import `formatResetDate`. */
-export declare function formatResetDate(iso: string | null | undefined): string;
 /** Bar cells so `  [bar] 100% used` stays inside the terminal. */
 export declare function usageBarWidth(columns: number): number;
 export type UsagePanelJob = {
@@ -38,6 +36,7 @@ export type UsagePanelInput = {
     plan: string;
     used: number;
     limit: number | null;
+    bonusRemaining?: number;
     resetsAt: string | null | undefined;
     jobs: UsagePanelJob[];
     /** When the jobs fetch failed, show this instead of "No review jobs yet." */

package/dist/ui/usage.js

@@ -83,10 +83,6 @@ export function formatDaysLeft(iso, now = new Date()) {
         return `${hours}h left`;
     return "resets soon";
 }
-/** Alias kept for callers that still import `formatResetDate`. */
-export function formatResetDate(iso) {
-    return formatResetLabel(iso);
-}
 /** Bar cells so `  [bar] 100% used` stays inside the terminal. */
 export function usageBarWidth(columns) {
     return Math.max(8, frameWidth(80, columns) - 13);
@@ -112,6 +108,9 @@ export function formatUsagePanel(input) {
         `  ${identity}`,
         `  ${bar}`,
         `  ${formatResetLabel(input.resetsAt)}`,
+        ...(input.bonusRemaining == null
+            ? []
+            : [`  Bonus credits: ${input.bonusRemaining} remaining`]),
         "",
     ];
     if (input.jobs.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "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

@@ -62,11 +62,11 @@ Default: omit `router` (account setting).
 
 ## Submit
 
-Call `review_submit` on the repo cwd (git collect when `diff` is omitted). Pass one or two sentences of intent in `context`. Pass an ADR or spec as `context_files` when one exists in the repo under review — never from outside it. Do not paste the diff into context.
+Call `review_submit` with `wait: false` (the default) on the repo cwd (git collect when `diff` is omitted). Pass one or two sentences of intent in `context`. Pass an ADR or spec as `context_files` when one exists in the repo under review, never from outside it. Do not paste the diff into context.
 
-Optional: `thread`, `idempotency_key`, `wait`, `timeout_s`. Default wait is 300s; on timeout the tool returns `status: in_progress` and the job id — then call `review_wait`.
+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.
 
-Use `review_get` or `review_list` to resume a known job.
+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.
 
 Status handling:
 

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

@@ -18,24 +18,36 @@ mg skill install --claude --cursor
 ## Preconditions (in order)
 
 1. There is an already-open GitHub PR on a Vortex-monitored repo. No PR, wrong skill.
-2. Auto-patch (Cyclone) must be off so you are the only patcher. Do not take anyone's word for it: the settings API is the source of truth, and step 1 of the loop verifies it before anything else runs.
-3. `whoami` works on the `mergestorm` MCP server (or `mg whoami --json` exits 0). Otherwise stop and ask for install/login.
+2. Auto-patch (Cyclone) must be off for this PR so you are the only patcher. Do not take anyone's word for it: the settings API and the PR's stack are the source of truth, and step 1 of the loop verifies them before anything else runs. Cyclone is off for the PR when its adopted stack has `autoPatchOverride` `false`, or when that override is unset and the account `auto_patch_enabled` is `false`.
+3. The Bearer key and the Cyclone GitHub App install must be the same Mergestorm account. `stack_list` / `stack_status` expose `keyUserId`, `cycloneInstallUserId`, and `cycloneOwnerMatch`. Cyclone apply always uses the install account, not the key. If those identities differ, your `settings_get` mute reading is about the wrong person.
+4. `whoami` works on the `mergestorm` MCP server (or `mg whoami --json` exits 0). Otherwise stop and ask for install/login.
 
 ## Loop (in order)
 
-1. Call `settings_get` and read `auto_patch_enabled`.
+1. Find the PR's stack with `stack_list` (the stack whose `layers` contain this PR's `prNumber` for this owner/repo). If you already have its `stack_id`, `stack_status` is the same payload.
+   - If there is no stack and the human asked you to mute Cyclone or continue the loop: call `stack_adopt` with `{ owner, repo, pr_number, auto_patch: false }` (equivalent to `mg stack adopt … --auto-patch off`). Then call `stack_status` with the returned `result.stack.id`, confirm this PR is in the stack and `autoPatchOverride` is `false`. If adoption or verification fails, refuse the loop. Otherwise continue through the ownership check below and the remaining loop steps; do not stop and ask the human to adopt. Do not turn account auto-patch off.
+   - Adoption does not fix installer ≠ key. After adoption, the same `cycloneOwnerMatch` refusal below still applies.
+   - Read `cycloneOwnerMatch` on that stack. If it is missing, `lookup_failed`, or `different`: refuse the loop. Do not wait, patch, or push. Tell the human the API key and the Cyclone GitHub App install are different Mergestorm accounts (or the comparison could not be loaded). Cyclone still patches as the installer. Do not turn account auto-patch off, and do not set `auto_patch: false` to paper over this.
+   - If it is `same` or `none`: continue. `none` means no Cyclone install monitors this repo.
+2. Call `settings_get` and read `auto_patch_enabled`.
    - If `settings_get` errors or its result has no `auto_patch_enabled`: refuse the loop. Do not wait, patch, or push; tell the human that Cyclone auto-patch could not be verified.
-   - If it is `false`: continue. You are the only patcher.
-   - If it is `true` and the human asked you to turn Cyclone off: call `settings_set` with `auto_patch_enabled: false`, then call `settings_get` again and confirm it now reads `false`.
-   - If it is `true` otherwise: refuse the loop. Do not wait, patch, or push; tell the human Cyclone auto-patch is still on and where to turn it off.
-   - Never set `auto_patch_enabled` to `true`.
-2. Call `review_wait_pr` with the PR's owner, repo, and pr_number (`review_get_pr` works for a first look at the resting state).
-3. 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 7 with `after_sha` set to that head.
-4. Read `findings.inline` and `findings.offDiff` (or `off_diff`) sorted by severity. Fix or explain each.
-5. Patch on the PR head branch only.
-6. 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.
-7. Call `review_wait_pr` again with `after_sha` set to the SHA you just pushed (7+ hex). An envelope whose `head_sha` is an older commit is a previous pass, not yours; keep waiting.
-8. Repeat from step 3 until a stop rule fires.
+   - If it is `false`: read `autoPatchOverride` on the stack from step 1. If it is `true`, refuse unless the human asked you to turn Cyclone off for this PR; if they did, use the `stack_set { auto_patch: false }` path below. Otherwise continue. You are the only patcher.
+   - If it is `true`: read `autoPatchOverride` on that same stack.
+     - If `autoPatchOverride` is `false`: continue. Cyclone is pinned off for this stack.
+     - 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`.
+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.
+   - 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.
+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.
+9. Repeat from step 4 until a stop rule fires.
 
 ## Stop rules
 
@@ -44,20 +56,23 @@ Map these to `mergestorm.pr_review/v1` envelope fields; do not invent statuses.
 - `finding_count` is 0 (empty inline and offDiff): stop. Tell the human the PR is clear and that Auto land owns landing. Never merge it yourself.
 - status is `rate_limited`, or `patch_policy.mode` is `"hold"`: surface the findings to the human and stop. Do not patch.
 - status is `failed`: report to the human. Do not keep pushing to retrigger.
-- status is `in_progress` and the envelope has a `head_sha`: the pass is still running; call `review_wait_pr` again with the same `after_sha`.
-- status is `in_progress` and the envelope has no `head_sha`: the wait timed out before Vortex wrote a pass for your SHA. Call `review_wait_pr` once more with the same `after_sha`. If it comes back the same way a second time in a row, stop and tell the human that Vortex did not pick up the push. Do not push again to retrigger.
+- status is `in_progress` and the envelope has a `head_sha`: the pass is still running; call `review_wait_pr` again with the same `after_sha` and the same `after_pass`.
+- status is `in_progress` and the envelope has no `head_sha`: the wait timed out before Vortex wrote a pass for your SHA. Call `review_wait_pr` once more with the same `after_sha` and the same `after_pass`. If it comes back the same way a second time in a row, stop and tell the human that Vortex did not pick up the push. Do not push again to retrigger.
 - status is `skipped`, `stopped`, `trial_expired`, or `synced`: surface the status and reason to the human and stop. Do not patch or push.
 
 ## 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.
-- land, merge, enqueue, or touch stack authoring or the merge queue
-- turn `auto_patch_enabled` on, from this skill, for any reason
+- 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
+- set `auto_patch: true` on any stack
 - push any branch other than the PR head
 - force-push, or rebase and retry a push that was rejected because the remote moved
 - 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
 
 ## Fallback (no MCP)
 
@@ -67,10 +82,10 @@ Verify auto-patch with the CLI instead of `settings_get`:
 mg settings --json
 ```
 
-Read `auto_patch_enabled` from stdout. If the command errors or the result has no `auto_patch_enabled`, refuse the loop and tell the human that Cyclone auto-patch could not be verified. If it is `true` and the human asked you to turn Cyclone off, run `mg settings --auto-patch off` and re-read; otherwise refuse the loop, same rule as step 1.
+Read `auto_patch_enabled` from stdout. If the command errors or the result has no `auto_patch_enabled`, refuse the loop and tell the human that Cyclone auto-patch could not be verified. Run `mg stack list --json` and find the stack whose layers contain this PR. If there is no stack, or its `cycloneOwnerMatch` is missing, `lookup_failed`, or `different`, refuse the loop. Tell the human the API key and the Cyclone install are different accounts (or adopt first, or the lookup failed). Do not run `mg settings --auto-patch off`. If `cycloneOwnerMatch` is `same` or `none` and `autoPatchOverride` is `false`, continue. If it is unset and the account flag is `false`, continue. If it is `true`, or it is unset while the account flag is `true`, refuse unless the human asked you to turn Cyclone off for this PR; only then run `mg stack set <stack-id> --auto-patch off` and re-read with `mg stack list --json`.
 
 ```bash
-mg pr <owner/repo>#<n> --json --wait --after-sha <sha> --timeout <s>
+mg pr <owner/repo>#<n> --json --wait --after-sha <sha> --after-pass <saved-pass> --timeout <s>
 ```
 
-Parse stdout as one `mergestorm.pr_review/v1` object. Same fields, same stop rules.
+Parse stdout as one `mergestorm.pr_review/v1` object. Same fields, same stop rules. `--after-pass` follows the same rule as `after_pass` above: only when the last envelope you acted on is on that same `head_sha`; omit it for a freshly pushed SHA. `--pass <n>` reads one exact attempt on the head.