versionary 1.0.1 → 1.2.0

package/dist/release/pr.js

@@ -1,14 +1,16 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { loadConfig } from "../config/load-config.js";
 import { ensureGitIdentity } from "../git/identity.js";
 import { getScmClient } from "../scm/client.js";
 import { resolvePackageStrategyContext, resolveReleaseName, } from "../strategy/package-context.js";
 import { applyConfiguredArtifactRules } from "./artifact-rules.js";
-import { extractUnreleasedNotes, prependChangelog, renderReleaseNotesSection, renderReleasePlanChangelog, renderReviewRequestFooter, } from "./changelog.js";
+import { extractUnreleasedNotes, prependChangelog, renderReleaseNotesSection, renderReleasePlanChangelog, renderReviewRequestFooter, renderRNewsReleaseNotes, } from "./changelog.js";
+import { buildInitialReleaseCohorts, resolveSeparateReleaseBranch, resolveSeparateReleaseBranchPrefix, stabilizeReleaseCohorts, } from "./cohorts.js";
 import { createReleasePlan, getChangelogDefaults, resolvePackageDependencies, } from "./plan.js";
-import { getBaselineStatePath, writeBaselineSha, } from "./state.js";
+import { hasFullyUntaggedPendingRelease, readPendingReleaseCohorts, readPendingReleaseTargets, writeBaselineSha, writePackageReleaseState, } from "./state.js";
 const SAFE_DIRTY_FILES = new Set([
     "pnpm-lock.yaml",
     "package-lock.json",
@@ -132,15 +134,21 @@ function fetchRemoteReleaseBranch(cwd, branch) {
     return remoteRef;
 }
 function buildReleaseTargets(cwd, plan, loadedConfig) {
+    const releasingPaths = new Set(plan.packages?.filter((pkg) => pkg.nextVersion).map((pkg) => pkg.path) ?? [
+        ".",
+    ]);
     const releaseTargets = plan.packages
         ? plan.packages
             .filter((pkg) => pkg.nextVersion)
             .map((pkg) => {
+            const dependencies = (pkg.dependencySourcePaths ?? []).filter((dependencyPath) => releasingPaths.has(dependencyPath));
+            const releaseDependencies = dependencies.length > 0 ? { dependencies } : {};
             if (pkg.path === ".") {
                 return {
                     path: pkg.path,
                     version: pkg.nextVersion ?? "",
                     tag: `v${pkg.nextVersion ?? ""}`,
+                    ...releaseDependencies,
                 };
             }
             const packageConfig = loadedConfig.packages?.[pkg.path] ?? {};
@@ -151,6 +159,7 @@ function buildReleaseTargets(cwd, plan, loadedConfig) {
                 path: pkg.path,
                 version: pkg.nextVersion ?? "",
                 tag: `${tagPrefix}-v${pkg.nextVersion ?? ""}`,
+                ...releaseDependencies,
             };
         })
         : [
@@ -196,6 +205,158 @@ function formatReleaseCommitTitle(releaseTargets) {
     }
     return `chore(release): ${tags[0]} (+${tags.length - 1} more)`;
 }
+function getCommitSubject(cwd, revision) {
+    return execFileSync("git", ["show", "-s", "--format=%s", revision], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+function getFirstParent(cwd, revision) {
+    return execFileSync("git", ["rev-parse", `${revision}^`], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+export function renderPendingReleaseReviewRequestBody(targets) {
+    const releases = targets
+        .map((target) => `- \`${target.tag}\` (${target.path})`)
+        .join("\n");
+    return `## Pending release recovery\n\nThis PR retries a release that did not reach the publish stage. Its empty release commit records the corrected CI-tested commit as the release target; it does not advance any versions.\n\n${releases}\n\n${renderReviewRequestFooter()}`;
+}
+/**
+ * Recreate the release marker on the corrected base without advancing an
+ * untagged version. The empty commit is intentional: the version and
+ * changelog changes were already reviewed in the original release PR.
+ */
+export function preparePendingReleasePr(cwd = process.cwd(), options = {}) {
+    const targets = readPendingReleaseTargets(cwd);
+    if (!hasFullyUntaggedPendingRelease(cwd)) {
+        throw new Error("No unpublished pending release found to recover.");
+    }
+    ensureCleanWorktree(cwd, options.logger);
+    const loaded = loadConfig(cwd);
+    const branch = loaded.config["release-branch"] ?? "versionary/release";
+    const title = formatReleaseCommitTitle(targets);
+    const releaseBaselineSha = execFileSync("git", ["rev-parse", "HEAD"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const hasRemoteReleaseBranch = remoteReleaseBranchExists(cwd, branch);
+    const remoteReleaseRef = hasRemoteReleaseBranch
+        ? fetchRemoteReleaseBranch(cwd, branch)
+        : null;
+    execFileSync("git", ["checkout", "-B", branch], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    ensureGitIdentity(cwd);
+    execFileSync("git", ["commit", "--allow-empty", "-m", title, "-m", VERSIONARY_RELEASE_TRAILER], { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    const updated = !remoteReleaseRef ||
+        getFirstParent(cwd, remoteReleaseRef) !== releaseBaselineSha ||
+        getCommitSubject(cwd, remoteReleaseRef) !== title;
+    return {
+        branch,
+        title,
+        updated,
+        targets,
+        body: renderPendingReleaseReviewRequestBody(targets),
+    };
+}
+/**
+ * Recreate each unpublished package cohort on its own corrected-base branch.
+ * A temporary worktree keeps the caller on the trunk commit that triggered
+ * recovery while still leaving local branch refs available for pushing.
+ */
+export function preparePendingSeparateReleasePrs(cwd = process.cwd(), options = {}) {
+    const loaded = loadConfig(cwd);
+    if (!loaded.config["separate-release-prs"]) {
+        throw new Error('preparePendingSeparateReleasePrs requires "separate-release-prs" to be enabled.');
+    }
+    const cohorts = readPendingReleaseCohorts(cwd);
+    if (cohorts.length === 0) {
+        throw new Error("No unpublished pending release found to recover.");
+    }
+    const candidates = cohorts.map((cohort) => {
+        const title = formatReleaseCommitTitle(cohort.targets);
+        return {
+            branch: cohort.branch,
+            title,
+            updated: true,
+            packagePaths: cohort.targets.map((target) => target.path),
+            targets: cohort.targets,
+            body: renderPendingReleaseReviewRequestBody(cohort.targets),
+        };
+    });
+    if (options["dry-run"]) {
+        return candidates;
+    }
+    ensureCleanWorktree(cwd, options.logger);
+    const baselineSha = execFileSync("git", ["rev-parse", "HEAD"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "versionary-recovery-worktree-"));
+    const worktree = path.join(temporaryRoot, "worktree");
+    execFileSync("git", ["worktree", "add", "--detach", worktree, baselineSha], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    try {
+        for (const candidate of candidates) {
+            resetTemporaryWorktree(worktree, baselineSha);
+            const remoteRef = remoteReleaseBranchExists(cwd, candidate.branch)
+                ? fetchRemoteReleaseBranch(cwd, candidate.branch)
+                : null;
+            execFileSync("git", ["checkout", "-B", candidate.branch, baselineSha], {
+                cwd: worktree,
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            ensureGitIdentity(worktree);
+            execFileSync("git", [
+                "commit",
+                "--allow-empty",
+                "-m",
+                candidate.title,
+                "-m",
+                VERSIONARY_RELEASE_TRAILER,
+            ], { cwd: worktree, stdio: ["ignore", "pipe", "ignore"] });
+            candidate.updated =
+                !remoteRef ||
+                    getFirstParent(worktree, remoteRef) !== baselineSha ||
+                    getCommitSubject(worktree, remoteRef) !== candidate.title;
+            resetTemporaryWorktree(worktree, baselineSha);
+        }
+        return candidates;
+    }
+    finally {
+        // Cleanup is best effort: a throwing `worktree remove` must neither replace
+        // the error we may be unwinding with nor skip the prune that drops the
+        // stale administrative entry.
+        try {
+            execFileSync("git", ["worktree", "remove", "--force", worktree], {
+                cwd,
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+        }
+        catch {
+            // Ignored; the prune below still clears the registration.
+        }
+        try {
+            execFileSync("git", ["worktree", "prune"], {
+                cwd,
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+        }
+        catch {
+            // Ignored.
+        }
+        fs.rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+}
 export function prepareReleasePr(cwd = process.cwd(), options = {}) {
     const plan = createReleasePlan(cwd);
     const loaded = loadConfig(cwd);
@@ -272,7 +433,7 @@ export function prepareReleasePr(cwd = process.cwd(), options = {}) {
         }
         const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
         const packageContext = resolvePackageStrategyContext(loaded.config, packagePlan.path, packageConfig);
-        const { changelogFile: packageChangelogFile } = getChangelogDefaults({
+        const { changelogFile: packageChangelogFile, changelogFormat: packageChangelogFormat, } = getChangelogDefaults({
             "release-type": packageConfig["release-type"] ?? loaded.config["release-type"],
             "changelog-file": packageConfig["changelog-file"] ?? loaded.config["changelog-file"],
             "changelog-format": packageConfig["changelog-format"] ?? loaded.config["changelog-format"],
@@ -283,17 +444,25 @@ export function prepareReleasePr(cwd = process.cwd(), options = {}) {
             continue;
         }
         const packageChangelogPath = path.posix.join(packagePlan.path, packageChangelogFile);
-        const packageHighlights = readChangelogHighlights(cwd, packageChangelogPath, "markdown-changelog");
-        const packageSection = renderReleaseNotesSection({
-            currentVersion: packagePlan.currentVersion,
-            nextVersion: packagePlan.nextVersion,
-            commits: packagePlan.commits,
-            tagPrefix: packageMetadata.tagPrefix,
-            cwd,
-            dependencies: resolvePackageDependencies(plan, packagePlan.path),
-            highlights: packageHighlights,
-        });
-        prependChangelog(cwd, packageChangelogPath, packageSection, "markdown-changelog");
+        const packageHighlights = readChangelogHighlights(cwd, packageChangelogPath, packageChangelogFormat);
+        const packageSection = packageChangelogFormat === "r-news"
+            ? renderRNewsReleaseNotes({
+                packageName: packageMetadata.releaseName,
+                nextVersion: packagePlan.nextVersion,
+                commits: packagePlan.commits,
+                cwd,
+                highlights: packageHighlights,
+            })
+            : renderReleaseNotesSection({
+                currentVersion: packagePlan.currentVersion,
+                nextVersion: packagePlan.nextVersion,
+                commits: packagePlan.commits,
+                tagPrefix: packageMetadata.tagPrefix,
+                cwd,
+                dependencies: resolvePackageDependencies(plan, packagePlan.path),
+                highlights: packageHighlights,
+            });
+        prependChangelog(cwd, packageChangelogPath, packageSection, packageChangelogFormat);
         updatedChangelogFiles.push(packageChangelogPath);
     }
     const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
@@ -323,8 +492,8 @@ export function prepareReleasePr(cwd = process.cwd(), options = {}) {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
-    writeBaselineSha(cwd, releaseBaselineSha, releaseTargets);
-    execFileSync("git", ["add", getBaselineStatePath(cwd)], {
+    const updatedStateFiles = writeBaselineSha(cwd, releaseBaselineSha, releaseTargets);
+    execFileSync("git", ["add", ...updatedStateFiles], {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
@@ -345,8 +514,280 @@ export function prepareReleasePr(cwd = process.cwd(), options = {}) {
         highlights,
     };
 }
+function scopeReleasePlan(plan, packagePaths) {
+    const selected = new Set(packagePaths);
+    const packages = (plan.packages ?? []).map((pkg) => selected.has(pkg.path)
+        ? pkg
+        : {
+            ...pkg,
+            releaseType: null,
+            nextVersion: null,
+            bumpReason: undefined,
+            dependencySourcePaths: undefined,
+        });
+    const releasing = packages.filter((pkg) => pkg.nextVersion);
+    const first = releasing[0];
+    return {
+        ...plan,
+        releaseType: first?.releaseType ?? null,
+        currentVersion: first?.currentVersion ?? plan.currentVersion,
+        nextVersion: first?.nextVersion ?? null,
+        commits: releasing.flatMap((pkg) => pkg.commits),
+        packages,
+    };
+}
+function materializeCandidateChanges(cwd, plan, options) {
+    const loaded = loadConfig(cwd);
+    const finalizeContext = {
+        releaseCommitSha: options.baselineSha,
+        releaseDate: resolveCommitDate(cwd, options.baselineSha),
+    };
+    const updatedVersionFiles = [];
+    const writesByStrategy = new Map();
+    for (const packagePlan of plan.packages ?? []) {
+        if (!packagePlan.nextVersion) {
+            continue;
+        }
+        const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+        const packageContext = resolvePackageStrategyContext(loaded.config, packagePlan.path, packageConfig);
+        updatedVersionFiles.push(...packageContext.strategy.writeVersion(cwd, packageContext.config, packagePlan.nextVersion));
+        const existing = writesByStrategy.get(packageContext.strategy.name);
+        const write = {
+            packagePath: packagePlan.path,
+            versionFile: packageContext.versionFile,
+            version: packagePlan.nextVersion,
+        };
+        if (existing) {
+            existing.writes.push(write);
+        }
+        else {
+            writesByStrategy.set(packageContext.strategy.name, {
+                strategy: packageContext.strategy,
+                writes: [write],
+            });
+        }
+    }
+    for (const strategyGroup of writesByStrategy.values()) {
+        updatedVersionFiles.push(...(strategyGroup.strategy.finalizeVersionWrites?.(cwd, strategyGroup.writes, finalizeContext) ?? []));
+    }
+    const updatedArtifactFiles = applyConfiguredArtifactRules(cwd, loaded.config, plan);
+    const packageReleaseMetadata = buildPackageReleaseMetadata(cwd, plan, loaded.config);
+    const rootIsReleasing = Boolean(plan.packages?.find((pkg) => pkg.path === ".")?.nextVersion);
+    const highlights = rootIsReleasing
+        ? resolveReleaseHighlights(cwd, plan.changelogFile, plan.changelogFormat)
+            .highlights
+        : "";
+    const updatedChangelogFiles = [];
+    const rootSection = rootIsReleasing
+        ? renderReleasePlanChangelog(plan, { highlights, cwd })
+        : "";
+    if (rootSection.length > 0) {
+        prependChangelog(cwd, plan.changelogFile, rootSection, plan.changelogFormat);
+        updatedChangelogFiles.push(plan.changelogFile);
+    }
+    for (const packagePlan of plan.packages ?? []) {
+        if (!packagePlan.nextVersion || packagePlan.path === ".") {
+            continue;
+        }
+        const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+        const packageContext = resolvePackageStrategyContext(loaded.config, packagePlan.path, packageConfig);
+        const { changelogFile: packageChangelogFile, changelogFormat: packageChangelogFormat, } = getChangelogDefaults({
+            "release-type": packageConfig["release-type"] ?? loaded.config["release-type"],
+            "changelog-file": packageConfig["changelog-file"] ?? loaded.config["changelog-file"],
+            "changelog-format": packageConfig["changelog-format"] ?? loaded.config["changelog-format"],
+            defaultChangelogFormat: packageContext.strategy.getDefaultChangelogFormat?.(),
+        });
+        const metadata = packageReleaseMetadata[packagePlan.path];
+        if (!metadata) {
+            continue;
+        }
+        const packageChangelogPath = path.posix.join(packagePlan.path, packageChangelogFile);
+        const packageHighlights = readChangelogHighlights(cwd, packageChangelogPath, packageChangelogFormat);
+        const section = packageChangelogFormat === "r-news"
+            ? renderRNewsReleaseNotes({
+                packageName: metadata.releaseName,
+                nextVersion: packagePlan.nextVersion,
+                commits: packagePlan.commits,
+                cwd,
+                highlights: packageHighlights,
+            })
+            : renderReleaseNotesSection({
+                currentVersion: packagePlan.currentVersion,
+                nextVersion: packagePlan.nextVersion,
+                commits: packagePlan.commits,
+                tagPrefix: metadata.tagPrefix,
+                cwd,
+                dependencies: resolvePackageDependencies(plan, packagePlan.path),
+                highlights: packageHighlights,
+            });
+        prependChangelog(cwd, packageChangelogPath, section, packageChangelogFormat);
+        updatedChangelogFiles.push(packageChangelogPath);
+    }
+    const targets = buildReleaseTargets(cwd, plan, loaded.config);
+    const stateFiles = options.writePackageState && options.branch
+        ? writePackageReleaseState(cwd, options.baselineSha, targets, options.branch)
+        : [];
+    return {
+        files: [
+            ...new Set([
+                ...updatedVersionFiles,
+                ...updatedArtifactFiles,
+                ...updatedChangelogFiles,
+                ...stateFiles,
+            ]),
+        ].sort((a, b) => a.localeCompare(b)),
+        highlights,
+        targets,
+    };
+}
+function packageReleaseName(cwd, plan, packagePath, config) {
+    if (packagePath === ".") {
+        return plan.packageName;
+    }
+    const packageConfig = config.packages?.[packagePath] ?? {};
+    const packageContext = resolvePackageStrategyContext(config, packagePath, packageConfig);
+    return resolveReleaseName(cwd, packagePath, packageConfig, packageContext.strategy, packageContext.config);
+}
+function resetTemporaryWorktree(cwd, baselineSha) {
+    execFileSync("git", ["checkout", "--detach", baselineSha], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    execFileSync("git", ["reset", "--hard", baselineSha], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    execFileSync("git", ["clean", "-fdx"], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+}
+/**
+ * Build every independently mergeable release branch from the same immutable
+ * base without moving or modifying the caller's worktree.
+ */
+export function prepareSeparateReleasePrs(cwd = process.cwd(), options = {}) {
+    const plan = createReleasePlan(cwd);
+    const loaded = loadConfig(cwd);
+    if (!loaded.config["separate-release-prs"]) {
+        throw new Error('prepareSeparateReleasePrs requires "separate-release-prs" to be enabled.');
+    }
+    const initialCohorts = buildInitialReleaseCohorts(plan);
+    if (initialCohorts.length === 0) {
+        return [];
+    }
+    buildReleaseTargets(cwd, plan, loaded.config);
+    ensureCleanWorktree(cwd, options.logger);
+    const baselineSha = execFileSync("git", ["rev-parse", "HEAD"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "versionary-release-worktree-"));
+    const worktree = path.join(temporaryRoot, "worktree");
+    execFileSync("git", ["worktree", "add", "--detach", worktree, baselineSha], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    try {
+        const cohorts = stabilizeReleaseCohorts(initialCohorts, (packagePaths) => {
+            resetTemporaryWorktree(worktree, baselineSha);
+            return materializeCandidateChanges(worktree, scopeReleasePlan(plan, packagePaths), { baselineSha }).files;
+        });
+        const prepared = [];
+        for (const packagePaths of cohorts) {
+            resetTemporaryWorktree(worktree, baselineSha);
+            const leader = packagePaths[0];
+            if (!leader) {
+                continue;
+            }
+            const branch = resolveSeparateReleaseBranch(plan.releaseBranchPrefix, packageReleaseName(worktree, plan, leader, loaded.config), leader);
+            const remoteRef = !options["dry-run"] && remoteReleaseBranchExists(cwd, branch)
+                ? fetchRemoteReleaseBranch(cwd, branch)
+                : null;
+            if (!options["dry-run"]) {
+                execFileSync("git", ["checkout", "-B", branch, baselineSha], {
+                    cwd: worktree,
+                    stdio: ["ignore", "pipe", "ignore"],
+                });
+            }
+            const scopedPlan = scopeReleasePlan(plan, packagePaths);
+            const materialized = materializeCandidateChanges(worktree, scopedPlan, {
+                baselineSha,
+                branch,
+                writePackageState: true,
+            });
+            const title = formatReleaseCommitTitle(materialized.targets);
+            if (!options["dry-run"]) {
+                execFileSync("git", ["add", ...materialized.files], {
+                    cwd: worktree,
+                    stdio: ["ignore", "pipe", "ignore"],
+                });
+                ensureGitIdentity(worktree);
+                execFileSync("git", ["commit", "-m", title, "-m", VERSIONARY_RELEASE_TRAILER], {
+                    cwd: worktree,
+                    stdio: ["ignore", "pipe", "ignore"],
+                });
+            }
+            const updated = options["dry-run"] ||
+                !remoteRef ||
+                getCommitTreeSha(worktree, "HEAD") !==
+                    getCommitTreeSha(worktree, remoteRef);
+            const firstPackage = scopedPlan.packages?.find((pkg) => pkg.nextVersion);
+            const commits = [
+                ...new Map((scopedPlan.packages ?? [])
+                    .filter((pkg) => pkg.nextVersion)
+                    .flatMap((pkg) => pkg.commits)
+                    .map((commit) => [commit.hash, commit])).values(),
+            ];
+            const version = materialized.targets[0]?.version ?? "";
+            const body = renderSimpleReviewRequestBody(version, firstPackage?.currentVersion ?? version, commits, scopedPlan, worktree, materialized.highlights, loaded.config);
+            prepared.push({
+                branch,
+                title,
+                version,
+                previousVersion: firstPackage?.currentVersion ?? version,
+                commits,
+                plan: scopedPlan,
+                updated,
+                highlights: materialized.highlights,
+                packagePaths,
+                targets: materialized.targets,
+                body,
+            });
+            resetTemporaryWorktree(worktree, baselineSha);
+        }
+        return prepared;
+    }
+    finally {
+        // Cleanup is best effort: a throwing `worktree remove` must neither replace
+        // the error we may be unwinding with nor skip the prune that drops the
+        // stale administrative entry.
+        try {
+            execFileSync("git", ["worktree", "remove", "--force", worktree], {
+                cwd,
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+        }
+        catch {
+            // Ignored; the prune below still clears the registration.
+        }
+        try {
+            execFileSync("git", ["worktree", "prune"], {
+                cwd,
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+        }
+        catch {
+            // Ignored.
+        }
+        fs.rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+}
 export function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd(), highlights = "", loadedConfig) {
-    const rootPackageLabel = path.basename(cwd);
+    // `cwd` can be a temporary worktree, whose basename would leak into the PR
+    // body; the plan carries the repository-derived name.
+    const rootPackageLabel = plan?.packageName ?? path.basename(cwd);
     const formatPackageLabel = (packagePath) => packagePath === "." ? rootPackageLabel : packagePath;
     const resolveTagPrefix = (packagePath) => {
         if (packagePath === ".") {
@@ -417,7 +858,8 @@ export async function openOrUpdateReviewRequest(cwd, branch, title, version, pre
         baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
         headBranch: branch,
         title,
-        body: renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd, options.highlights ?? "", loaded.config),
+        body: options.body ??
+            renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd, options.highlights ?? "", loaded.config),
         labels: ["release"],
     }, {
         cwd,
@@ -425,6 +867,70 @@ export async function openOrUpdateReviewRequest(cwd, branch, title, version, pre
     });
     return result.url;
 }
+export async function reconcileSeparateReviewRequests(cwd, prepared, options = {}) {
+    if (options["dry-run"]) {
+        return prepared.map((candidate) => ({
+            packagePaths: candidate.packagePaths,
+            branch: candidate.branch,
+            title: candidate.title,
+            status: "dry-run",
+            targets: candidate.targets,
+        }));
+    }
+    const loaded = loadConfig(cwd);
+    const baseBranch = process.env.VERSIONARY_BASE_BRANCH ?? "main";
+    const branchPrefix = resolveSeparateReleaseBranchPrefix(loaded.config["release-branch"] ?? "versionary/release");
+    const scmClient = getScmClient();
+    const existing = await scmClient.listOpenReviewRequests({
+        baseBranch,
+        headBranchPrefix: branchPrefix,
+        labels: ["release"],
+    }, { cwd, logger: options.logger });
+    const activeBranches = new Set(prepared.map((candidate) => candidate.branch));
+    const results = [];
+    for (const candidate of prepared) {
+        const existingRequest = existing.find((request) => request.headBranch === candidate.branch);
+        let reviewUrl = existingRequest?.url;
+        if (candidate.updated) {
+            pushReleaseBranch(cwd, candidate.branch);
+        }
+        if (candidate.updated || !existingRequest) {
+            const result = await scmClient.createOrUpdateReviewRequest({
+                baseBranch,
+                headBranch: candidate.branch,
+                title: candidate.title,
+                body: candidate.body,
+                labels: ["release"],
+            }, { cwd, logger: options.logger });
+            reviewUrl = result.url;
+        }
+        results.push({
+            packagePaths: candidate.packagePaths,
+            branch: candidate.branch,
+            title: candidate.title,
+            reviewUrl,
+            status: candidate.updated || !existingRequest
+                ? options.recovered
+                    ? "recovered"
+                    : "prepared"
+                : "up-to-date",
+            targets: candidate.targets,
+        });
+    }
+    if (!options.recovered) {
+        for (const stale of existing) {
+            if (activeBranches.has(stale.headBranch)) {
+                continue;
+            }
+            await scmClient.closeReviewRequestIfExists({
+                baseBranch,
+                headBranch: stale.headBranch,
+                reason: "Closing stale release PR because its package cohort is no longer releasable for the current baseline/tag state.",
+            }, { cwd, logger: options.logger });
+        }
+    }
+    return results.sort((a, b) => a.branch.localeCompare(b.branch));
+}
 function hasScmRuntimeContext() {
     const hasRepository = Boolean(process.env.GITHUB_REPOSITORY);
     const hasToken = Boolean(process.env.VERSIONARY_PR_TOKEN ??
@@ -436,18 +942,45 @@ export async function closeStaleReviewRequestIfExists(cwd = process.cwd(), optio
     if (!hasScmRuntimeContext()) {
         return { closed: false };
     }
-    const plan = createReleasePlan(cwd);
+    const loaded = loadConfig(cwd);
     const scmClient = getScmClient();
+    const baseBranch = process.env.VERSIONARY_BASE_BRANCH ?? "main";
+    const releaseBranch = loaded.config["release-branch"] ?? "versionary/release";
+    if (loaded.config["separate-release-prs"]) {
+        const branchPrefix = resolveSeparateReleaseBranchPrefix(releaseBranch);
+        const openRequests = await scmClient.listOpenReviewRequests({
+            baseBranch,
+            headBranchPrefix: branchPrefix,
+            labels: ["release"],
+        }, { cwd, logger: options.logger });
+        let firstClosed = {
+            closed: false,
+        };
+        for (const request of openRequests) {
+            const result = await scmClient.closeReviewRequestIfExists({
+                baseBranch,
+                headBranch: request.headBranch,
+                reason: "Closing stale release PR because no releasable commits remain for the current baseline/tag state.",
+            }, { cwd, logger: options.logger });
+            if (result.closed && !firstClosed.closed) {
+                firstClosed = result;
+            }
+            if (result.closed && result.number) {
+                options.logger?.info(`Closed stale release review request #${result.number} for ${request.headBranch}.`);
+            }
+        }
+        return firstClosed;
+    }
     const result = await scmClient.closeReviewRequestIfExists({
-        baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
-        headBranch: plan.releaseBranchPrefix,
+        baseBranch,
+        headBranch: releaseBranch,
         reason: "Closing stale release PR because no releasable commits remain for the current baseline/tag state.",
     }, {
         cwd,
         logger: options.logger,
     });
     if (result.closed && result.number) {
-        options.logger?.info(`Closed stale release review request #${result.number} for ${plan.releaseBranchPrefix}.`);
+        options.logger?.info(`Closed stale release review request #${result.number} for ${releaseBranch}.`);
     }
     return result;
 }