mergestorm 0.3.15 → 0.3.16

package/README.md

@@ -45,12 +45,12 @@ On a TTY, bare `mergestorm` (or `mergestorm shell`) opens a branded REPL: a comp
 
 ```
 ╭──────────────────────────────────────────────────────────────────────────────╮
-│ ▟██▛  mergestorm v0.3.15                                                     │
+│ ▟██▛  mergestorm v0.3.16                                                     │
 │  ▜▙   ● 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.15: PR wait + settings + both skills in the npm tarball    │
+│       New in v0.3.16: verify findings, small diff, public dismiss on skip    │
 ╰──────────────────────────────────────────────────────────────────────────────╯
 mergestorm
 ╭──────────────────────────────────────────────────────────────────────────────╮
@@ -99,7 +99,7 @@ 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**. On review-unit stacks, `stack land` **promotes** the tip into the unit (same gates as the dashboard); otherwise it lands the bottom open PR. `stack adopt` is for importing a chain that already exists on GitHub (legacy / Graphite). Restack/land use the same login key (`/api/v1/stacks`). Unattended landing is `mg queue add`.
 
-`stack create` checks out a new branch from the current tip (or `--onto <branch>`), discovers trunk (`main` / `master` / `origin/HEAD`, overridable with `--trunk`), and records `{ branch, parentBranch }` in CLI-managed state under **`~/.mergestorm/stacks/<repo-id>/stack.json`**. The CLI updates this automatically; never edit it. Linked worktrees share state, while independent clones remain isolated. Creating onto trunk with a non-empty active stack starts a new one. `--trunk` only sets trunk metadata — it does **not** change the parent; use `--onto main` (etc.) for a fresh stack from trunk.
+`stack create` checks out a new branch from the current tip (or `--onto <branch>`), discovers trunk (`main` / `master` / `origin/HEAD`, overridable with `--trunk`), and records `{ branch, parentBranch }` in CLI-managed state under **`~/.mergestorm/stacks/<repo-id>/stack.json`**. The CLI updates this automatically; never edit it. Each worktree has its own authoring state; independent clones stay isolated too. Creating onto trunk with a non-empty active stack starts a new one. `--trunk` only sets trunk metadata — it does **not** change the parent; use `--onto main` (etc.) for a fresh stack from trunk.
 
 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`.
 
@@ -119,7 +119,7 @@ Removes `~/.mergestorm/config.json` so the stored key is no longer used.
 
 ### `review [base] [head]`
 
-Collects `git diff base...head` (default: discovered trunk — `origin/HEAD`, `main`, or `master`), attaches the changed file contents (up to 40 files, skipping files > 400 KB), submits the job, and polls until it finishes (~8 min max — Core plus a Max fleet can exceed 3 minutes). The thread slug defaults to the current branch (`local/<branch>`); pass `--thread` to override so follow-ups chain on a chosen slug. The CLI does not scan `.mergestorm/context/`.
+Collects `git diff base...head` (default: discovered trunk — `origin/HEAD`, `main`, or `master`), attaches the changed file contents (up to 40 files, skipping files > 400 KB), submits the job, and polls until it finishes (~8 min max — Core plus a Max fleet can exceed 3 minutes). The thread slug defaults to the current branch (`local/<branch>`); pass `--thread` to override so follow-ups chain on a chosen slug. The CLI still does not scan a repo folder for review context. GitHub Vortex will read house-rule files in a later PR (`AGENTS.md`, `CLAUDE.md`, alwaysApply Cursor rules). That ingest is not shipping yet.
 
 ```bash
 mergestorm review              # discovered trunk (origin/HEAD, main, or master)...HEAD

package/dist/api.d.ts

@@ -1,4 +1,5 @@
 import { type Config } from "./config.js";
+import { BEARER_SETTINGS_KEYS as SETTINGS_WRITABLE_KEYS, type BearerSettingsKey as SettingsWritableKey } from "./automation-catalog.js";
 import type { MergeQueueEntryDto, StackDto } from "./stack-dto.js";
 export type { MergeQueueBounceDetail, MergeQueueBounceKind, MergeQueueEnqueuedBy, MergeQueueEnqueuedVia, MergeQueueEntryDto, MergeQueueEntryState, StackBranchState, StackCiStatus, StackDto, StackLayerChecks, StackLayerDto, StackReviewStatus, StackTempestStatus, StackUnitDto, StackUnitMemberDto, } from "./stack-dto.js";
 /** Default per-request timeout so a hung API cannot stall the shell/CI forever. */
@@ -132,8 +133,8 @@ export type PrVortexReview = {
  * Bearer-writable settings keys, mirroring the `/api/v1/settings` allowlist.
  * The connected flags are read-only there and deliberately absent here.
  */
-export declare const SETTINGS_WRITABLE_KEYS: readonly ["auto_review_enabled", "auto_patch_enabled", "vortex_show_thinking_traces", "repo_overview_enabled", "review_unit_land_prs_enabled", "cyclone_review_unit_land_prs_enabled", "vortex_seam_specialist_enabled"];
-export type SettingsWritableKey = (typeof SETTINGS_WRITABLE_KEYS)[number];
+export { SETTINGS_WRITABLE_KEYS };
+export type { SettingsWritableKey };
 export type SettingsPatch = Partial<Record<SettingsWritableKey, boolean>>;
 /** GET and PATCH `/api/v1/settings` both answer with this shape. */
 export type SettingsResponse = Record<SettingsWritableKey, boolean> & {
@@ -180,13 +181,32 @@ export declare function listStacks(cfg?: Config, opts?: {
 export declare function getEnrichedStack(stackId: string, cfg?: Config, opts?: {
     timeoutMs?: number;
 }): Promise<StackDto | null>;
+/**
+ * Per-stack automation policy. Auto land is a boolean; the review / patch
+ * overrides are tri-state (`null` clears back to the account flag). Absent
+ * keys are left untouched.
+ */
+export type StackPolicyPatch = {
+    autoEnqueueWhenReady?: boolean;
+    autoReviewOverride?: boolean | null;
+    autoPatchOverride?: boolean | null;
+};
+/** Drop undefined keys so the wire body only carries what was requested. */
+export declare function stackPolicyBody(policy: StackPolicyPatch | undefined): StackPolicyPatch;
 /** Adopt an open PR chain (Bearer POST /api/v1/stacks/adopt). */
-export declare function adoptStack(owner: string, repo: string, prNumber: number, cfg?: Config): Promise<unknown>;
+export declare function adoptStack(owner: string, repo: string, prNumber: number, cfg?: Config, policy?: StackPolicyPatch): Promise<unknown>;
 /** Mint or reuse the PR3+ park freeze (Bearer POST /api/v1/stacks/:id/ensure-upper-park). */
 export declare function ensureUpperPark(stackId: string, cfg?: Config): Promise<{
     freezeBranch: string;
     created: boolean;
 }>;
+/** Arm or disarm Auto land on one owned stack. */
+export declare function setStackAutoLand(stackId: string, enabled: boolean, cfg?: Config): Promise<unknown>;
+/**
+ * Patch any subset of one owned stack's automation policy
+ * (Bearer PATCH /api/v1/stacks/:id). `null` clears an override.
+ */
+export declare function setStackPolicy(stackId: string, policy: StackPolicyPatch, cfg?: Config): Promise<unknown>;
 /** 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). */

package/dist/api.js

@@ -1,4 +1,5 @@
 import { apiBase, loadConfig, resolveApiKey } from "./config.js";
+import { BEARER_SETTINGS_KEYS as SETTINGS_WRITABLE_KEYS, } from "./automation-catalog.js";
 import { CommandError, REVIEW_EXIT, rateLimitedMessage } from "./errors.js";
 /** Default per-request timeout so a hung API cannot stall the shell/CI forever. */
 export const DEFAULT_API_TIMEOUT_MS = 30_000;
@@ -158,15 +159,7 @@ export async function devicePost(base, route, json, opts = {}) {
  * Bearer-writable settings keys, mirroring the `/api/v1/settings` allowlist.
  * The connected flags are read-only there and deliberately absent here.
  */
-export const SETTINGS_WRITABLE_KEYS = [
-    "auto_review_enabled",
-    "auto_patch_enabled",
-    "vortex_show_thinking_traces",
-    "repo_overview_enabled",
-    "review_unit_land_prs_enabled",
-    "cyclone_review_unit_land_prs_enabled",
-    "vortex_seam_specialist_enabled",
-];
+export { SETTINGS_WRITABLE_KEYS };
 /**
  * Fetch Bearer /api/v1/settings; null on 404/network/timeouts so panels can
  * degrade (same contract as {@link getMe}), while 401 still surfaces.
@@ -343,12 +336,31 @@ export async function getEnrichedStack(stackId, cfg, opts) {
     }
     return stacks.find((stack) => stack?.id === id) ?? null;
 }
+/** Drop undefined keys so the wire body only carries what was requested. */
+export function stackPolicyBody(policy) {
+    const body = {};
+    if (typeof policy?.autoEnqueueWhenReady === "boolean") {
+        body.autoEnqueueWhenReady = policy.autoEnqueueWhenReady;
+    }
+    if (policy?.autoReviewOverride !== undefined) {
+        body.autoReviewOverride = policy.autoReviewOverride;
+    }
+    if (policy?.autoPatchOverride !== undefined) {
+        body.autoPatchOverride = policy.autoPatchOverride;
+    }
+    return body;
+}
 /** Adopt an open PR chain (Bearer POST /api/v1/stacks/adopt). */
-export async function adoptStack(owner, repo, prNumber, cfg) {
+export async function adoptStack(owner, repo, prNumber, cfg, policy) {
     const resolved = cfg ?? (await loadConfig());
     const { status, body } = await apiFetch(resolved, "/api/v1/stacks/adopt", {
         method: "POST",
-        json: { owner, repo, prNumber },
+        json: {
+            owner,
+            repo,
+            prNumber,
+            ...stackPolicyBody(policy),
+        },
     });
     if (status === 404) {
         throw new CommandError("Stacks API is not available on this server yet. Deploy the API update or use the dashboard.");
@@ -390,6 +402,21 @@ async function stackMutation(stackId, pathSuffix, method, json, failLabel, cfg)
     }
     return body;
 }
+/** Arm or disarm Auto land on one owned stack. */
+export async function setStackAutoLand(stackId, enabled, cfg) {
+    return setStackPolicy(stackId, { autoEnqueueWhenReady: enabled }, cfg);
+}
+/**
+ * Patch any subset of one owned stack's automation policy
+ * (Bearer PATCH /api/v1/stacks/:id). `null` clears an override.
+ */
+export async function setStackPolicy(stackId, policy, cfg) {
+    const json = stackPolicyBody(policy);
+    if (Object.keys(json).length === 0) {
+        throw new CommandError("setStackPolicy needs at least one policy key");
+    }
+    return stackMutation(stackId, "", "PATCH", json, "Failed to set stack policy", cfg);
+}
 /** Restack descendants (Bearer POST /api/v1/stacks/:id/restack). */
 export async function restackStack(stackId, cfg) {
     return stackMutation(stackId, "/restack", "POST", {}, "Failed to restack", cfg);

package/dist/automation-catalog.d.ts

@@ -0,0 +1,37 @@
+export declare const BEARER_SETTINGS: readonly [{
+    readonly key: "auto_review_enabled";
+    readonly flag: "--auto-review";
+    readonly label: "Auto review";
+}, {
+    readonly key: "auto_patch_enabled";
+    readonly flag: "--auto-patch";
+    readonly label: "Auto patch";
+}, {
+    readonly key: "vortex_show_thinking_traces";
+    readonly flag: "--vortex-thinking";
+    readonly label: "Vortex thinking traces";
+}, {
+    readonly key: "repo_overview_enabled";
+    readonly flag: "--repo-overview";
+    readonly label: "Repo overview";
+}, {
+    readonly key: "review_unit_land_prs_enabled";
+    readonly flag: "--review-unit-land";
+    readonly label: "Review Unit land PRs";
+}, {
+    readonly key: "cyclone_review_unit_land_prs_enabled";
+    readonly flag: "--cyclone-review-unit-land";
+    readonly label: "Cyclone Review Unit land PRs";
+}, {
+    readonly key: "vortex_seam_specialist_enabled";
+    readonly flag: "--vortex-seam";
+    readonly label: "Vortex seam specialist";
+}, {
+    readonly key: "auto_land_default";
+    readonly flag: "--auto-land";
+    readonly label: "Auto land (new stacks)";
+}];
+export type BearerSettingsKey = (typeof BEARER_SETTINGS)[number]["key"];
+export declare const BEARER_SETTINGS_KEYS: readonly BearerSettingsKey[];
+export declare const BEARER_SETTINGS_FLAGS: Record<string, BearerSettingsKey>;
+export declare const BEARER_SETTINGS_LABELS: Record<BearerSettingsKey, string>;

package/dist/automation-catalog.js

@@ -0,0 +1,13 @@
+export const BEARER_SETTINGS = [
+    { key: "auto_review_enabled", flag: "--auto-review", label: "Auto review" },
+    { key: "auto_patch_enabled", flag: "--auto-patch", label: "Auto patch" },
+    { key: "vortex_show_thinking_traces", flag: "--vortex-thinking", label: "Vortex thinking traces" },
+    { key: "repo_overview_enabled", flag: "--repo-overview", label: "Repo overview" },
+    { key: "review_unit_land_prs_enabled", flag: "--review-unit-land", label: "Review Unit land PRs" },
+    { key: "cyclone_review_unit_land_prs_enabled", flag: "--cyclone-review-unit-land", label: "Cyclone Review Unit land PRs" },
+    { key: "vortex_seam_specialist_enabled", flag: "--vortex-seam", label: "Vortex seam specialist" },
+    { key: "auto_land_default", flag: "--auto-land", label: "Auto land (new stacks)" },
+];
+export const BEARER_SETTINGS_KEYS = BEARER_SETTINGS.map((r) => r.key);
+export const BEARER_SETTINGS_FLAGS = Object.fromEntries(BEARER_SETTINGS.map((r) => [r.flag, r.key]));
+export const BEARER_SETTINGS_LABELS = Object.fromEntries(BEARER_SETTINGS.map((r) => [r.key, r.label]));

package/dist/client/index.d.ts

@@ -1,5 +1,6 @@
 export { DEFAULT_API, apiBase, clearConfig, configPath, keyDisplay, loadConfig, mergestormHome, resolveApiKey, saveConfig, type Config, } from "../config.js";
-export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, type ApiFetchInit, type ApiFetchResult, type JobListItem, type MeResponse, type MergeQueueBounceDetail, type MergeQueueBounceKind, type MergeQueueEnqueuedBy, type MergeQueueEnqueuedVia, type MergeQueueEntryDto, type MergeQueueEntryState, type PrReviewFinding, type PrReviewFindings, type PrVortexReview, type SettingsPatch, type SettingsResponse, type SettingsWritableKey, type StackDto, type ThreadDetail, type ThreadListItem, } from "../api.js";
+export { BEARER_SETTINGS, BEARER_SETTINGS_FLAGS, BEARER_SETTINGS_KEYS, BEARER_SETTINGS_LABELS, type BearerSettingsKey, } from "../automation-catalog.js";
+export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, setStackAutoLand, setStackPolicy, stackPolicyBody, type ApiFetchInit, type ApiFetchResult, type JobListItem, type MeResponse, type MergeQueueBounceDetail, type MergeQueueBounceKind, type MergeQueueEnqueuedBy, type MergeQueueEnqueuedVia, type MergeQueueEntryDto, type MergeQueueEntryState, type PrReviewFinding, type PrReviewFindings, type PrVortexReview, type SettingsPatch, type SettingsResponse, type SettingsWritableKey, type StackDto, type StackPolicyPatch, type ThreadDetail, type ThreadListItem, } from "../api.js";
 export { CommandError, DetachedError, RATE_LIMITED_HINT, REVIEW_EXIT, isCommandErrorCode, rateLimitedMessage, type CommandErrorCode, type CommandErrorExtras, } from "../errors.js";
 export { REVIEW_POLL_BACKOFF_MS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_POLL_STRETCH_AFTER_MS, REVIEW_POLL_STRETCH_SPAN_MS, REVIEW_THREAD_SLUG_RE, PrReviewPollTimeoutError, ReviewPollTimeoutError, collectReviewInput, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollPrVortexReview, pollReview, stretchedPollIntervalMs, submitReview, transientRetryWaitMs, type PollReviewOptions, type PollPrVortexReviewOptions, type ReviewInput, type SubmitReviewOptions, } from "../commands/review-client.js";
 export { REVIEW_JOB_ENVELOPE_SCHEMA, toReviewJobEnvelope, type ReviewEnvelopeFallbacks, type ReviewJobEnvelope, type ReviewJobRow, } from "../ui/job-envelope.js";

package/dist/client/index.js

@@ -1,5 +1,6 @@
 export { DEFAULT_API, apiBase, clearConfig, configPath, keyDisplay, loadConfig, mergestormHome, resolveApiKey, saveConfig, } from "../config.js";
-export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, } from "../api.js";
+export { BEARER_SETTINGS, BEARER_SETTINGS_FLAGS, BEARER_SETTINGS_KEYS, BEARER_SETTINGS_LABELS, } from "../automation-catalog.js";
+export { API_TIMEOUT_PREFIX, DEFAULT_API_TIMEOUT_MS, SETTINGS_WRITABLE_KEYS, adoptStack, apiFetch, cancelMergeQueueEntry, devicePost, enqueueStack, ensureUpperPark, getEnrichedStack, getMe, getPrVortexReview, getReview, getSettings, landNextStack, listJobs, listMergeQueueEntries, listStacks, listThreads, parseRetryAfterSeconds, patchSettings, restackStack, setStackAutoLand, setStackPolicy, stackPolicyBody, } from "../api.js";
 export { CommandError, DetachedError, RATE_LIMITED_HINT, REVIEW_EXIT, isCommandErrorCode, rateLimitedMessage, } from "../errors.js";
 export { REVIEW_POLL_BACKOFF_MS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_INTERVAL_MS, REVIEW_POLL_MAX_INTERVAL_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_POLL_STRETCH_AFTER_MS, REVIEW_POLL_STRETCH_SPAN_MS, REVIEW_THREAD_SLUG_RE, PrReviewPollTimeoutError, ReviewPollTimeoutError, collectReviewInput, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollPrVortexReview, pollReview, stretchedPollIntervalMs, submitReview, transientRetryWaitMs, } from "../commands/review-client.js";
 export { REVIEW_JOB_ENVELOPE_SCHEMA, toReviewJobEnvelope, } from "../ui/job-envelope.js";

package/dist/commands/browse.d.ts

@@ -1,4 +1,4 @@
-import { type JobListItem, type SettingsResponse, type SettingsWritableKey } from "../api.js";
+import { type JobListItem, type SettingsResponse } from "../api.js";
 import { type ReviewJobRow } from "../ui/job-envelope.js";
 import { type TabId, type TabsConfigRow } from "../ui/tabs.js";
 import { type UsagePanelJob } from "../ui/usage.js";
@@ -27,7 +27,7 @@ export declare function buildStatusTabLines(input: StatusTabInput): string[];
 /** In-place job detail for the Jobs tab (same envelope as `status <id>`). */
 export declare function formatJobDetailLines(row: ReviewJobRow): string[];
 /** Human labels for the Config tab and the static `settings` printout. */
-export declare const SETTINGS_LABELS: Record<SettingsWritableKey, string>;
+export declare const SETTINGS_LABELS: Record<"auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_review_unit_land_prs_enabled" | "vortex_seam_specialist_enabled" | "auto_land_default", string>;
 /** Config rows in a stable order: writable toggles, then connected flags. */
 export declare function buildConfigRows(settings: SettingsResponse): TabsConfigRow[];
 /**

package/dist/commands/browse.js

@@ -1,4 +1,5 @@
 import { getMe, getReview, getSettings, listJobs, patchSettings, SETTINGS_WRITABLE_KEYS, } from "../api.js";
+import { BEARER_SETTINGS_LABELS } from "../automation-catalog.js";
 import { apiBase, keyDisplay, loadConfig, resolveApiKey } from "../config.js";
 import { CommandError } from "../errors.js";
 import { ansi } from "../ui/ansi.js";
@@ -117,15 +118,7 @@ export function formatJobDetailLines(row) {
     return lines;
 }
 /** Human labels for the Config tab and the static `settings` printout. */
-export const SETTINGS_LABELS = {
-    auto_review_enabled: "Auto review",
-    auto_patch_enabled: "Auto patch",
-    vortex_show_thinking_traces: "Vortex thinking traces",
-    repo_overview_enabled: "Repo overview",
-    review_unit_land_prs_enabled: "Review Unit land PRs",
-    cyclone_review_unit_land_prs_enabled: "Cyclone Review Unit land PRs",
-    vortex_seam_specialist_enabled: "Vortex seam specialist",
-};
+export const SETTINGS_LABELS = BEARER_SETTINGS_LABELS;
 /** Config rows in a stable order: writable toggles, then connected flags. */
 export function buildConfigRows(settings) {
     return [

package/dist/commands/registry.js

@@ -164,6 +164,7 @@ export const COMMAND_REGISTRY = [
             "  [--auto-review on|off] [--auto-patch on|off] [--vortex-thinking on|off]",
             "  [--repo-overview on|off] [--review-unit-land on|off]",
             "  [--cyclone-review-unit-land on|off] [--vortex-seam on|off]",
+            "  [--auto-land on|off]            Auto land default for stacks opened after this",
             "  With flags: PATCH those settings and print the stored result",
         ],
         async run(args, ctx) {
@@ -210,11 +211,12 @@ export const COMMAND_REGISTRY = [
         name: "stack",
         summary: "Stacks: /stack how-to, list yours, create → submit",
         usage: [
-            "mergestorm stack create [name]  New local stack layer ([--onto] [--trunk] [--extend])",
-            "mergestorm stack submit         Push active local stack, open PRs ([--extend])",
+            "mergestorm stack create [name]  New local layer ([--onto] [--trunk] [--extend] [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off])",
+            "mergestorm stack submit         Push/open active stack ([--extend] [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off])",
             "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 set <stack-id> [--auto-land on|off] [--auto-review on|off|default] [--auto-patch on|off|default] [--json]  Per-stack policy",
+            "mergestorm stack adopt <owner/repo>#<pr> [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off]  Import an open PR chain",
             "mergestorm stack restack <stack-id>   Restack stack descendants",
             "mergestorm stack land <stack-id>      Land bottom PR (or promote into unit)",
         ],

package/dist/commands/settings.d.ts

@@ -1,9 +1,9 @@
-import { type SettingsPatch, type SettingsResponse, type SettingsWritableKey } from "../api.js";
+import { type SettingsPatch, type SettingsResponse } from "../api.js";
 /**
  * CLI flag → Bearer settings key. on|off only. The connected flags are
  * read-only on the API and deliberately have no flag here.
  */
-export declare const SETTINGS_FLAGS: Record<string, SettingsWritableKey>;
+export declare const SETTINGS_FLAGS: Record<string, "auto_review_enabled" | "auto_patch_enabled" | "vortex_show_thinking_traces" | "repo_overview_enabled" | "review_unit_land_prs_enabled" | "cyclone_review_unit_land_prs_enabled" | "vortex_seam_specialist_enabled" | "auto_land_default">;
 export type SettingsArgs = {
     json: boolean;
     patch: SettingsPatch;

package/dist/commands/settings.js

@@ -1,4 +1,5 @@
 import { getSettings, patchSettings, } from "../api.js";
+import { BEARER_SETTINGS_FLAGS } from "../automation-catalog.js";
 import { loadConfig } from "../config.js";
 import { CommandError } from "../errors.js";
 import { present } from "../ui/present.js";
@@ -7,15 +8,7 @@ import { buildConfigRows, canBrowse, openTabsBrowser } from "./browse.js";
  * CLI flag → Bearer settings key. on|off only. The connected flags are
  * read-only on the API and deliberately have no flag here.
  */
-export const SETTINGS_FLAGS = {
-    "--auto-review": "auto_review_enabled",
-    "--auto-patch": "auto_patch_enabled",
-    "--vortex-thinking": "vortex_show_thinking_traces",
-    "--repo-overview": "repo_overview_enabled",
-    "--review-unit-land": "review_unit_land_prs_enabled",
-    "--cyclone-review-unit-land": "cyclone_review_unit_land_prs_enabled",
-    "--vortex-seam": "vortex_seam_specialist_enabled",
-};
+export const SETTINGS_FLAGS = BEARER_SETTINGS_FLAGS;
 /** Parse `settings` argv. Accepts `--flag on|off` and `--flag=on|off`. */
 export function parseSettingsArgs(args) {
     let json = false;

package/dist/commands/stack.d.ts

@@ -1,9 +1,10 @@
-import { adoptStack, ensureUpperPark, listStacks, type StackDto } from "../api.js";
+import { adoptStack, ensureUpperPark, listStacks, setStackPolicy, type StackDto, type StackPolicyPatch } from "../api.js";
 import { loadConfig } from "../config.js";
 import { createPr, findOpenPrNumber } from "../gh.js";
 import { parseGithubOriginRepo } from "../git.js";
-import { branchExists, commitsAheadOf, fetchRemoteBranch, pushBranch, tipCommitMessage, tipCommitSubject } from "../git-stack.js";
+import { branchExists, commitsAheadOf, createBranchFromHead, currentBranch, defaultLayerBranchName, deleteBranch, discoverTrunk, fetchRemoteBranch, pushBranch, tipCommitMessage, tipCommitSubject, worktreeDirty } from "../git-stack.js";
 import { buildPrBodyFromCommit } from "../pr-body.js";
+import { gitTopLevel } from "../repo-identity.js";
 import { loadStackMeta, saveStackMeta } from "../stack-meta.js";
 /** A registered stack layer that would become the parent of a new layer. */
 export type RegisteredParentHit = {
@@ -30,27 +31,72 @@ export declare function parseAdoptTarget(args: string[]): {
 };
 /** Empty + populated bodies for the TTY `stack list` panel. */
 export declare function buildStackListLines(stacks: StackDto[]): string[];
+/** Short per-stack policy suffixes: Auto land when on, overrides when pinned. */
+export declare function stackPolicyLabels(s: Pick<StackDto, "autoEnqueueWhenReady" | "autoReviewOverride" | "autoPatchOverride">): string[];
+/** Per-open policy flags shared by create, submit, and adopt (`on|off` only). */
+export type StackOpenPolicyFlags = {
+    autoLand?: boolean;
+    autoReview?: boolean;
+    autoPatch?: boolean;
+};
+/** Wire policy for adopt from the parsed `on|off` flags; absent keys stay off the body. */
+export declare function openPolicyPatch(flags: StackOpenPolicyFlags): StackPolicyPatch | undefined;
 /** Parse `stack create` argv into options. Exported for tests. */
 export declare function parseStackCreateArgs(args: string[]): {
     name?: string;
     onto?: string;
     trunk?: string;
     extend: boolean;
+    autoLand?: boolean;
+    autoReview?: boolean;
+    autoPatch?: boolean;
     asJson: boolean;
 };
 /** Parse `stack submit` argv. Exported for tests. */
 export declare function parseStackSubmitArgs(args: string[]): {
     extend: boolean;
+    autoLand?: boolean;
+    autoReview?: boolean;
+    autoPatch?: boolean;
+    asJson: boolean;
+};
+export declare function parseStackAdoptArgs(args: string[]): {
+    owner: string;
+    repo: string;
+    prNumber: number;
+    autoLand?: boolean;
+    autoReview?: boolean;
+    autoPatch?: boolean;
+    asJson: boolean;
+};
+export type StackSetArgs = {
+    stackId: string;
+    /** At least one of these is present. */
+    autoLand?: boolean;
+    autoReview?: boolean | null;
+    autoPatch?: boolean | null;
     asJson: boolean;
 };
+export declare function parseStackSetArgs(args: string[]): StackSetArgs;
 export declare function parseStackResetArgs(args: string[]): void;
 /** Injectable seams for unit tests. Production callers omit deps. */
 export type StackCreateDeps = {
     cwd?: string;
+    gitTopLevel?: typeof gitTopLevel;
+    worktreeDirty?: typeof worktreeDirty;
+    currentBranch?: typeof currentBranch;
+    branchExists?: typeof branchExists;
+    createBranchFromHead?: typeof createBranchFromHead;
+    deleteBranch?: typeof deleteBranch;
+    discoverTrunk?: typeof discoverTrunk;
+    defaultLayerBranchName?: typeof defaultLayerBranchName;
+    loadStackMeta?: typeof loadStackMeta;
+    saveStackMeta?: typeof saveStackMeta;
     listStacks?: typeof listStacks;
     loadConfig?: typeof loadConfig;
     parseGithubOriginRepo?: typeof parseGithubOriginRepo;
 };
+export declare function cmdStackCreate(args: string[], deps?: StackCreateDeps): Promise<void>;
 /** Injectable seams for unit tests (STRUCT-04). Production callers omit deps. */
 export type StackSubmitDeps = {
     cwd?: string;
@@ -74,4 +120,11 @@ export type StackSubmitDeps = {
     ensureUpperPark?: typeof ensureUpperPark;
 };
 export declare function cmdStackSubmit(args: string[], deps?: StackSubmitDeps): Promise<void>;
+export type StackSetDeps = {
+    loadConfig?: typeof loadConfig;
+    setStackPolicy?: typeof setStackPolicy;
+};
+/** Human summary lines for a `stack set` write, one per flag. */
+export declare function stackSetSummary(parsed: StackSetArgs): string[];
+export declare function cmdStackSet(args: string[], deps?: StackSetDeps): Promise<void>;
 export declare function cmdStack(args: string[]): Promise<void>;

package/dist/commands/stack.js

@@ -1,4 +1,4 @@
-import { adoptStack, ensureUpperPark, landNextStack, listStacks, restackStack, } from "../api.js";
+import { adoptStack, ensureUpperPark, landNextStack, listStacks, restackStack, setStackPolicy, } from "../api.js";
 import { loadConfig } from "../config.js";
 import { CommandError } from "../errors.js";
 import { createPr, findOpenPrNumber, requireGh } from "../gh.js";
@@ -6,7 +6,7 @@ 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";
 import { gitTopLevel } from "../repo-identity.js";
-import { activeLayers, appendLayer, emptyStackMeta, loadStackMeta, removeActiveStack, resetStackMeta, saveStackMeta, selectStackForCreate, } from "../stack-meta.js";
+import { activeLayers, appendLayer, emptyStackMeta, loadStackMeta, removeActiveStack, resetStackMeta, saveStackMeta, selectStackForCreate, setActivePolicy, } from "../stack-meta.js";
 import { isMgParkBranch, planSubmitLayerBases } from "../submit-pr-base.js";
 import { ansi } from "../ui/ansi.js";
 import { runLineTabsBrowser } from "../ui/line-tabs.js";
@@ -14,14 +14,18 @@ import { present } from "../ui/present.js";
 import { canBrowse } from "./browse.js";
 import { openHelpBrowser } from "./help.js";
 const STACK_USAGE = `usage:
-  mergestorm stack create [name] [--onto <branch>] [--trunk <branch>] [--extend] [--json]
-  mergestorm stack submit [--extend] [--json]
+  mergestorm stack create [name] [--onto <branch>] [--trunk <branch>] [--extend] [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off] [--json]
+  mergestorm stack submit [--extend] [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off] [--json]
   mergestorm stack reset --force
   mergestorm stack list [--json]
-  mergestorm stack adopt <owner/repo>#<pr>
+  mergestorm stack set <stack-id> [--auto-land on|off] [--auto-review on|off|default] [--auto-patch on|off|default] [--json]
+  mergestorm stack adopt <owner/repo>#<pr> [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off] [--json]
   mergestorm stack restack <stack-id> [--json]
   mergestorm stack land <stack-id> [--json]
 
+  --auto-review / --auto-patch pin Vortex auto-review / Cyclone auto-patch for
+  one stack in either direction. Absent, or \`default\` on stack set, follows
+  the account setting.
   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.
@@ -126,9 +130,25 @@ export function buildStackListLines(stacks) {
     lines.push(ansi.dim("  create · submit · land <id> · q to close"));
     return lines;
 }
+/** Short per-stack policy suffixes: Auto land when on, overrides when pinned. */
+export function stackPolicyLabels(s) {
+    const labels = [];
+    if (s.autoEnqueueWhenReady)
+        labels.push("auto-land on");
+    if (typeof s.autoReviewOverride === "boolean") {
+        labels.push(`auto-review ${s.autoReviewOverride ? "on" : "off"}`);
+    }
+    if (typeof s.autoPatchOverride === "boolean") {
+        labels.push(`auto-patch ${s.autoPatchOverride ? "on" : "off"}`);
+    }
+    return labels;
+}
 function formatStackHuman(s) {
     const lines = [];
-    lines.push(`  ${ansi.bold(`${s.owner}/${s.repo}`)}  trunk=${s.trunkBranch}`);
+    lines.push(`  ${ansi.bold(`${s.owner}/${s.repo}`)}  trunk=${s.trunkBranch}` +
+        stackPolicyLabels(s)
+            .map((label) => `  ${label}`)
+            .join(""));
     lines.push(`  ${ansi.dim(s.id)}`);
     if (s.layers.length === 0) {
         lines.push(ansi.dim("    (no layers)"));
@@ -141,12 +161,45 @@ function formatStackHuman(s) {
     }
     return lines;
 }
+const OPEN_POLICY_FLAGS = [
+    { flag: "--auto-land", key: "autoLand" },
+    { flag: "--auto-review", key: "autoReview" },
+    { flag: "--auto-patch", key: "autoPatch" },
+];
+/**
+ * Consume one `--auto-* on|off` flag at `args[i]` (space or `=` form). Returns
+ * the next index to scan, or null when `args[i]` is not a policy flag.
+ */
+function takeOpenPolicyFlag(args, i, into, verb) {
+    const a = args[i];
+    for (const { flag, key } of OPEN_POLICY_FLAGS) {
+        if (a === flag) {
+            into[key] = parseOnOff(args[i + 1], flag, verb);
+            return i + 2;
+        }
+        if (a.startsWith(`${flag}=`)) {
+            into[key] = parseOnOff(a.slice(flag.length + 1), flag, verb);
+            return i + 1;
+        }
+    }
+    return null;
+}
+/** Wire policy for adopt from the parsed `on|off` flags; absent keys stay off the body. */
+export function openPolicyPatch(flags) {
+    const patch = {
+        ...(typeof flags.autoLand === "boolean" ? { autoEnqueueWhenReady: flags.autoLand } : {}),
+        ...(typeof flags.autoReview === "boolean" ? { autoReviewOverride: flags.autoReview } : {}),
+        ...(typeof flags.autoPatch === "boolean" ? { autoPatchOverride: flags.autoPatch } : {}),
+    };
+    return Object.keys(patch).length > 0 ? patch : undefined;
+}
 /** Parse `stack create` argv into options. Exported for tests. */
 export function parseStackCreateArgs(args) {
     let name;
     let onto;
     let trunk;
     let extend = false;
+    const policy = {};
     let asJson = false;
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
@@ -158,6 +211,11 @@ export function parseStackCreateArgs(args) {
             extend = true;
             continue;
         }
+        const next = takeOpenPolicyFlag(args, i, policy, "stack create");
+        if (next !== null) {
+            i = next - 1;
+            continue;
+        }
         if (a === "--onto") {
             const v = args[++i];
             if (!v) {
@@ -190,13 +248,24 @@ export function parseStackCreateArgs(args) {
         }
         name = a;
     }
-    return { name, onto, trunk, extend, asJson };
+    return {
+        name,
+        onto,
+        trunk,
+        extend,
+        autoLand: policy.autoLand,
+        autoReview: policy.autoReview,
+        autoPatch: policy.autoPatch,
+        asJson,
+    };
 }
 /** Parse `stack submit` argv. Exported for tests. */
 export function parseStackSubmitArgs(args) {
     let extend = false;
+    const policy = {};
     let asJson = false;
-    for (const a of args) {
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
         if (a === "--json") {
             asJson = true;
             continue;
@@ -205,43 +274,159 @@ export function parseStackSubmitArgs(args) {
             extend = true;
             continue;
         }
-        throw new CommandError("usage: mergestorm stack submit [--extend] [--json]");
+        const next = takeOpenPolicyFlag(args, i, policy, "stack submit");
+        if (next !== null) {
+            i = next - 1;
+            continue;
+        }
+        throw new CommandError("usage: mergestorm stack submit [--extend] [--auto-land on|off] [--auto-review on|off] [--auto-patch on|off] [--json]");
+    }
+    return {
+        extend,
+        autoLand: policy.autoLand,
+        autoReview: policy.autoReview,
+        autoPatch: policy.autoPatch,
+        asJson,
+    };
+}
+function parseOnOff(raw, flag, verb) {
+    if (raw === "on")
+        return true;
+    if (raw === "off")
+        return false;
+    throw new CommandError(`usage: mergestorm ${verb} [${flag} on|off]`);
+}
+/** `stack set` overrides are tri-state: `default` writes null (follow the account flag). */
+function parseOnOffDefault(raw, flag, verb) {
+    if (raw === "on")
+        return true;
+    if (raw === "off")
+        return false;
+    if (raw === "default")
+        return null;
+    throw new CommandError(`usage: mergestorm ${verb} [${flag} on|off|default]`);
+}
+export function parseStackAdoptArgs(args) {
+    const targetArgs = [];
+    const policy = {};
+    let asJson = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--json") {
+            asJson = true;
+            continue;
+        }
+        const next = takeOpenPolicyFlag(args, i, policy, "stack adopt <owner/repo>#<pr>");
+        if (next !== null) {
+            i = next - 1;
+            continue;
+        }
+        if (a.startsWith("-")) {
+            throw new CommandError(`${STACK_USAGE}\nunknown flag: ${a}`);
+        }
+        targetArgs.push(a);
+    }
+    const target = parseAdoptTarget(targetArgs);
+    return {
+        ...target,
+        autoLand: policy.autoLand,
+        autoReview: policy.autoReview,
+        autoPatch: policy.autoPatch,
+        asJson,
+    };
+}
+export function parseStackSetArgs(args) {
+    const usage = "usage: mergestorm stack set <stack-id> [--auto-land on|off] [--auto-review on|off|default] [--auto-patch on|off|default] [--json]";
+    const verb = "stack set <stack-id>";
+    let stackId;
+    let autoLand;
+    let autoReview;
+    let autoPatch;
+    let asJson = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--json") {
+            asJson = true;
+        }
+        else if (arg === "--auto-land") {
+            autoLand = parseOnOff(args[++i], "--auto-land", verb);
+        }
+        else if (arg.startsWith("--auto-land=")) {
+            autoLand = parseOnOff(arg.slice("--auto-land=".length), "--auto-land", verb);
+        }
+        else if (arg === "--auto-review") {
+            autoReview = parseOnOffDefault(args[++i], "--auto-review", verb);
+        }
+        else if (arg.startsWith("--auto-review=")) {
+            autoReview = parseOnOffDefault(arg.slice("--auto-review=".length), "--auto-review", verb);
+        }
+        else if (arg === "--auto-patch") {
+            autoPatch = parseOnOffDefault(args[++i], "--auto-patch", verb);
+        }
+        else if (arg.startsWith("--auto-patch=")) {
+            autoPatch = parseOnOffDefault(arg.slice("--auto-patch=".length), "--auto-patch", verb);
+        }
+        else if (arg.startsWith("-") || stackId !== undefined) {
+            throw new CommandError(usage);
+        }
+        else {
+            stackId = arg;
+        }
     }
-    return { extend, asJson };
+    if (autoLand === undefined && autoReview === undefined && autoPatch === undefined) {
+        throw new CommandError(usage);
+    }
+    return {
+        stackId: requireStackId(stackId, usage),
+        ...(autoLand !== undefined ? { autoLand } : {}),
+        ...(autoReview !== undefined ? { autoReview } : {}),
+        ...(autoPatch !== undefined ? { autoPatch } : {}),
+        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, deps = {}) {
-    const { name, onto, trunk: trunkFlag, extend, asJson } = parseStackCreateArgs(args);
+export async function cmdStackCreate(args, deps = {}) {
+    const { name, onto, trunk: trunkFlag, extend, autoLand, autoReview, autoPatch, asJson, } = parseStackCreateArgs(args);
     const cwd = deps.cwd ?? process.cwd();
+    const gitTopLevelFn = deps.gitTopLevel ?? gitTopLevel;
+    const worktreeDirtyFn = deps.worktreeDirty ?? worktreeDirty;
+    const currentBranchFn = deps.currentBranch ?? currentBranch;
+    const branchExistsFn = deps.branchExists ?? branchExists;
+    const createBranchFromHeadFn = deps.createBranchFromHead ?? createBranchFromHead;
+    const deleteBranchFn = deps.deleteBranch ?? deleteBranch;
+    const discoverTrunkFn = deps.discoverTrunk ?? discoverTrunk;
+    const defaultLayerBranchNameFn = deps.defaultLayerBranchName ?? defaultLayerBranchName;
+    const loadStackMetaFn = deps.loadStackMeta ?? loadStackMeta;
+    const saveStackMetaFn = deps.saveStackMeta ?? saveStackMeta;
     const listStacksFn = deps.listStacks ?? listStacks;
     const loadConfigFn = deps.loadConfig ?? loadConfig;
     const parseOriginFn = deps.parseGithubOriginRepo ?? parseGithubOriginRepo;
     try {
-        gitTopLevel(cwd);
+        gitTopLevelFn(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)) {
+    if (worktreeDirtyFn(cwd)) {
         throw new CommandError("Working tree is dirty. Commit or stash changes before `stack create`.");
     }
-    const parentBranch = onto?.trim() || currentBranch(cwd);
+    const parentBranch = onto?.trim() || currentBranchFn(cwd);
     if (!parentBranch) {
         throw new CommandError("Detached HEAD. Check out a branch (or pass --onto <branch>) before `stack create`.");
     }
-    if (!branchExists(parentBranch, cwd)) {
+    if (!branchExistsFn(parentBranch, cwd)) {
         throw new CommandError(`Parent branch not found: ${parentBranch}`);
     }
-    const branch = defaultLayerBranchName(name);
-    if (branchExists(branch, cwd)) {
+    const branch = defaultLayerBranchNameFn(name);
+    if (branchExistsFn(branch, cwd)) {
         throw new CommandError(`Branch already exists: ${branch}`);
     }
-    let meta = await loadStackMeta(cwd);
-    const trunk = trunkFlag?.trim() || meta?.trunk || discoverTrunk(cwd);
+    let meta = await loadStackMetaFn(cwd);
+    const trunk = trunkFlag?.trim() || meta?.trunk || discoverTrunkFn(cwd);
     if (!meta) {
         meta = emptyStackMeta(trunk);
     }
@@ -281,23 +466,28 @@ async function cmdStackCreate(args, deps = {}) {
     }
     try {
         meta = selectStackForCreate(meta, parentBranch);
+        meta = setActivePolicy(meta, {
+            autoEnqueueWhenReady: autoLand,
+            autoReviewOverride: autoReview,
+            autoPatchOverride: autoPatch,
+        });
     }
     catch (err) {
         throw new CommandError(err instanceof Error ? err.message : String(err));
     }
     try {
-        createBranchFromHead(branch, cwd);
+        createBranchFromHeadFn(branch, cwd);
     }
     catch (err) {
         throw new CommandError(err instanceof Error ? err.message : String(err));
     }
     try {
         meta = appendLayer(meta, { branch, parentBranch });
-        await saveStackMeta(meta, cwd);
+        await saveStackMetaFn(meta, cwd);
     }
     catch (err) {
         try {
-            deleteBranch(branch, cwd);
+            deleteBranchFn(branch, cwd);
         }
         catch { /* rollback best-effort */ }
         throw new CommandError(err instanceof Error ? err.message : String(err));
@@ -328,7 +518,7 @@ async function cmdStackCreate(args, deps = {}) {
     await present("Stack", created);
 }
 export async function cmdStackSubmit(args, deps = {}) {
-    const { extend, asJson } = parseStackSubmitArgs(args);
+    const { extend, autoLand, autoReview, autoPatch, asJson } = parseStackSubmitArgs(args);
     const cwd = deps.cwd ?? process.cwd();
     const gitTopLevelFn = deps.gitTopLevel ?? gitTopLevel;
     const loadStackMetaFn = deps.loadStackMeta ?? loadStackMeta;
@@ -399,6 +589,21 @@ export async function cmdStackSubmit(args, deps = {}) {
         owner,
         repo,
     });
+    // Explicit submit flags win; otherwise a fresh (unregistered) stack carries
+    // the choices remembered at `stack create`. Joining a registered stack
+    // never replays stored create-time flags onto it.
+    const stored = meta.stacks[meta.active];
+    const freshStack = plans.every((plan) => plan.stackId === null);
+    const pick = (flag, remembered) => typeof flag === "boolean"
+        ? flag
+        : freshStack && typeof remembered === "boolean"
+            ? remembered
+            : undefined;
+    const policy = openPolicyPatch({
+        autoLand: pick(autoLand, stored?.autoEnqueueWhenReady),
+        autoReview: pick(autoReview, stored?.autoReviewOverride),
+        autoPatch: pick(autoPatch, stored?.autoPatchOverride),
+    });
     for (const layer of layers) {
         if (!branchExistsFn(layer.branch, cwd)) {
             throw new CommandError(`Stack layer branch missing locally: ${layer.branch}`);
@@ -475,7 +680,7 @@ export async function cmdStackSubmit(args, deps = {}) {
     let stackId = plans.find((plan) => plan.stackId)?.stackId ?? null;
     const registerPr = async (prNumber) => {
         console.log(ansi.dim(`  Registering stack via import (${owner}/${repo}#${prNumber}) …`));
-        const body = await adoptStackFn(owner, repo, prNumber, cfg);
+        const body = await adoptStackFn(owner, repo, prNumber, cfg, policy);
         if (typeof body !== "object" || body === null) {
             throw new CommandError("Unexpected response shape from adopt API");
         }
@@ -576,15 +781,39 @@ async function cmdStackList(args) {
     listed.push(ansi.dim("  Dashboard: https://mergestorm.ai/dashboard"));
     await present("Stacks", listed);
 }
-async function cmdStackAdopt(args) {
-    const asJson = args.includes("--json");
-    const targetArgs = args.filter((a) => a !== "--json");
-    if (targetArgs.length === 0) {
-        throw new CommandError(`usage: mergestorm stack adopt <owner/repo>#<pr>`);
+/** Human summary lines for a `stack set` write, one per flag. */
+export function stackSetSummary(parsed) {
+    const tri = (value) => value === null ? "default (account setting)" : value ? "on" : "off";
+    const lines = [];
+    if (parsed.autoLand !== undefined) {
+        lines.push(`Auto land ${parsed.autoLand ? "on" : "off"}`);
     }
-    const { owner, repo, prNumber } = parseAdoptTarget(targetArgs);
+    if (parsed.autoReview !== undefined) {
+        lines.push(`Auto-review ${tri(parsed.autoReview)}`);
+    }
+    if (parsed.autoPatch !== undefined) {
+        lines.push(`Auto-patch ${tri(parsed.autoPatch)}`);
+    }
+    return lines;
+}
+export async function cmdStackSet(args, deps = {}) {
+    const parsed = parseStackSetArgs(args);
+    const cfg = await (deps.loadConfig ?? loadConfig)();
+    const body = await (deps.setStackPolicy ?? setStackPolicy)(parsed.stackId, {
+        ...(parsed.autoLand !== undefined ? { autoEnqueueWhenReady: parsed.autoLand } : {}),
+        ...(parsed.autoReview !== undefined ? { autoReviewOverride: parsed.autoReview } : {}),
+        ...(parsed.autoPatch !== undefined ? { autoPatchOverride: parsed.autoPatch } : {}),
+    }, cfg);
+    if (parsed.asJson) {
+        console.log(JSON.stringify(body, null, 2));
+        return;
+    }
+    await present("Stack", stackSetSummary(parsed).map((line) => ansi.brightGreen(`  ${line} for ${parsed.stackId}`)));
+}
+async function cmdStackAdopt(args) {
+    const { owner, repo, prNumber, autoLand, autoReview, autoPatch, asJson } = parseStackAdoptArgs(args);
     const cfg = await loadConfig();
-    const body = await adoptStack(owner, repo, prNumber, cfg);
+    const body = await adoptStack(owner, repo, prNumber, cfg, openPolicyPatch({ autoLand, autoReview, autoPatch }));
     if (asJson) {
         console.log(JSON.stringify(body, null, 2));
         return;
@@ -670,6 +899,8 @@ export async function cmdStack(args) {
         return cmdStackReset(rest);
     if (sub === "list" || sub === "ls")
         return cmdStackList(rest);
+    if (sub === "set")
+        return cmdStackSet(rest);
     if (sub === "adopt")
         return cmdStackAdopt(rest);
     if (sub === "restack")

package/dist/repo-identity.d.ts

@@ -2,7 +2,7 @@ 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.
+ * Each worktree has its own authoring state.
  * Independent clones remain isolated even when they point at the same remote.
  */
 export declare function stableRepoId(cwd?: string): string;

package/dist/repo-identity.js

@@ -41,11 +41,22 @@ export function gitCommonDir(cwd = process.cwd()) {
     }
 }
 /**
- * A physical clone and all its linked worktrees share one authoring state.
+ * Each worktree has its own 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);
+    let raw;
+    try {
+        raw = git(["rev-parse", "--git-dir"], cwd).trim();
+    }
+    catch (err) {
+        rethrowIfNotARepo(err);
+    }
+    const absolute = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
+    return createHash("sha256")
+        .update(realpathSync(absolute))
+        .digest("hex")
+        .slice(0, 20);
 }
 export function cliStacksRoot() {
     return path.join(mergestormHome(), "stacks");

package/dist/stack-dto.d.ts

@@ -224,6 +224,16 @@ 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;
     layers: StackLayerDto[];
     /** Present when a review-unit row exists for this stack. */
     unit?: StackUnitDto;

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,9 @@ 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",
+    ],
 };
 function densityFromVariant(variant) {
     if (variant === "mini" || variant === "nano")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "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-pr-loop/SKILL.md

@@ -18,23 +18,29 @@ 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.
+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. `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`.
    - 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).
+   - If it is `false`: find the PR's stack with `stack_list`. If its `autoPatchOverride` is `true`, refuse unless the human asked you to turn Cyclone off for this PR; if they did, use the adopted-stack and `stack_set { auto_patch: false }` path below. Otherwise continue. You are the only patcher.
+   - If it is `true`: find the PR's stack with `stack_list` (the stack whose `layers` contain this PR's `prNumber` for this owner/repo) and read its `autoPatchOverride`.
+     - If that stack's `autoPatchOverride` is `false`: continue. Cyclone is pinned off for this stack.
+     - If the PR has no stack, or the override is not `false`, and the human asked you to turn Cyclone off for this PR: the PR must be an adopted stack layer first (if it is not, stop and tell the human to adopt it, for example `mg stack adopt <owner/repo>#<n> --auto-patch off`). Then 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.
+2. 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.
 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.
+4. 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). Do not use the `cyclone-outcome:` prefix.
 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.
+7. Call `review_wait_pr` again with `after_sha` set to the SHA you just pushed (7+ hex) and `timeout_s` 45. 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.
 
 ## Stop rules
@@ -52,12 +58,14 @@ Map these to `mergestorm.pr_review/v1` envelope fields; do not invent statuses.
 
 - 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
+- change the account `auto_patch_enabled` from this skill, for any reason; Cyclone is muted per stack with `stack_set`, never per account
+- 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,7 +75,7 @@ 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 its `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` (adopt first with `mg stack adopt <owner/repo>#<n> --auto-patch off` when the PR has no stack) and re-read with `mg stack list --json`. Do not run `mg settings --auto-patch off`: that changes the account, not this PR.
 
 ```bash
 mg pr <owner/repo>#<n> --json --wait --after-sha <sha> --timeout <s>