mergestorm 0.3.4 → 0.3.6

package/README.md

@@ -48,14 +48,14 @@ mergestorm          # uses your local build
 On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a **full-width** welcome panel (logo + status on the left, tips / what's new on the right) and a **full-width** bordered input box with a live `/` slash-command dropdown. Non-TTY (CI/pipes) prints usage instead — no hanging prompt.
 
 ```
-╭─ mergestorm v0.3.4 ──────────────────────────────────────────────────────────╮
+╭─ mergestorm v0.3.6 ──────────────────────────────────────────────────────────╮
 │      ▟██████████▛       Tips for getting started                             │
 │       ▜████████▛          review      review main...HEAD                     │
 │        ▝▜████▛▘           stack       create → submit → restack → land       │
 │          ▜██▛             /help       list all commands                      │
 │           ██                                                                 │
-│           ▝▘            What's new in v0.3.4                                 │
-│  ● msk…  ·  maelstrom     • stack create / submit (author with mg)           │
+│           ▝▘            What's new in v0.3.6                                 │
+│  ● msk…  ·  maelstrom     • stack state under ~/.mergestorm/stacks/          │
 │  [████░░░░░░░░░░] 12% used                                                   │
 ╰──────────────────────────────────────────────────────────────────────────────╯
 mergestorm
@@ -99,13 +99,16 @@ mergestorm stack adopt <owner/repo>#<pr>  Import an existing open PR chain
 mergestorm stack restack <stack-id>  Restack descendants
 mergestorm stack land <stack-id>     Land the bottom open PR
 mergestorm stack auto-land on|off <stack-id>  Toggle auto-land when green
+mergestorm stack reset --force  Clear local authoring state (not branches/PRs)
 ```
 
 `mg` is a short alias for `mergestorm` (same binary), e.g. `mg stack create`. Happy path: **create → commit → submit → restack → land**. `stack adopt` is for importing a chain that already exists on GitHub (legacy / Graphite). Restack/land use the same login key (`/api/v1/stacks`).
 
-`stack create` is local-only: it checks out a new branch from the current tip (or `--onto <branch>`), discovers trunk (`main` / `master` / `origin/HEAD`, overridable with `--trunk`), and appends `{ branch, parentBranch }` under **`.mergestorm/stack.json`**. No GitHub or API calls.
+`stack create` is local-only: it 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. Linked worktrees share state, while independent clones remain isolated. Creating onto trunk with a non-empty active stack starts a new one. No repository file, GitHub call, or API call is made.
 
-`stack submit` walks that meta: `git push -u origin` each layer, opens a PR with `gh` (`--base` = parent or trunk; skips heads that already have an open PR), then registers the stack with `POST /api/v1/stacks/adopt` internally (Mergestorm API key). Push/PR auth is your local `git` + `gh auth` — not a Cyclone app token.
+`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 Cyclone app token.
+
+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.
 
 ### `login`
 
@@ -119,7 +122,7 @@ Removes `~/.mergestorm/config.json` so the stored key is no longer used.
 
 ### `review [base] [head]`
 
-Collects `git diff base...head` (default `main...HEAD`), attaches the changed file contents (up to 40 files, skipping files > 400 KB), auto-attaches context from `./.mergestorm/**/*.md|*.txt`, submits the job, and polls until it finishes (~3 min max). The thread slug is derived from the current branch (`local/<branch>`), so repeated runs on the same branch chain their findings.
+Collects `git diff base...head` (default `main...HEAD`), attaches the changed file contents (up to 40 files, skipping files > 400 KB), submits the job, and polls until it finishes (~3 min max). The thread slug is derived from the current branch (`local/<branch>`), so repeated runs on the same branch chain their findings. Programmatic callers can provide explicit review context through the Review Jobs API.
 
 ```bash
 mergestorm review              # main...HEAD
@@ -141,10 +144,6 @@ Require a logged-in key and API support for `GET /api/v1/me` and `GET /api/v1/re
 
 `branches` calls `GET /api/v1/threads` for recently active review threads (branches). On a TTY it opens an arrow-key selector; Enter loads that thread's job timeline. `chain [slug]` is the direct timeline view — omit the slug to use `local/<current-git-branch>` (same slug `review` stamps).
 
-## Context pack (`.mergestorm/`)
-
-Any `*.md` / `*.txt` files under `./.mergestorm/` (one level of nesting) are attached as context so the reviewer understands intent, conventions, or migration notes without you resending history.
-
 ## Environment
 
 | Variable | Purpose | Default |

package/dist/api.d.ts

@@ -91,6 +91,13 @@ export type StackLayerDto = {
     htmlUrl: string | null;
     ciStatus: string;
     reviewStatus: string;
+    checks: {
+        total: number;
+        success: number;
+        pending: number;
+        failure: number;
+        failingName: string | null;
+    } | null;
     conflictDetail: string | null;
     lastRestackedSha: string | null;
 };
@@ -99,7 +106,7 @@ export type StackDto = {
     owner: string;
     repo: string;
     trunkBranch: string;
-    autoLandWhenGreen: boolean;
+    autoPromoteWhenGreen: boolean;
     layers: StackLayerDto[];
 };
 /** List stacks (Bearer GET /api/v1/stacks). */
@@ -109,8 +116,10 @@ export declare function adoptStack(owner: string, repo: string, prNumber: number
 /** Restack descendants (Bearer POST /api/v1/stacks/:id/restack). */
 export declare function restackStack(stackId: string, cfg?: Config): Promise<unknown>;
 /** Land the bottom open layer (Bearer POST /api/v1/stacks/:id/land-next). */
-export declare function landNextStack(stackId: string, cfg?: Config): Promise<unknown>;
-/** Toggle auto-land when green (Bearer PATCH /api/v1/stacks/:id). */
-export declare function setStackAutoLand(stackId: string, autoLandWhenGreen: boolean, cfg?: Config): Promise<unknown>;
+export declare function landNextStack(stackId: string, cfg?: Config, opts?: {
+    prNumber?: number;
+}): Promise<unknown>;
+/** Toggle auto-promote when green (Bearer PATCH /api/v1/stacks/:id). */
+export declare function setStackAutoPromote(stackId: string, autoPromoteWhenGreen: boolean, cfg?: Config): Promise<unknown>;
 /** Recently reviewed branches/threads (Bearer GET /api/v1/threads). */
 export declare function listThreads(limit?: number, cfg?: Config): Promise<ThreadListItem[]>;

package/dist/api.js

@@ -119,12 +119,15 @@ export async function restackStack(stackId, cfg) {
     return stackMutation(stackId, "/restack", "POST", {}, "Failed to restack", cfg);
 }
 /** Land the bottom open layer (Bearer POST /api/v1/stacks/:id/land-next). */
-export async function landNextStack(stackId, cfg) {
-    return stackMutation(stackId, "/land-next", "POST", {}, "Failed to land next", cfg);
+export async function landNextStack(stackId, cfg, opts) {
+    const json = opts?.prNumber != null && Number.isInteger(opts.prNumber) && opts.prNumber > 0
+        ? { prNumber: opts.prNumber }
+        : {};
+    return stackMutation(stackId, "/land-next", "POST", json, "Failed to land next", cfg);
 }
-/** Toggle auto-land when green (Bearer PATCH /api/v1/stacks/:id). */
-export async function setStackAutoLand(stackId, autoLandWhenGreen, cfg) {
-    return stackMutation(stackId, "", "PATCH", { autoLandWhenGreen }, "Failed to update auto-land", cfg);
+/** Toggle auto-promote when green (Bearer PATCH /api/v1/stacks/:id). */
+export async function setStackAutoPromote(stackId, autoPromoteWhenGreen, cfg) {
+    return stackMutation(stackId, "", "PATCH", { autoPromoteWhenGreen }, "Failed to update auto-promote", cfg);
 }
 /** Recently reviewed branches/threads (Bearer GET /api/v1/threads). */
 export async function listThreads(limit = 20, cfg) {

package/dist/cli.js

@@ -30,13 +30,14 @@ function usage() {
   mergestorm chain [slug]         Branch review-chain timeline (default: current)
   mergestorm whoami [--json]      Key + plan + API base
   mergestorm thread <slug>        Jobs in a review thread
-  mergestorm stack create [name]  New local stack layer (.mergestorm/stack.json)
-  mergestorm stack submit         Push layers, open chained PRs, register stack
+  mergestorm stack create [name]  New local stack layer (CLI-managed authoring state)
+  mergestorm stack submit         Push active local stack, open PRs, register stack
+  mergestorm stack reset --force  Clear this repo's pre-submit authoring state
   mergestorm stack list [--json]  List registered stacks
   mergestorm stack adopt <owner/repo>#<pr>  Import an existing open PR chain
   mergestorm stack restack <stack-id>   Restack stack descendants
-  mergestorm stack land <stack-id>      Land the bottom open PR
-  mergestorm stack auto-land on|off <stack-id>  Toggle auto-land when green
+  mergestorm stack land <stack-id>      Land bottom PR (or promote into unit)
+  mergestorm stack auto-promote on|off <stack-id>  Toggle auto-promote when green
 
   mg is a short alias for mergestorm (same binary).
 

package/dist/commands/review.d.ts

@@ -4,7 +4,7 @@ export type ReviewOptions = {
     interactive?: boolean;
 };
 /** Parse `origin` remote into GitHub owner/repo when possible. */
-export declare function parseGithubOriginRepo(): {
+export declare function parseGithubOriginRepo(cwd?: string): {
     owner: string;
     repo: string;
 } | null;

package/dist/commands/review.js

@@ -1,12 +1,12 @@
 import { apiFetch, getMe } from "../api.js";
 import { loadConfig } from "../config.js";
 import { CommandError, DetachedError } from "../errors.js";
-import { collectChangedFiles, collectContextFiles, git } from "../git.js";
+import { collectChangedFiles, git } from "../git.js";
 import { ansi } from "../ui/ansi.js";
 /** Parse `origin` remote into GitHub owner/repo when possible. */
-export function parseGithubOriginRepo() {
+export function parseGithubOriginRepo(cwd = process.cwd()) {
     try {
-        const url = git(["remote", "get-url", "origin"]).trim();
+        const url = git(["remote", "get-url", "origin"], cwd).trim();
         if (!url)
             return null;
         const m = url.match(/^(?:https?:\/\/|git@)?github\.com[:/]([A-Za-z0-9_-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?\/?$/i);
@@ -44,11 +44,10 @@ export async function cmdReview(args, opts = {}) {
         return;
     }
     const files = await collectChangedFiles(base, head);
-    const context_files = await collectContextFiles(process.cwd());
     const branch = git(["rev-parse", "--abbrev-ref", "HEAD"]).trim() || "local";
     const thread = `local/${branch}`.replace(/[^a-zA-Z0-9._/-]/g, "-").slice(0, 120);
     const originRepo = parseGithubOriginRepo();
-    console.log(`Submitting review (${Buffer.byteLength(diff, "utf8")} byte diff, ${files.length} file(s), ${context_files.length} context file(s))…`);
+    console.log(`Submitting review (${Buffer.byteLength(diff, "utf8")} byte diff, ${files.length} file(s))…`);
     const { status, body } = await apiFetch(cfg, "/api/v1/reviews", {
         method: "POST",
         json: {
@@ -59,7 +58,6 @@ export async function cmdReview(args, opts = {}) {
             head_label: head,
             diff,
             files,
-            context_files,
         },
         signal: opts.signal,
     });

package/dist/commands/stack.d.ts

@@ -12,4 +12,5 @@ export declare function parseStackCreateArgs(args: string[]): {
     trunk?: string;
     asJson: boolean;
 };
+export declare function parseStackResetArgs(args: string[]): void;
 export declare function cmdStack(args: string[]): Promise<void>;

package/dist/commands/stack.js

@@ -1,19 +1,26 @@
-import { adoptStack, landNextStack, listStacks, restackStack, setStackAutoLand, } from "../api.js";
+import { adoptStack, landNextStack, listStacks, restackStack, setStackAutoPromote, } from "../api.js";
 import { loadConfig } from "../config.js";
 import { CommandError } from "../errors.js";
 import { createPr, findOpenPrNumber, requireGh } from "../gh.js";
-import { branchExists, createBranchFromHead, currentBranch, defaultLayerBranchName, deleteBranch, discoverTrunk, pushBranch, tipCommitSubject, worktreeDirty, } from "../git-stack.js";
-import { appendLayer, loadStackMeta, saveStackMeta, } from "../stack-meta.js";
+import { branchExists, createBranchFromHead, currentBranch, defaultLayerBranchName, deleteBranch, discoverTrunk, pushBranch, tipCommitMessage, tipCommitSubject, worktreeDirty, } from "../git-stack.js";
+import { buildPrBodyFromCommit } from "../pr-body.js";
+import { gitTopLevel } from "../repo-identity.js";
+import { activeLayers, appendLayer, emptyStackMeta, loadStackMeta, removeActiveStack, resetStackMeta, saveStackMeta, selectStackForCreate, } from "../stack-meta.js";
 import { ansi } from "../ui/ansi.js";
 import { parseGithubOriginRepo } from "./review.js";
 const STACK_USAGE = `usage:
   mergestorm stack create [name] [--onto <branch>] [--trunk <branch>] [--json]
   mergestorm stack submit [--json]
+  mergestorm stack reset --force
   mergestorm stack list [--json]
   mergestorm stack adopt <owner/repo>#<pr>
   mergestorm stack restack <stack-id> [--json]
   mergestorm stack land <stack-id> [--json]
-  mergestorm stack auto-land on|off <stack-id> [--json]`;
+  mergestorm stack auto-promote on|off <stack-id> [--json]
+
+  stack submit opens PRs with a body generated from each layer tip commit.
+  stack land promotes into the review unit when one exists; otherwise lands
+  the bottom open PR (unit-less stacks).`;
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 export function requireStackId(raw, usage) {
     const id = raw?.trim() ?? "";
@@ -44,7 +51,7 @@ export function parseAdoptTarget(args) {
 }
 function formatStackHuman(s) {
     const lines = [];
-    const auto = s.autoLandWhenGreen ? " · auto-land" : "";
+    const auto = s.autoPromoteWhenGreen ? " · auto-promote" : "";
     lines.push(`  ${ansi.bold(`${s.owner}/${s.repo}`)}  trunk=${s.trunkBranch}${auto}`);
     lines.push(`  ${ansi.dim(s.id)}`);
     if (s.layers.length === 0) {
@@ -102,9 +109,20 @@ export function parseStackCreateArgs(args) {
     }
     return { name, onto, trunk, asJson };
 }
+export function parseStackResetArgs(args) {
+    if (args.length !== 1 || args[0] !== "--force") {
+        throw new CommandError("usage: mergestorm stack reset --force\nClears only CLI-managed pre-submit state; branches, PRs, and registered stacks are unchanged.");
+    }
+}
 async function cmdStackCreate(args) {
     const { name, onto, trunk: trunkFlag, asJson } = parseStackCreateArgs(args);
     const cwd = process.cwd();
+    try {
+        gitTopLevel(cwd);
+    }
+    catch {
+        throw new CommandError("Not in a git repository. Run `mg stack create` from inside the repository whose stack you want to author.");
+    }
     if (worktreeDirty(cwd)) {
         throw new CommandError("Working tree is dirty. Commit or stash changes before `stack create`.");
     }
@@ -122,16 +140,16 @@ async function cmdStackCreate(args) {
     let meta = await loadStackMeta(cwd);
     const trunk = trunkFlag?.trim() || meta?.trunk || discoverTrunk(cwd);
     if (!meta) {
-        meta = { version: 1, trunk, layers: [] };
+        meta = emptyStackMeta(trunk);
     }
     else if (trunkFlag?.trim() && meta.trunk !== trunk) {
-        throw new CommandError(`Stack trunk is ${meta.trunk}; refusing --trunk ${trunk}. Edit .mergestorm/stack.json or start fresh.`);
+        throw new CommandError(`Stack trunk is ${meta.trunk}; refusing --trunk ${trunk}. Run \`mg stack reset --force\` to discard local pre-submit state.`);
     }
-    // Parent must be trunk or an existing layer (linear local stack).
-    if (meta.layers.length > 0 &&
-        parentBranch !== meta.trunk &&
-        !meta.layers.some((l) => l.branch === parentBranch)) {
-        throw new CommandError(`Parent ${parentBranch} is not trunk (${meta.trunk}) or a stack layer. Use --onto <branch>.`);
+    try {
+        meta = selectStackForCreate(meta, parentBranch);
+    }
+    catch (err) {
+        throw new CommandError(err instanceof Error ? err.message : String(err));
     }
     try {
         createBranchFromHead(branch, cwd);
@@ -139,10 +157,9 @@ async function cmdStackCreate(args) {
     catch (err) {
         throw new CommandError(err instanceof Error ? err.message : String(err));
     }
-    let next;
     try {
-        next = appendLayer(meta, { branch, parentBranch });
-        await saveStackMeta(next, cwd);
+        meta = appendLayer(meta, { branch, parentBranch });
+        await saveStackMeta(meta, cwd);
     }
     catch (err) {
         try {
@@ -151,13 +168,22 @@ async function cmdStackCreate(args) {
         catch { /* rollback best-effort */ }
         throw new CommandError(err instanceof Error ? err.message : String(err));
     }
+    const layers = activeLayers(meta);
     if (asJson) {
-        console.log(JSON.stringify({ branch, parentBranch, trunk: next.trunk, meta: next }, null, 2));
+        console.log(JSON.stringify({
+            branch,
+            parentBranch,
+            trunk: meta.trunk,
+            active: meta.active,
+            stacks: meta.stacks.length,
+            layers,
+            meta,
+        }, null, 2));
         return;
     }
     console.log(ansi.green(`  Created ${branch} (onto ${parentBranch})`));
-    console.log(ansi.dim(`  trunk: ${next.trunk} · layers: ${next.layers.length}`));
-    console.log(ansi.dim(`  meta: .mergestorm/stack.json`));
+    console.log(ansi.dim(`  trunk: ${meta.trunk} · local stacks: ${meta.stacks.length} · active layers: ${layers.length}`));
+    console.log(ansi.dim("  authoring state: managed automatically outside the repository"));
 }
 async function cmdStackSubmit(args) {
     const asJson = args.includes("--json");
@@ -165,18 +191,25 @@ async function cmdStackSubmit(args) {
         throw new CommandError("usage: mergestorm stack submit [--json]");
     }
     const cwd = process.cwd();
+    try {
+        gitTopLevel(cwd);
+    }
+    catch {
+        throw new CommandError("Not in a git repository. Run `mg stack submit` from inside the repo whose stack you want to push.");
+    }
     const meta = await loadStackMeta(cwd);
-    if (!meta || meta.layers.length === 0) {
-        throw new CommandError("No local stack layers. Run `mg stack create` (and commit) before `stack submit`.");
+    const layers = meta ? activeLayers(meta) : [];
+    if (!meta || layers.length === 0) {
+        throw new CommandError("No local stack layers. Run `mg stack create` (then commit your code) before `stack submit`.");
     }
-    const origin = parseGithubOriginRepo();
+    const origin = parseGithubOriginRepo(cwd);
     if (!origin) {
         throw new CommandError("Could not parse GitHub owner/repo from `origin`. Set a github.com remote and retry.");
     }
     const { owner, repo } = origin;
     requireGh(cwd);
     const opened = [];
-    for (const layer of meta.layers) {
+    for (const layer of layers) {
         const base = layer.parentBranch || meta.trunk;
         if (!branchExists(layer.branch, cwd)) {
             throw new CommandError(`Stack layer branch missing locally: ${layer.branch}`);
@@ -192,6 +225,7 @@ async function cmdStackSubmit(args) {
         let created = false;
         if (prNumber == null) {
             const title = tipCommitSubject(layer.branch, cwd);
+            const body = buildPrBodyFromCommit(tipCommitMessage(layer.branch, cwd));
             console.log(ansi.dim(`  Opening PR ${layer.branch} → ${base} …`));
             prNumber = createPr({
                 owner,
@@ -199,7 +233,7 @@ async function cmdStackSubmit(args) {
                 base,
                 head: layer.branch,
                 title,
-                body: "",
+                body,
                 cwd,
             });
             created = true;
@@ -224,6 +258,8 @@ async function cmdStackSubmit(args) {
         throw new CommandError("Stack was not registered");
     }
     const stackId = data.stack.id;
+    // Drop the submitted local stack so the next create onto trunk starts fresh.
+    await saveStackMeta(removeActiveStack(meta), cwd);
     if (asJson) {
         console.log(JSON.stringify({
             owner,
@@ -247,6 +283,11 @@ async function cmdStackSubmit(args) {
     }
     console.log(ansi.dim("  Dashboard: https://mergestorm.ai/dashboard/stacks"));
 }
+async function cmdStackReset(args) {
+    parseStackResetArgs(args);
+    await resetStackMeta(process.cwd());
+    console.log(ansi.green("  Cleared CLI-managed pre-submit stack state. Branches, PRs, and registered stacks were not changed."));
+}
 async function cmdStackList(args) {
     const asJson = args.includes("--json");
     const cfg = await loadConfig();
@@ -311,6 +352,7 @@ async function cmdStackLand(args) {
     const asJson = args.includes("--json");
     const id = requireStackId(args.find((a) => a !== "--json"), "usage: mergestorm stack land <stack-id>");
     const cfg = await loadConfig();
+    // Server routes unit stacks to promote-next (#244 / AUD-07).
     const body = await landNextStack(id, cfg);
     if (asJson) {
         console.log(JSON.stringify(body, null, 2));
@@ -318,6 +360,15 @@ async function cmdStackLand(args) {
     }
     const pr = body.mergedPrNumber;
     const branch = body.mergedBranch;
+    const uNumber = body.uNumber;
+    if (typeof uNumber === "number" && uNumber > 0) {
+        console.log(ansi.green(`  Promoted` +
+            (pr != null ? ` #${pr}` : "") +
+            ` into U${uNumber}` +
+            (branch ? ` (${branch})` : "") +
+            ` on ${id}`));
+        return;
+    }
     console.log(ansi.green(`  Landed` +
         (pr != null ? ` #${pr}` : "") +
         (branch ? ` (${branch})` : "") +
@@ -327,17 +378,17 @@ async function cmdStackAutoLand(args) {
     const asJson = args.includes("--json");
     const filtered = args.filter((a) => a !== "--json");
     const mode = filtered[0]?.toLowerCase();
-    const id = requireStackId(filtered[1], "usage: mergestorm stack auto-land on|off <stack-id>");
+    const id = requireStackId(filtered[1], "usage: mergestorm stack auto-promote on|off <stack-id>");
     if (mode !== "on" && mode !== "off") {
-        throw new CommandError("usage: mergestorm stack auto-land on|off <stack-id>");
+        throw new CommandError("usage: mergestorm stack auto-promote on|off <stack-id>");
     }
     const cfg = await loadConfig();
-    const body = await setStackAutoLand(id, mode === "on", cfg);
+    const body = await setStackAutoPromote(id, mode === "on", cfg);
     if (asJson) {
         console.log(JSON.stringify(body, null, 2));
         return;
     }
-    console.log(ansi.green(`  Auto-land ${mode} for ${id}`));
+    console.log(ansi.green(`  Auto-promote ${mode} for ${id}`));
 }
 export async function cmdStack(args) {
     const sub = args[0]?.toLowerCase();
@@ -349,6 +400,8 @@ export async function cmdStack(args) {
         return cmdStackCreate(rest);
     if (sub === "submit")
         return cmdStackSubmit(rest);
+    if (sub === "reset")
+        return cmdStackReset(rest);
     if (sub === "list" || sub === "ls")
         return cmdStackList(rest);
     if (sub === "adopt")
@@ -357,7 +410,11 @@ export async function cmdStack(args) {
         return cmdStackRestack(rest);
     if (sub === "land" || sub === "land-next")
         return cmdStackLand(rest);
-    if (sub === "auto-land" || sub === "autoland")
+    if (sub === "auto-promote" ||
+        sub === "autopromote" ||
+        sub === "auto-land" ||
+        sub === "autoland") {
         return cmdStackAutoLand(rest);
+    }
     throw new CommandError(`${STACK_USAGE}\nunknown stack subcommand: ${sub}`);
 }

package/dist/config.d.ts

@@ -3,6 +3,7 @@ export type Config = {
     apiKey?: string;
     apiBase?: string;
 };
+export declare function mergestormHome(): string;
 export declare function configPath(): string;
 export declare function loadConfig(): Promise<Config>;
 export declare function saveConfig(cfg: Config): Promise<void>;

package/dist/config.js

@@ -2,8 +2,11 @@ import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 export const DEFAULT_API = "https://api.mergestorm.ai";
+export function mergestormHome() {
+    return path.join(homedir(), ".mergestorm");
+}
 export function configPath() {
-    return path.join(homedir(), ".mergestorm", "config.json");
+    return path.join(mergestormHome(), "config.json");
 }
 export async function loadConfig() {
     try {

package/dist/git-stack.d.ts

@@ -1,6 +1,12 @@
 /** Current branch name, or null when detached. */
 export declare function currentBranch(cwd?: string): string | null;
-/** True when the worktree has staged/unstaged/untracked changes. */
+/**
+ * True when the worktree has staged/unstaged/untracked changes that should
+ * block `stack create`. Stack authoring metadata lives outside the worktree.
+ * Legacy repo-local `.mergestorm/stack.json` is ignored because `loadStackMeta`
+ * migrates it out of the worktree during `stack create`; counting it as dirty
+ * would block that migration and every subsequent create.
+ */
 export declare function worktreeDirty(cwd?: string): boolean;
 /**
  * Resolve trunk branch: --trunk flag, then origin/HEAD, then main/master if present.
@@ -16,3 +22,5 @@ export declare function defaultLayerBranchName(explicit?: string): string;
 export declare function pushBranch(branch: string, cwd?: string): void;
 /** First line of the tip commit on `branch` (for PR title). */
 export declare function tipCommitSubject(branch: string, cwd?: string): string;
+/** Full tip commit message on `branch` (subject + body; for PR description). */
+export declare function tipCommitMessage(branch: string, cwd?: string): string;

package/dist/git-stack.js

@@ -11,10 +11,32 @@ export function currentBranch(cwd = process.cwd()) {
         return null;
     }
 }
-/** True when the worktree has staged/unstaged/untracked changes. */
+/**
+ * True when the worktree has staged/unstaged/untracked changes that should
+ * block `stack create`. Stack authoring metadata lives outside the worktree.
+ * Legacy repo-local `.mergestorm/stack.json` is ignored because `loadStackMeta`
+ * migrates it out of the worktree during `stack create`; counting it as dirty
+ * would block that migration and every subsequent create.
+ */
 export function worktreeDirty(cwd = process.cwd()) {
     const out = git(["status", "--porcelain"], cwd);
-    return out.trim().length > 0;
+    for (const line of out.split("\n")) {
+        const trimmed = line.trimEnd();
+        if (!trimmed)
+            continue;
+        // porcelain: XY PATH or XY ORIG -> PATH (renames only)
+        const status = trimmed.slice(0, 2);
+        const pathPart = (status.includes("R") || status.includes("C"))
+            ? trimmed.slice(3).split(" -> ").pop()?.trim() ?? ""
+            : trimmed.slice(3).trim();
+        if (pathPart.startsWith(".mergestorm/") ||
+            pathPart.endsWith("/.mergestorm/") ||
+            pathPart.endsWith("/.mergestorm/stack.json")) {
+            continue;
+        }
+        return true;
+    }
+    return false;
 }
 /**
  * Resolve trunk branch: --trunk flag, then origin/HEAD, then main/master if present.
@@ -97,3 +119,15 @@ export function tipCommitSubject(branch, cwd = process.cwd()) {
         return branch;
     }
 }
+/** Full tip commit message on `branch` (subject + body; for PR description). */
+export function tipCommitMessage(branch, cwd = process.cwd()) {
+    try {
+        const s = git(["log", "-1", "--format=%B", branch], cwd);
+        if (s.trim())
+            return s;
+        return tipCommitSubject(branch, cwd);
+    }
+    catch {
+        return tipCommitSubject(branch, cwd);
+    }
+}

package/dist/git.d.ts

@@ -1,8 +1,4 @@
 export declare function git(args: string[], cwd?: string): string;
-export declare function collectContextFiles(root: string): Promise<{
-    path: string;
-    content: string;
-}[]>;
 export declare function collectChangedFiles(base: string, head: string): Promise<{
     path: string;
     content: string;

package/dist/git.js

@@ -1,7 +1,6 @@
 import { spawnSync } from "node:child_process";
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
-const CONTEXT_DIR = ".mergestorm";
 export function git(args, cwd = process.cwd()) {
     try {
         const result = spawnSync("git", args, { cwd, encoding: "utf8" });
@@ -14,36 +13,6 @@ export function git(args, cwd = process.cwd()) {
         throw new Error(`git ${args.join(" ")} failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-export async function collectContextFiles(root) {
-    const pack = path.join(root, CONTEXT_DIR);
-    let entries;
-    try {
-        entries = await readdir(pack, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const files = [];
-    for (const entry of entries) {
-        if (entry.isFile() &&
-            (entry.name.toLowerCase().endsWith(".md") || entry.name.toLowerCase().endsWith(".txt"))) {
-            const content = await readFile(path.join(pack, entry.name), "utf8");
-            files.push({ path: entry.name, content });
-        }
-        else if (entry.isDirectory() && !entry.name.startsWith(".")) {
-            const nested = await readdir(path.join(pack, entry.name), { withFileTypes: true }).catch(() => []);
-            for (const child of nested) {
-                if (child.isFile() &&
-                    (child.name.toLowerCase().endsWith(".md") || child.name.toLowerCase().endsWith(".txt"))) {
-                    const rel = `${entry.name}/${child.name}`;
-                    const content = await readFile(path.join(pack, entry.name, child.name), "utf8");
-                    files.push({ path: rel, content });
-                }
-            }
-        }
-    }
-    return files;
-}
 export async function collectChangedFiles(base, head) {
     const names = git(["diff", "--name-only", "--diff-filter=ACMR", `${base}...${head}`])
         .split("\n")

package/dist/pr-body.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Build a GitHub PR body from a tip commit message (#217).
+ * Pure — no git / network.
+ */
+/**
+ * Turn `git log -1 --format=%B` output into a non-empty PR description.
+ */
+export declare function buildPrBodyFromCommit(fullMessage: string): string;

package/dist/pr-body.js

@@ -0,0 +1,63 @@
+/**
+ * Build a GitHub PR body from a tip commit message (#217).
+ * Pure — no git / network.
+ */
+const TRAILER_RE = /^(fixes|closes|resolves)\s+#(\d+)\s*$/i;
+/**
+ * Turn `git log -1 --format=%B` output into a non-empty PR description.
+ */
+export function buildPrBodyFromCommit(fullMessage) {
+    const lines = fullMessage.replace(/\r\n/g, "\n").split("\n");
+    const subject = (lines[0] ?? "").trim() || "Update";
+    const trailers = [];
+    const bodyLines = [];
+    for (const raw of lines.slice(1)) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        const m = TRAILER_RE.exec(line);
+        if (m) {
+            const verb = m[1][0].toUpperCase() + m[1].slice(1).toLowerCase();
+            trailers.push(`${verb} #${m[2]}`);
+            continue;
+        }
+        bodyLines.push(line);
+    }
+    // Also pick trailers that appear as the whole subject (unusual but cheap).
+    const subjectTrailer = TRAILER_RE.exec(subject);
+    const summaryBullets = [];
+    if (subjectTrailer) {
+        const verb = subjectTrailer[1][0].toUpperCase() + subjectTrailer[1].slice(1).toLowerCase();
+        trailers.unshift(`${verb} #${subjectTrailer[2]}`);
+        summaryBullets.push(`- ${subject}`);
+    }
+    else {
+        summaryBullets.push(`- ${subject}`);
+    }
+    for (const para of bodyLines) {
+        summaryBullets.push(`- ${para}`);
+    }
+    const parts = [
+        "## Summary",
+        ...summaryBullets,
+        "",
+        "## Test plan",
+        "- [ ] CI green",
+    ];
+    if (trailers.length > 0) {
+        parts.push("", ...uniqueTrailers(trailers));
+    }
+    return parts.join("\n") + "\n";
+}
+function uniqueTrailers(trailers) {
+    const seen = new Set();
+    const out = [];
+    for (const t of trailers) {
+        const key = t.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(t);
+    }
+    return out;
+}

package/dist/repo-identity.d.ts

@@ -0,0 +1,12 @@
+export declare const LEGACY_STACK_META_REL: string;
+export declare function gitTopLevel(cwd?: string): string;
+export declare function gitCommonDir(cwd?: string): string;
+/**
+ * A physical clone and all its linked worktrees share one authoring state.
+ * Independent clones remain isolated even when they point at the same remote.
+ */
+export declare function stableRepoId(cwd?: string): string;
+export declare function cliStacksRoot(): string;
+export declare function repoStateDir(cwd?: string, stacksRoot?: string): string;
+export declare function stackMetaPath(cwd?: string, stacksRoot?: string): string;
+export declare function legacyStackMetaPath(cwd?: string): string;

package/dist/repo-identity.js

@@ -0,0 +1,42 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { mergestormHome } from "./config.js";
+import { CommandError } from "./errors.js";
+import { git } from "./git.js";
+export const LEGACY_STACK_META_REL = path.join(".mergestorm", "stack.json");
+export function gitTopLevel(cwd = process.cwd()) {
+    return realpathSync(git(["rev-parse", "--show-toplevel"], cwd).trim());
+}
+export function gitCommonDir(cwd = process.cwd()) {
+    const raw = git(["rev-parse", "--git-common-dir"], cwd).trim();
+    const absolute = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
+    try {
+        return realpathSync(absolute);
+    }
+    catch (err) {
+        if (err?.code === "ENOENT") {
+            throw new CommandError(`git common directory is missing (${absolute}); this is often a linked worktree whose main repository was deleted. Run \`mg stack reset --force\` to clear local pre-submit state.`);
+        }
+        throw err;
+    }
+}
+/**
+ * A physical clone and all its linked worktrees share one authoring state.
+ * Independent clones remain isolated even when they point at the same remote.
+ */
+export function stableRepoId(cwd = process.cwd()) {
+    return createHash("sha256").update(gitCommonDir(cwd)).digest("hex").slice(0, 20);
+}
+export function cliStacksRoot() {
+    return path.join(mergestormHome(), "stacks");
+}
+export function repoStateDir(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
+    return path.join(stacksRoot, stableRepoId(cwd));
+}
+export function stackMetaPath(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
+    return path.join(repoStateDir(cwd, stacksRoot), "stack.json");
+}
+export function legacyStackMetaPath(cwd = process.cwd()) {
+    return path.join(gitTopLevel(cwd), LEGACY_STACK_META_REL);
+}

package/dist/stack-meta.d.ts

@@ -3,13 +3,31 @@ export type StackLayerMeta = {
     /** Parent branch name (trunk for the bottom layer). */
     parentBranch: string;
 };
+export type LocalStack = {
+    layers: StackLayerMeta[];
+};
 export type StackMeta = {
-    version: 1;
+    version: 2;
     trunk: string;
-    layers: StackLayerMeta[];
+    stacks: LocalStack[];
+    /** Index into `stacks` for create/submit. */
+    active: number;
 };
+/** Exported only for legacy migration/tests. New state never uses this path. */
 export declare const STACK_META_REL: string;
-export declare function stackMetaPath(cwd?: string): string;
-export declare function loadStackMeta(cwd?: string): Promise<StackMeta | null>;
-export declare function saveStackMeta(meta: StackMeta, cwd?: string): Promise<void>;
+export declare function stackMetaPath(cwd?: string, stacksRoot?: string): string;
+export declare function loadStackMeta(cwd?: string, stacksRoot?: string): Promise<StackMeta | null>;
+export declare function emptyStackMeta(trunk: string): StackMeta;
+export declare function activeStack(meta: StackMeta): LocalStack;
+export declare function activeLayers(meta: StackMeta): StackLayerMeta[];
+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>;
 export declare function appendLayer(meta: StackMeta, layer: StackLayerMeta): StackMeta;
+/**
+ * Decide which local stack receives a new layer.
+ * Onto trunk with a non-empty active stack → start a fresh local stack.
+ */
+export declare function selectStackForCreate(meta: StackMeta, parentBranch: string): StackMeta;
+/** Drop the active stack after a successful submit. */
+export declare function removeActiveStack(meta: StackMeta): StackMeta;

package/dist/stack-meta.js

@@ -1,25 +1,78 @@
 /**
- * Local stack metadata for `mg stack create` / `submit`.
- * Stored at `.mergestorm/stack.json` in the repo root.
+ * CLI-owned pre-submit stack metadata for `mg stack create` / `submit`.
+ * Stored outside repositories under ~/.mergestorm/stacks/<repo-id>/.
  */
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { chmod, copyFile, mkdir, readFile, readdir, rename, rm, rmdir, unlink, writeFile, } from "node:fs/promises";
 import path from "node:path";
-export const STACK_META_REL = path.join(".mergestorm", "stack.json");
-export function stackMetaPath(cwd = process.cwd()) {
-    return path.join(cwd, STACK_META_REL);
-}
-export async function loadStackMeta(cwd = process.cwd()) {
-    try {
-        const raw = await readFile(stackMetaPath(cwd), "utf8");
-        const parsed = JSON.parse(raw);
-        if (!parsed ||
-            parsed.version !== 1 ||
-            typeof parsed.trunk !== "string" ||
-            !Array.isArray(parsed.layers) ||
-            !parsed.layers.every(l => typeof l.branch === 'string' && typeof l.parentBranch === 'string')) {
-            return null;
+import { CommandError } from "./errors.js";
+import { git } from "./git.js";
+import { cliStacksRoot, gitTopLevel, LEGACY_STACK_META_REL, legacyStackMetaPath, repoStateDir, stackMetaPath as resolveStackMetaPath, } from "./repo-identity.js";
+/** 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()) {
+    return resolveStackMetaPath(cwd, stacksRoot);
+}
+function isLayer(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const layer = value;
+    return typeof layer.branch === "string" && typeof layer.parentBranch === "string";
+}
+function normalizeMeta(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const obj = raw;
+    if (typeof obj.trunk !== "string" || !obj.trunk.trim()) {
+        throw new Error("Stack authoring state has no trunk; run `mg stack reset --force` to clear it.");
+    }
+    if (obj.version === 2) {
+        if (!Array.isArray(obj.stacks) || obj.stacks.length === 0) {
+            throw new Error("Stack authoring state has no stacks; run `mg stack reset --force` to clear it.");
+        }
+        const stacks = [];
+        for (const stack of obj.stacks) {
+            if (!stack ||
+                typeof stack !== "object" ||
+                !Array.isArray(stack.layers) ||
+                !stack.layers.every(isLayer)) {
+                throw new Error("Stack authoring state has a malformed stack entry; run `mg stack reset --force` to clear it.");
+            }
+            stacks.push({ layers: stack.layers });
         }
-        return parsed;
+        const active = obj.active;
+        if (typeof active !== "number" ||
+            !Number.isInteger(active) ||
+            active < 0 ||
+            active >= stacks.length) {
+            throw new Error("Stack authoring state has an invalid active stack; run `mg stack reset --force` to clear it.");
+        }
+        return { version: 2, trunk: obj.trunk, stacks, active };
+    }
+    if (obj.version === 1) {
+        if (!Array.isArray(obj.layers) || !obj.layers.every(isLayer)) {
+            throw new Error("Stack authoring state has malformed legacy layers; run `mg stack reset --force` to clear it.");
+        }
+        return {
+            version: 2,
+            trunk: obj.trunk,
+            stacks: [{ layers: obj.layers }],
+            active: 0,
+        };
+    }
+    throw new Error("Stack authoring state has an unknown version; run `mg stack reset --force` to clear it.");
+}
+function parseStateJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new CommandError("Stack authoring state is not valid JSON; run `mg stack reset --force` to clear it.");
+    }
+}
+async function readIfExists(file) {
+    try {
+        return await readFile(file, "utf8");
     }
     catch (err) {
         const code = err?.code;
@@ -28,14 +81,196 @@ export async function loadStackMeta(cwd = process.cwd()) {
         throw err;
     }
 }
-export async function saveStackMeta(meta, cwd = process.cwd()) {
-    const file = stackMetaPath(cwd);
-    await mkdir(path.dirname(file), { recursive: true });
-    await writeFile(file, `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+async function removeLegacyFile(file, cwd = process.cwd(), force = false) {
+    const top = gitTopLevel(cwd);
+    const rel = path.relative(top, file);
+    try {
+        git(["rm", "-f", "--", rel], top);
+    }
+    catch (err) {
+        // Fall back to a plain unlink only for untracked files; otherwise the
+        // index entry would remain after the worktree copy is gone.
+        if (git(["ls-files", "--", rel], top).trim() !== "") {
+            if (!force) {
+                throw new Error(`git rm failed for tracked ${rel}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            git(["update-index", "--force-remove", "--", rel], top);
+        }
+        await unlink(file);
+    }
+    try {
+        await rmdir(path.dirname(file));
+    }
+    catch {
+        // Leave a non-empty .mergestorm directory untouched.
+    }
+}
+export async function loadStackMeta(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
+    const file = stackMetaPath(cwd, stacksRoot);
+    const legacyFile = legacyStackMetaPath(cwd);
+    const raw = await readIfExists(file);
+    const legacyRaw = await readIfExists(legacyFile);
+    if (raw !== null) {
+        const meta = normalizeMeta(parseStateJson(raw));
+        if (meta === null) {
+            throw new CommandError("Stack authoring state is not an object; run `mg stack reset --force` to clear it.");
+        }
+        if (legacyRaw !== null) {
+            const stateDir = repoStateDir(cwd, stacksRoot);
+            const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const backup = path.join(stateDir, `legacy-conflict-${stamp}.json`);
+            try {
+                await mkdir(stateDir, { recursive: true, mode: 0o700 });
+                await chmod(stateDir, 0o700);
+                await copyFile(legacyFile, backup);
+                await chmod(backup, 0o600);
+                await removeLegacyFile(legacyFile, cwd);
+            }
+            catch (err) {
+                throw new CommandError(`Failed to preserve legacy stack state${err instanceof Error ? `: ${err.message}` : ""}; run \`mg stack reset --force\` to clear it.`);
+            }
+            console.warn(`Warning: global stack state already existed; preserved legacy state at ${backup}.`);
+        }
+        return meta;
+    }
+    if (legacyRaw === null)
+        return null;
+    const migrated = normalizeMeta(parseStateJson(legacyRaw));
+    if (!migrated)
+        return null;
+    try {
+        await saveStackMeta(migrated, cwd, stacksRoot);
+        await removeLegacyFile(legacyFile, cwd);
+    }
+    catch (err) {
+        throw new CommandError(`Failed to migrate legacy stack state${err instanceof Error ? `: ${err.message}` : ""}; run \`mg stack reset --force\` to clear it.`);
+    }
+    return migrated;
+}
+export function emptyStackMeta(trunk) {
+    return {
+        version: 2,
+        trunk,
+        stacks: [{ layers: [] }],
+        active: 0,
+    };
+}
+export function activeStack(meta) {
+    const stack = meta.stacks[meta.active];
+    if (!stack) {
+        throw new Error("Stack authoring state has an out-of-range active stack; run `mg stack reset --force` to clear it.");
+    }
+    return stack;
+}
+export function activeLayers(meta) {
+    return activeStack(meta).layers;
+}
+export async function saveStackMeta(meta, cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
+    const file = stackMetaPath(cwd, stacksRoot);
+    const dir = path.dirname(file);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await chmod(dir, 0o700);
+    const base = path.basename(file);
+    for (const name of await readdir(dir)) {
+        if (name.startsWith(`${base}.`) && name.endsWith(".tmp")) {
+            await rm(path.join(dir, name), { force: true }).catch(() => { });
+        }
+    }
+    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temp, `${JSON.stringify(meta, null, 2)}\n`, {
+            encoding: "utf8",
+            mode: 0o600,
+            flag: "wx",
+        });
+        await rename(temp, file);
+        await chmod(file, 0o600);
+    }
+    catch (err) {
+        await rm(temp, { force: true }).catch(() => { });
+        throw err;
+    }
+}
+/** Explicit recovery. Does not touch branches, PRs, or registered server stacks. */
+export async function resetStackMeta(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
+    let stateFile;
+    let legacyFile;
+    try {
+        stateFile = stackMetaPath(cwd, stacksRoot);
+        legacyFile = legacyStackMetaPath(cwd);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code !== undefined)
+            throw err;
+        if (err instanceof Error &&
+            (err.message.includes("not a git repository") ||
+                err.message.includes("git common directory is missing"))) {
+            return;
+        }
+        throw err;
+    }
+    await rm(stateFile, { force: true });
+    try {
+        await removeLegacyFile(legacyFile, cwd, true);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code !== "ENOENT")
+            throw err;
+    }
 }
 export function appendLayer(meta, layer) {
-    if (meta.layers.some((l) => l.branch === layer.branch)) {
+    const current = activeLayers(meta);
+    if (current.some((l) => l.branch === layer.branch)) {
         throw new Error(`branch already in stack: ${layer.branch}`);
     }
-    return { ...meta, layers: [...meta.layers, layer] };
+    for (let i = 0; i < meta.stacks.length; i++) {
+        if (i === meta.active)
+            continue;
+        if (meta.stacks[i].layers.some((l) => l.branch === layer.branch)) {
+            throw new Error(`branch already in another local stack: ${layer.branch}`);
+        }
+    }
+    const stacks = meta.stacks.map((stack, index) => index === meta.active
+        ? { layers: [...stack.layers, layer] }
+        : stack);
+    return { ...meta, stacks };
+}
+/**
+ * Decide which local stack receives a new layer.
+ * Onto trunk with a non-empty active stack → start a fresh local stack.
+ */
+export function selectStackForCreate(meta, parentBranch) {
+    const layers = activeLayers(meta);
+    if (parentBranch === meta.trunk) {
+        if (layers.length === 0)
+            return meta;
+        return {
+            ...meta,
+            stacks: [...meta.stacks, { layers: [] }],
+            active: meta.stacks.length,
+        };
+    }
+    if (layers.some((l) => l.branch === parentBranch)) {
+        return meta;
+    }
+    if (layers.length === 0) {
+        return meta;
+    }
+    for (let i = 0; i < meta.stacks.length; i++) {
+        if (meta.stacks[i].layers.some((l) => l.branch === parentBranch)) {
+            throw new Error(`Parent ${parentBranch} is a layer of a different local stack than the active one.`);
+        }
+    }
+    throw new Error(`Parent ${parentBranch} is not trunk (${meta.trunk}) or a stack layer.`);
+}
+/** Drop the active stack after a successful submit. */
+export function removeActiveStack(meta) {
+    if (meta.stacks.length <= 1) {
+        return { ...meta, stacks: [{ layers: [] }], active: 0 };
+    }
+    const stacks = meta.stacks.filter((_, index) => index !== meta.active);
+    const active = Math.min(meta.active, stacks.length - 1);
+    return { ...meta, stacks, active };
 }

package/dist/ui/banner.js

@@ -42,6 +42,14 @@ const WHATS_NEW = {
         "`stack create` / `submit` — author stacks with `mg` (not Graphite)",
         "Adopt is import-only; happy path is create → submit → restack → land",
     ],
+    "0.3.5": [
+        "`stack submit` fills PR body from the tip commit (keeps Fixes/Closes)",
+        "Unit-stack `stack land` promotes (matches server gates)",
+    ],
+    "0.3.6": [
+        "Stack state under ~/.mergestorm/stacks/ (multi-stack + legacy migrate)",
+        "`stack reset --force` clears stale local authoring state",
+    ],
 };
 function formatStatusLines(me, key, barWidth) {
     if (!key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "MergeStorm CLI — interactive shell and one-shot review commands",
   "type": "module",
   "bin": {