mergestorm 0.3.22 → 0.3.23

package/README.md

@@ -45,12 +45,12 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│ ▟██▛  mergestorm v0.3.22                                                     │
+│ ▟██▛  mergestorm v0.3.23                                                     │
 │  ▜▙   ● msk_live_…  · maelstrom                                              │
 │       [████████░░░░░░░░░░░░░░░░░░░░░░] 25% used · Resets Sep 5, 10:53am (UTC)│
 │                                                                              │
 │       review a diff · usage for tabs · /help for all commands                │
-│       New in v0.3.22: stack wait holds an unchanged queue instead of spinning│
+│       New in v0.3.23: leave a stack bottom on mg-stack-<n>                  │
 ╰──────────────────────────────────────────────────────────────────────────────╯
 mergestorm
 ╭──────────────────────────────────────────────────────────────────────────────╮
@@ -104,7 +104,7 @@ mergestorm stack reset --force  Clear local authoring state (not branches/PRs)
 
 If the parent branch is already a layer of a **registered** (submitted) stack, `create` and `submit` refuse unless you pass **`--extend`**. That blocks accidentally gluing an unrelated PR onto an open unit. Growing a registered stack on purpose: `mg stack create --onto <tip> --extend` → commit → `mg stack submit --extend`.
 
-`stack submit` walks the **active** local stack: `git push -u origin` each layer, opens a PR with `gh` (`--base` = parent or trunk; skips heads that already have an open PR; body from the tip commit — Summary + Test plan, preserving Fixes/Closes/Resolves), registers the stack with `POST /api/v1/stacks/adopt` internally (Mergestorm API key), then drops that local stack entry so the next create onto trunk is clean. Push/PR auth is your local `git` + `gh auth` — not a GitHub App installation token.
+`stack submit` walks the **active** local stack: `git push -u origin` each layer, opens a PR with `gh` (`--base` = parent or trunk; adopt then moves the bottom of a 2+ PR stack onto `mg-stack-<n>` — leave it there; skips heads that already have an open PR; body from the tip commit — Summary + Test plan, preserving Fixes/Closes/Resolves), registers the stack with `POST /api/v1/stacks/adopt` internally (Mergestorm API key), then drops that local stack entry so the next create onto trunk is clean. Push is always your local `git` credentials. PRs open as you when `gh` is installed and `gh api user` succeeds; otherwise `stack submit` asks the Mergestorm API (`POST /api/v1/stacks/pulls`) to open them as Cyclone on your behalf, after checking your GitHub account has write access, and assigns you. Without either, submit stops before pushing and links the Cyclone install page.
 
 Legacy repo-local `.mergestorm/stack.json` state migrates automatically on the next stack command. If local authoring state is stale or malformed, use `mg stack reset --force`; this clears only pre-submit CLI state and never deletes branches, PRs, or registered stacks.
 

package/dist/api.d.ts

@@ -225,6 +225,25 @@ export declare function ensureUpperPark(stackId: string, cfg?: Config): Promise<
     freezeBranch: string;
     created: boolean;
 }>;
+export declare const CYCLONE_INSTALL_URL = "https://github.com/apps/mergestorm-cyclone/installations/new";
+export declare function cycloneNotInstalledMessage(owner: string, repo: string, installUrl?: string): string;
+export declare function findStackPull(cfg: Config, input: {
+    owner: string;
+    repo: string;
+    head: string;
+}): Promise<number | null>;
+export declare function openStackPull(cfg: Config, input: {
+    owner: string;
+    repo: string;
+    head: string;
+    base: string;
+    title: string;
+    body: string;
+}): Promise<{
+    number: number;
+    url: string;
+    created: boolean;
+}>;
 /** Arm or disarm Auto land on one owned stack. */
 export declare function setStackAutoLand(stackId: string, enabled: boolean, cfg?: Config): Promise<unknown>;
 /**

package/dist/api.js

@@ -437,6 +437,56 @@ export async function ensureUpperPark(stackId, cfg) {
         created: body.created === true,
     };
 }
+export const CYCLONE_INSTALL_URL = "https://github.com/apps/mergestorm-cyclone/installations/new";
+export function cycloneNotInstalledMessage(owner, repo, installUrl = CYCLONE_INSTALL_URL) {
+    return (`Opening PRs needs either the GitHub CLI (gh auth login) or Cyclone installed on ` +
+        `${owner}/${repo} (${installUrl}).`);
+}
+function installUrlFrom(message) {
+    if (typeof message !== "string")
+        return CYCLONE_INSTALL_URL;
+    return message.match(/https:\/\/github\.com\/apps\/[^\s)]+\/installations\/new/)?.[0] ?? CYCLONE_INSTALL_URL;
+}
+function stackPullFailure(status, body, owner, repo, failLabel) {
+    const rejection = (body && typeof body === "object" ? body : {});
+    const text = `${String(rejection.error ?? "")} ${String(rejection.message ?? "")}`;
+    if (rejection.error === "cyclone_not_installed" ||
+        /not installed|installation[^\n]*not found/i.test(text)) {
+        return new CommandError(cycloneNotInstalledMessage(owner, repo, installUrlFrom(rejection.message)), 1, "cyclone_not_installed");
+    }
+    if (status === 404) {
+        return new CommandError("Stacks API cannot open PRs on this server yet. Install the GitHub CLI (gh auth login) and retry.");
+    }
+    const detail = typeof rejection.message === "string" ? rejection.message : JSON.stringify(body);
+    return new CommandError(`${failLabel} (HTTP ${status}): ${detail}`);
+}
+export async function findStackPull(cfg, input) {
+    const query = new URLSearchParams(input).toString();
+    const { status, body } = await apiFetch(cfg, `/api/v1/stacks/pulls?${query}`);
+    if (status !== 200) {
+        throw stackPullFailure(status, body, input.owner, input.repo, `Failed to look up the PR for ${input.head}`);
+    }
+    const n = body?.number;
+    return typeof n === "number" && n > 0 ? n : null;
+}
+export async function openStackPull(cfg, input) {
+    const { status, body } = await apiFetch(cfg, "/api/v1/stacks/pulls", {
+        method: "POST",
+        json: input,
+    });
+    if (status !== 200 && status !== 201) {
+        throw stackPullFailure(status, body, input.owner, input.repo, `Failed to open PR ${input.head} → ${input.base}`);
+    }
+    const row = (body ?? {});
+    if (typeof row.number !== "number" || row.number <= 0) {
+        throw new CommandError(`Failed to open PR ${input.head} → ${input.base}: no pull request number returned`);
+    }
+    return {
+        number: row.number,
+        url: typeof row.url === "string" ? row.url : "",
+        created: row.created === true,
+    };
+}
 async function stackMutation(stackId, pathSuffix, method, json, failLabel, cfg) {
     const resolved = cfg ?? (await loadConfig());
     const { status, body } = await apiFetch(resolved, `/api/v1/stacks/${encodeURIComponent(stackId)}${pathSuffix}`, method === "PATCH"

package/dist/commands/stack.d.ts

@@ -1,4 +1,4 @@
-import { adoptStack, ensureUpperPark, getEnrichedStack, listStacks, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
+import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, listStacks, openStackPull, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
 import { loadConfig } from "../config.js";
 import { createPrs, findOpenPrNumber } from "../gh.js";
 import { parseGithubOriginRepo } from "../git.js";
@@ -106,7 +106,7 @@ export type StackSubmitDeps = {
     loadStackMeta?: typeof loadStackMeta;
     saveStackMeta?: typeof saveStackMeta;
     parseGithubOriginRepo?: typeof parseGithubOriginRepo;
-    requireGh?: (cwd?: string) => void;
+    ghReady?: (cwd?: string) => boolean;
     branchExists?: typeof branchExists;
     fetchRemoteBranch?: typeof fetchRemoteBranch;
     pushBranch?: typeof pushBranch;
@@ -116,6 +116,8 @@ export type StackSubmitDeps = {
     tipCommitMessage?: typeof tipCommitMessage;
     buildPrBodyFromCommit?: typeof buildPrBodyFromCommit;
     createPrs?: typeof createPrs;
+    findStackPull?: typeof findStackPull;
+    openStackPull?: typeof openStackPull;
     loadConfig?: typeof loadConfig;
     listStacks?: typeof listStacks;
     adoptStack?: typeof adoptStack;

package/dist/commands/stack.js

@@ -1,8 +1,8 @@
 import { stackBlockersSummary } from "../stack-blockers.js";
-import { adoptStack, ensureUpperPark, getEnrichedStack, landNextStack, listStacks, restackStack, setStackPolicy, } from "../api.js";
+import { adoptStack, ensureUpperPark, findStackPull, getEnrichedStack, landNextStack, listStacks, openStackPull, restackStack, setStackPolicy, } from "../api.js";
 import { loadConfig } from "../config.js";
 import { rateLimitedMessage, REVIEW_EXIT, CommandError } from "../errors.js";
-import { createPrs, findOpenPrNumber, githubApiFromEnv, requireGh, } from "../gh.js";
+import { createPrs, findOpenPrNumber, ghReady, githubApiFromEnv, } from "../gh.js";
 import { parseGithubOriginRepo } from "../git.js";
 import { branchExists, commitsAheadOf, createBranchFromHead, currentBranch, defaultLayerBranchName, deleteBranch, discoverTrunk, fetchRemoteBranch, pushBranch, tipCommitMessage, tipCommitSubject, worktreeDirty, } from "../git-stack.js";
 import { buildPrBodyFromCommit } from "../pr-body.js";
@@ -33,6 +33,9 @@ const STACK_USAGE = `usage:
   stack submit opens PRs with a body generated from each layer tip commit.
   Layers 1–2 use the git parent as GitHub base. Layer 3+ opens onto the
   review-unit park freeze (mg-park-*) so adopt does not retarget after open.
+  After adopt, the bottom of a 2+ PR stack is based on the owned trunk
+  mg-stack-<n>; leave it (do not retarget it to trunk). A 1-PR stack stays on
+  trunk.
   stack submit talks to GitHub GraphQL and falls back to the REST API when
   GraphQL is blocked; --rest (or MERGESTORM_GITHUB_API=rest) forces REST.
   Parenting onto a branch that already belongs to a registered (submitted)
@@ -545,7 +548,7 @@ export async function cmdStackSubmit(args, deps = {}) {
     const loadStackMetaFn = deps.loadStackMeta ?? loadStackMeta;
     const saveStackMetaFn = deps.saveStackMeta ?? saveStackMeta;
     const parseOriginFn = deps.parseGithubOriginRepo ?? parseGithubOriginRepo;
-    const requireGhFn = deps.requireGh ?? requireGh;
+    const ghReadyFn = deps.ghReady ?? ghReady;
     const branchExistsFn = deps.branchExists ?? branchExists;
     const fetchRemoteBranchFn = deps.fetchRemoteBranch ?? fetchRemoteBranch;
     const pushBranchFn = deps.pushBranch ?? pushBranch;
@@ -555,6 +558,8 @@ export async function cmdStackSubmit(args, deps = {}) {
     const tipCommitMessageFn = deps.tipCommitMessage ?? tipCommitMessage;
     const buildPrBodyFn = deps.buildPrBodyFromCommit ?? buildPrBodyFromCommit;
     const createPrsFn = deps.createPrs ?? createPrs;
+    const findStackPullFn = deps.findStackPull ?? findStackPull;
+    const openStackPullFn = deps.openStackPull ?? openStackPull;
     const loadConfigFn = deps.loadConfig ?? loadConfig;
     const listStacksFn = deps.listStacks ?? listStacks;
     const adoptStackFn = deps.adoptStack ?? adoptStack;
@@ -575,7 +580,27 @@ export async function cmdStackSubmit(args, deps = {}) {
         throw new CommandError("Could not parse GitHub owner/repo from `origin`. Set a github.com remote and retry.");
     }
     const { owner, repo } = origin;
-    requireGhFn(cwd);
+    let opener;
+    if (ghReadyFn(cwd)) {
+        opener = {
+            findOpen: async (branch) => findOpenPrNumberFn(owner, repo, branch, cwd, { api }),
+            create: async (prs) => createPrsFn({ owner, repo, prs, cwd, api }).map((number) => ({ number, created: true })),
+        };
+    }
+    else {
+        const apiCfg = await loadConfigFn();
+        opener = {
+            findOpen: (branch) => findStackPullFn(apiCfg, { owner, repo, head: branch }),
+            create: async (prs) => {
+                const rows = [];
+                for (const pr of prs) {
+                    const row = await openStackPullFn(apiCfg, { owner, repo, ...pr });
+                    rows.push({ number: row.number, created: row.created });
+                }
+                return rows;
+            },
+        };
+    }
     // Safety net: refuse submit that would open/register onto a registered tip
     // without --extend. Check every layer's parent (mid-stack layers from older
     // local state must not sail through), scoped to this repo, and fail closed
@@ -625,6 +650,10 @@ export async function cmdStackSubmit(args, deps = {}) {
         autoReview: pick(autoReview, stored?.autoReviewOverride),
         autoPatch: pick(autoPatch, stored?.autoPatchOverride),
     });
+    const existingPrs = new Map();
+    for (const plan of plans) {
+        existingPrs.set(plan.branch, await opener.findOpen(plan.branch));
+    }
     for (const layer of layers) {
         if (!branchExistsFn(layer.branch, cwd)) {
             throw new CommandError(`Stack layer branch missing locally: ${layer.branch}`);
@@ -638,11 +667,7 @@ export async function cmdStackSubmit(args, deps = {}) {
         }
     }
     const opened = [];
-    const pendingPark = plans.filter((plan) => {
-        if (findOpenPrNumberFn(owner, repo, plan.branch, cwd, { api }) != null)
-            return false;
-        return plan.githubBase == null;
-    });
+    const pendingPark = plans.filter((plan) => existingPrs.get(plan.branch) == null && plan.githubBase == null);
     const prepareLayerPr = (branch, base) => {
         const aheadRef = isMgParkBranch(base) ? `origin/${base}` : base;
         if (isMgParkBranch(base)) {
@@ -674,11 +699,11 @@ export async function cmdStackSubmit(args, deps = {}) {
             body: buildPrBodyFn(tipCommitMessageFn(branch, cwd)),
         };
     };
-    const openLayerWave = (wave) => {
+    const openLayerWave = async (wave) => {
         const rows = [];
         const pending = [];
         for (const { branch, base } of wave) {
-            const existing = findOpenPrNumberFn(owner, repo, branch, cwd, { api });
+            const existing = existingPrs.get(branch) ?? null;
             if (existing != null) {
                 progress(ansi.dim(`  PR #${existing} already open for ${branch}`));
                 rows.push({ branch, base, prNumber: existing, created: false });
@@ -692,19 +717,19 @@ export async function cmdStackSubmit(args, deps = {}) {
         for (const { pr } of pending) {
             progress(ansi.dim(`  Opening PR ${pr.head} → ${pr.base} …`));
         }
-        const numbers = createPrsFn({ owner, repo, prs: pending.map((p) => p.pr), cwd, api });
+        const numbers = await opener.create(pending.map((p) => p.pr));
         if (numbers.length !== pending.length) {
             throw new CommandError(`GitHub returned ${numbers.length} PR numbers for ${pending.length} new pull requests.`);
         }
         pending.forEach(({ index }, i) => {
-            rows[index].prNumber = numbers[i];
+            rows[index].prNumber = numbers[i].number;
+            rows[index].created = numbers[i].created;
         });
         return rows;
     };
-    opened.push(...openLayerWave(plans
-        .filter((plan) => plan.githubBase != null ||
-        findOpenPrNumberFn(owner, repo, plan.branch, cwd, { api }) != null)
-        .map((plan) => ({ branch: plan.branch, base: plan.githubBase ?? plan.gitParent }))));
+    opened.push(...(await openLayerWave(plans
+        .filter((plan) => plan.githubBase != null || existingPrs.get(plan.branch) != null)
+        .map((plan) => ({ branch: plan.branch, base: plan.githubBase ?? plan.gitParent })))));
     const cfg = await loadConfigFn();
     let adoptData = null;
     let stackId = plans.find((plan) => plan.stackId)?.stackId ?? null;
@@ -735,7 +760,7 @@ export async function cmdStackSubmit(args, deps = {}) {
         }
         progress(ansi.dim(`  Ensuring upper-park freeze for stack ${stackId} …`));
         const park = await ensureUpperParkFn(stackId, cfg);
-        opened.push(...openLayerWave(pendingPark.map((plan) => ({ branch: plan.branch, base: park.freezeBranch }))));
+        opened.push(...(await openLayerWave(pendingPark.map((plan) => ({ branch: plan.branch, base: park.freezeBranch })))));
         await registerPr(opened[opened.length - 1].prNumber);
     }
     else {
@@ -763,6 +788,10 @@ export async function cmdStackSubmit(args, deps = {}) {
         const verb = row.created ? "opened" : "exists";
         summary.push(ansi.brightGreen(`  #${row.prNumber}  ${row.branch} → ${row.base}  (${verb})`));
     }
+    const adoptedTrunk = data.stack?.trunkBranch;
+    if (adoptedTrunk?.startsWith("mg-stack-")) {
+        summary.push(ansi.dim(`  Bottom base is now ${adoptedTrunk} (Mergestorm-owned trunk). Leave it.`));
+    }
     if (stackId) {
         summary.push(ansi.brightGreen(`  Registered stack ${stackId}`));
     }

package/dist/gh.d.ts

@@ -28,7 +28,7 @@ type GhSpawn = (command: string, args: string[], options: {
     status: number | null;
 };
 export declare function runGh(args: string[], cwd?: string, input?: string, spawn?: GhSpawn): GhResult;
-export declare function requireGh(cwd?: string): void;
+export declare function ghReady(cwd?: string, gh?: GhRunner): boolean;
 /** Open PR number for `head` branch in owner/repo, or null. */
 export declare function findOpenPrNumber(owner: string, repo: string, headBranch: string, cwd?: string, options?: {
     api?: GithubApi;

package/dist/gh.js

@@ -40,15 +40,8 @@ export function runGh(args, cwd = process.cwd(), input, spawn = spawnSync) {
     }
     return { ok: true, stdout: result.stdout ?? "" };
 }
-export function requireGh(cwd = process.cwd()) {
-    const check = runGh(["--version"], cwd);
-    if (!check.ok) {
-        throw new CommandError("GitHub CLI (`gh`) is required for `stack submit`. Install https://cli.github.com and run `gh auth login`.");
-    }
-    const auth = runGh(["auth", "status"], cwd);
-    if (!auth.ok) {
-        throw new CommandError("`gh` is installed but not authenticated. Run `gh auth login`, then retry `stack submit`.");
-    }
+export function ghReady(cwd = process.cwd(), gh = (args) => runGh(args, cwd)) {
+    return gh(["--version"]).ok && gh(["api", "user"]).ok;
 }
 /** Open PR number for `head` branch in owner/repo, or null. */
 export function findOpenPrNumber(owner, repo, headBranch, cwd = process.cwd(), options = {}) {

package/dist/ui/banner.js

@@ -99,6 +99,9 @@ const WHATS_NEW = {
     "0.3.22": [
         "stack wait holds an unchanged queue instead of spinning",
     ],
+    "0.3.23": [
+        "leave a stack bottom on mg-stack-<n>",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

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

@@ -18,7 +18,7 @@ Call `stack_status` with `stack_id`. Require that stack's `autoEnqueueWhenReady`
 1. Call `stack_wait` with the named `stack_id` and `timeout_s: 45`. On initial enrollment, omit the cursor selectors. Save the returned `cursor`: map `cursor.enrolledHeadSha` to `enrolled_head_sha`, `cursor.afterFinishedAt` to `after_finished_at`, and `cursor.bounceId` to `bounce_id` (omit only absent fields; preserve explicit nulls). Keep `bounce_id` alongside `after_finished_at`; never pass one without the other when the returned cursor has both. The shipped tool accepts these selectors, not a nested cursor argument.
 2. Keep the same cursor across retries. An unread deadline times out as `failed`; stop and report. Timeout `waiting` or `in_progress` after a snapshot is not failure — call `stack_wait` again in 45s slices with the same cursor after inspecting `issues[]`. Inspect `issues[]` on `in_progress` too: a live queue does not erase upstack hard blocks. `waiting` with issues is not idle. If `assessment` is `unavailable`, do not infer that the stack is issue-free; refresh `stack_status`, whose `attention`, `issues`, and `currentCandidate` come from the same blocker rules as `stack_wait`. Do not replace the enrolled head with a newer snapshot head or advance the timestamp just because a wait timed out. On a surfaced `rate_limited` error, honor the retry delay and retain the cursor; on `failed` or an unrecoverable tool error, stop and report the reason. `queue_status` returning `queue_entry_not_found` is not a failure: an empty queue for the stack is a normal wait.
 3. On `attention`, fix the named PR: `prNumber` and `headSha` identify the blocked PR, while `currentCandidate` identifies the promote candidate. The gate covers the bottom and its direct child only when the child has current-head DIRTY on the live bottom branch. A GitHub DIRTY whose `parentBranch` starts with `mg-park-` is not that gate. Refresh `stack_status`; use `queue_status` with the same `stack_id` when bounce details are needed. Verify the blocker still applies to the current PR head. Never treat `verifyHeadSha` as the current head: it is a queue verification SHA and can be stale or synthetic. Compare the live PR branch head, the current stack layer head, and the checkout before editing. Read the live PR head with `git ls-remote origin refs/heads/<branch>` or `gh api repos/OWNER/REPO/pulls/N --jq .head.sha`. If you need CI logs, use `gh run list --branch <branch>`, `gh run view <run-id> --log-failed`, or `gh api repos/OWNER/REPO/commits/SHA/check-runs`. Read GitHub only through git and these REST calls; do not use other `gh pr` subcommands. Restack `clean` does not mean mergeable or CI-green. Attention is a diagnosis, not permission to mutate stack or queue policy.
-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 — 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.
+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. 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.
 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.
@@ -48,4 +48,5 @@ A kind is context, not permission to mutate queue or stack policy. Diagnose the
 - 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 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

@@ -30,6 +30,7 @@ mg skill install --claude --cursor --agents
    - Adoption needs the Cyclone GitHub App on the account; without it `stack_adopt` returns `cyclone_not_connected` — stop and tell the human, do not retry.
    - 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.
+   - After adopting 2+ PRs the bottom PR's GitHub base is `mg-stack-<n>` and PR3+ sit on an `mg-park-*` freeze; a 1-PR stack stays on main. That is expected; leave every base as Mergestorm set it.
    - 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`.
@@ -73,6 +74,7 @@ Map these to `mergestorm.pr_review/v1` envelope fields; do not invent statuses.
 - 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
+- change a PR's GitHub base (`gh pr edit --base` or the REST equivalent), including moving a bottom from `mg-stack-<n>` back to main. If one was moved, stop and tell the human. Do not run stack land or re-adopt to repair it.
 - 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