agentplane 0.3.1 → 0.3.3

package/dist/commands/release/apply.command.js

@@ -1,289 +1,168 @@
-import { readFile, writeFile, readdir, mkdir } from "node:fs/promises";
 import path from "node:path";
-import { resolveProject, loadConfig } from "@agentplaneorg/core";
-import { usageError } from "../../cli/spec/errors.js";
+import { loadConfig, resolveProject } from "@agentplaneorg/core";
 import { exitCodeForError } from "../../cli/exit-codes.js";
+import { usageError } from "../../cli/spec/errors.js";
+import { withDiagnosticContext } from "../../shared/diagnostics.js";
 import { CliError } from "../../shared/errors.js";
 import { execFileAsync, gitEnv } from "../shared/git.js";
 import { GitContext } from "../shared/git-context.js";
 import { ensureNetworkApproved } from "../shared/network-approval.js";
-async function fileExists(p) {
-    try {
-        await readFile(p, "utf8");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readJsonFile(p) {
-    return JSON.parse(await readFile(p, "utf8"));
-}
-function assertNonEmptyString(value, label) {
-    if (typeof value !== "string" || !value.trim()) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Invalid ${label} (expected non-empty string).`,
-        });
-    }
-    return value.trim();
-}
-function parseVersionPlan(raw) {
-    if (!raw || typeof raw !== "object") {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: "Invalid version.json (expected object).",
-        });
-    }
-    const obj = raw;
-    const bumpRaw = assertNonEmptyString(obj.bump, "bump");
-    if (bumpRaw !== "patch" && bumpRaw !== "minor" && bumpRaw !== "major") {
+import { cleanHookEnv, maybePersistExpectedCliVersion, maybeRefreshGeneratedReference, maybeUpdateBunLockfile, replaceAgentplanePackageMetadata, replacePackageVersionInFile, } from "./apply.mutation.js";
+import { ensureCleanTrackedTree, ensureNpmVersionsAvailable, ensureRemoteExists, ensureRemoteTagDoesNotExist, ensureTagDoesNotExist, fileExists, loadReleasePlan, readCoreDependencyVersion, readPackageVersion, runReleasePrepublishGate, validateReleaseNotes, } from "./apply.preflight.js";
+import { pushReleaseRefs, writeReleaseApplyReport } from "./apply.reporting.js";
+async function resolveReleasePlanInputs(opts) {
+    const { planDir, plan, minBullets } = await loadReleasePlan({
+        gitRoot: opts.gitRoot,
+        planOverride: opts.planOverride,
+    });
+    if (!/^v\d+\.\d+\.\d+$/u.test(plan.nextTag)) {
         throw new CliError({
             exitCode: exitCodeForError("E_VALIDATION"),
             code: "E_VALIDATION",
-            message: `Invalid bump in version.json: ${bumpRaw}`,
+            message: `Invalid nextTag in version.json (expected vX.Y.Z): ${plan.nextTag}`,
         });
     }
-    const prevTagVal = obj.prevTag;
-    const prevTag = prevTagVal === null ? null : typeof prevTagVal === "string" ? prevTagVal : null;
-    const prevVersion = assertNonEmptyString(obj.prevVersion, "prevVersion");
-    const nextTag = assertNonEmptyString(obj.nextTag, "nextTag");
-    const nextVersion = assertNonEmptyString(obj.nextVersion, "nextVersion");
-    return { prevTag, prevVersion, nextTag, nextVersion, bump: bumpRaw };
-}
-async function findLatestPlanDir(gitRoot) {
-    const base = path.join(gitRoot, ".agentplane", ".release", "plan");
-    const runNames = await readdir(base);
-    const runs = runNames
-        .map((s) => s.trim())
-        .filter(Boolean)
-        .toSorted();
-    const latest = runs.at(-1);
-    if (!latest) {
+    const notesPath = path.join(opts.gitRoot, "docs", "releases", `${plan.nextTag}.md`);
+    if (!(await fileExists(notesPath))) {
         throw new CliError({
             exitCode: exitCodeForError("E_IO"),
             code: "E_IO",
-            message: "No release plan runs found under .agentplane/.release/plan/. Run `agentplane release plan` first.",
-        });
-    }
-    return path.join(base, latest);
-}
-async function readPackageVersion(pkgJsonPath) {
-    const raw = JSON.parse(await readFile(pkgJsonPath, "utf8"));
-    const version = typeof raw.version === "string" ? raw.version.trim() : "";
-    if (!version) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Missing package.json version: ${pkgJsonPath}`,
-        });
-    }
-    return version;
-}
-async function readCoreDependencyVersion(pkgJsonPath) {
-    const raw = JSON.parse(await readFile(pkgJsonPath, "utf8"));
-    const value = raw.dependencies?.["@agentplaneorg/core"];
-    const version = typeof value === "string" ? value.trim() : "";
-    if (!version) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Missing dependency @agentplaneorg/core in ${pkgJsonPath}. ` +
-                "Release parity requires packages/agentplane to pin @agentplaneorg/core to the same version.",
+            message: `Missing release notes: ${path.relative(opts.gitRoot, notesPath)}\n` +
+                "Write this file using a DOCS agent before applying the release.",
         });
     }
-    return version;
+    await validateReleaseNotes(notesPath, minBullets);
+    return { planDir, plan, notesPath, minBullets };
 }
-async function replacePackageVersionInFile(pkgJsonPath, nextVersion) {
-    const text = await readFile(pkgJsonPath, "utf8");
-    const replaced = text.replace(/"version"\s*:\s*"[^"]*"/u, `"version": "${nextVersion}"`);
-    if (replaced === text) {
+async function ensureReleasePlanMatchesRepoState(opts) {
+    const [coreVersion, agentplaneVersion, coreDependencyVersion] = await Promise.all([
+        readPackageVersion(opts.corePkgPath),
+        readPackageVersion(opts.agentplanePkgPath),
+        readCoreDependencyVersion(opts.agentplanePkgPath),
+    ]);
+    if (coreVersion !== agentplaneVersion) {
         throw new CliError({
             exitCode: exitCodeForError("E_VALIDATION"),
             code: "E_VALIDATION",
-            message: `Failed to update version in ${pkgJsonPath} (missing "version" field).`,
+            message: `Package versions must match before applying a release. ` +
+                `packages/core=${coreVersion} packages/agentplane=${agentplaneVersion}`,
         });
     }
-    await writeFile(pkgJsonPath, replaced, "utf8");
-}
-async function replaceAgentplanePackageMetadata(pkgJsonPath, nextVersion) {
-    const text = await readFile(pkgJsonPath, "utf8");
-    const withVersion = text.replace(/"version"\s*:\s*"[^"]*"/u, `"version": "${nextVersion}"`);
-    if (withVersion === text) {
+    if (coreDependencyVersion !== coreVersion) {
         throw new CliError({
             exitCode: exitCodeForError("E_VALIDATION"),
             code: "E_VALIDATION",
-            message: `Failed to update version in ${pkgJsonPath} (missing "version" field).`,
+            message: "Release dependency parity check failed before apply. " +
+                `packages/agentplane dependency @agentplaneorg/core=${coreDependencyVersion} ` +
+                `must match packages/core version ${coreVersion}.`,
         });
     }
-    const withDependency = withVersion.replace(/("@agentplaneorg\/core"\s*:\s*")[^"]*(")/u, `$1${nextVersion}$2`);
-    if (withDependency === withVersion) {
+    await ensureCleanTrackedTree(opts.gitRoot);
+    await ensureTagDoesNotExist(opts.gitRoot, opts.plan.nextTag);
+    if (coreVersion !== opts.plan.prevVersion) {
         throw new CliError({
             exitCode: exitCodeForError("E_VALIDATION"),
             code: "E_VALIDATION",
-            message: `Failed to update @agentplaneorg/core dependency in ${pkgJsonPath}. ` +
-                "Ensure packages/agentplane/package.json declares this dependency.",
+            message: `Current version does not match the release-plan baseline. ` +
+                `current=${coreVersion} expected_prev=${opts.plan.prevVersion} expected_next=${opts.plan.nextVersion}\n` +
+                "Re-run `agentplane release plan` to generate a fresh plan for this repo state.",
+            context: withDiagnosticContext({ command: "release apply" }, {
+                state: "the repository version no longer matches the prepared release-plan baseline",
+                likelyCause: "package versions changed after the plan was generated, so continuing would apply the release over a partially drifted local state",
+                nextAction: {
+                    command: "agentplane release plan",
+                    reason: "generate a fresh release plan from the current repository state before applying the release",
+                    reasonCode: "release_plan_drifted",
+                },
+            }),
         });
     }
-    await writeFile(pkgJsonPath, withDependency, "utf8");
 }
-function cleanHookEnv() {
-    const env = { ...gitEnv() };
-    delete env.AGENTPLANE_TASK_ID;
-    delete env.AGENTPLANE_STATUS_TO;
-    delete env.AGENTPLANE_AGENT_ID;
-    return env;
+async function runPushPreflight(opts) {
+    const loaded = await loadConfig(opts.agentplaneDir);
+    await ensureNetworkApproved({
+        config: loaded.config,
+        yes: opts.yes,
+        reason: "release apply --push validates npm version availability and pushes over network",
+        interactive: Boolean(process.stdin.isTTY),
+    });
+    await ensureRemoteExists(opts.gitRoot, opts.remote);
+    await ensureRemoteTagDoesNotExist(opts.gitRoot, opts.remote, opts.nextTag);
+    await ensureNpmVersionsAvailable(opts.gitRoot, opts.nextVersion);
+    await runReleasePrepublishGate(opts.gitRoot);
+    return true;
 }
-async function validateReleaseNotes(notesPath, minBullets) {
-    const content = await readFile(notesPath, "utf8");
-    if (!/release\s+notes/i.test(content)) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Release notes must include a "Release Notes" heading in ${notesPath}.`,
-        });
-    }
-    const bulletCount = content.split(/\r?\n/u).filter((line) => /^\s*[-*]\s+\S+/u.test(line)).length;
-    if (bulletCount < minBullets) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Release notes must include at least ${minBullets} bullet points in ${notesPath}.`,
-        });
+async function applyReleaseMutation(opts) {
+    let releaseCommit = null;
+    await Promise.all([
+        replacePackageVersionInFile(opts.corePkgPath, opts.nextVersion),
+        replaceAgentplanePackageMetadata(opts.agentplanePkgPath, opts.nextVersion),
+    ]);
+    const expectedCliVersionPersisted = await maybePersistExpectedCliVersion(opts.agentplaneDir, opts.nextVersion);
+    await maybeUpdateBunLockfile(opts.gitRoot, fileExists);
+    const generatedReferenceExists = await maybeRefreshGeneratedReference(opts.gitRoot, fileExists);
+    const stagePaths = [
+        "packages/core/package.json",
+        "packages/agentplane/package.json",
+        path.relative(opts.gitRoot, opts.notesPath),
+    ];
+    if (expectedCliVersionPersisted) {
+        stagePaths.push(".agentplane/config.json");
     }
-    if (/[\u0400-\u04FF]/u.test(content)) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Release notes must be written in English (no Cyrillic) in ${notesPath}.`,
-        });
+    if (generatedReferenceExists) {
+        stagePaths.push("docs/reference/generated-reference.mdx");
     }
-}
-async function maybeUpdateBunLockfile(gitRoot) {
-    // GitHub publish uses `bun install --frozen-lockfile`, which will fail if the lockfile
-    // needs regeneration after bumping workspace package versions.
-    const bunLockPath = path.join(gitRoot, "bun.lock");
-    const rootPkgPath = path.join(gitRoot, "package.json");
-    if (!(await fileExists(bunLockPath)))
-        return;
-    if (!(await fileExists(rootPkgPath)))
-        return;
-    try {
-        await execFileAsync("bun", ["install", "--ignore-scripts"], {
-            cwd: gitRoot,
-            env: process.env,
-            maxBuffer: 50 * 1024 * 1024,
-        });
+    if (await fileExists(path.join(opts.gitRoot, "bun.lock"))) {
+        stagePaths.push("bun.lock");
     }
-    catch (err) {
-        const e = err;
-        throw new CliError({
-            exitCode: exitCodeForError("E_IO"),
-            code: "E_IO",
-            message: "Failed to update bun.lock via `bun install --ignore-scripts`.\n" +
-                "Fix:\n" +
-                "  1) Run `bun install --ignore-scripts` manually\n" +
-                "  2) Re-run `agentplane release apply`\n" +
-                (e?.message ? `\nDetails:\n${e.message}` : ""),
-        });
+    await opts.git.stage(stagePaths);
+    const staged = await opts.git.statusStagedPaths();
+    if (staged.length === 0) {
+        process.stdout.write("No changes to commit.\n");
+        return { releaseCommit };
     }
-}
-async function ensureCleanTrackedTree(gitRoot) {
-    const { stdout } = await execFileAsync("git", ["status", "--short", "--untracked-files=no"], {
-        cwd: gitRoot,
+    const subject = `✨ release: ${opts.nextTag}`;
+    await opts.git.commit({ message: subject, env: cleanHookEnv() });
+    const { stdout: headHash } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+        cwd: opts.gitRoot,
         env: gitEnv(),
-        maxBuffer: 10 * 1024 * 1024,
-    });
-    const dirty = String(stdout ?? "")
-        .split(/\r?\n/u)
-        .map((line) => line.trimEnd())
-        .filter((line) => line.length > 0);
-    if (dirty.length === 0)
-        return;
-    throw new CliError({
-        exitCode: exitCodeForError("E_GIT"),
-        code: "E_GIT",
-        message: "Release apply requires a clean tracked working tree.\n" +
-            `Found tracked changes:\n${dirty.map((line) => `  ${line}`).join("\n")}`,
     });
+    releaseCommit = { hash: String(headHash ?? "").trim(), subject };
+    return { releaseCommit };
 }
-async function ensureTagDoesNotExist(gitRoot, tag) {
-    try {
-        await execFileAsync("git", ["rev-parse", "-q", "--verify", `refs/tags/${tag}`], {
-            cwd: gitRoot,
-            env: gitEnv(),
-        });
-        throw new CliError({
-            exitCode: exitCodeForError("E_GIT"),
-            code: "E_GIT",
-            message: `Tag already exists: ${tag}`,
-        });
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code !== 1)
-            throw err;
-    }
-}
-async function ensureNpmVersionsAvailable(gitRoot, version) {
-    const scriptPath = path.join(gitRoot, "scripts", "check-npm-version-availability.mjs");
-    try {
-        await execFileAsync("node", [scriptPath, "--version", version], {
-            cwd: gitRoot,
-            env: process.env,
-            maxBuffer: 10 * 1024 * 1024,
-        });
-    }
-    catch (err) {
-        const details = String(err?.stderr ?? "").trim();
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Pre-publish npm check failed for version ${version}. ` +
-                "Ensure this version is not already published for @agentplaneorg/core and agentplane." +
-                (details ? `\n\n${details}` : ""),
-        });
-    }
-}
-async function runReleasePrepublishGate(gitRoot) {
-    try {
-        await execFileAsync("bun", ["run", "release:prepublish"], {
-            cwd: gitRoot,
-            env: {
-                ...process.env,
-                GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME ?? "agentplane-release",
-                GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL ?? "agentplane-release@example.com",
-                GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME ?? "agentplane-release",
-                GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL ?? "agentplane-release@example.com",
-            },
-            maxBuffer: 200 * 1024 * 1024,
-        });
+async function finalizeReleaseApply(opts) {
+    await execFileAsync("git", ["tag", opts.plan.nextTag], {
+        cwd: opts.gitRoot,
+        env: gitEnv(),
+    });
+    process.stdout.write(`Release tag created: ${opts.plan.nextTag}\n`);
+    if (opts.push) {
+        await pushReleaseRefs(opts.gitRoot, opts.remote, opts.plan.nextTag);
+        process.stdout.write(`Pushed: ${opts.remote} HEAD + ${opts.plan.nextTag}\n`);
     }
-    catch (err) {
-        const details = String(err?.stderr ??
-            err?.stdout ??
-            err?.message ??
-            "").trim();
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: "Release prepublish gate failed. `agentplane release apply --push` requires a successful local `bun run release:prepublish` run before pushing the release tag." +
-                (details ? `\n\n${details}` : ""),
-        });
+    else {
+        process.stdout.write(`Next: git push <remote> HEAD && git push <remote> ${opts.plan.nextTag}\n`);
     }
-}
-async function writeReleaseApplyReport(gitRoot, report) {
-    const runId = new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-");
-    const dir = path.join(gitRoot, ".agentplane", ".release", "apply");
-    await mkdir(dir, { recursive: true });
-    const reportPath = path.join(dir, `${runId}.json`);
-    const latestPath = path.join(dir, "latest.json");
-    const text = `${JSON.stringify(report, null, 2)}\n`;
-    await writeFile(reportPath, text, "utf8");
-    await writeFile(latestPath, text, "utf8");
-    return reportPath;
+    const reportPath = await writeReleaseApplyReport(opts.gitRoot, {
+        applied_at: new Date().toISOString(),
+        plan_dir: path.relative(opts.gitRoot, opts.planDir),
+        notes_path: path.relative(opts.gitRoot, opts.notesPath),
+        prev_version: opts.plan.prevVersion,
+        next_version: opts.plan.nextVersion,
+        prev_tag: opts.plan.prevTag,
+        next_tag: opts.plan.nextTag,
+        bump: opts.plan.bump,
+        checks: {
+            clean_tracked_tree: true,
+            tag_absent: true,
+            notes_validated: true,
+            npm_version_available_checked: opts.npmVersionChecked,
+        },
+        commit: opts.releaseCommit,
+        push: { requested: opts.push, remote: opts.remote, performed: opts.push },
+    });
+    process.stdout.write(`Release report: ${path.relative(opts.gitRoot, reportPath)}\n`);
+    return 0;
 }
 export const releaseApplySpec = {
     id: ["release", "apply"],
@@ -373,21 +252,10 @@ export const runReleaseApply = async (ctx, flags) => {
     }
     const resolved = await resolveProject({ cwd: ctx.cwd, rootOverride: ctx.rootOverride ?? null });
     const gitRoot = resolved.gitRoot;
-    const planDir = flags.plan ? path.resolve(gitRoot, flags.plan) : await findLatestPlanDir(gitRoot);
-    const versionJsonPath = path.join(planDir, "version.json");
-    if (!(await fileExists(versionJsonPath))) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_IO"),
-            code: "E_IO",
-            message: `Missing version.json in plan dir: ${path.relative(gitRoot, versionJsonPath)}`,
-        });
-    }
-    const plan = parseVersionPlan(await readJsonFile(versionJsonPath));
-    const changesJsonPath = path.join(planDir, "changes.json");
-    const changes = (await fileExists(changesJsonPath))
-        ? await readJsonFile(changesJsonPath)
-        : [];
-    const minBullets = Math.max(1, Array.isArray(changes) ? changes.length : 0);
+    const { planDir, plan, notesPath } = await resolveReleasePlanInputs({
+        gitRoot,
+        planOverride: flags.plan,
+    });
     if ((plan.bump === "minor" || plan.bump === "major") && flags.yes !== true) {
         throw usageError({
             spec: releaseApplySpec,
@@ -395,136 +263,45 @@ export const runReleaseApply = async (ctx, flags) => {
             message: `Bump '${plan.bump}' requires explicit approval. Re-run with --yes.`,
         });
     }
-    if (!/^v\d+\.\d+\.\d+$/u.test(plan.nextTag)) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Invalid nextTag in version.json (expected vX.Y.Z): ${plan.nextTag}`,
-        });
-    }
-    const notesPath = path.join(gitRoot, "docs", "releases", `${plan.nextTag}.md`);
-    if (!(await fileExists(notesPath))) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_IO"),
-            code: "E_IO",
-            message: `Missing release notes: ${path.relative(gitRoot, notesPath)}\n` +
-                "Write this file using a DOCS agent before applying the release.",
-        });
-    }
-    await validateReleaseNotes(notesPath, minBullets);
     const corePkgPath = path.join(gitRoot, "packages", "core", "package.json");
     const agentplanePkgPath = path.join(gitRoot, "packages", "agentplane", "package.json");
-    const [coreVersion, agentplaneVersion, coreDependencyVersion] = await Promise.all([
-        readPackageVersion(corePkgPath),
-        readPackageVersion(agentplanePkgPath),
-        readCoreDependencyVersion(agentplanePkgPath),
-    ]);
-    if (coreVersion !== agentplaneVersion) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Package versions must match before applying a release. ` +
-                `packages/core=${coreVersion} packages/agentplane=${agentplaneVersion}`,
-        });
-    }
-    if (coreDependencyVersion !== coreVersion) {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: "Release dependency parity check failed before apply. " +
-                `packages/agentplane dependency @agentplaneorg/core=${coreDependencyVersion} ` +
-                `must match packages/core version ${coreVersion}.`,
-        });
-    }
-    const git = new GitContext({ gitRoot });
-    await ensureCleanTrackedTree(gitRoot);
-    await ensureTagDoesNotExist(gitRoot, plan.nextTag);
+    await ensureReleasePlanMatchesRepoState({
+        gitRoot,
+        plan,
+        corePkgPath,
+        agentplanePkgPath,
+    });
     let npmVersionChecked = false;
     if (flags.push) {
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        await ensureNetworkApproved({
-            config: loaded.config,
+        npmVersionChecked = await runPushPreflight({
+            agentplaneDir: resolved.agentplaneDir,
+            gitRoot,
+            remote: flags.remote,
+            nextTag: plan.nextTag,
+            nextVersion: plan.nextVersion,
             yes: flags.yes,
-            reason: "release apply --push validates npm version availability and pushes over network",
-            interactive: Boolean(process.stdin.isTTY),
-        });
-        await runReleasePrepublishGate(gitRoot);
-        await ensureNpmVersionsAvailable(gitRoot, plan.nextVersion);
-        npmVersionChecked = true;
-    }
-    let releaseCommit = null;
-    if (coreVersion === plan.prevVersion) {
-        await Promise.all([
-            replacePackageVersionInFile(corePkgPath, plan.nextVersion),
-            replaceAgentplanePackageMetadata(agentplanePkgPath, plan.nextVersion),
-        ]);
-    }
-    else if (coreVersion === plan.nextVersion) {
-        await replaceAgentplanePackageMetadata(agentplanePkgPath, plan.nextVersion);
-    }
-    else {
-        throw new CliError({
-            exitCode: exitCodeForError("E_VALIDATION"),
-            code: "E_VALIDATION",
-            message: `Current version does not match plan. ` +
-                `current=${coreVersion} expected_prev=${plan.prevVersion} expected_next=${plan.nextVersion}\n` +
-                "Re-run `agentplane release plan` to generate a fresh plan for this repo state.",
-        });
-    }
-    await maybeUpdateBunLockfile(gitRoot);
-    const stagePaths = [
-        "packages/core/package.json",
-        "packages/agentplane/package.json",
-        path.relative(gitRoot, notesPath),
-    ];
-    if (await fileExists(path.join(gitRoot, "bun.lock"))) {
-        stagePaths.push("bun.lock");
-    }
-    await git.stage(stagePaths);
-    const staged = await git.statusStagedPaths();
-    if (staged.length === 0) {
-        process.stdout.write("No changes to commit.\n");
-    }
-    else {
-        const subject = `✨ release: ${plan.nextTag}`;
-        await git.commit({ message: subject, env: cleanHookEnv() });
-        const { stdout: headHash } = await execFileAsync("git", ["rev-parse", "HEAD"], {
-            cwd: gitRoot,
-            env: gitEnv(),
-        });
-        releaseCommit = { hash: String(headHash ?? "").trim(), subject };
-    }
-    await execFileAsync("git", ["tag", plan.nextTag], { cwd: gitRoot, env: gitEnv() });
-    process.stdout.write(`Release tag created: ${plan.nextTag}\n`);
-    if (flags.push) {
-        await execFileAsync("git", ["push", flags.remote, "HEAD"], { cwd: gitRoot, env: gitEnv() });
-        await execFileAsync("git", ["push", flags.remote, plan.nextTag], {
-            cwd: gitRoot,
-            env: gitEnv(),
         });
-        process.stdout.write(`Pushed: ${flags.remote} HEAD + ${plan.nextTag}\n`);
     }
-    else {
-        process.stdout.write(`Next: git push <remote> HEAD && git push <remote> ${plan.nextTag}\n`);
-    }
-    const reportPath = await writeReleaseApplyReport(gitRoot, {
-        applied_at: new Date().toISOString(),
-        plan_dir: path.relative(gitRoot, planDir),
-        notes_path: path.relative(gitRoot, notesPath),
-        prev_version: plan.prevVersion,
-        next_version: plan.nextVersion,
-        prev_tag: plan.prevTag,
-        next_tag: plan.nextTag,
-        bump: plan.bump,
-        checks: {
-            clean_tracked_tree: true,
-            tag_absent: true,
-            notes_validated: true,
-            npm_version_available_checked: npmVersionChecked,
-        },
-        commit: releaseCommit,
-        push: { requested: flags.push, remote: flags.remote, performed: flags.push },
+    const git = new GitContext({ gitRoot });
+    const { releaseCommit } = await applyReleaseMutation({
+        agentplaneDir: resolved.agentplaneDir,
+        gitRoot,
+        git,
+        notesPath,
+        corePkgPath,
+        agentplanePkgPath,
+        nextTag: plan.nextTag,
+        nextVersion: plan.nextVersion,
+    });
+    return await finalizeReleaseApply({
+        gitRoot,
+        planDir,
+        notesPath,
+        plan,
+        npmVersionChecked,
+        releaseCommit,
+        push: flags.push,
+        remote: flags.remote,
     });
-    process.stdout.write(`Release report: ${path.relative(gitRoot, reportPath)}\n`);
-    return 0;
 };
+export { pushReleaseRefs } from "./apply.reporting.js";

package/dist/commands/release/apply.mutation.d.ts

@@ -0,0 +1,7 @@
+export declare function replacePackageVersionInFile(pkgJsonPath: string, nextVersion: string): Promise<void>;
+export declare function replaceAgentplanePackageMetadata(pkgJsonPath: string, nextVersion: string): Promise<void>;
+export declare function maybeUpdateBunLockfile(gitRoot: string, fileExists: (p: string) => Promise<boolean>): Promise<void>;
+export declare function maybeRefreshGeneratedReference(gitRoot: string, fileExists: (p: string) => Promise<boolean>): Promise<boolean>;
+export declare function maybePersistExpectedCliVersion(agentplaneDir: string, nextVersion: string): Promise<boolean>;
+export declare function cleanHookEnv(): NodeJS.ProcessEnv;
+//# sourceMappingURL=apply.mutation.d.ts.map

package/dist/commands/release/apply.mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.mutation.d.ts","sourceRoot":"","sources":["../../../src/commands/release/apply.mutation.ts"],"names":[],"mappings":"AASA,wBAAsB,2BAA2B,CAC/C,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,wBAAsB,gCAAgC,CACpD,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAwBf;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAC1C,OAAO,CAAC,IAAI,CAAC,CAyBf;AAED,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAC1C,OAAO,CAAC,OAAO,CAAC,CAyBlB;AAED,wBAAsB,8BAA8B,CAClD,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC,CAQlB;AAED,wBAAgB,YAAY,IAAI,MAAM,CAAC,UAAU,CAMhD"}