agentplane 0.3.12 → 0.3.14

package/dist/commands/recipes.test-helpers.js

@@ -1,21 +1,24 @@
 import { generateKeyPairSync, sign } from "node:crypto";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, vi } from "vitest";
-import { cmdRecipeCachePruneParsed, cmdRecipeExplainParsed, cmdRecipeInfoParsed, cmdRecipeInstall, cmdRecipeListParsed, cmdRecipeListRemoteParsed, cmdRecipeRemoveParsed, } from "./recipes.js";
+import { cmdRecipeAddParsed, cmdRecipeCachePruneParsed, cmdRecipeDetachParsed, cmdRecipeExplainParsed, cmdRecipeInfoParsed, cmdRecipeInstall, cmdRecipeListParsed, cmdRecipeListRemoteParsed, cmdRecipeRemoveParsed, cmdRecipeUpdateParsed, hashRecipeTree, } from "./recipes.js";
 import { cmdScenarioInfoParsed, cmdScenarioListParsed, cmdScenarioRunParsed } from "./scenario.js";
 import { exitCodeForError } from "../cli/exit-codes.js";
 import { parseCommandArgv } from "../cli/spec/parse.js";
 import { captureStdIO, createRecipeArchive, mkGitRepoRoot, writeDefaultConfig, } from "../cli/run-cli.test-helpers.js";
 import { CliError } from "../shared/errors.js";
 import { recipesCachePruneSpec } from "./recipes/cache-prune.command.js";
+import { recipesAddSpec } from "./recipes/add.command.js";
 import { recipesExplainSpec } from "./recipes/explain.command.js";
 import { recipesInfoSpec } from "./recipes/info.command.js";
 import { recipesInstallSpec } from "./recipes/install.spec.js";
 import { recipesListRemoteSpec } from "./recipes/list-remote.command.js";
 import { recipesListSpec } from "./recipes/list.command.js";
+import { recipesDetachSpec } from "./recipes/detach.command.js";
 import { recipesRemoveSpec } from "./recipes/remove.command.js";
+import { recipesUpdateSpec } from "./recipes/update.command.js";
 import { scenarioInfoSpec } from "./scenario/info.command.js";
 import { scenarioListSpec } from "./scenario/list.command.js";
 import { scenarioRunSpec } from "./scenario/run.command.js";
@@ -73,16 +76,25 @@ export async function writeSignedIndex(indexPath, payload) {
     await writeFile(`${indexPath}.sig`, JSON.stringify(signature, null, 2), "utf8");
 }
 export function resolveProjectRecipeDir(projectDir, recipeId) {
-    return path.join(projectDir, ".agentplane", "recipes", recipeId);
+    return path.join(projectDir, ".agentplane", "recipes", "packages", recipeId);
+}
+export function resolveProjectRecipesRegistryPath(projectDir) {
+    return path.join(projectDir, ".agentplane", "recipes", "registry.json");
 }
 function readStringFixtureValue(record, key, fallback) {
     const value = record[key];
     return typeof value === "string" ? value : fallback;
 }
 export async function writeInstalledRecipes(projectDir, recipes) {
-    const recipesDir = path.join(projectDir, ".agentplane", "recipes");
+    const recipesHome = requireRecipesTempHome();
+    const recipesDir = path.join(recipesHome, "recipes-store");
     await rm(recipesDir, { recursive: true, force: true });
     await mkdir(recipesDir, { recursive: true });
+    const vendoredRecipesDir = path.join(projectDir, ".agentplane", "recipes", "packages");
+    await rm(vendoredRecipesDir, { recursive: true, force: true });
+    await mkdir(vendoredRecipesDir, { recursive: true });
+    const cachedEntries = [];
+    const registryEntries = [];
     for (const entry of recipes) {
         const record = entry;
         const manifest = record.manifest;
@@ -95,18 +107,20 @@ export async function writeInstalledRecipes(projectDir, recipes) {
             : Array.isArray(manifest.tags)
                 ? manifest.tags
                 : [];
-        const recipeDir = resolveProjectRecipeDir(projectDir, recipeId);
+        const recipeDir = path.join(recipesDir, recipeId, recipeVersion);
         await mkdir(recipeDir, { recursive: true });
         await writeFile(path.join(recipeDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
-        await writeFile(path.join(recipeDir, ".install.json"), JSON.stringify({
-            schema_version: 1,
+        const vendoredRecipeDir = resolveProjectRecipeDir(projectDir, recipeId);
+        await mkdir(vendoredRecipeDir, { recursive: true });
+        await writeFile(path.join(vendoredRecipeDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+        cachedEntries.push({
             id: recipeId,
             version: recipeVersion,
             source,
             installed_at: installedAt,
             tags,
-            install_mode: "project-local",
-        }, null, 2), "utf8");
+            manifest,
+        });
         const scenarios = Array.isArray(manifest.scenarios)
             ? manifest.scenarios.filter((scenario) => !!scenario && typeof scenario === "object")
             : [];
@@ -124,8 +138,10 @@ export async function writeInstalledRecipes(projectDir, recipes) {
                 ? scenario.required_inputs.filter((entry) => typeof entry === "string")
                 : [];
             const scenarioPath = path.join(recipeDir, scenarioFile);
+            const vendoredScenarioPath = path.join(vendoredRecipeDir, scenarioFile);
             await mkdir(path.dirname(scenarioPath), { recursive: true });
-            await writeFile(scenarioPath, JSON.stringify({
+            await mkdir(path.dirname(vendoredScenarioPath), { recursive: true });
+            const scenarioPayload = JSON.stringify({
                 schema_version: "1",
                 id: scenarioId,
                 summary: scenarioSummary,
@@ -138,9 +154,44 @@ export async function writeInstalledRecipes(projectDir, recipes) {
                 inputs: scenarioInputs.map((name) => ({ name, type: "string" })),
                 outputs: scenarioOutputs.map((name) => ({ name, type: "string" })),
                 steps: [],
-            }, null, 2), "utf8");
+            }, null, 2);
+            await writeFile(scenarioPath, scenarioPayload, "utf8");
+            await writeFile(vendoredScenarioPath, scenarioPayload, "utf8");
+        }
+        const tools = Array.isArray(manifest.tools)
+            ? manifest.tools.filter((tool) => !!tool && typeof tool === "object")
+            : [];
+        for (const tool of tools) {
+            const entrypoint = readStringFixtureValue(tool, "entrypoint", "").trim();
+            if (!entrypoint)
+                continue;
+            const toolSource = "console.log('ok');\n";
+            const toolPath = path.join(recipeDir, entrypoint);
+            const vendoredToolPath = path.join(vendoredRecipeDir, entrypoint);
+            await mkdir(path.dirname(toolPath), { recursive: true });
+            await mkdir(path.dirname(vendoredToolPath), { recursive: true });
+            await writeFile(toolPath, toolSource, "utf8");
+            await writeFile(vendoredToolPath, toolSource, "utf8");
         }
+        registryEntries.push({
+            id: recipeId,
+            version: recipeVersion,
+            path: `packages/${recipeId}`,
+            active: false,
+            materialization: "copy",
+            source_ref: source,
+            source_sha256: await hashRecipeTree(recipeDir),
+            vendored_sha256: await hashRecipeTree(vendoredRecipeDir),
+            installed_at: installedAt,
+            tags,
+        });
     }
+    await writeInstalledRecipesRegistry(cachedEntries);
+    await writeFile(resolveProjectRecipesRegistryPath(projectDir), JSON.stringify({
+        schema_version: 1,
+        updated_at: "2026-02-05T00:00:00Z",
+        recipes: registryEntries,
+    }, null, 2), "utf8");
 }
 export async function writeInstalledRecipesRegistry(recipes) {
     const recipesHome = requireRecipesTempHome();
@@ -155,8 +206,7 @@ export function skillEntry(overrides) {
     return {
         id: "RECIPE_SKILL",
         summary: "Recipe skill",
-        kind: "agent-skill",
-        file: "skills/recipe.json",
+        file: "skills/recipe.md",
         ...overrides,
     };
 }
@@ -177,7 +227,7 @@ export function agentEntry(overrides) {
         summary: "Recipe agent",
         skills: ["RECIPE_SKILL"],
         tools: ["RECIPE_TOOL"],
-        file: "agents/recipe.json",
+        file: "agents/recipe.md",
         ...overrides,
     };
 }
@@ -247,6 +297,20 @@ export async function installRecipe(opts) {
             command: "install",
             args: ["--path", archivePath],
         });
+        if (opts.vendor ?? true) {
+            const recipesHome = process.env.AGENTPLANE_HOME?.trim() ?? requireRecipesTempHome();
+            const installed = JSON.parse(await readFile(path.join(recipesHome, "recipes.json"), "utf8"));
+            const latest = installed.recipes?.at(-1);
+            if (!latest)
+                throw new Error("cached recipe registry unexpectedly empty after install");
+            await runRecipesTest({
+                cwd: opts.projectDir,
+                command: "add",
+                args: opts.mode
+                    ? [`${latest.id}@${latest.version}`, "--mode", opts.mode]
+                    : [`${latest.id}@${latest.version}`],
+            });
+        }
     }
     finally {
         io.restore();
@@ -271,7 +335,7 @@ export async function createInstalledRecipeProject(opts = {}) {
     };
 }
 export function resolveInstalledScenarioPath(projectDir, recipeId, scenarioFile = path.join("scenarios", "recipe-scenario.json")) {
-    return path.join(projectDir, ".agentplane", "recipes", recipeId, scenarioFile);
+    return path.join(projectDir, ".agentplane", "recipes", "packages", recipeId, scenarioFile);
 }
 export async function runRecipesTest(opts) {
     if (!opts.command) {
@@ -318,6 +382,15 @@ export async function runRecipesTest(opts) {
             const parsed = parseCommandArgv(recipesInstallSpec, opts.args).parsed;
             return await cmdRecipeInstall({ cwd: opts.cwd, rootOverride: opts.rootOverride, ...parsed });
         }
+        case "add": {
+            const parsed = parseCommandArgv(recipesAddSpec, opts.args).parsed;
+            return await cmdRecipeAddParsed({
+                cwd: opts.cwd,
+                rootOverride: opts.rootOverride,
+                recipeRef: parsed.recipeRef,
+                mode: parsed.mode,
+            });
+        }
         case "remove": {
             const parsed = parseCommandArgv(recipesRemoveSpec, opts.args).parsed;
             return await cmdRecipeRemoveParsed({
@@ -326,6 +399,23 @@ export async function runRecipesTest(opts) {
                 id: parsed.id,
             });
         }
+        case "update": {
+            const parsed = parseCommandArgv(recipesUpdateSpec, opts.args).parsed;
+            return await cmdRecipeUpdateParsed({
+                cwd: opts.cwd,
+                rootOverride: opts.rootOverride,
+                id: parsed.id,
+                force: parsed.force,
+            });
+        }
+        case "detach": {
+            const parsed = parseCommandArgv(recipesDetachSpec, opts.args).parsed;
+            return await cmdRecipeDetachParsed({
+                cwd: opts.cwd,
+                rootOverride: opts.rootOverride,
+                id: parsed.id,
+            });
+        }
         case "cache": {
             const [sub, ...tail] = opts.args;
             if (sub !== "prune") {

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

@@ -4,5 +4,5 @@ export declare const releaseApplySpec: CommandSpec<ReleaseApplyParsed>;
 export declare const releaseCandidateSpec: CommandSpec<ReleaseApplyParsed>;
 export declare const runReleaseApply: CommandHandler<ReleaseApplyParsed>;
 export declare const runReleaseCandidate: CommandHandler<ReleaseApplyParsed>;
-export { pushReleaseCandidateBranch, pushReleaseRefs } from "./apply.reporting.js";
+export { pushReleaseCandidateBranch, pushReleaseRefs } from "./apply.pipeline.js";
 //# sourceMappingURL=apply.command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"apply.command.d.ts","sourceRoot":"","sources":["../../../src/commands/release/apply.command.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAoC1E,OAAO,KAAK,EACV,kBAAkB,EAInB,MAAM,kBAAkB,CAAC;AA8c1B,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,kBAAkB,CA0E5D,CAAC;AAgCF,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,kBAAkB,CAuChE,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,kBAAkB,CAwF9D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,kBAAkB,CAwFlE,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"apply.command.d.ts","sourceRoot":"","sources":["../../../src/commands/release/apply.command.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAK1E,OAAO,KAAK,EAAE,kBAAkB,EAAqB,MAAM,kBAAkB,CAAC;AAgM9E,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,kBAAkB,CA0E5D,CAAC;AAgCF,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,kBAAkB,CAuChE,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,kBAAkB,CAQ9D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,kBAAkB,CAQlE,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC"}

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

@@ -1,114 +1,10 @@
-import path from "node:path";
-import { extractTaskSuffix, loadConfig, resolveBaseBranch, resolveProject, } from "@agentplaneorg/core";
-import { createCliEmitter } from "../../cli/output.js";
+import { loadConfig, resolveBaseBranch } 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 { gitCurrentBranch } from "../shared/git-ops.js";
-import { parseTaskIdFromBranch } from "../shared/git-worktree.js";
-import { ensureActionApproved } from "../shared/approval-requirements.js";
-import { ensureNetworkApproved } from "../shared/network-approval.js";
-import { runOperatorPipeline } from "../shared/operator-pipeline.js";
-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 { pushReleaseCandidateBranch, pushReleaseRefs, writeReleaseApplyReport, } from "./apply.reporting.js";
-const output = createCliEmitter();
-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 nextTag in version.json (expected vX.Y.Z): ${plan.nextTag}`,
-        });
-    }
-    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: `Missing release notes: ${path.relative(opts.gitRoot, notesPath)}\n` +
-                "Write this file using a DOCS agent before applying the release.",
-        });
-    }
-    await validateReleaseNotes(notesPath, minBullets);
-    return { planDir, plan, notesPath, minBullets };
-}
-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: `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}.`,
-        });
-    }
-    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: `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",
-                },
-            }),
-        });
-    }
-}
-async function runPushPreflight(opts) {
-    const loaded = await loadConfig(opts.agentplaneDir);
-    const pushReason = opts.route.kind === "release_candidate"
-        ? `${opts.commandLabel} will push current branch ${opts.route.current_branch} to ${opts.remote} as a release candidate for ${opts.nextTag}; final publication remains gated on merge to ${opts.route.base_branch}`
-        : `${opts.commandLabel} will push HEAD and ${opts.nextTag} to ${opts.remote}`;
-    await ensureNetworkApproved({
-        action: opts.route.kind === "release_candidate" ? "release_candidate" : "release_apply",
-        config: loaded.config,
-        yes: opts.yes,
-        reason: `${opts.commandLabel} validates npm version availability and pushes over network`,
-        interactive: Boolean(process.stdin.isTTY),
-    });
-    await ensureActionApproved({
-        action: "git_push",
-        config: loaded.config,
-        yes: opts.yes,
-        reason: pushReason,
-        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;
-}
+import { runReleaseCommandPipeline } from "./apply.pipeline.js";
 async function resolveDirectReleaseRoute(opts) {
     const loaded = await loadConfig(opts.agentplaneDir);
     const workflowMode = loaded.config.workflow_mode;
@@ -243,112 +139,6 @@ async function resolveReleaseCandidateRoute(opts) {
         base_branch: baseBranch,
     };
 }
-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 (generatedReferenceExists) {
-        stagePaths.push("docs/reference/generated-reference.mdx");
-    }
-    if (await fileExists(path.join(opts.gitRoot, "bun.lock"))) {
-        stagePaths.push("bun.lock");
-    }
-    await opts.git.stage(stagePaths);
-    const staged = await opts.git.statusStagedPaths();
-    if (staged.length === 0) {
-        output.line("No changes to commit.");
-        return { releaseCommit };
-    }
-    const taskId = opts.route.kind === "release_candidate"
-        ? parseTaskIdFromBranch(opts.taskBranchPrefix, opts.route.current_branch)
-        : null;
-    const subject = taskId
-        ? `✨ ${extractTaskSuffix(taskId)} release: publish ${opts.nextTag}`
-        : `✨ release: publish ${opts.nextTag}`;
-    await opts.git.commit({ message: subject, env: cleanHookEnv() });
-    const { stdout: headHash } = await execFileAsync("git", ["rev-parse", "HEAD"], {
-        cwd: opts.gitRoot,
-        env: gitEnv(),
-    });
-    releaseCommit = { hash: String(headHash ?? "").trim(), subject };
-    return { releaseCommit };
-}
-async function finalizeReleaseApply(opts) {
-    const tagCreated = opts.route.kind === "direct_release";
-    const pushedRefs = [];
-    if (tagCreated) {
-        await execFileAsync("git", ["tag", opts.plan.nextTag], {
-            cwd: opts.gitRoot,
-            env: gitEnv(),
-        });
-        output.line(`Release tag created: ${opts.plan.nextTag}`);
-    }
-    else {
-        output.line(`Release candidate prepared on ${opts.route.current_branch}; skipped local tag creation for ${opts.plan.nextTag} because final publication is deferred until merge to ${opts.route.base_branch}.`);
-    }
-    if (opts.push) {
-        if (opts.route.kind === "release_candidate") {
-            await pushReleaseCandidateBranch(opts.gitRoot, opts.remote);
-            pushedRefs.push("HEAD");
-            output.line(`Pushed: ${opts.remote} ${opts.route.current_branch} (release candidate branch only; no tag pushed)`);
-        }
-        else {
-            await pushReleaseRefs(opts.gitRoot, opts.remote, opts.plan.nextTag);
-            pushedRefs.push("HEAD", opts.plan.nextTag);
-            output.line(`Pushed: ${opts.remote} HEAD + ${opts.plan.nextTag}`);
-        }
-    }
-    else if (opts.route.kind === "release_candidate") {
-        output.line(`Next: git push <remote> HEAD  # merge ${opts.route.current_branch} into ${opts.route.base_branch} before publishing ${opts.plan.nextTag}`);
-    }
-    else {
-        output.line(`Next: git push <remote> HEAD && git push <remote> ${opts.plan.nextTag}`);
-    }
-    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,
-        route: opts.route,
-        tag: {
-            name: opts.plan.nextTag,
-            created: tagCreated,
-            pushed: tagCreated && opts.push,
-        },
-        push: {
-            requested: opts.push,
-            remote: opts.remote,
-            performed: pushedRefs.length > 0,
-            refs: pushedRefs,
-        },
-    });
-    output.line(`Release report: ${path.relative(opts.gitRoot, reportPath)}`);
-    return 0;
-}
 export const releaseApplySpec = {
     id: ["release", "apply"],
     group: "Release",
@@ -485,175 +275,21 @@ export const releaseCandidateSpec = {
     ],
 };
 export const runReleaseApply = async (ctx, flags) => {
-    return await runOperatorPipeline({
-        init: async () => {
-            const resolved = await resolveProject({
-                cwd: ctx.cwd,
-                rootOverride: ctx.rootOverride ?? null,
-            });
-            const gitRoot = resolved.gitRoot;
-            const { planDir, plan, notesPath } = await resolveReleasePlanInputs({
-                gitRoot,
-                planOverride: flags.plan,
-            });
-            const loaded = await loadConfig(resolved.agentplaneDir);
-            return {
-                resolved,
-                gitRoot,
-                planDir,
-                plan,
-                notesPath,
-                taskBranchPrefix: loaded.config.branch.task_prefix,
-                route: await resolveDirectReleaseRoute({
-                    cwd: ctx.cwd,
-                    rootOverride: ctx.rootOverride ?? null,
-                    gitRoot,
-                    agentplaneDir: resolved.agentplaneDir,
-                }),
-                corePkgPath: path.join(gitRoot, "packages", "core", "package.json"),
-                agentplanePkgPath: path.join(gitRoot, "packages", "agentplane", "package.json"),
-                npmVersionChecked: false,
-            };
-        },
-        preflight: async (state) => {
-            if ((state.plan.bump === "minor" || state.plan.bump === "major") && flags.yes !== true) {
-                throw usageError({
-                    spec: releaseApplySpec,
-                    command: "release apply",
-                    message: `Bump '${state.plan.bump}' requires explicit approval. Re-run with --yes.`,
-                });
-            }
-            await ensureReleasePlanMatchesRepoState({
-                gitRoot: state.gitRoot,
-                plan: state.plan,
-                corePkgPath: state.corePkgPath,
-                agentplanePkgPath: state.agentplanePkgPath,
-            });
-            if (flags.push) {
-                state.npmVersionChecked = await runPushPreflight({
-                    agentplaneDir: state.resolved.agentplaneDir,
-                    gitRoot: state.gitRoot,
-                    remote: flags.remote,
-                    nextTag: state.plan.nextTag,
-                    nextVersion: state.plan.nextVersion,
-                    route: state.route,
-                    yes: flags.yes,
-                    commandLabel: "release apply --push",
-                });
-            }
-        },
-        execute: async (state) => {
-            const git = new GitContext({ gitRoot: state.gitRoot });
-            return await applyReleaseMutation({
-                agentplaneDir: state.resolved.agentplaneDir,
-                gitRoot: state.gitRoot,
-                git,
-                notesPath: state.notesPath,
-                corePkgPath: state.corePkgPath,
-                agentplanePkgPath: state.agentplanePkgPath,
-                nextTag: state.plan.nextTag,
-                nextVersion: state.plan.nextVersion,
-                route: state.route,
-                taskBranchPrefix: state.taskBranchPrefix,
-            });
-        },
-        finalize: async (state, mutation) => await finalizeReleaseApply({
-            gitRoot: state.gitRoot,
-            planDir: state.planDir,
-            notesPath: state.notesPath,
-            plan: state.plan,
-            npmVersionChecked: state.npmVersionChecked,
-            releaseCommit: mutation.releaseCommit,
-            route: state.route,
-            push: flags.push,
-            remote: flags.remote,
-        }),
+    return await runReleaseCommandPipeline({
+        ctx,
+        flags,
+        spec: releaseApplySpec,
+        commandLabel: "release apply",
+        routeResolver: resolveDirectReleaseRoute,
     });
 };
 export const runReleaseCandidate = async (ctx, flags) => {
-    return await runOperatorPipeline({
-        init: async () => {
-            const resolved = await resolveProject({
-                cwd: ctx.cwd,
-                rootOverride: ctx.rootOverride ?? null,
-            });
-            const gitRoot = resolved.gitRoot;
-            const { planDir, plan, notesPath } = await resolveReleasePlanInputs({
-                gitRoot,
-                planOverride: flags.plan,
-            });
-            const loaded = await loadConfig(resolved.agentplaneDir);
-            return {
-                resolved,
-                gitRoot,
-                planDir,
-                plan,
-                notesPath,
-                taskBranchPrefix: loaded.config.branch.task_prefix,
-                route: await resolveReleaseCandidateRoute({
-                    cwd: ctx.cwd,
-                    rootOverride: ctx.rootOverride ?? null,
-                    gitRoot,
-                    agentplaneDir: resolved.agentplaneDir,
-                }),
-                corePkgPath: path.join(gitRoot, "packages", "core", "package.json"),
-                agentplanePkgPath: path.join(gitRoot, "packages", "agentplane", "package.json"),
-                npmVersionChecked: false,
-            };
-        },
-        preflight: async (state) => {
-            if ((state.plan.bump === "minor" || state.plan.bump === "major") && flags.yes !== true) {
-                throw usageError({
-                    spec: releaseCandidateSpec,
-                    command: "release candidate",
-                    message: `Bump '${state.plan.bump}' requires explicit approval. Re-run with --yes.`,
-                });
-            }
-            await ensureReleasePlanMatchesRepoState({
-                gitRoot: state.gitRoot,
-                plan: state.plan,
-                corePkgPath: state.corePkgPath,
-                agentplanePkgPath: state.agentplanePkgPath,
-            });
-            if (flags.push) {
-                state.npmVersionChecked = await runPushPreflight({
-                    agentplaneDir: state.resolved.agentplaneDir,
-                    gitRoot: state.gitRoot,
-                    remote: flags.remote,
-                    nextTag: state.plan.nextTag,
-                    nextVersion: state.plan.nextVersion,
-                    route: state.route,
-                    yes: flags.yes,
-                    commandLabel: "release candidate --push",
-                });
-            }
-        },
-        execute: async (state) => {
-            const git = new GitContext({ gitRoot: state.gitRoot });
-            return await applyReleaseMutation({
-                agentplaneDir: state.resolved.agentplaneDir,
-                gitRoot: state.gitRoot,
-                git,
-                notesPath: state.notesPath,
-                corePkgPath: state.corePkgPath,
-                agentplanePkgPath: state.agentplanePkgPath,
-                nextTag: state.plan.nextTag,
-                nextVersion: state.plan.nextVersion,
-                route: state.route,
-                taskBranchPrefix: state.taskBranchPrefix,
-            });
-        },
-        finalize: async (state, mutation) => await finalizeReleaseApply({
-            gitRoot: state.gitRoot,
-            planDir: state.planDir,
-            notesPath: state.notesPath,
-            plan: state.plan,
-            npmVersionChecked: state.npmVersionChecked,
-            releaseCommit: mutation.releaseCommit,
-            route: state.route,
-            push: flags.push,
-            remote: flags.remote,
-        }),
+    return await runReleaseCommandPipeline({
+        ctx,
+        flags,
+        spec: releaseCandidateSpec,
+        commandLabel: "release candidate",
+        routeResolver: resolveReleaseCandidateRoute,
     });
 };
-export { pushReleaseCandidateBranch, pushReleaseRefs } from "./apply.reporting.js";
+export { pushReleaseCandidateBranch, pushReleaseRefs } from "./apply.pipeline.js";

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

@@ -1,5 +1,6 @@
 export declare function replacePackageVersionInFile(pkgJsonPath: string, nextVersion: string): Promise<void>;
 export declare function replaceAgentplanePackageMetadata(pkgJsonPath: string, nextVersion: string): Promise<void>;
+export declare function replacePackageDependencyVersion(pkgJsonPath: string, dependencyName: 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>;

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

@@ -1 +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,CAOhD"}
+{"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,CAqCf;AAED,wBAAsB,+BAA+B,CACnD,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAcf;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,CAOhD"}