verelease 0.1.2-alpha.0 → 0.1.2-alpha.2

package/dist/bin.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve2, join as join10 } from "path";
-import { writeFile as writeFile5, mkdir as mkdir5, readFile as readFile5, unlink } from "fs/promises";
+import { resolve as resolve2, join as join13 } from "path";
+import { writeFile as writeFile5, mkdir as mkdir6, readFile as readFile7, unlink, rm as rm4 } from "fs/promises";
+import { mkdtemp as mkdtemp5 } from "fs/promises";
+import { tmpdir as tmpdir5 } from "os";
+import { existsSync } from "fs";
+import { createInterface } from "readline/promises";
 
 // ../workspace/dist/graph.js
 var PackageGraphImpl = class {
@@ -554,12 +558,14 @@ var CandidatePacker = class {
 
 // ../contracts/dist/runner.js
 import { mkdir as mkdir3, symlink, rm as rm2, writeFile as writeFile2, copyFile } from "fs/promises";
-import { join as join4, basename } from "path";
+import { join as join5, basename } from "path";
 import { tmpdir as tmpdir2 } from "os";
 import { mkdtemp as mkdtemp2 } from "fs/promises";
 
 // ../test-adapter-node/dist/node-test.js
 import { spawn } from "child_process";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
 var NodeTestAdapter = class {
   options;
   name = "node:test";
@@ -582,8 +588,22 @@ var NodeTestAdapter = class {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startTime = Date.now();
     const reporter = this.options.reporter || "tap";
-    const loaderArgs = this.options.loaderArgs || [];
-    const testFiles = ctx.testFiles && ctx.testFiles.length > 0 ? ctx.testFiles : [];
+    let loaderArgs = this.options.loaderArgs || [];
+    let testFiles = ctx.testFiles && ctx.testFiles.length > 0 ? ctx.testFiles : [];
+    if (loaderArgs.length === 0 || testFiles.length === 0) {
+      try {
+        const pkgRaw = await readFile3(join4(ctx.packagePath, "package.json"), "utf8");
+        const pkg = JSON.parse(pkgRaw);
+        const testScript = pkg.scripts?.test || "";
+        if (loaderArgs.length === 0 && (testScript.includes("--import tsx") || testScript.includes("tsx"))) {
+          loaderArgs = ["--import", "tsx"];
+        }
+        if (testFiles.length === 0 && testScript.includes("src/**/*.test.ts")) {
+          testFiles = ["src/**/*.test.ts"];
+        }
+      } catch {
+      }
+    }
     const command = [
       "node",
       ...loaderArgs,
@@ -746,22 +766,22 @@ var ContractRunner = class {
   }
   async runContract(contract, candidate) {
     const startTime = Date.now();
-    const consumerEnvDir = await mkdtemp2(join4(tmpdir2(), "verelease-consumer-"));
-    const nodeModulesDir = join4(consumerEnvDir, "node_modules");
+    const consumerEnvDir = await mkdtemp2(join5(tmpdir2(), "verelease-consumer-"));
+    const nodeModulesDir = join5(consumerEnvDir, "node_modules");
     try {
-      await writeFile2(join4(consumerEnvDir, "package.json"), JSON.stringify({ name: "consumer-fixture", type: "module" }, null, 2), "utf8");
-      let targetPkgLink = join4(nodeModulesDir, candidate.packageName);
+      await writeFile2(join5(consumerEnvDir, "package.json"), JSON.stringify({ name: "consumer-fixture", type: "module" }, null, 2), "utf8");
+      let targetPkgLink = join5(nodeModulesDir, candidate.packageName);
       if (candidate.packageName.startsWith("@")) {
         const [scope, pkgName] = candidate.packageName.split("/");
-        const scopeDir = join4(nodeModulesDir, scope);
+        const scopeDir = join5(nodeModulesDir, scope);
         await mkdir3(scopeDir, { recursive: true });
-        targetPkgLink = join4(scopeDir, pkgName);
+        targetPkgLink = join5(scopeDir, pkgName);
       } else {
         await mkdir3(nodeModulesDir, { recursive: true });
       }
       await symlink(candidate.unpackedDir, targetPkgLink, "junction");
       const isolatedTestName = basename(contract.testFile);
-      const isolatedTestPath = join4(consumerEnvDir, isolatedTestName);
+      const isolatedTestPath = join5(consumerEnvDir, isolatedTestName);
       await copyFile(contract.testFile, isolatedTestPath);
       const testRun = await this.testAdapter.run({
         packagePath: consumerEnvDir,
@@ -1098,8 +1118,8 @@ var ApiDiffEngine = class {
 };
 
 // ../api-diff/dist/analyzer.js
-import { readFile as readFile3, stat as stat2 } from "fs/promises";
-import { join as join5 } from "path";
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { join as join6 } from "path";
 async function fileExists2(path) {
   try {
     const s = await stat2(path);
@@ -1121,11 +1141,11 @@ var ApiDiffAnalyzer = class {
     if (!candidateEntrypoint) {
       return [];
     }
-    const candidateSource = await readFile3(candidateEntrypoint, "utf8");
+    const candidateSource = await readFile4(candidateEntrypoint, "utf8");
     const candidateSnapshot = this.extractor.extractFromSource(candidateSource, candidateEntrypoint);
     let baselineSnapshot;
     if (context.baselinePath && await fileExists2(context.baselinePath)) {
-      const baseSource = await readFile3(context.baselinePath, "utf8");
+      const baseSource = await readFile4(context.baselinePath, "utf8");
       if (context.baselinePath.endsWith(".json")) {
         baselineSnapshot = JSON.parse(baseSource);
       } else {
@@ -1139,11 +1159,11 @@ var ApiDiffAnalyzer = class {
   }
   async findEntrypoint(pkgDir) {
     const candidates = [
-      join5(pkgDir, "src", "index.ts"),
-      join5(pkgDir, "src", "index.js"),
-      join5(pkgDir, "index.ts"),
-      join5(pkgDir, "index.js"),
-      join5(pkgDir, "dist", "index.d.ts")
+      join6(pkgDir, "src", "index.ts"),
+      join6(pkgDir, "src", "index.js"),
+      join6(pkgDir, "index.ts"),
+      join6(pkgDir, "index.js"),
+      join6(pkgDir, "dist", "index.d.ts")
     ];
     for (const c of candidates) {
       if (await fileExists2(c)) {
@@ -1154,9 +1174,14 @@ var ApiDiffAnalyzer = class {
   }
 };
 
-// ../manifest/dist/mutator.js
-import { readFile as readFile4, writeFile as writeFile3, stat as stat3 } from "fs/promises";
-import { join as join6 } from "path";
+// ../api-diff/dist/baseline.js
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { mkdtemp as mkdtemp3, mkdir as mkdir4, stat as stat3 } from "fs/promises";
+import { join as join7 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import * as tar2 from "tar";
+var execFileAsync2 = promisify2(execFile2);
 async function fileExists3(path) {
   try {
     const s = await stat3(path);
@@ -1165,6 +1190,86 @@ async function fileExists3(path) {
     return false;
   }
 }
+var BaselineFetcher = class {
+  /**
+   * Fetch the latest published version of a package from npm,
+   * download its tarball, extract it, and locate its entry point.
+   *
+   * Returns `null` if the package has never been published, is offline,
+   * or the extracted package has no recognizable entry point.
+   */
+  async fetch(packageName, parentTmpDir) {
+    const version = await this.getLatestVersion(packageName);
+    if (!version)
+      return null;
+    const tempDir = parentTmpDir ? join7(parentTmpDir, packageName.replace(/\//g, "__")) : await mkdtemp3(join7(tmpdir3(), "verelease-baseline-"));
+    await mkdir4(tempDir, { recursive: true });
+    let tarballFilename;
+    try {
+      const { stdout } = await execFileAsync2("npm", ["pack", `${packageName}@${version}`, "--pack-destination", tempDir], { timeout: 3e4 });
+      tarballFilename = stdout.trim().split("\n").pop().trim();
+    } catch {
+      return null;
+    }
+    const tarballPath = join7(tempDir, tarballFilename);
+    const extractedDir = join7(tempDir, "extracted");
+    await mkdir4(extractedDir, { recursive: true });
+    try {
+      await tar2.x({
+        file: tarballPath,
+        cwd: extractedDir,
+        strip: 1
+        // npm tarballs contain a top-level `package/` directory
+      });
+    } catch {
+      return null;
+    }
+    const entryPointPath = await this.findEntrypoint(extractedDir);
+    if (!entryPointPath)
+      return null;
+    return { version, entryPointPath, extractedDir };
+  }
+  async getLatestVersion(packageName) {
+    try {
+      const { stdout } = await execFileAsync2("npm", ["view", packageName, "version", "--json"], { timeout: 15e3 });
+      const parsed = JSON.parse(stdout.trim());
+      if (typeof parsed === "string")
+        return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async findEntrypoint(pkgDir) {
+    const candidates = [
+      join7(pkgDir, "dist", "index.d.ts"),
+      join7(pkgDir, "dist", "index.d.mts"),
+      join7(pkgDir, "src", "index.ts"),
+      join7(pkgDir, "src", "index.js"),
+      join7(pkgDir, "index.d.ts"),
+      join7(pkgDir, "index.ts"),
+      join7(pkgDir, "index.js")
+    ];
+    for (const candidate of candidates) {
+      if (await fileExists3(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+};
+
+// ../manifest/dist/mutator.js
+import { readFile as readFile5, writeFile as writeFile3, stat as stat4 } from "fs/promises";
+import { join as join8 } from "path";
+async function fileExists4(path) {
+  try {
+    const s = await stat4(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
 var TransactionalManifestMutator = class {
   async applyPlan(plan) {
     const backups = [];
@@ -1172,27 +1277,27 @@ var TransactionalManifestMutator = class {
     const filesToTouch = /* @__PURE__ */ new Set();
     for (const pkgPlan of plan.packages) {
       if (pkgPlan.bump !== "none") {
-        const pkgJson = join6(pkgPlan.directory, "package.json");
-        const jsrJson = join6(pkgPlan.directory, "jsr.json");
-        const denoJson = join6(pkgPlan.directory, "deno.json");
-        if (await fileExists3(pkgJson))
+        const pkgJson = join8(pkgPlan.directory, "package.json");
+        const jsrJson = join8(pkgPlan.directory, "jsr.json");
+        const denoJson = join8(pkgPlan.directory, "deno.json");
+        if (await fileExists4(pkgJson))
           filesToTouch.add(pkgJson);
-        if (await fileExists3(jsrJson))
+        if (await fileExists4(jsrJson))
           filesToTouch.add(jsrJson);
-        if (await fileExists3(denoJson))
+        if (await fileExists4(denoJson))
           filesToTouch.add(denoJson);
       }
       for (const update of pkgPlan.dependentUpdates) {
         const depPkgPlan = plan.packages.find((p) => p.name === update.dependentName);
         if (depPkgPlan) {
-          const depPkgJson = join6(depPkgPlan.directory, "package.json");
-          if (await fileExists3(depPkgJson))
+          const depPkgJson = join8(depPkgPlan.directory, "package.json");
+          if (await fileExists4(depPkgJson))
             filesToTouch.add(depPkgJson);
         }
       }
     }
     for (const filePath of filesToTouch) {
-      const originalContent = await readFile4(filePath, "utf8");
+      const originalContent = await readFile5(filePath, "utf8");
       backups.push({ filePath, originalContent });
     }
     try {
@@ -1216,9 +1321,9 @@ var TransactionalManifestMutator = class {
         }
       }
       for (const pkgPlan of plan.packages) {
-        const pkgJsonPath = join6(pkgPlan.directory, "package.json");
+        const pkgJsonPath = join8(pkgPlan.directory, "package.json");
         if (filesToTouch.has(pkgJsonPath)) {
-          const content = await readFile4(pkgJsonPath, "utf8");
+          const content = await readFile5(pkgJsonPath, "utf8");
           const parsed = JSON.parse(content);
           if (versionMap.has(pkgPlan.name)) {
             parsed.version = versionMap.get(pkgPlan.name);
@@ -1235,9 +1340,9 @@ var TransactionalManifestMutator = class {
           await writeFile3(pkgJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
           modifiedFiles.push(pkgJsonPath);
         }
-        const jsrJsonPath = join6(pkgPlan.directory, "jsr.json");
+        const jsrJsonPath = join8(pkgPlan.directory, "jsr.json");
         if (filesToTouch.has(jsrJsonPath)) {
-          const content = await readFile4(jsrJsonPath, "utf8");
+          const content = await readFile5(jsrJsonPath, "utf8");
           const parsed = JSON.parse(content);
           if (versionMap.has(pkgPlan.name)) {
             parsed.version = versionMap.get(pkgPlan.name);
@@ -1245,9 +1350,9 @@ var TransactionalManifestMutator = class {
           await writeFile3(jsrJsonPath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
           modifiedFiles.push(jsrJsonPath);
         }
-        const denoJsonPath = join6(pkgPlan.directory, "deno.json");
+        const denoJsonPath = join8(pkgPlan.directory, "deno.json");
         if (filesToTouch.has(denoJsonPath)) {
-          const content = await readFile4(denoJsonPath, "utf8");
+          const content = await readFile5(denoJsonPath, "utf8");
           const parsed = JSON.parse(content);
           if (versionMap.has(pkgPlan.name)) {
             parsed.version = versionMap.get(pkgPlan.name);
@@ -1281,14 +1386,14 @@ var TransactionalManifestMutator = class {
 };
 
 // ../manifest/dist/lockfile.js
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-import { stat as stat4 } from "fs/promises";
-import { join as join7 } from "path";
-var execFileAsync2 = promisify2(execFile2);
-async function fileExists4(path) {
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { stat as stat5 } from "fs/promises";
+import { join as join9 } from "path";
+var execFileAsync3 = promisify3(execFile3);
+async function fileExists5(path) {
   try {
-    const s = await stat4(path);
+    const s = await stat5(path);
     return s.isFile();
   } catch {
     return false;
@@ -1299,7 +1404,7 @@ var PnpmLockfileAdapter = class {
   async regenerateLockfile(rootDirectory) {
     const start = Date.now();
     try {
-      const { stdout, stderr } = await execFileAsync2("pnpm", ["install", "--lockfile-only"], {
+      const { stdout, stderr } = await execFileAsync3("pnpm", ["install", "--lockfile-only"], {
         cwd: rootDirectory
       });
       return {
@@ -1321,7 +1426,7 @@ var NpmLockfileAdapter = class {
   async regenerateLockfile(rootDirectory) {
     const start = Date.now();
     try {
-      const { stdout, stderr } = await execFileAsync2("npm", ["install", "--package-lock-only"], {
+      const { stdout, stderr } = await execFileAsync3("npm", ["install", "--package-lock-only"], {
         cwd: rootDirectory
       });
       return {
@@ -1341,11 +1446,11 @@ var NpmLockfileAdapter = class {
 var AutoLockfileAdapter = class {
   packageManager = "npm";
   async regenerateLockfile(rootDirectory) {
-    if (await fileExists4(join7(rootDirectory, "pnpm-lock.yaml"))) {
+    if (await fileExists5(join9(rootDirectory, "pnpm-lock.yaml"))) {
       this.packageManager = "pnpm";
       return new PnpmLockfileAdapter().regenerateLockfile(rootDirectory);
     }
-    if (await fileExists4(join7(rootDirectory, "package-lock.json"))) {
+    if (await fileExists5(join9(rootDirectory, "package-lock.json"))) {
       this.packageManager = "npm";
       return new NpmLockfileAdapter().regenerateLockfile(rootDirectory);
     }
@@ -1354,18 +1459,18 @@ var AutoLockfileAdapter = class {
 };
 
 // ../publisher-npm/dist/publisher.js
-import { execFile as execFile3, spawn as spawn2 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile3);
+import { execFile as execFile4, spawn as spawn2 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync4 = promisify4(execFile4);
 function openBrowser(url) {
   const platform = process.platform;
   try {
     if (platform === "darwin") {
-      execFile3("open", [url]);
+      execFile4("open", [url]);
     } else if (platform === "win32") {
-      execFile3("cmd", ["/c", "start", '""', url]);
+      execFile4("cmd", ["/c", "start", '""', url]);
     } else {
-      execFile3("xdg-open", [url]);
+      execFile4("xdg-open", [url]);
     }
   } catch {
   }
@@ -1404,12 +1509,19 @@ var NpmPublishProvider = class {
   }
   async prepare(ctx) {
     try {
-      await execFileAsync3("npm", ["pack", "--dry-run"], {
+      await execFileAsync4("npm", ["pack", "--dry-run"], {
         cwd: ctx.packagePlan.directory
       });
     } catch (err) {
       throw new Error(`Failed packing verification for package ${ctx.packagePlan.name}: ${err.message || String(err)}`);
     }
+    if (!ctx.dryRun && !process.env.CI) {
+      try {
+        await execFileAsync4("npm", ["whoami"]);
+      } catch {
+        throw new Error(`You are not logged in to npm (npm whoami failed with 401). Please run 'npm login' first.`);
+      }
+    }
   }
   async publish(ctx) {
     const startTime = Date.now();
@@ -1465,7 +1577,7 @@ var NpmPublishProvider = class {
               distTag,
               durationMs: Date.now() - startTime,
               output: "",
-              error: `npm publish exited with code ${code} (2FA authentication failed, timed out, or was aborted)`
+              error: `npm publish exited with code ${code}. Check the npm error log above (e.g. run 'npm login' if unauthenticated, or check package permissions).`
             });
           }
         });
@@ -1485,7 +1597,7 @@ var NpmPublishProvider = class {
       });
     }
     try {
-      const { stdout, stderr } = await execFileAsync3("npm", args, {
+      const { stdout, stderr } = await execFileAsync4("npm", args, {
         cwd: ctx.packagePlan.directory
       });
       return {
@@ -1543,7 +1655,7 @@ ${err.message || ""}`;
   }
   async getPublishedVersions(packageName) {
     try {
-      const { stdout } = await execFileAsync3("npm", ["view", packageName, "versions", "--json"]);
+      const { stdout } = await execFileAsync4("npm", ["view", packageName, "versions", "--json"]);
       const parsed = JSON.parse(stdout.trim());
       if (Array.isArray(parsed)) {
         return parsed;
@@ -1559,12 +1671,12 @@ ${err.message || ""}`;
 };
 
 // ../config/dist/config.js
-import { stat as stat5 } from "fs/promises";
-import { join as join8 } from "path";
+import { stat as stat6 } from "fs/promises";
+import { join as join10 } from "path";
 import { pathToFileURL } from "url";
-async function fileExists5(path) {
+async function fileExists6(path) {
   try {
-    const s = await stat5(path);
+    const s = await stat6(path);
     return s.isFile();
   } catch {
     return false;
@@ -1582,8 +1694,8 @@ async function loadConfig(rootDir) {
     "autoversion.config.mjs"
   ];
   for (const name of candidateNames) {
-    const fullPath = join8(rootDir, name);
-    if (await fileExists5(fullPath)) {
+    const fullPath = join10(rootDir, name);
+    if (await fileExists6(fullPath)) {
       try {
         const fileUrl = pathToFileURL(fullPath).href;
         const mod = await import(fileUrl);
@@ -1837,13 +1949,13 @@ walkAndTransform(targetDir);
 }
 
 // ../ai/dist/validation.js
-import { cp, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile4, mkdir as mkdir4, symlink as symlink2, readdir as readdir3 } from "fs/promises";
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
-import { join as join9 } from "path";
-import { tmpdir as tmpdir3 } from "os";
-import * as tar2 from "tar";
-var execFileAsync4 = promisify4(execFile4);
+import { cp, mkdtemp as mkdtemp4, rm as rm3, writeFile as writeFile4, mkdir as mkdir5, symlink as symlink2, readdir as readdir3 } from "fs/promises";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { join as join11 } from "path";
+import { tmpdir as tmpdir4 } from "os";
+import * as tar3 from "tar";
+var execFileAsync5 = promisify5(execFile5);
 
 // ../ai/dist/provider.js
 var TanStackReleaseAI = class {
@@ -1901,9 +2013,9 @@ ${JSON.stringify(input.breakingChanges, null, 2)}`;
 };
 
 // ../git/dist/git.js
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
-var execFileAsync5 = promisify5(execFile5);
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+var execFileAsync6 = promisify6(execFile6);
 var GitManager = class {
   cwd;
   constructor(cwd = process.cwd()) {
@@ -1919,207 +2031,982 @@ var GitManager = class {
     return `${options.packageName}@${options.version}`;
   }
   async isClean() {
-    const { stdout } = await execFileAsync5("git", ["status", "--porcelain"], {
+    const { stdout } = await execFileAsync6("git", ["status", "--porcelain"], {
       cwd: this.cwd
     });
     return stdout.trim().length === 0;
   }
   async getHeadCommit() {
-    const { stdout } = await execFileAsync5("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await execFileAsync6("git", ["rev-parse", "HEAD"], {
       cwd: this.cwd
     });
     return stdout.trim();
   }
   async createTag(tagName, message) {
     const args = ["tag", "-a", tagName, "-m", message || `Release ${tagName}`];
-    await execFileAsync5("git", args, { cwd: this.cwd });
+    await execFileAsync6("git", args, { cwd: this.cwd });
   }
   async createReleaseCommit(files, message = "chore(release): publish") {
     if (files.length > 0) {
-      await execFileAsync5("git", ["add", ...files], { cwd: this.cwd });
+      await execFileAsync6("git", ["add", ...files], { cwd: this.cwd });
     } else {
-      await execFileAsync5("git", ["add", "-A"], { cwd: this.cwd });
+      await execFileAsync6("git", ["add", "-A"], { cwd: this.cwd });
     }
-    await execFileAsync5("git", ["commit", "-m", message], { cwd: this.cwd });
+    await execFileAsync6("git", ["commit", "-m", message], { cwd: this.cwd });
     return this.getHeadCommit();
   }
 };
 
-// src/cli.ts
-import semver4 from "semver";
-var VereleaseCli = class {
-  cwd;
-  constructor(options = {}) {
-    this.cwd = resolve2(options.cwd || process.cwd());
+// ../test-adapter/dist/command.js
+import { spawn as spawn3 } from "child_process";
+var CommandTestAdapter = class {
+  config;
+  name = "command";
+  constructor(config) {
+    this.config = config;
   }
-  async createPlan(options = {}) {
-    const config = await loadConfig(this.cwd);
-    const resolver = new DefaultWorkspaceResolver();
-    const discovery = await resolver.resolve(this.cwd);
-    const contractStore = new FileContractStore(
-      join10(this.cwd, config.contracts?.directory || ".verelease/contracts")
-    );
-    const contractAnalyzer = new ContractCompatibilityAnalyzer(contractStore);
-    const apiDiffAnalyzer = new ApiDiffAnalyzer();
-    const semverEngine = new DefaultSemVerDecisionEngine();
-    const npmPublisher = new NpmPublishProvider();
-    const evidenceMap = /* @__PURE__ */ new Map();
-    const initialBumps = /* @__PURE__ */ new Map();
-    for (const pkg of discovery.packages) {
-      const evidence = [];
-      try {
-        const contractEv = await contractAnalyzer.analyze({
-          packageName: pkg.name,
-          packagePath: pkg.directory,
-          currentVersion: pkg.version
-        });
-        evidence.push(...contractEv);
-      } catch {
-      }
-      try {
-        const apiEv = await apiDiffAnalyzer.analyze({
-          packageName: pkg.name,
-          packagePath: pkg.directory,
-          currentVersion: pkg.version
-        });
-        evidence.push(...apiEv);
-      } catch {
-      }
-      evidenceMap.set(pkg.name, evidence);
-      const decision = semverEngine.evaluate(
-        pkg.name,
-        pkg.version,
-        evidence,
-        config.versioning,
-        options.channel || "stable"
-      );
-      const forced = options.forceBump?.[pkg.name] || options.defaultBump;
-      let bump = forced || decision.bump;
-      let proposedVersion = decision.proposedVersion;
-      const reasons = [...decision.reasons];
-      if (forced && decision.bump === "none") {
-        const channel = options.channel || config.versioning?.channel || "stable";
-        if (channel !== "stable") {
-          const baseBump = `pre${forced}`;
-          proposedVersion = semver4.inc(pkg.version, baseBump, channel) || pkg.version;
-        } else {
-          proposedVersion = semver4.inc(pkg.version, forced) || pkg.version;
-        }
-        reasons.push(`Bump manually requested (${forced}) for channel ${channel}`);
-      }
-      if (!pkg.isPrivate) {
-        try {
-          const publishedVersions = await npmPublisher.getPublishedVersions(pkg.name);
-          const channel = options.channel || config.versioning?.channel || "stable";
-          if (publishedVersions.includes(proposedVersion) || bump !== "none" && publishedVersions.includes(pkg.version)) {
-            reasons.push(`Version ${proposedVersion} is already published on npm registry.`);
-            let nextCandidate = proposedVersion;
-            if (channel !== "stable") {
-              const baseBump = bump === "none" ? "patch" : bump;
-              const parsed = semver4.parse(pkg.version);
-              if (parsed.prerelease.length > 0 && parsed.prerelease[0] === channel) {
-                nextCandidate = semver4.inc(pkg.version, "prerelease", channel) || pkg.version;
-              } else {
-                nextCandidate = semver4.inc(pkg.version, `pre${baseBump}`, channel) || pkg.version;
-              }
-              while (publishedVersions.includes(nextCandidate)) {
-                nextCandidate = semver4.inc(nextCandidate, "prerelease", channel) || nextCandidate;
-              }
-            } else {
-              const baseBump = bump === "none" ? "patch" : bump;
-              nextCandidate = semver4.inc(pkg.version, baseBump) || pkg.version;
-              while (publishedVersions.includes(nextCandidate)) {
-                nextCandidate = semver4.inc(nextCandidate, "patch") || nextCandidate;
-              }
+  async detect(ctx) {
+    const scripts = ctx.manifest.scripts || {};
+    if (scripts.test) {
+      return {
+        supported: true,
+        confidence: 0.5,
+        suggestedConfig: { command: ["npm", "test"] }
+      };
+    }
+    return { supported: false, confidence: 0 };
+  }
+  async run(ctx) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    const cmd = this.config?.command || ["npm", "test"];
+    const [executable, ...args] = cmd;
+    const finalArgs = [...args, ...ctx.extraArgs || []];
+    return new Promise((resolve3) => {
+      const child = spawn3(executable, finalArgs, {
+        cwd: ctx.packagePath,
+        env: { ...process.env, ...ctx.env },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("close", (code) => {
+        const durationMs = Date.now() - startTime;
+        const success = code === 0;
+        const testCases = [
+          {
+            name: `${executable} ${finalArgs.join(" ")}`,
+            status: success ? "passed" : "failed",
+            durationMs,
+            failure: success ? void 0 : {
+              message: `Process exited with code ${code}`,
+              stack: stderr || stdout
             }
-            proposedVersion = nextCandidate;
-            bump = bump === "none" ? "patch" : bump;
-            reasons.push(`Automatically resolved next available registry version: ${proposedVersion}`);
           }
-        } catch {
-        }
-      }
-      initialBumps.set(pkg.name, {
-        name: pkg.name,
-        currentVersion: pkg.version,
-        proposedVersion,
-        bump,
-        reasons
+        ];
+        resolve3({
+          adapter: this.name,
+          runtime: process.version,
+          command: [executable, ...finalArgs],
+          startedAt,
+          durationMs,
+          success,
+          suites: [
+            {
+              name: "command-suite",
+              status: success ? "passed" : "failed",
+              durationMs,
+              tests: testCases
+            }
+          ],
+          diagnostics: success ? [] : [
+            {
+              severity: "error",
+              message: stderr.trim() || `Exit code ${code}`
+            }
+          ],
+          totalTests: 1,
+          passedTests: success ? 1 : 0,
+          failedTests: success ? 0 : 1,
+          skippedTests: 0
+        });
       });
-    }
-    const propagator = new VersionPropagator(discovery.graph);
-    const { bumps: finalBumps, dependencyUpdates } = propagator.propagate(initialBumps);
-    const publishOrder = discovery.graph.getTopologicalOrder();
-    const packagePlans = [];
-    for (const pkgName of publishOrder) {
-      const pkg = discovery.packages.find((p) => p.name === pkgName);
-      if (!pkg) continue;
-      const bumpTarget = finalBumps.get(pkgName);
-      const evidence = evidenceMap.get(pkgName) || [];
-      const depUpdates = dependencyUpdates.get(pkgName) || [];
-      const decision = semverEngine.evaluate(
-        pkg.name,
-        pkg.version,
-        evidence,
-        config.versioning,
-        options.channel || "stable"
-      );
-      packagePlans.push({
-        name: pkg.name,
-        directory: pkg.directory,
-        currentVersion: pkg.version,
-        proposedVersion: bumpTarget.proposedVersion,
-        bump: bumpTarget.bump,
-        channel: options.channel || "stable",
-        evidence,
-        reasons: bumpTarget.reasons,
-        confidence: decision.confidence,
-        requiresApproval: decision.requiresApproval,
-        dependentUpdates: depUpdates.map((d) => ({
-          dependentName: pkgName,
-          dependencyName: d.dependencyName,
-          dependencyType: d.type,
-          previousRange: d.previousRange,
-          newRange: d.newRange
-        })),
-        filesToUpdate: [pkg.manifestPath],
-        publish: !pkg.isPrivate && bumpTarget.bump !== "none"
+      child.on("error", (err) => {
+        const durationMs = Date.now() - startTime;
+        resolve3({
+          adapter: this.name,
+          runtime: process.version,
+          command: [executable, ...finalArgs],
+          startedAt,
+          durationMs,
+          success: false,
+          suites: [],
+          diagnostics: [
+            {
+              severity: "error",
+              message: err.message,
+              stack: err.stack
+            }
+          ],
+          totalTests: 1,
+          passedTests: 0,
+          failedTests: 1,
+          skippedTests: 0
+        });
       });
-    }
-    const plan = {
-      schemaVersion: 1,
-      id: `plan-${Date.now()}`,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      rootDirectory: this.cwd,
-      channel: options.channel || "stable",
-      packages: packagePlans,
-      publishOrder,
-      summary: {
-        totalPackages: packagePlans.length,
-        bumpedPackages: packagePlans.filter((p) => p.bump !== "none").length,
-        majorBumps: packagePlans.filter((p) => p.bump === "major").length,
-        minorBumps: packagePlans.filter((p) => p.bump === "minor").length,
-        patchBumps: packagePlans.filter((p) => p.bump === "patch").length,
-        noneBumps: packagePlans.filter((p) => p.bump === "none").length
-      }
-    };
-    return { plan, evidenceMap };
+    });
   }
-  async runPlanCommand(options = {}) {
-    const { plan } = await this.createPlan(options);
-    if (options.json) {
-      console.log(JSON.stringify(plan, null, 2));
-      return plan;
-    }
-    this.printPlan(plan);
+};
+
+// ../test-adapter/dist/test-suite-analyzer.js
+import { readFile as readFile6, readdir as readdir4 } from "fs/promises";
+import { join as join12 } from "path";
+var TestSuiteAnalyzer = class {
+  name = "test-suite-analyzer";
+  adapters;
+  timeoutMs;
+  constructor(options) {
+    this.adapters = [
+      ...options?.adapters ?? [],
+      new CommandTestAdapter()
+      // always available as lowest-confidence fallback
+    ];
+    this.timeoutMs = options?.timeout ?? 12e4;
+  }
+  async analyze(context) {
+    const { packageName, packagePath } = context;
+    let manifest;
     try {
-      const verelDir = join10(this.cwd, ".verelease");
-      await mkdir5(verelDir, { recursive: true });
-      await writeFile5(
-        join10(verelDir, "release-plan.json"),
-        JSON.stringify(plan, null, 2),
-        "utf8"
-      );
+      const raw = await readFile6(join12(packagePath, "package.json"), "utf8");
+      manifest = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+    const scripts = manifest.scripts || {};
+    if (!scripts.test) {
+      return [];
+    }
+    let files;
+    try {
+      const entries = await readdir4(packagePath, { recursive: true });
+      files = entries.map(String);
+    } catch {
+      files = [];
+    }
+    const detectionCtx = { packagePath, manifest, files };
+    const best = await this.detectBestAdapter(detectionCtx);
+    if (!best) {
+      return [];
+    }
+    let testRun;
+    try {
+      testRun = await best.adapter.run({
+        packagePath,
+        targetPackageName: packageName,
+        timeoutMs: this.timeoutMs
+      });
+    } catch (error) {
+      return [
+        {
+          id: `test.suite.error:${packageName}`,
+          package: packageName,
+          source: "test",
+          severity: "major",
+          confidence: 0.7,
+          title: "Test suite failed to execute",
+          description: `Test runner "${best.adapter.name}" crashed: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ];
+    }
+    return this.convertToEvidence(packageName, testRun, best.adapter.name);
+  }
+  async detectBestAdapter(ctx) {
+    const candidates = [];
+    for (const adapter of this.adapters) {
+      try {
+        const detection = await adapter.detect(ctx);
+        if (detection.supported) {
+          candidates.push({ adapter, detection });
+        }
+      } catch {
+      }
+    }
+    if (candidates.length === 0)
+      return null;
+    candidates.sort((a, b) => b.detection.confidence - a.detection.confidence);
+    return candidates[0];
+  }
+  convertToEvidence(packageName, testRun, adapterName) {
+    if (testRun.totalTests === 0) {
+      return [];
+    }
+    if (testRun.success) {
+      return [
+        {
+          id: `test.suite.pass:${packageName}`,
+          package: packageName,
+          source: "test",
+          severity: "patch",
+          confidence: 0.9,
+          title: `Test suite passed (${testRun.passedTests}/${testRun.totalTests} tests)`,
+          description: `All ${testRun.totalTests} tests passed via ${adapterName} in ${testRun.durationMs}ms. Code changes are confirmed compatible.`,
+          metadata: {
+            adapter: adapterName,
+            total: testRun.totalTests,
+            passed: testRun.passedTests,
+            failed: testRun.failedTests,
+            skipped: testRun.skippedTests,
+            durationMs: testRun.durationMs
+          }
+        }
+      ];
+    }
+    const failedSuites = testRun.suites.filter((s) => s.status === "failed");
+    const failedTests = failedSuites.flatMap((s) => s.tests.filter((t) => t.status === "failed"));
+    const failureMessages = failedTests.slice(0, 5).map((t) => `  - ${t.name}: ${t.failure?.message ?? "unknown failure"}`).join("\n");
+    return [
+      {
+        id: `test.suite.fail:${packageName}`,
+        package: packageName,
+        source: "test",
+        severity: "major",
+        confidence: 0.85,
+        title: `Test suite failed (${testRun.failedTests}/${testRun.totalTests} tests failed)`,
+        description: `${testRun.failedTests} tests failed via ${adapterName}:
+${failureMessages}`,
+        metadata: {
+          adapter: adapterName,
+          total: testRun.totalTests,
+          passed: testRun.passedTests,
+          failed: testRun.failedTests,
+          skipped: testRun.skippedTests,
+          durationMs: testRun.durationMs
+        }
+      }
+    ];
+  }
+};
+
+// ../test-adapter-vitest/dist/vitest.js
+import { spawn as spawn4 } from "child_process";
+var VitestTestAdapter = class {
+  name = "vitest";
+  async detect(ctx) {
+    const scripts = ctx.manifest.scripts || {};
+    const devDeps = ctx.manifest.devDependencies || {};
+    const deps = ctx.manifest.dependencies || {};
+    const hasVitestDep = !!devDeps.vitest || !!deps.vitest;
+    const hasVitestScript = Object.values(scripts).some((s) => s.includes("vitest"));
+    const hasVitestConfig = ctx.files.some((f) => f.includes("vitest.config"));
+    if (hasVitestConfig || hasVitestScript) {
+      return { supported: true, confidence: 0.95 };
+    }
+    if (hasVitestDep) {
+      return { supported: true, confidence: 0.8 };
+    }
+    return { supported: false, confidence: 0 };
+  }
+  async run(ctx) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    const command = ["npx", "vitest", "run", "--reporter=json", ...ctx.testFiles || []];
+    return new Promise((resolve3) => {
+      const child = spawn4(command[0], command.slice(1), {
+        cwd: ctx.packagePath,
+        env: {
+          ...process.env,
+          ...ctx.env,
+          ...ctx.isolatedNodeModulesPath ? { NODE_PATH: ctx.isolatedNodeModulesPath } : {}
+        },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("close", (code) => {
+        const durationMs = Date.now() - startTime;
+        const normalized = this.parseJsonOutput(stdout, stderr, code === 0, durationMs, startedAt, command);
+        resolve3(normalized);
+      });
+      child.on("error", (err) => {
+        resolve3({
+          adapter: this.name,
+          runtime: process.version,
+          command,
+          startedAt,
+          durationMs: Date.now() - startTime,
+          success: false,
+          suites: [],
+          diagnostics: [{ severity: "error", message: err.message, stack: err.stack }],
+          totalTests: 1,
+          passedTests: 0,
+          failedTests: 1,
+          skippedTests: 0
+        });
+      });
+    });
+  }
+  parseJsonOutput(stdout, stderr, overallSuccess, durationMs, startedAt, command) {
+    try {
+      const jsonStart = stdout.indexOf("{");
+      const jsonEnd = stdout.lastIndexOf("}");
+      if (jsonStart !== -1 && jsonEnd !== -1) {
+        const jsonStr = stdout.slice(jsonStart, jsonEnd + 1);
+        const parsed = JSON.parse(jsonStr);
+        const suites = (parsed.testResults || []).map((tr) => {
+          const tests = (tr.assertionResults || []).map((ar) => ({
+            name: ar.title || ar.fullName,
+            status: ar.status === "passed" ? "passed" : ar.status === "pending" ? "skipped" : "failed",
+            durationMs: ar.duration,
+            failure: ar.status === "failed" ? {
+              message: ar.failureMessages?.join("\n") || "Assertion failed"
+            } : void 0
+          }));
+          return {
+            name: tr.name,
+            file: tr.name,
+            status: tr.status === "passed" ? "passed" : "failed",
+            durationMs: tr.endTime - tr.startTime,
+            tests
+          };
+        });
+        const totalTests = parsed.numTotalTests || suites.reduce((acc, s) => acc + s.tests.length, 0);
+        const passedTests = parsed.numPassedTests || suites.reduce((acc, s) => acc + s.tests.filter((t) => t.status === "passed").length, 0);
+        const failedTests = parsed.numFailedTests || suites.reduce((acc, s) => acc + s.tests.filter((t) => t.status === "failed").length, 0);
+        const skippedTests = parsed.numPendingTests || 0;
+        return {
+          adapter: this.name,
+          runtime: process.version,
+          command,
+          startedAt,
+          durationMs,
+          success: overallSuccess && failedTests === 0,
+          suites,
+          diagnostics: stderr.trim() ? [{ severity: "warning", message: stderr.trim() }] : [],
+          totalTests,
+          passedTests,
+          failedTests,
+          skippedTests
+        };
+      }
+    } catch {
+    }
+    return {
+      adapter: this.name,
+      runtime: process.version,
+      command,
+      startedAt,
+      durationMs,
+      success: overallSuccess,
+      suites: [
+        {
+          name: "vitest-suite",
+          status: overallSuccess ? "passed" : "failed",
+          durationMs,
+          tests: [
+            {
+              name: "vitest execution",
+              status: overallSuccess ? "passed" : "failed",
+              durationMs,
+              failure: overallSuccess ? void 0 : { message: stderr || stdout || "Vitest run failed" }
+            }
+          ]
+        }
+      ],
+      diagnostics: stderr.trim() ? [{ severity: "warning", message: stderr.trim() }] : [],
+      totalTests: 1,
+      passedTests: overallSuccess ? 1 : 0,
+      failedTests: overallSuccess ? 0 : 1,
+      skippedTests: 0
+    };
+  }
+};
+
+// ../test-adapter-jest/dist/jest.js
+import { spawn as spawn5 } from "child_process";
+var JestTestAdapter = class {
+  name = "jest";
+  async detect(ctx) {
+    const scripts = ctx.manifest.scripts || {};
+    const devDeps = ctx.manifest.devDependencies || {};
+    const deps = ctx.manifest.dependencies || {};
+    const hasJest = !!devDeps.jest || !!deps.jest || !!devDeps["@types/jest"];
+    const hasRtl = !!devDeps["@testing-library/react"] || !!deps["@testing-library/react"];
+    const hasJestScript = Object.values(scripts).some((s) => s.includes("jest"));
+    const hasJestConfig = ctx.files.some((f) => f.includes("jest.config"));
+    if (hasJestConfig || hasJestScript) {
+      return { supported: true, confidence: 0.95 };
+    }
+    if (hasJest || hasRtl) {
+      return { supported: true, confidence: 0.85 };
+    }
+    return { supported: false, confidence: 0 };
+  }
+  async run(ctx) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    const command = ["npx", "jest", "--json", ...ctx.testFiles || []];
+    return new Promise((resolve3) => {
+      const child = spawn5(command[0], command.slice(1), {
+        cwd: ctx.packagePath,
+        env: {
+          ...process.env,
+          ...ctx.env,
+          ...ctx.isolatedNodeModulesPath ? { NODE_PATH: ctx.isolatedNodeModulesPath } : {}
+        },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("close", (code) => {
+        const durationMs = Date.now() - startTime;
+        const normalized = this.parseJsonOutput(stdout, stderr, code === 0, durationMs, startedAt, command);
+        resolve3(normalized);
+      });
+      child.on("error", (err) => {
+        resolve3({
+          adapter: this.name,
+          runtime: process.version,
+          command,
+          startedAt,
+          durationMs: Date.now() - startTime,
+          success: false,
+          suites: [],
+          diagnostics: [{ severity: "error", message: err.message, stack: err.stack }],
+          totalTests: 1,
+          passedTests: 0,
+          failedTests: 1,
+          skippedTests: 0
+        });
+      });
+    });
+  }
+  parseJsonOutput(stdout, stderr, overallSuccess, durationMs, startedAt, command) {
+    try {
+      const jsonStart = stdout.indexOf("{");
+      const jsonEnd = stdout.lastIndexOf("}");
+      if (jsonStart !== -1 && jsonEnd !== -1) {
+        const parsed = JSON.parse(stdout.slice(jsonStart, jsonEnd + 1));
+        const suites = (parsed.testResults || []).map((tr) => {
+          const tests = (tr.assertionResults || []).map((ar) => ({
+            name: ar.title || ar.fullName,
+            status: ar.status === "passed" ? "passed" : ar.status === "pending" ? "skipped" : "failed",
+            durationMs: ar.duration,
+            failure: ar.status === "failed" ? {
+              message: ar.failureMessages?.join("\n") || "Assertion failed"
+            } : void 0
+          }));
+          return {
+            name: tr.name,
+            file: tr.name,
+            status: tr.status === "passed" ? "passed" : "failed",
+            durationMs: tr.endTime - tr.startTime,
+            tests
+          };
+        });
+        const totalTests = parsed.numTotalTests || suites.reduce((acc, s) => acc + s.tests.length, 0);
+        const passedTests = parsed.numPassedTests || 0;
+        const failedTests = parsed.numFailedTests || 0;
+        const skippedTests = parsed.numPendingTests || 0;
+        return {
+          adapter: this.name,
+          runtime: process.version,
+          command,
+          startedAt,
+          durationMs,
+          success: overallSuccess && failedTests === 0,
+          suites,
+          diagnostics: stderr.trim() ? [{ severity: "warning", message: stderr.trim() }] : [],
+          totalTests,
+          passedTests,
+          failedTests,
+          skippedTests
+        };
+      }
+    } catch {
+    }
+    return {
+      adapter: this.name,
+      runtime: process.version,
+      command,
+      startedAt,
+      durationMs,
+      success: overallSuccess,
+      suites: [
+        {
+          name: "jest-suite",
+          status: overallSuccess ? "passed" : "failed",
+          durationMs,
+          tests: [
+            {
+              name: "jest execution",
+              status: overallSuccess ? "passed" : "failed",
+              durationMs,
+              failure: overallSuccess ? void 0 : { message: stderr || stdout || "Jest execution failed" }
+            }
+          ]
+        }
+      ],
+      diagnostics: stderr.trim() ? [{ severity: "warning", message: stderr.trim() }] : [],
+      totalTests: 1,
+      passedTests: overallSuccess ? 1 : 0,
+      failedTests: overallSuccess ? 0 : 1,
+      skippedTests: 0
+    };
+  }
+};
+
+// ../test-adapter-bun/dist/bun.js
+import { spawn as spawn6 } from "child_process";
+var BunTestAdapter = class {
+  name = "bun:test";
+  async detect(ctx) {
+    const scripts = ctx.manifest.scripts || {};
+    const hasBunLock = ctx.files.some((f) => f === "bun.lock" || f === "bun.lockb");
+    const hasBunScript = Object.values(scripts).some((s) => s.includes("bun test"));
+    if (hasBunLock || hasBunScript) {
+      return { supported: true, confidence: 0.9 };
+    }
+    return { supported: false, confidence: 0 };
+  }
+  async run(ctx) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    const command = ["bun", "test", ...ctx.testFiles || []];
+    return new Promise((resolve3) => {
+      const child = spawn6(command[0], command.slice(1), {
+        cwd: ctx.packagePath,
+        env: {
+          ...process.env,
+          ...ctx.env,
+          ...ctx.isolatedNodeModulesPath ? { NODE_PATH: ctx.isolatedNodeModulesPath } : {}
+        },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("close", (code) => {
+        const durationMs = Date.now() - startTime;
+        const normalized = this.parseOutput(stdout, stderr, code === 0, durationMs, startedAt, command);
+        resolve3(normalized);
+      });
+      child.on("error", (err) => {
+        resolve3({
+          adapter: this.name,
+          runtime: "bun",
+          command,
+          startedAt,
+          durationMs: Date.now() - startTime,
+          success: false,
+          suites: [],
+          diagnostics: [{ severity: "error", message: err.message, stack: err.stack }],
+          totalTests: 1,
+          passedTests: 0,
+          failedTests: 1,
+          skippedTests: 0
+        });
+      });
+    });
+  }
+  parseOutput(stdout, stderr, overallSuccess, durationMs, startedAt, command) {
+    const combined = stdout + "\n" + stderr;
+    const lines = combined.split("\n");
+    const testCases = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("\u2713 ") || trimmed.startsWith("(pass)")) {
+        const name = trimmed.replace(/^(✓|\(pass\))\s*/, "").replace(/\[.*?\]$/, "").trim();
+        testCases.push({ name, status: "passed" });
+      } else if (trimmed.startsWith("\u2717 ") || trimmed.startsWith("(fail)")) {
+        const name = trimmed.replace(/^(✗|\(fail\))\s*/, "").replace(/\[.*?\]$/, "").trim();
+        testCases.push({ name, status: "failed", failure: { message: "Bun test failure" } });
+      }
+    }
+    if (testCases.length === 0) {
+      testCases.push({
+        name: "bun test execution",
+        status: overallSuccess ? "passed" : "failed",
+        durationMs,
+        failure: overallSuccess ? void 0 : { message: stderr || stdout || "Bun execution failed" }
+      });
+    }
+    const passed = testCases.filter((t) => t.status === "passed").length;
+    const failed = testCases.filter((t) => t.status === "failed").length;
+    const suite = {
+      name: "bun:test",
+      status: failed === 0 && overallSuccess ? "passed" : "failed",
+      durationMs,
+      tests: testCases
+    };
+    return {
+      adapter: this.name,
+      runtime: "bun",
+      command,
+      startedAt,
+      durationMs,
+      success: overallSuccess && failed === 0,
+      suites: [suite],
+      diagnostics: stderr.trim() ? [{ severity: "warning", message: stderr.trim() }] : [],
+      totalTests: testCases.length,
+      passedTests: passed,
+      failedTests: failed,
+      skippedTests: 0
+    };
+  }
+};
+
+// ../test-adapter-deno/dist/deno.js
+import { spawn as spawn7 } from "child_process";
+var DenoTestAdapter = class {
+  name = "deno:test";
+  async detect(ctx) {
+    const scripts = ctx.manifest.scripts || {};
+    const hasDenoJson = ctx.files.some((f) => f === "deno.json" || f === "deno.jsonc");
+    const hasDenoScript = Object.values(scripts).some((s) => s.includes("deno test"));
+    if (hasDenoJson || hasDenoScript) {
+      return { supported: true, confidence: 0.95 };
+    }
+    return { supported: false, confidence: 0 };
+  }
+  async run(ctx) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    const command = ["deno", "test", "--allow-all", ...ctx.testFiles || []];
+    return new Promise((resolve3) => {
+      const child = spawn7(command[0], command.slice(1), {
+        cwd: ctx.packagePath,
+        env: {
+          ...process.env,
+          ...ctx.env
+        },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.on("close", (code) => {
+        const durationMs = Date.now() - startTime;
+        const normalized = this.parseOutput(stdout, stderr, code === 0, durationMs, startedAt, command);
+        resolve3(normalized);
+      });
+      child.on("error", (err) => {
+        resolve3({
+          adapter: this.name,
+          runtime: "deno",
+          command,
+          startedAt,
+          durationMs: Date.now() - startTime,
+          success: false,
+          suites: [],
+          diagnostics: [{ severity: "error", message: err.message, stack: err.stack }],
+          totalTests: 1,
+          passedTests: 0,
+          failedTests: 1,
+          skippedTests: 0
+        });
+      });
+    });
+  }
+  parseOutput(stdout, stderr, overallSuccess, durationMs, startedAt, command) {
+    const combined = stdout + "\n" + stderr;
+    const lines = combined.split("\n");
+    const testCases = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("test ") && (trimmed.endsWith("ok") || trimmed.includes("... ok"))) {
+        const name = trimmed.replace(/^test\s+/, "").replace(/\s*\.\.\.\s*ok.*$/, "").trim();
+        testCases.push({ name, status: "passed" });
+      } else if (trimmed.startsWith("test ") && (trimmed.includes("FAILED") || trimmed.endsWith("FAILED"))) {
+        const name = trimmed.replace(/^test\s+/, "").replace(/\s*\.\.\.\s*FAILED.*$/, "").trim();
+        testCases.push({ name, status: "failed", failure: { message: "Deno test failure" } });
+      }
+    }
+    if (testCases.length === 0) {
+      testCases.push({
+        name: "deno test execution",
+        status: overallSuccess ? "passed" : "failed",
+        durationMs,
+        failure: overallSuccess ? void 0 : { message: stderr || stdout || "Deno execution failed" }
+      });
+    }
+    const passed = testCases.filter((t) => t.status === "passed").length;
+    const failed = testCases.filter((t) => t.status === "failed").length;
+    const suite = {
+      name: "deno:test",
+      status: failed === 0 && overallSuccess ? "passed" : "failed",
+      durationMs,
+      tests: testCases
+    };
+    return {
+      adapter: this.name,
+      runtime: "deno",
+      command,
+      startedAt,
+      durationMs,
+      success: overallSuccess && failed === 0,
+      suites: [suite],
+      diagnostics: stderr.trim() ? [{ severity: "warning", message: stderr.trim() }] : [],
+      totalTests: testCases.length,
+      passedTests: passed,
+      failedTests: failed,
+      skippedTests: 0
+    };
+  }
+};
+
+// src/cli.ts
+import semver4 from "semver";
+async function promptConfirm(question, defaultYes = false) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    if (!answer) return defaultYes;
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+var VereleaseCli = class {
+  cwd;
+  constructor(options = {}) {
+    this.cwd = resolve2(options.cwd || process.cwd());
+  }
+  async createPlan(options = {}) {
+    const config = await loadConfig(this.cwd);
+    const resolver = new DefaultWorkspaceResolver();
+    const discovery = await resolver.resolve(this.cwd);
+    const contractStore = new FileContractStore(
+      join13(this.cwd, config.contracts?.directory || ".verelease/contracts")
+    );
+    const contractAnalyzer = new ContractCompatibilityAnalyzer(contractStore);
+    const apiDiffAnalyzer = new ApiDiffAnalyzer();
+    const baselineFetcher = new BaselineFetcher();
+    const testSuiteAnalyzer = config.tests?.skip ? null : new TestSuiteAnalyzer({
+      adapters: [
+        new VitestTestAdapter(),
+        new JestTestAdapter(),
+        new NodeTestAdapter(),
+        new BunTestAdapter(),
+        new DenoTestAdapter()
+      ],
+      timeout: config.tests?.timeout ?? 12e4
+    });
+    const semverEngine = new DefaultSemVerDecisionEngine();
+    const npmPublisher = new NpmPublishProvider();
+    const evidenceMap = /* @__PURE__ */ new Map();
+    const initialBumps = /* @__PURE__ */ new Map();
+    const baselineTmpDir = await mkdtemp5(join13(tmpdir5(), "verelease-baseline-"));
+    try {
+      for (const pkg of discovery.packages) {
+        const evidence = [];
+        try {
+          const contractEv = await contractAnalyzer.analyze({
+            packageName: pkg.name,
+            packagePath: pkg.directory,
+            currentVersion: pkg.version
+          });
+          evidence.push(...contractEv);
+        } catch {
+        }
+        let baselineResult = null;
+        try {
+          if (!pkg.isPrivate) {
+            baselineResult = await baselineFetcher.fetch(pkg.name, baselineTmpDir);
+          }
+        } catch {
+        }
+        try {
+          const apiEv = await apiDiffAnalyzer.analyze({
+            packageName: pkg.name,
+            packagePath: pkg.directory,
+            currentVersion: pkg.version,
+            baselinePath: baselineResult?.entryPointPath,
+            previousVersion: baselineResult?.version
+          });
+          evidence.push(...apiEv);
+        } catch {
+        }
+        if (testSuiteAnalyzer) {
+          try {
+            const testEv = await testSuiteAnalyzer.analyze({
+              packageName: pkg.name,
+              packagePath: pkg.directory,
+              currentVersion: pkg.version
+            });
+            evidence.push(...testEv);
+          } catch {
+          }
+        }
+        evidenceMap.set(pkg.name, evidence);
+        const decision = semverEngine.evaluate(
+          pkg.name,
+          pkg.version,
+          evidence,
+          config.versioning,
+          options.channel || "stable"
+        );
+        const forced = options.forceBump?.[pkg.name] || options.defaultBump;
+        let bump = forced || decision.bump;
+        let proposedVersion = decision.proposedVersion;
+        const reasons = [...decision.reasons];
+        if (forced && decision.bump === "none") {
+          const channel = options.channel || config.versioning?.channel || "stable";
+          if (channel !== "stable") {
+            const baseBump = `pre${forced}`;
+            proposedVersion = semver4.inc(pkg.version, baseBump, channel) || pkg.version;
+          } else {
+            proposedVersion = semver4.inc(pkg.version, forced) || pkg.version;
+          }
+          reasons.push(`Bump manually requested (${forced}) for channel ${channel}`);
+        }
+        if (!pkg.isPrivate) {
+          try {
+            const publishedVersions = await npmPublisher.getPublishedVersions(pkg.name);
+            const channel = options.channel || config.versioning?.channel || "stable";
+            if (publishedVersions.includes(proposedVersion) || bump !== "none" && publishedVersions.includes(pkg.version)) {
+              reasons.push(`Version ${proposedVersion} is already published on npm registry.`);
+              let nextCandidate = proposedVersion;
+              if (channel !== "stable") {
+                const baseBump = bump === "none" ? "patch" : bump;
+                const parsed = semver4.parse(pkg.version);
+                if (parsed.prerelease.length > 0 && parsed.prerelease[0] === channel) {
+                  nextCandidate = semver4.inc(pkg.version, "prerelease", channel) || pkg.version;
+                } else {
+                  nextCandidate = semver4.inc(pkg.version, `pre${baseBump}`, channel) || pkg.version;
+                }
+                while (publishedVersions.includes(nextCandidate)) {
+                  nextCandidate = semver4.inc(nextCandidate, "prerelease", channel) || nextCandidate;
+                }
+              } else {
+                const baseBump = bump === "none" ? "patch" : bump;
+                nextCandidate = semver4.inc(pkg.version, baseBump) || pkg.version;
+                while (publishedVersions.includes(nextCandidate)) {
+                  nextCandidate = semver4.inc(nextCandidate, "patch") || nextCandidate;
+                }
+              }
+              proposedVersion = nextCandidate;
+              bump = bump === "none" ? "patch" : bump;
+              reasons.push(`Automatically resolved next available registry version: ${proposedVersion}`);
+            }
+          } catch {
+          }
+        }
+        initialBumps.set(pkg.name, {
+          name: pkg.name,
+          currentVersion: pkg.version,
+          proposedVersion,
+          bump,
+          reasons
+        });
+      }
+    } finally {
+      await rm4(baselineTmpDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    const propagator = new VersionPropagator(discovery.graph);
+    const { bumps: finalBumps, dependencyUpdates } = propagator.propagate(initialBumps);
+    const publishOrder = discovery.graph.getTopologicalOrder();
+    const packagePlans = [];
+    for (const pkgName of publishOrder) {
+      const pkg = discovery.packages.find((p) => p.name === pkgName);
+      if (!pkg) continue;
+      const bumpTarget = finalBumps.get(pkgName);
+      const evidence = evidenceMap.get(pkgName) || [];
+      const depUpdates = dependencyUpdates.get(pkgName) || [];
+      const decision = semverEngine.evaluate(
+        pkg.name,
+        pkg.version,
+        evidence,
+        config.versioning,
+        options.channel || "stable"
+      );
+      packagePlans.push({
+        name: pkg.name,
+        directory: pkg.directory,
+        currentVersion: pkg.version,
+        proposedVersion: bumpTarget.proposedVersion,
+        bump: bumpTarget.bump,
+        channel: options.channel || "stable",
+        evidence,
+        reasons: bumpTarget.reasons,
+        confidence: decision.confidence,
+        requiresApproval: decision.requiresApproval,
+        dependentUpdates: depUpdates.map((d) => ({
+          dependentName: pkgName,
+          dependencyName: d.dependencyName,
+          dependencyType: d.type,
+          previousRange: d.previousRange,
+          newRange: d.newRange
+        })),
+        filesToUpdate: [pkg.manifestPath],
+        publish: !pkg.isPrivate && bumpTarget.bump !== "none"
+      });
+    }
+    const plan = {
+      schemaVersion: 1,
+      id: `plan-${Date.now()}`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      rootDirectory: this.cwd,
+      channel: options.channel || "stable",
+      packages: packagePlans,
+      publishOrder,
+      summary: {
+        totalPackages: packagePlans.length,
+        bumpedPackages: packagePlans.filter((p) => p.bump !== "none").length,
+        majorBumps: packagePlans.filter((p) => p.bump === "major").length,
+        minorBumps: packagePlans.filter((p) => p.bump === "minor").length,
+        patchBumps: packagePlans.filter((p) => p.bump === "patch").length,
+        noneBumps: packagePlans.filter((p) => p.bump === "none").length
+      }
+    };
+    return { plan, evidenceMap };
+  }
+  async runPlanCommand(options = {}) {
+    const { plan } = await this.createPlan(options);
+    if (options.json) {
+      console.log(JSON.stringify(plan, null, 2));
+      return plan;
+    }
+    this.printPlan(plan);
+    try {
+      const verelDir = join13(this.cwd, ".verelease");
+      await mkdir6(verelDir, { recursive: true });
+      await writeFile5(
+        join13(verelDir, "release-plan.json"),
+        JSON.stringify(plan, null, 2),
+        "utf8"
+      );
     } catch {
     }
     return plan;
@@ -2134,6 +3021,20 @@ var VereleaseCli = class {
       console.log("\n\u2728 No packages require release.");
       return;
     }
+    const publishable = plan.packages.filter((p) => p.publish && p.bump !== "none");
+    const internalBumps = plan.packages.filter((p) => !p.publish && p.bump !== "none");
+    const promptDescription = publishable.length > 0 ? `publishing ${publishable.map((p) => `${p.name}@${p.proposedVersion}`).join(", ")}` + (internalBumps.length > 0 ? ` and bumping ${internalBumps.length} internal package(s)` : "") : `bumping ${internalBumps.length} internal package(s)`;
+    const shouldPrompt = !options.dryRun && !options.yes && !process.env.CI && process.stdin.isTTY;
+    if (shouldPrompt) {
+      const confirmed = await promptConfirm(
+        `
+? Proceed with ${promptDescription}? [y/N] `
+      );
+      if (!confirmed) {
+        console.log("\n\u274C Release cancelled by user. No manifests, lockfiles, or packages were modified.\n");
+        return;
+      }
+    }
     const mutator = new TransactionalManifestMutator();
     const lockfileAdapter = new AutoLockfileAdapter();
     const npmPublisher = new NpmPublishProvider();
@@ -2165,10 +3066,10 @@ var VereleaseCli = class {
           newVersion: pkgPlan.proposedVersion,
           evidence
         });
-        const changelogPath = join10(pkgPlan.directory, "CHANGELOG.md");
+        const changelogPath = join13(pkgPlan.directory, "CHANGELOG.md");
         let existingChangelog = null;
         try {
-          existingChangelog = await readFile5(changelogPath, "utf8");
+          existingChangelog = await readFile7(changelogPath, "utf8");
         } catch {
           existingChangelog = null;
         }
@@ -2189,9 +3090,9 @@ ${existingChangelog || ""}`.trim() + "\n",
             newVersion: pkgPlan.proposedVersion,
             breakingChanges: breakingEvidence
           });
-          const migrationsDir = join10(pkgPlan.directory, "docs", "migrations");
-          await mkdir5(migrationsDir, { recursive: true });
-          const guidePath = join10(
+          const migrationsDir = join13(pkgPlan.directory, "docs", "migrations");
+          await mkdir6(migrationsDir, { recursive: true });
+          const guidePath = join13(
             migrationsDir,
             `${pkgPlan.currentVersion.split(".")[0]}-to-${pkgPlan.proposedVersion.split(".")[0]}.md`
           );
@@ -2292,6 +3193,151 @@ ${existingChangelog || ""}`.trim() + "\n",
       }
     }
   }
+  async runGuideCommand(options = {}) {
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            name: "verelease",
+            description: "Compatibility-aware SemVer release engine",
+            rules: [
+              "Never manually edit 'version' in package.json",
+              "SemVer bumps are calculated from contract tests, API diffs, and dependency ranges",
+              "Pass --yes to bypass interactive prompts in CI"
+            ],
+            commands: {
+              plan: "verel plan [--channel <channel>] [--json]",
+              release: "verel release [--channel <channel>] [-y, --yes]",
+              explain: "verel explain <pkg>",
+              guide: "verel guide [--json]",
+              init: "verel init"
+            },
+            configuration: "verelease.config.ts",
+            contractsDirectory: ".verelease/contracts",
+            channels: ["stable", "alpha", "beta", "rc"]
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(`
+# Verelease Agent Guide
+
+Verelease is an evidence-based SemVer release engine for JavaScript & TypeScript.
+
+## Core Rules for AI Coding Agents
+1. **NEVER manually edit "version" in package.json**: Always let Verelease determine versions.
+2. **Inspect first**: Run \`pnpm verel plan\` to preview proposed version bumps without modifying files.
+3. **Diagnose bumps**: Run \`pnpm verel explain <pkg>\` to understand the evidence behind any bump.
+4. **Automated releases**: In CI or automated workflows, run \`pnpm verel release --yes\` to bypass prompts.
+5. **Interactive releases**: When run locally, Verelease asks for [y/N] confirmation and supports Touch ID / WebAuthn.
+
+## Command Reference
+- \`pnpm verel plan\`                     Preview release plan for stable channel
+- \`pnpm verel plan --channel alpha\`     Preview pre-release bumps for alpha channel
+- \`pnpm verel release\`                  Interactive release pipeline
+- \`pnpm verel release -y\`               Non-interactive release (for agents/CI)
+- \`pnpm verel explain <package>\`        Inspect compatibility evidence and decision reasons
+- \`pnpm verel init\`                     Initialize config, contracts, and AGENTS.md
+
+## Configuration
+Config is loaded from \`verelease.config.ts\` or \`verelease.config.js\`.
+Contract test suites live in \`.verelease/contracts/\`.
+`);
+  }
+  async runInitCommand(options = {}) {
+    const configPath = join13(this.cwd, "verelease.config.ts");
+    const contractsDir = join13(this.cwd, ".verelease", "contracts");
+    const agentsPath = join13(this.cwd, "AGENTS.md");
+    const pkgJsonPath = join13(this.cwd, "package.json");
+    console.log("\n\u{1F680} Initializing Verelease in current project...\n");
+    if (!existsSync(configPath)) {
+      const sampleConfig = `import { defineConfig } from "verelease/config";
+
+export default defineConfig({
+  policy: {
+    defaultChannel: "stable",
+    channels: {
+      stable: { distTag: "latest", prerelease: false },
+      alpha: { distTag: "alpha", prerelease: true },
+      beta: { distTag: "beta", prerelease: true },
+      rc: { distTag: "rc", prerelease: true },
+    },
+  },
+  contracts: {
+    directory: ".verelease/contracts",
+    failOnBreaking: true,
+  },
+  publish: {
+    access: "public",
+  },
+});
+`;
+      await writeFile5(configPath, sampleConfig, "utf8");
+      console.log("  \u2713 Created verelease.config.ts");
+    } else {
+      console.log("  \u2022 verelease.config.ts already exists");
+    }
+    if (!existsSync(contractsDir)) {
+      await mkdir6(contractsDir, { recursive: true });
+      await writeFile5(
+        join13(contractsDir, "README.md"),
+        "# Verelease Contracts\n\nPlace consumer-driven contract definitions (.json or .yaml) here.\n",
+        "utf8"
+      );
+      console.log("  \u2713 Created .verelease/contracts/");
+    } else {
+      console.log("  \u2022 .verelease/contracts/ already exists");
+    }
+    const agentGuidance = `
+## Releases & Versioning (Verelease)
+This repository uses [Verelease](https://github.com/ivanjeremic/verelease) for automated, evidence-based SemVer releases.
+- Run \`pnpm verel plan\` to inspect proposed version bumps without modifying files.
+- Run \`pnpm verel explain <pkg>\` to understand why a specific bump was determined.
+- Run \`pnpm verel release --channel <alpha|stable>\` to release.
+- In CI or automated agent tasks, use \`pnpm verel release --yes\`.
+- **NEVER manually edit "version" in package.json.**
+`;
+    if (!existsSync(agentsPath)) {
+      await writeFile5(agentsPath, `# Agent Guidelines
+${agentGuidance}
+`, "utf8");
+      console.log("  \u2713 Created AGENTS.md with Verelease instructions");
+    } else {
+      const currentContent = await readFile7(agentsPath, "utf8");
+      if (!currentContent.includes("Verelease")) {
+        await writeFile5(agentsPath, `${currentContent.trim()}
+${agentGuidance}
+`, "utf8");
+        console.log("  \u2713 Appended Verelease instructions to AGENTS.md");
+      } else {
+        console.log("  \u2022 AGENTS.md already contains Verelease instructions");
+      }
+    }
+    if (existsSync(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(await readFile7(pkgJsonPath, "utf8"));
+        pkg.scripts = pkg.scripts || {};
+        let modified = false;
+        if (!pkg.scripts.plan) {
+          pkg.scripts.plan = "verelease plan";
+          modified = true;
+        }
+        if (!pkg.scripts.release) {
+          pkg.scripts.release = "verelease release";
+          modified = true;
+        }
+        if (modified) {
+          await writeFile5(pkgJsonPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+          console.log("  \u2713 Added 'plan' and 'release' scripts to package.json");
+        }
+      } catch {
+      }
+    }
+    console.log("\n\u2728 Verelease successfully initialized!\n");
+  }
   printPlan(plan) {
     console.log(`
 \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
@@ -2324,10 +3370,34 @@ ${existingChangelog || ""}`.trim() + "\n",
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0] || "plan";
+  if (args.includes("--help") || args.includes("-h") || command === "help") {
+    console.log(`
+Usage: verelease [command] [options]
+
+Commands:
+  plan              Preview the release plan without making changes (default)
+  release           Apply version bumps, generate changelogs, and publish
+  explain <pkg>     Explain compatibility evidence and bump decision for a package
+  guide             Show agent-optimized cheat sheet and machine-readable instructions
+  init              Initialize verelease.config.ts, contracts, and AGENTS.md
+
+Options:
+  --channel <name>  Release channel (e.g. stable, alpha, beta, rc) [default: stable]
+  --bump <type>     Manual bump override (patch | minor | major)
+  --dry-run         Simulate pipeline without modifying manifests or publishing
+  -y, --yes         Skip interactive confirmation prompt
+  --otp <code>      One-time password for npm 2FA
+  --tag             Create git commit and tags for release
+  --json            Output machine-readable JSON
+  -h, --help        Show this help message
+`);
+    return;
+  }
   const options = {
     dryRun: args.includes("--dry-run"),
     json: args.includes("--json"),
-    tag: args.includes("--tag")
+    tag: args.includes("--tag"),
+    yes: args.includes("--yes") || args.includes("-y")
   };
   const channelIdx = args.indexOf("--channel");
   if (channelIdx !== -1 && args[channelIdx + 1]) {
@@ -2357,6 +3427,12 @@ async function main() {
       case "version":
         await cli.runReleaseCommand({ ...options, dryRun: false });
         break;
+      case "guide":
+        await cli.runGuideCommand(options);
+        break;
+      case "init":
+        await cli.runInitCommand(options);
+        break;
       case "explain":
         const targetPkg = args[1];
         if (!targetPkg) {
@@ -2367,7 +3443,7 @@ async function main() {
         break;
       default:
         console.log(`Unknown command: ${command}`);
-        console.log(`Available commands: plan, release, version, explain`);
+        console.log(`Run 'verelease --help' for available commands and options.`);
         process.exit(1);
     }
   } catch (err) {