mergestorm 0.3.13 → 0.3.16

package/dist/commands/review-client.js

@@ -210,6 +210,116 @@ export class ReviewPollTimeoutError extends Error {
         this.lastRow = lastRow;
     }
 }
+export class PrReviewPollTimeoutError extends Error {
+    owner;
+    repo;
+    prNumber;
+    lastEnvelope;
+    constructor(owner, repo, prNumber, lastEnvelope) {
+        super(`Timed out waiting for PR review ${owner}/${repo}#${prNumber}`);
+        this.name = "PrReviewPollTimeoutError";
+        this.owner = owner;
+        this.repo = repo;
+        this.prNumber = prNumber;
+        this.lastEnvelope = lastEnvelope;
+    }
+}
+function shaMatches(actual, expected) {
+    const left = actual?.trim().toLowerCase() ?? "";
+    const right = expected.trim().toLowerCase();
+    return Boolean(left && right.length >= 7 && (left.startsWith(right) || right.startsWith(left)));
+}
+/** Poll the DB-only PR review endpoint until the requested pass is resting. */
+export async function pollPrVortexReview(cfg, owner, repo, prNumber, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? REVIEW_POLL_DEFAULT_TIMEOUT_MS;
+    const intervalMs = opts.intervalMs ?? REVIEW_POLL_INTERVAL_MS;
+    const now = opts.now ?? Date.now;
+    const wait = opts.sleep ?? sleep;
+    const startedAt = now();
+    const deadline = startedAt + timeoutMs;
+    const query = new URLSearchParams({
+        owner,
+        repo,
+        pr_number: String(prNumber),
+    });
+    if (opts.afterSha)
+        query.set("after_sha", opts.afterSha);
+    let transientFailures = 0;
+    let lastEnvelope = null;
+    const sleepBeforeRetry = async (retryAfterSeconds) => {
+        const waitMs = Math.min(transientRetryWaitMs({
+            retryAfterSeconds,
+            failureCount: transientFailures,
+            random: opts.random,
+        }), Math.max(0, deadline - now()));
+        if (waitMs > 0)
+            await wait(waitMs, opts.signal);
+    };
+    const sleepBeforePoll = async () => {
+        const waitMs = Math.min(stretchedPollIntervalMs(now() - startedAt, intervalMs), Math.max(0, deadline - now()));
+        if (waitMs > 0)
+            await wait(waitMs, opts.signal);
+    };
+    while (now() < deadline) {
+        let poll;
+        try {
+            poll = await apiFetch(cfg, `/api/v1/stacks/pr-review?${query.toString()}`, {
+                signal: opts.signal,
+                timeoutMs: Math.max(1, Math.min(30_000, deadline - now())),
+            });
+        }
+        catch (err) {
+            if (isTransientReviewPollError(err) &&
+                transientFailures < REVIEW_POLL_MAX_TRANSIENT_RETRIES) {
+                transientFailures += 1;
+                opts.onTick?.("retry");
+                await sleepBeforeRetry();
+                continue;
+            }
+            if (isCommandErrorCode(err, "api_timeout")) {
+                if (opts.propagateTimeout)
+                    throw err;
+                break;
+            }
+            if (isTransientReviewPollError(err)) {
+                const detail = err instanceof Error ? err.message : String(err);
+                throw new CommandError(`Poll failed: ${detail}`, REVIEW_EXIT.failed, "review_failed");
+            }
+            throw err;
+        }
+        if (poll.status === 404) {
+            transientFailures = 0;
+            opts.onTick?.("progress");
+            await sleepBeforePoll();
+            continue;
+        }
+        if (poll.status !== 200) {
+            if (isTransientReviewPollStatus(poll.status) &&
+                transientFailures < REVIEW_POLL_MAX_TRANSIENT_RETRIES) {
+                transientFailures += 1;
+                opts.onTick?.("retry");
+                await sleepBeforeRetry(poll.retryAfterSeconds);
+                continue;
+            }
+            if (poll.status === 429) {
+                throw new CommandError(rateLimitedMessage(poll.retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", { retryAfterSeconds: poll.retryAfterSeconds });
+            }
+            throw new CommandError(`Poll failed: ${JSON.stringify(poll.body, null, 2)}`, REVIEW_EXIT.failed, "review_failed");
+        }
+        transientFailures = 0;
+        if (!poll.body || typeof poll.body !== "object") {
+            throw new CommandError("Poll failed: invalid PR review response", REVIEW_EXIT.failed, "review_failed");
+        }
+        lastEnvelope = poll.body;
+        const resting = (lastEnvelope.raw_status ?? lastEnvelope.status) !== "in_progress";
+        const matches = !opts.afterSha || shaMatches(lastEnvelope.head_sha, opts.afterSha);
+        if (resting && matches)
+            return lastEnvelope;
+        opts.onTick?.("progress");
+        await sleepBeforePoll();
+    }
+    throw new PrReviewPollTimeoutError(owner, repo, prNumber, lastEnvelope);
+}
 export async function pollReview(cfg, jobId, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? REVIEW_POLL_DEFAULT_TIMEOUT_MS;
     const intervalMs = opts.intervalMs ?? REVIEW_POLL_INTERVAL_MS;

package/dist/commands/review.d.ts

@@ -7,6 +7,12 @@ export declare const VORTEX_ROUTER_CAPS: {
     readonly standard: 3;
     readonly max: 5;
 };
+/**
+ * Pinnable L0 lanes only. Keep this list byte-identical to
+ * `pinnableVortexSpecialistIds(VORTEX_SPECIALIST_IDS)` in review-findings
+ * (`cli-lockstep.test.ts`). Do not add `governance` (round-gated) or `seam`
+ * (phase-gated). Those L1 lanes are not local pins.
+ */
 export declare const VORTEX_SPECIALIST_IDS: readonly ["security", "performance", "architecture", "tests", "data", "api", "frontend"];
 type VortexRouterMode = (typeof VORTEX_ROUTER_MODES)[number];
 type VortexSpecialistId = (typeof VORTEX_SPECIALIST_IDS)[number];

package/dist/commands/review.js

@@ -3,7 +3,8 @@ import { loadConfig } from "../config.js";
 import { CommandError, DetachedError, REVIEW_EXIT, isCommandErrorCode, rateLimitedMessage, } from "../errors.js";
 import { discoverTrunk } from "../git-stack.js";
 import { ansi } from "../ui/ansi.js";
-import { renderFindings } from "../ui/findings.js";
+import { formatFindingsLines } from "../ui/findings.js";
+import { present } from "../ui/present.js";
 import { toReviewJobEnvelope, } from "../ui/job-envelope.js";
 import { MAX_IDEMPOTENCY_KEY_CHARS, REVIEW_POLL_DEFAULT_TIMEOUT_MS, REVIEW_POLL_MAX_TRANSIENT_RETRIES, REVIEW_THREAD_SLUG_RE, ReviewPollTimeoutError, collectReviewInput, isTransientReviewPollError, isTransientReviewPollStatus, loadReviewContext, pollReview, submitReview, } from "./review-client.js";
 export { REVIEW_POLL_MAX_TRANSIENT_RETRIES, isTransientReviewPollError, isTransientReviewPollStatus, };
@@ -11,6 +12,12 @@ export { REVIEW_POLL_MAX_TRANSIENT_RETRIES, isTransientReviewPollError, isTransi
 export const VORTEX_ROUTER_MODES = ["off", "standard", "max", "manual"];
 /** Standard/Max fleet caps; Manual is capped at Max. */
 export const VORTEX_ROUTER_CAPS = { standard: 3, max: 5 };
+/**
+ * Pinnable L0 lanes only. Keep this list byte-identical to
+ * `pinnableVortexSpecialistIds(VORTEX_SPECIALIST_IDS)` in review-findings
+ * (`cli-lockstep.test.ts`). Do not add `governance` (round-gated) or `seam`
+ * (phase-gated). Those L1 lanes are not local pins.
+ */
 export const VORTEX_SPECIALIST_IDS = [
     "security",
     "performance",
@@ -394,14 +401,17 @@ export async function cmdReview(args, opts = {}) {
             printJson(row, { jobId });
             return;
         }
-        console.log(`\nVerdict: ${ansi.bold(row.verdict ?? "comment")}`);
         const ran = row.specialists_run ?? row.findings?.specialists_run ?? [];
+        const result = [
+            `Verdict: ${ansi.bold(row.verdict ?? "comment")}`,
+        ];
         if (ran.length > 0)
-            console.log(ansi.dim(`Specialists: ${ran.join(", ")}`));
-        console.log(row.summary ?? "");
-        renderFindings(row.findings, {
+            result.push(ansi.dim(`Specialists: ${ran.join(", ")}`));
+        if (row.summary)
+            result.push(row.summary);
+        result.push(...formatFindingsLines(row.findings, {
             emptyMessage: true,
-        });
+        }));
         if (interactive && meBefore) {
             const meAfter = await getMe(cfg);
             if (meAfter) {
@@ -409,10 +419,11 @@ export async function cmdReview(args, opts = {}) {
                 const afterLeft = meAfter.usage.standard.remaining ?? 0;
                 const used = Math.max(0, beforeLeft - afterLeft);
                 if (used > 0) {
-                    console.log(ansi.dim(`\n${used} credit${used === 1 ? "" : "s"} used · ${afterLeft} remaining`));
+                    result.push(ansi.dim(`${used} credit${used === 1 ? "" : "s"} used · ${afterLeft} remaining`));
                 }
             }
         }
+        await present("Review", result);
     }
     catch (err) {
         if (err instanceof DetachedError)

package/dist/commands/settings.d.ts

@@ -0,0 +1,17 @@
+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, "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;
+};
+/** Parse `settings` argv. Accepts `--flag on|off` and `--flag=on|off`. */
+export declare function parseSettingsArgs(args: string[]): SettingsArgs;
+/** Static printout of the GET/PATCH response shape (rows match the Config tab). */
+export declare function formatSettingsLines(settings: SettingsResponse): string[];
+export declare function cmdSettings(args: string[], opts?: {
+    mode?: "oneshot" | "shell";
+}): Promise<void>;

package/dist/commands/settings.js

@@ -0,0 +1,82 @@
+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";
+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 = BEARER_SETTINGS_FLAGS;
+/** Parse `settings` argv. Accepts `--flag on|off` and `--flag=on|off`. */
+export function parseSettingsArgs(args) {
+    let json = false;
+    const patch = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        const eq = arg.indexOf("=");
+        const flag = eq >= 0 ? arg.slice(0, eq) : arg;
+        const key = SETTINGS_FLAGS[flag];
+        if (!key) {
+            throw new CommandError(`Unknown settings flag: ${flag}. See \`mergestorm --help\`.`, 2, "usage");
+        }
+        const value = eq >= 0 ? arg.slice(eq + 1) : args[++i];
+        if (value !== "on" && value !== "off") {
+            throw new CommandError(`${flag} takes on or off.`, 2, "usage");
+        }
+        patch[key] = value === "on";
+    }
+    return { json, patch };
+}
+/** Static printout of the GET/PATCH response shape (rows match the Config tab). */
+export function formatSettingsLines(settings) {
+    const rows = buildConfigRows(settings);
+    const labelWidth = Math.max(...rows.map((r) => r.label.length));
+    return rows.map((row) => {
+        const value = row.writable
+            ? row.value
+                ? "on"
+                : "off"
+            : row.value
+                ? "connected"
+                : "not connected";
+        return `  ${row.label.padEnd(labelWidth + 2)}${value}`;
+    });
+}
+export async function cmdSettings(args, opts = {}) {
+    const { json, patch } = parseSettingsArgs(args);
+    const hasPatch = Object.keys(patch).length > 0;
+    // Bare `settings` on a TTY: the tabbed browser, opened on Config.
+    if (!hasPatch && !json && canBrowse()) {
+        await openTabsBrowser("config");
+        return;
+    }
+    const cfg = await loadConfig();
+    let settings;
+    if (hasPatch) {
+        settings = await patchSettings(patch, cfg);
+    }
+    else {
+        const got = await getSettings(cfg);
+        if (!got) {
+            throw new CommandError("Settings are not available (offline or API too old). " +
+                "Try again or open https://mergestorm.ai/settings");
+        }
+        settings = got;
+    }
+    if (json) {
+        const text = JSON.stringify(settings, null, 2);
+        if (opts.mode === "shell") {
+            await present("Settings", text.split("\n"));
+            return;
+        }
+        console.log(text);
+        return;
+    }
+    await present("Settings", formatSettingsLines(settings));
+}

package/dist/commands/skill.d.ts

@@ -0,0 +1,20 @@
+export declare const SKILL_NAME = "mergestorm-review";
+export declare const PR_LOOP_SKILL_NAME = "mergestorm-pr-loop";
+export declare const SKILL_NAMES: readonly ["mergestorm-review", "mergestorm-pr-loop"];
+export type SkillName = (typeof SKILL_NAMES)[number];
+export declare const SKILL_USAGE = "usage:\n  mergestorm skill install --claude|--cursor [--json]\n\n  Copies mergestorm-review and mergestorm-pr-loop into this repo (git toplevel, else cwd):\n    --claude  .claude/skills/<name>/SKILL.md\n    --cursor  .cursor/skills/<name>/SKILL.md\n  Pass both flags to write both trees. Overwrites existing copies.";
+export type SkillTarget = "claude" | "cursor";
+export type SkillInstallRequest = {
+    help: boolean;
+    json: boolean;
+    targets: SkillTarget[];
+};
+export declare function parseSkillArgs(args: string[]): SkillInstallRequest;
+/** Prefer the git repo root so `mg skill install` from a subdir still lands in-project. */
+export declare function skillInstallRoot(cwd?: string): string;
+export declare function skillDestination(root: string, target: SkillTarget, name?: SkillName): string;
+export declare function resolveBundledSkillPath(fromFile?: string, name?: SkillName): string;
+export declare function writeSkillCopies(sourcePath: string, destinations: string[]): Promise<string[]>;
+export declare function cmdSkill(args: string[], opts?: {
+    cwd?: string;
+}): Promise<void>;

package/dist/commands/skill.js

@@ -0,0 +1,145 @@
+import { existsSync, readFileSync } from "node:fs";
+import { lstat, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CommandError, isCommandErrorCode } from "../errors.js";
+import { gitTopLevel } from "../repo-identity.js";
+import { present } from "../ui/present.js";
+export const SKILL_NAME = "mergestorm-review";
+export const PR_LOOP_SKILL_NAME = "mergestorm-pr-loop";
+export const SKILL_NAMES = [SKILL_NAME, PR_LOOP_SKILL_NAME];
+export const SKILL_USAGE = `usage:
+  mergestorm skill install --claude|--cursor [--json]
+
+  Copies mergestorm-review and mergestorm-pr-loop into this repo (git toplevel, else cwd):
+    --claude  .claude/skills/<name>/SKILL.md
+    --cursor  .cursor/skills/<name>/SKILL.md
+  Pass both flags to write both trees. Overwrites existing copies.`;
+export function parseSkillArgs(args) {
+    const [sub, ...rest] = args;
+    if (!sub || sub === "-h" || sub === "--help" || sub === "help") {
+        return { help: true, json: false, targets: [] };
+    }
+    if (sub !== "install") {
+        throw new CommandError(`${SKILL_USAGE}\nunknown skill subcommand: ${sub}`, 1, "usage");
+    }
+    let json = false;
+    const targets = [];
+    for (const arg of rest) {
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--claude") {
+            if (!targets.includes("claude"))
+                targets.push("claude");
+            continue;
+        }
+        if (arg === "--cursor") {
+            if (!targets.includes("cursor"))
+                targets.push("cursor");
+            continue;
+        }
+        if (arg === "-h" || arg === "--help" || arg === "help") {
+            return { help: true, json: false, targets: [] };
+        }
+        throw new CommandError(`${SKILL_USAGE}\nunknown flag: ${arg}`, 1, "usage");
+    }
+    if (targets.length === 0) {
+        throw new CommandError(`${SKILL_USAGE}\npass --claude and/or --cursor`, 1, "usage");
+    }
+    return { help: false, json, targets };
+}
+/** Prefer the git repo root so `mg skill install` from a subdir still lands in-project. */
+export function skillInstallRoot(cwd = process.cwd()) {
+    try {
+        return gitTopLevel(cwd);
+    }
+    catch (err) {
+        if (isCommandErrorCode(err, "not_a_repo"))
+            return path.resolve(cwd);
+        throw err;
+    }
+}
+export function skillDestination(root, target, name = SKILL_NAME) {
+    if (target === "claude") {
+        return path.join(root, ".claude", "skills", name, "SKILL.md");
+    }
+    return path.join(root, ".cursor", "skills", name, "SKILL.md");
+}
+export function resolveBundledSkillPath(fromFile = import.meta.url, name = SKILL_NAME) {
+    const here = path.dirname(fileURLToPath(fromFile));
+    const packageRoot = path.resolve(here, "..", "..");
+    // The published package ships the review skill at skill/SKILL.md; extra
+    // skills sit beside it in per-name directories. The monorepo keeps every
+    // skill under skills/<name>/SKILL.md.
+    const candidates = name === SKILL_NAME
+        ? [
+            path.join(packageRoot, "skill", "SKILL.md"),
+            path.join(packageRoot, "..", "..", "skills", name, "SKILL.md"),
+        ]
+        : [
+            path.join(packageRoot, "skill", name, "SKILL.md"),
+            path.join(packageRoot, "..", "..", "skills", name, "SKILL.md"),
+        ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    throw new CommandError(`${name} skill is missing (looked in ${candidates.join(" and ")})`);
+}
+async function assertNoSymlink(dest) {
+    const parts = dest.split(path.sep);
+    const marker = parts.findIndex((p) => p === ".claude" || p === ".cursor");
+    const first = marker === -1 ? parts.length - 1 : marker;
+    for (let i = first; i < parts.length; i++) {
+        const candidate = parts.slice(0, i + 1).join(path.sep);
+        let stat;
+        try {
+            stat = await lstat(candidate);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        if (stat.isSymbolicLink()) {
+            throw new CommandError(`refusing to write skill through symlink: ${candidate}`);
+        }
+    }
+}
+export async function writeSkillCopies(sourcePath, destinations) {
+    const body = readFileSync(sourcePath, "utf8");
+    const written = [];
+    for (const dest of destinations) {
+        await assertNoSymlink(dest);
+        await mkdir(path.dirname(dest), { recursive: true });
+        await writeFile(dest, body, "utf8");
+        written.push(dest);
+    }
+    return written;
+}
+export async function cmdSkill(args, opts = {}) {
+    const req = parseSkillArgs(args);
+    if (req.help) {
+        await present("Skill", SKILL_USAGE.split("\n"));
+        return;
+    }
+    const root = skillInstallRoot(opts.cwd);
+    const sources = {};
+    const written = [];
+    for (const name of SKILL_NAMES) {
+        const source = resolveBundledSkillPath(undefined, name);
+        sources[name] = source;
+        const destinations = req.targets.map((t) => skillDestination(root, t, name));
+        written.push(...(await writeSkillCopies(source, destinations)));
+    }
+    if (req.json) {
+        await present("Skill", JSON.stringify({ names: SKILL_NAMES, sources, written }, null, 2).split("\n"));
+        return;
+    }
+    await present("Skill", [
+        `  Installed ${SKILL_NAMES.join(" and ")}`,
+        ...written.map((dest) => `  ${dest}`),
+    ]);
+}

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 = {
@@ -28,27 +29,74 @@ export declare function parseAdoptTarget(args: string[]): {
     repo: string;
     prNumber: number;
 };
+/** 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;
@@ -72,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>;