@cleocode/cleo 2026.3.17 → 2026.3.19

package/dist/mcp/index.js

@@ -1809,6 +1809,16 @@ var init_registry = __esm({
         sessionRequired: false,
         requiredParams: ["version"]
       },
+      {
+        gateway: "query",
+        domain: "pipeline",
+        operation: "release.channel.show",
+        description: "Show the current release channel based on git branch (latest/beta/alpha)",
+        tier: 0,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: []
+      },
       {
         gateway: "mutate",
         domain: "pipeline",
@@ -1869,6 +1879,16 @@ var init_registry = __esm({
         sessionRequired: false,
         requiredParams: []
       },
+      {
+        gateway: "mutate",
+        domain: "pipeline",
+        operation: "release.cancel",
+        description: "pipeline.release.cancel (mutate)",
+        tier: 0,
+        idempotent: false,
+        sessionRequired: false,
+        requiredParams: ["version"]
+      },
       {
         gateway: "mutate",
         domain: "pipeline",
@@ -19948,10 +19968,10 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join63 } = await import("node:path");
-    const { existsSync: existsSync63 } = await import("node:fs");
-    const dbPath = join63(projectRoot, ".cleo", "tasks.db");
-    if (!existsSync63(dbPath)) {
+    const { join: join64 } = await import("node:path");
+    const { existsSync: existsSync64 } = await import("node:fs");
+    const dbPath = join64(projectRoot, ".cleo", "tasks.db");
+    if (!existsSync64(dbPath)) {
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
       return {
@@ -20695,10 +20715,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync45, existsSync: existsSync63 } = await import("node:fs");
+    const { readFileSync: readFileSync46, existsSync: existsSync64 } = await import("node:fs");
     const infoPath = join34(projectPath, ".cleo", "project-info.json");
-    if (!existsSync63(infoPath)) return "";
-    const data = JSON.parse(readFileSync45(infoPath, "utf-8"));
+    if (!existsSync64(infoPath)) return "";
+    const data = JSON.parse(readFileSync46(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -28490,7 +28510,8 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
   }
   function buildEntry(task) {
     const cleanTitle = capitalize(stripConventionalPrefix(task.title));
-    const desc6 = task.description?.trim();
+    const safeDesc = task.description?.replace(/\r?\n/g, " ").replace(/\s{2,}/g, " ").trim();
+    const desc6 = safeDesc;
     const shouldIncludeDesc = (() => {
       if (!desc6 || desc6.length === 0) return false;
       const titleNorm = cleanTitle.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
@@ -28507,23 +28528,29 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
   }
   function categorizeTask(task) {
     if (task.type === "epic") return "changes";
-    const labels = task.labels ?? [];
-    const titleLower = stripConventionalPrefix(task.title).toLowerCase();
-    const rawTitleLower = task.title.toLowerCase();
+    const taskType = (task.type ?? "").toLowerCase();
+    if (taskType === "test") return "tests";
+    if (taskType === "fix" || taskType === "bugfix") return "fixes";
+    if (taskType === "feat" || taskType === "feature") return "features";
+    if (taskType === "docs" || taskType === "doc") return "docs";
+    if (taskType === "chore" || taskType === "refactor") return "chores";
     if (/^feat(\([^)]+\))?:/.test(task.title.toLowerCase())) return "features";
     if (/^fix(\([^)]+\))?:/.test(task.title.toLowerCase())) return "fixes";
     if (/^docs?(\([^)]+\))?:/.test(task.title.toLowerCase())) return "docs";
     if (/^test(\([^)]+\))?:/.test(task.title.toLowerCase())) return "tests";
     if (/^(chore|refactor|style|ci|build|perf)(\([^)]+\))?:/.test(task.title.toLowerCase())) return "chores";
-    if (labels.some((l) => ["feat", "feature", "enhancement", "add"].includes(l.toLowerCase()))) return "features";
+    const labels = task.labels ?? [];
+    if (labels.some((l) => ["test", "testing"].includes(l.toLowerCase()))) return "tests";
     if (labels.some((l) => ["fix", "bug", "bugfix", "regression"].includes(l.toLowerCase()))) return "fixes";
+    if (labels.some((l) => ["feat", "feature", "enhancement", "add"].includes(l.toLowerCase()))) return "features";
     if (labels.some((l) => ["docs", "documentation"].includes(l.toLowerCase()))) return "docs";
-    if (labels.some((l) => ["test", "testing"].includes(l.toLowerCase()))) return "tests";
     if (labels.some((l) => ["chore", "refactor", "cleanup", "maintenance"].includes(l.toLowerCase()))) return "chores";
-    if (titleLower.startsWith("add ") || titleLower.includes("implement") || titleLower.startsWith("create ") || titleLower.startsWith("introduce ")) return "features";
+    const titleLower = stripConventionalPrefix(task.title).toLowerCase();
+    const rawTitleLower = task.title.toLowerCase();
+    if (titleLower.startsWith("test") || titleLower.includes("test") && titleLower.includes("add")) return "tests";
     if (titleLower.includes("bug") || titleLower.startsWith("fix") || titleLower.includes("regression") || titleLower.includes("broken")) return "fixes";
+    if (titleLower.startsWith("add ") || titleLower.includes("implement") || titleLower.startsWith("create ") || titleLower.startsWith("introduce ")) return "features";
     if (titleLower.startsWith("doc") || titleLower.includes("documentation") || titleLower.includes("readme") || titleLower.includes("changelog")) return "docs";
-    if (titleLower.startsWith("test") || titleLower.includes("test") && titleLower.includes("add")) return "tests";
     if (titleLower.startsWith("chore") || titleLower.includes("refactor") || titleLower.includes("cleanup") || titleLower.includes("migrate") || titleLower.includes("upgrade") || titleLower.includes("remove ") || titleLower.startsWith("audit")) return "chores";
     if (rawTitleLower.startsWith("feat")) return "features";
     return "changes";
@@ -28534,6 +28561,10 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
     if (task.type === "epic") continue;
     if (task.labels?.some((l) => l.toLowerCase() === "epic")) continue;
     if (/^epic:/i.test(task.title.trim())) continue;
+    const labelsLower = (task.labels ?? []).map((l) => l.toLowerCase());
+    if (labelsLower.some((l) => ["research", "internal", "spike", "audit"].includes(l))) continue;
+    if (["spike", "research"].includes((task.type ?? "").toLowerCase())) continue;
+    if (/^(research|investigate|audit|spike)\s/i.test(task.title.trim())) continue;
     const category = categorizeTask(task);
     const entry = buildEntry(task);
     if (category === "features") features.push(entry);
@@ -28591,7 +28622,7 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
   }
   const { customBlocks } = parseChangelogBlocks(existingChangelogContent);
   const changelogBody = sections.slice(2).join("\n");
-  await writeChangelogSection(normalizedVersion, changelogBody, customBlocks, changelogPath);
+  await writeChangelogSection(normalizedVersion.replace(/^v/, ""), changelogBody, customBlocks, changelogPath);
   return {
     version: normalizedVersion,
     changelog,
@@ -28664,7 +28695,7 @@ async function tagRelease(version, cwd) {
   await db.update(releaseManifests).set({ status: "tagged", taggedAt }).where(eq14(releaseManifests.version, normalizedVersion)).run();
   return { version: normalizedVersion, status: "tagged", taggedAt };
 }
-async function runReleaseGates(version, loadTasksFn, cwd) {
+async function runReleaseGates(version, loadTasksFn, cwd, opts) {
   if (!version) {
     throw new Error("version is required");
   }
@@ -28712,23 +28743,31 @@ async function runReleaseGates(version, loadTasksFn, cwd) {
       message: existsSync50(distPath) ? "dist/cli/index.js present" : "dist/ not built \u2014 run: npm run build"
     });
   }
-  let workingTreeClean = true;
-  let dirtyFiles = [];
-  try {
-    const porcelain = execFileSync7("git", ["status", "--porcelain"], {
-      cwd: projectRoot,
-      encoding: "utf-8",
-      stdio: "pipe"
+  if (opts?.dryRun) {
+    gates.push({
+      name: "clean_working_tree",
+      status: "passed",
+      message: "Skipped in dry-run mode"
+    });
+  } else {
+    let workingTreeClean = true;
+    let dirtyFiles = [];
+    try {
+      const porcelain = execFileSync7("git", ["status", "--porcelain"], {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      dirtyFiles = porcelain.split("\n").filter((l) => l.trim()).filter((l) => !l.startsWith("?? ")).map((l) => l.slice(3).trim()).filter((f) => f !== "CHANGELOG.md" && f !== "VERSION" && f !== "package.json");
+      workingTreeClean = dirtyFiles.length === 0;
+    } catch {
+    }
+    gates.push({
+      name: "clean_working_tree",
+      status: workingTreeClean ? "passed" : "failed",
+      message: workingTreeClean ? "Working tree clean (excluding CHANGELOG.md, VERSION, package.json)" : `Uncommitted changes in: ${dirtyFiles.slice(0, 5).join(", ")}${dirtyFiles.length > 5 ? ` (+${dirtyFiles.length - 5} more)` : ""}`
     });
-    dirtyFiles = porcelain.split("\n").filter((l) => l.trim()).map((l) => l.slice(3).trim()).filter((f) => f !== "CHANGELOG.md" && f !== "VERSION" && f !== "package.json");
-    workingTreeClean = dirtyFiles.length === 0;
-  } catch {
   }
-  gates.push({
-    name: "clean_working_tree",
-    status: workingTreeClean ? "passed" : "failed",
-    message: workingTreeClean ? "Working tree clean (excluding CHANGELOG.md, VERSION, package.json)" : `Uncommitted changes in: ${dirtyFiles.slice(0, 5).join(", ")}${dirtyFiles.length > 5 ? ` (+${dirtyFiles.length - 5} more)` : ""}`
-  });
   const isPreRelease = normalizedVersion.includes("-");
   let currentBranch = "";
   try {
@@ -28788,6 +28827,28 @@ async function runReleaseGates(version, loadTasksFn, cwd) {
     metadata
   };
 }
+async function cancelRelease(version, projectRoot) {
+  if (!version) {
+    throw new Error("version is required");
+  }
+  const normalizedVersion = normalizeVersion(version);
+  const db = await getDb(projectRoot);
+  const rows = await db.select().from(releaseManifests).where(eq14(releaseManifests.version, normalizedVersion)).limit(1).all();
+  if (rows.length === 0) {
+    return { success: false, message: `Release ${normalizedVersion} not found`, version: normalizedVersion };
+  }
+  const status = rows[0].status;
+  const cancellableStates = ["draft", "prepared"];
+  if (!cancellableStates.includes(status)) {
+    return {
+      success: false,
+      message: `Cannot cancel a release in '${status}' state. Use 'release rollback' instead.`,
+      version: normalizedVersion
+    };
+  }
+  await db.delete(releaseManifests).where(eq14(releaseManifests.version, normalizedVersion)).run();
+  return { success: true, message: `Release ${normalizedVersion} cancelled and removed`, version: normalizedVersion };
+}
 async function rollbackRelease(version, reason, cwd) {
   if (!version) {
     throw new Error("version is required");
@@ -28862,7 +28923,8 @@ async function pushRelease(version, remote, cwd, opts) {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
-    if (statusOutput.trim().length > 0) {
+    const trackedDirty = statusOutput.split("\n").filter((l) => l.trim() && !l.startsWith("?? ")).join("\n");
+    if (trackedDirty.trim().length > 0) {
       throw new Error(
         "Git working tree is not clean. Commit or stash changes before pushing (config: release.push.requireCleanTree=true)."
       );
@@ -28994,6 +29056,179 @@ var init_guards = __esm({
   }
 });
 
+// src/core/release/version-bump.ts
+import { existsSync as existsSync51, readFileSync as readFileSync39, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join49 } from "node:path";
+function readConfigValueSync2(path, defaultValue, cwd) {
+  try {
+    const configPath = join49(getCleoDir(cwd), "config.json");
+    if (!existsSync51(configPath)) return defaultValue;
+    const config = JSON.parse(readFileSync39(configPath, "utf-8"));
+    const keys = path.split(".");
+    let value = config;
+    for (const key of keys) {
+      if (value == null || typeof value !== "object") return defaultValue;
+      value = value[key];
+    }
+    return value ?? defaultValue;
+  } catch {
+    return defaultValue;
+  }
+}
+function validateVersionFormat(version) {
+  return VERSION_WITH_PRERELEASE.test(version);
+}
+function getVersionBumpConfig(cwd) {
+  try {
+    const raw = readConfigValueSync2("release.versionBump.files", [], cwd);
+    return raw.map((entry) => ({
+      file: entry.path ?? entry.file ?? "",
+      strategy: entry.strategy,
+      field: entry.jsonPath?.replace(/^\./, "") ?? entry.field,
+      key: entry.key,
+      section: entry.section,
+      pattern: entry.sedPattern ?? entry.pattern
+    })).filter((t) => t.file !== "");
+  } catch {
+    return [];
+  }
+}
+function bumpFile(target, newVersion, projectRoot) {
+  const filePath = join49(projectRoot, target.file);
+  if (!existsSync51(filePath)) {
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: false,
+      error: `File not found: ${target.file}`
+    };
+  }
+  try {
+    const content = readFileSync39(filePath, "utf-8");
+    let previousVersion;
+    let newContent;
+    switch (target.strategy) {
+      case "plain": {
+        previousVersion = content.trim();
+        newContent = newVersion + "\n";
+        break;
+      }
+      case "json": {
+        const field = target.field ?? "version";
+        const json = JSON.parse(content);
+        previousVersion = getNestedField(json, field);
+        setNestedField(json, field, newVersion);
+        newContent = JSON.stringify(json, null, 2) + "\n";
+        break;
+      }
+      case "toml": {
+        const key = target.key ?? "version";
+        const versionRegex = new RegExp(`^(${key}\\s*=\\s*")([^"]+)(")`, "m");
+        const match = content.match(versionRegex);
+        previousVersion = match?.[2];
+        newContent = content.replace(versionRegex, `$1${newVersion}$3`);
+        break;
+      }
+      case "sed": {
+        const pattern = target.pattern ?? "";
+        if (!pattern.includes("{{VERSION}}")) {
+          return {
+            file: target.file,
+            strategy: target.strategy,
+            success: false,
+            error: "sed strategy requires {{VERSION}} placeholder in pattern"
+          };
+        }
+        const regex = new RegExp(pattern.replace("{{VERSION}}", "([\\d.]+)"));
+        const match = content.match(regex);
+        previousVersion = match?.[1];
+        newContent = content.replace(
+          regex,
+          pattern.replace("{{VERSION}}", newVersion)
+        );
+        break;
+      }
+      default:
+        return {
+          file: target.file,
+          strategy: target.strategy,
+          success: false,
+          error: `Unknown strategy: ${target.strategy}`
+        };
+    }
+    writeFileSync8(filePath, newContent, "utf-8");
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: true,
+      previousVersion,
+      newVersion
+    };
+  } catch (err) {
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: false,
+      error: String(err)
+    };
+  }
+}
+function bumpVersionFromConfig(newVersion, options = {}, cwd) {
+  if (!validateVersionFormat(newVersion)) {
+    throw new CleoError(
+      6 /* VALIDATION_ERROR */,
+      `Invalid version: '${newVersion}' (expected X.Y.Z or YYYY.M.patch)`
+    );
+  }
+  const targets = getVersionBumpConfig(cwd);
+  if (targets.length === 0) {
+    throw new CleoError(
+      1 /* GENERAL_ERROR */,
+      "No version bump targets configured. Add release.versionBump.files to .cleo/config.json"
+    );
+  }
+  const projectRoot = getProjectRoot(cwd);
+  const results = [];
+  if (options.dryRun) {
+    for (const target of targets) {
+      results.push({
+        file: target.file,
+        strategy: target.strategy,
+        success: true,
+        newVersion
+      });
+    }
+    return { results, allSuccess: true };
+  }
+  for (const target of targets) {
+    results.push(bumpFile(target, newVersion, projectRoot));
+  }
+  const allSuccess = results.every((r) => r.success);
+  return { results, allSuccess };
+}
+function getNestedField(obj, path) {
+  return path.split(".").reduce((acc, key) => acc?.[key], obj);
+}
+function setNestedField(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (typeof current[parts[i]] !== "object") current[parts[i]] = {};
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+var VERSION_WITH_PRERELEASE;
+var init_version_bump = __esm({
+  "src/core/release/version-bump.ts"() {
+    "use strict";
+    init_paths();
+    init_errors();
+    init_exit_codes();
+    VERSION_WITH_PRERELEASE = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
+  }
+});
+
 // src/dispatch/engines/release-engine.ts
 import { execFileSync as execFileSync8 } from "node:child_process";
 function isAgentContext() {
@@ -29116,6 +29351,23 @@ async function releaseRollback(version, reason, projectRoot) {
     return engineError(code, message);
   }
 }
+async function releaseCancel(version, projectRoot) {
+  if (!version) {
+    return engineError("E_INVALID_INPUT", "version is required");
+  }
+  try {
+    const result = await cancelRelease(version, projectRoot);
+    if (!result.success) {
+      const code = result.message.includes("not found") ? "E_NOT_FOUND" : "E_INVALID_STATE";
+      return engineError(code, result.message);
+    }
+    return { success: true, data: result };
+  } catch (err) {
+    const message = err.message;
+    const code = message.includes("not found") ? "E_NOT_FOUND" : "E_CANCEL_FAILED";
+    return engineError(code, message);
+  }
+}
 async function releasePush(version, remote, projectRoot, opts) {
   if (isAgentContext()) {
     const hasEntry = await hasManifestEntry(version, projectRoot);
@@ -29159,7 +29411,7 @@ async function releasePush(version, remote, projectRoot, opts) {
   }
 }
 async function releaseShip(params, projectRoot) {
-  const { version, epicId, remote, dryRun = false } = params;
+  const { version, epicId, remote, dryRun = false, bump = true } = params;
   if (!version) {
     return engineError("E_INVALID_INPUT", "version is required");
   }
@@ -29167,30 +29419,51 @@ async function releaseShip(params, projectRoot) {
     return engineError("E_INVALID_INPUT", "epicId is required");
   }
   const cwd = projectRoot ?? resolveProjectRoot();
+  const steps = [];
   const logStep = (n, total, label, done, error) => {
+    let msg;
     if (done === void 0) {
-      console.log(`[Step ${n}/${total}] ${label}...`);
+      msg = `[Step ${n}/${total}] ${label}...`;
     } else if (done) {
-      console.log(`  \u2713 ${label}`);
+      msg = `  \u2713 ${label}`;
     } else {
-      console.log(`  \u2717 ${label}: ${error ?? "failed"}`);
+      msg = `  \u2717 ${label}: ${error ?? "failed"}`;
     }
+    steps.push(msg);
+    console.log(msg);
   };
+  const bumpTargets = getVersionBumpConfig(cwd);
+  const shouldBump = bump && bumpTargets.length > 0;
   try {
-    logStep(1, 7, "Validate release gates");
+    if (shouldBump) {
+      logStep(0, 8, "Bump version files");
+      if (!dryRun) {
+        const bumpResults = bumpVersionFromConfig(version, { dryRun: false }, cwd);
+        if (!bumpResults.allSuccess) {
+          const failed = bumpResults.results.filter((r) => !r.success).map((r) => r.file);
+          steps.push(`  ! Version bump partial: failed for ${failed.join(", ")}`);
+        } else {
+          logStep(0, 8, "Bump version files", true);
+        }
+      } else {
+        logStep(0, 8, "Bump version files", true);
+      }
+    }
+    logStep(1, 8, "Validate release gates");
     const gatesResult = await runReleaseGates(
       version,
       () => loadTasks2(projectRoot),
-      projectRoot
+      projectRoot,
+      { dryRun }
     );
     if (gatesResult && !gatesResult.allPassed) {
       const failedGates = gatesResult.gates.filter((g) => g.status === "failed");
-      logStep(1, 7, "Validate release gates", false, failedGates.map((g) => g.name).join(", "));
+      logStep(1, 8, "Validate release gates", false, failedGates.map((g) => g.name).join(", "));
       return engineError("E_LIFECYCLE_GATE_FAILED", `Release gates failed for ${version}: ${failedGates.map((g) => g.name).join(", ")}`, {
         details: { gates: gatesResult.gates, failedCount: gatesResult.failedCount }
       });
     }
-    logStep(1, 7, "Validate release gates", true);
+    logStep(1, 8, "Validate release gates", true);
     let resolvedChannel = "latest";
     let currentBranchForPR = "HEAD";
     try {
@@ -29210,7 +29483,7 @@ async function releaseShip(params, projectRoot) {
     if (gateMetadata?.currentBranch) {
       currentBranchForPR = gateMetadata.currentBranch;
     }
-    logStep(2, 7, "Check epic completeness");
+    logStep(2, 8, "Check epic completeness");
     let releaseTaskIds = [];
     try {
       const manifest = await showManifestRelease(version, projectRoot);
@@ -29221,13 +29494,13 @@ async function releaseShip(params, projectRoot) {
     const epicCheck = await checkEpicCompleteness(releaseTaskIds, projectRoot, epicAccessor);
     if (epicCheck.hasIncomplete) {
       const incomplete = epicCheck.epics.filter((e) => e.missingChildren.length > 0).map((e) => `${e.epicId}: missing ${e.missingChildren.map((c) => c.id).join(", ")}`).join("; ");
-      logStep(2, 7, "Check epic completeness", false, incomplete);
+      logStep(2, 8, "Check epic completeness", false, incomplete);
       return engineError("E_LIFECYCLE_GATE_FAILED", `Epic completeness check failed: ${incomplete}`, {
         details: { epics: epicCheck.epics }
       });
     }
-    logStep(2, 7, "Check epic completeness", true);
-    logStep(3, 7, "Check task double-listing");
+    logStep(2, 8, "Check epic completeness", true);
+    logStep(3, 8, "Check task double-listing");
     const allReleases = await listManifestReleases(projectRoot);
     const existingReleases = (allReleases.releases ?? []).filter((r) => r.version !== version);
     const doubleCheck = checkDoubleListing(
@@ -29236,39 +29509,38 @@ async function releaseShip(params, projectRoot) {
     );
     if (doubleCheck.hasDoubleListing) {
       const dupes = doubleCheck.duplicates.map((d) => `${d.taskId} (in ${d.releases.join(", ")})`).join("; ");
-      logStep(3, 7, "Check task double-listing", false, dupes);
+      logStep(3, 8, "Check task double-listing", false, dupes);
       return engineError("E_VALIDATION", `Double-listing detected: ${dupes}`, {
         details: { duplicates: doubleCheck.duplicates }
       });
     }
-    logStep(3, 7, "Check task double-listing", true);
-    logStep(4, 7, "Generate CHANGELOG");
-    const changelogResult = await generateReleaseChangelog(
-      version,
-      () => loadTasks2(projectRoot),
-      projectRoot
-    );
-    const changelogPath = `${cwd}/CHANGELOG.md`;
-    const generatedContent = changelogResult.changelog ?? "";
-    logStep(4, 7, "Generate CHANGELOG", true);
+    logStep(3, 8, "Check task double-listing", true);
     const loadedConfig = loadReleaseConfig(cwd);
     const pushMode = getPushMode(loadedConfig);
     const gitflowCfg = getGitFlowConfig(loadedConfig);
     const targetBranch = targetBranchFromGates ?? gitflowCfg.branches.main;
     if (dryRun) {
+      logStep(4, 8, "Generate CHANGELOG");
+      logStep(4, 8, "Generate CHANGELOG", true);
       const wouldCreatePR = requiresPRFromGates || pushMode === "pr";
+      const filesToStagePreview = ["CHANGELOG.md", ...shouldBump ? bumpTargets.map((t) => t.file) : []];
+      const wouldDo = [];
+      if (shouldBump) {
+        wouldDo.push(`bump version files: ${bumpTargets.map((t) => t.file).join(", ")} \u2192 ${version}`);
+      }
+      wouldDo.push(
+        `write CHANGELOG.md: ## [${version}] - ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]} (preview only, not written in dry-run)`,
+        `git add ${filesToStagePreview.join(" ")}`,
+        `git commit -m "release: ship v${version} (${epicId})"`,
+        `git tag -a v${version} -m "Release v${version}"`
+      );
       const dryRunOutput = {
         version,
         epicId,
         dryRun: true,
         channel: resolvedChannel,
         pushMode,
-        wouldDo: [
-          `write CHANGELOG section for ${version} (${generatedContent.length} chars)`,
-          "git add CHANGELOG.md",
-          `git commit -m "release: ship v${version} (${epicId})"`,
-          `git tag -a v${version} -m "Release v${version}"`
-        ]
+        wouldDo
       };
       if (wouldCreatePR) {
         const ghAvailable = isGhCliAvailable();
@@ -29285,15 +29557,24 @@ async function releaseShip(params, projectRoot) {
         dryRunOutput["wouldCreatePR"] = false;
       }
       dryRunOutput["wouldDo"].push("markReleasePushed(...)");
-      return { success: true, data: dryRunOutput };
+      return { success: true, data: { ...dryRunOutput, steps } };
     }
-    logStep(5, 7, "Commit release");
+    logStep(4, 8, "Generate CHANGELOG");
+    await generateReleaseChangelog(
+      version,
+      () => loadTasks2(projectRoot),
+      projectRoot
+    );
+    const changelogPath = `${cwd}/CHANGELOG.md`;
+    logStep(4, 8, "Generate CHANGELOG", true);
+    logStep(5, 8, "Commit release");
     const gitCwd = { cwd, encoding: "utf-8", stdio: "pipe" };
+    const filesToStage = ["CHANGELOG.md", ...shouldBump ? bumpTargets.map((t) => t.file) : []];
     try {
-      execFileSync8("git", ["add", "CHANGELOG.md"], gitCwd);
+      execFileSync8("git", ["add", ...filesToStage], gitCwd);
     } catch (err) {
       const msg = err.message ?? String(err);
-      logStep(5, 7, "Commit release", false, `git add failed: ${msg}`);
+      logStep(5, 8, "Commit release", false, `git add failed: ${msg}`);
       return engineError("E_GENERAL", `git add failed: ${msg}`);
     }
     try {
@@ -29304,26 +29585,26 @@ async function releaseShip(params, projectRoot) {
       );
     } catch (err) {
       const msg = err.stderr ?? err.message ?? String(err);
-      logStep(5, 7, "Commit release", false, `git commit failed: ${msg}`);
+      logStep(5, 8, "Commit release", false, `git commit failed: ${msg}`);
       return engineError("E_GENERAL", `git commit failed: ${msg}`);
     }
-    logStep(5, 7, "Commit release", true);
+    logStep(5, 8, "Commit release", true);
     let commitSha;
     try {
       commitSha = execFileSync8("git", ["rev-parse", "HEAD"], gitCwd).toString().trim();
     } catch {
     }
-    logStep(6, 7, "Tag release");
+    logStep(6, 8, "Tag release");
     const gitTag = `v${version.replace(/^v/, "")}`;
     try {
       execFileSync8("git", ["tag", "-a", gitTag, "-m", `Release ${gitTag}`], gitCwd);
     } catch (err) {
       const msg = err.stderr ?? err.message ?? String(err);
-      logStep(6, 7, "Tag release", false, `git tag failed: ${msg}`);
+      logStep(6, 8, "Tag release", false, `git tag failed: ${msg}`);
       return engineError("E_GENERAL", `git tag failed: ${msg}`);
     }
-    logStep(6, 7, "Tag release", true);
-    logStep(7, 7, "Push / create PR");
+    logStep(6, 8, "Tag release", true);
+    logStep(7, 8, "Push / create PR");
     let prResult = null;
     const pushResult = await pushRelease(version, remote, projectRoot, {
       explicitPush: true,
@@ -29350,24 +29631,34 @@ async function releaseShip(params, projectRoot) {
         projectRoot: cwd
       });
       if (prResult.mode === "created") {
-        console.log(`  \u2713 Push / create PR`);
-        console.log(`  PR created: ${prResult.prUrl}`);
-        console.log(`  \u2192 Next: merge the PR, then CI will publish to npm @${resolvedChannel}`);
+        const m1 = `  \u2713 Push / create PR`;
+        const m2 = `  PR created: ${prResult.prUrl}`;
+        const m3 = `  \u2192 Next: merge the PR, then CI will publish to npm @${resolvedChannel}`;
+        steps.push(m1, m2, m3);
+        console.log(m1);
+        console.log(m2);
+        console.log(m3);
       } else if (prResult.mode === "skipped") {
-        console.log(`  \u2713 Push / create PR`);
-        console.log(`  PR already exists: ${prResult.prUrl}`);
+        const m1 = `  \u2713 Push / create PR`;
+        const m2 = `  PR already exists: ${prResult.prUrl}`;
+        steps.push(m1, m2);
+        console.log(m1);
+        console.log(m2);
       } else {
-        console.log(`  ! Push / create PR \u2014 manual PR required:`);
-        console.log(prResult.instructions);
+        const m1 = `  ! Push / create PR \u2014 manual PR required:`;
+        const m2 = prResult.instructions ?? "";
+        steps.push(m1, m2);
+        console.log(m1);
+        console.log(m2);
       }
     } else {
       try {
         execFileSync8("git", ["push", remote ?? "origin", "--follow-tags"], gitCwd);
-        logStep(7, 7, "Push / create PR", true);
+        logStep(7, 8, "Push / create PR", true);
       } catch (err) {
         const execError = err;
         const msg = (execError.stderr ?? execError.message ?? "").slice(0, 500);
-        logStep(7, 7, "Push / create PR", false, `git push failed: ${msg}`);
+        logStep(7, 8, "Push / create PR", false, `git push failed: ${msg}`);
         return engineError("E_GENERAL", `git push failed: ${msg}`, {
           details: { exitCode: execError.status }
         });
@@ -29385,6 +29676,7 @@ async function releaseShip(params, projectRoot) {
         pushedAt,
         changelog: changelogPath,
         channel: resolvedChannel,
+        steps,
         ...prResult ? {
           pr: {
             mode: prResult.mode,
@@ -29409,13 +29701,14 @@ var init_release_engine = __esm({
     init_github_pr();
     init_channel();
     init_release_config();
+    init_version_bump();
     init_error();
   }
 });
 
 // src/dispatch/engines/template-parser.ts
-import { readFileSync as readFileSync39, readdirSync as readdirSync12, existsSync as existsSync51 } from "fs";
-import { join as join49 } from "path";
+import { readFileSync as readFileSync40, readdirSync as readdirSync12, existsSync as existsSync52 } from "fs";
+import { join as join50 } from "path";
 import { parse as parseYaml } from "yaml";
 function deriveSubcommand(filename) {
   let stem = filename.replace(/\.ya?ml$/i, "");
@@ -29429,8 +29722,8 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile(templateDir, filename) {
-  const filePath = join49(templateDir, filename);
-  const raw = readFileSync39(filePath, "utf-8");
+  const filePath = join50(templateDir, filename);
+  const raw = readFileSync40(filePath, "utf-8");
   const parsed = parseYaml(raw);
   const name = typeof parsed.name === "string" ? parsed.name : filename;
   const titlePrefix = typeof parsed.title === "string" ? parsed.title : "";
@@ -29479,8 +29772,8 @@ function parseTemplateFile(templateDir, filename) {
   };
 }
 function parseIssueTemplates(projectRoot) {
-  const templateDir = join49(projectRoot, ".github", "ISSUE_TEMPLATE");
-  if (!existsSync51(templateDir)) {
+  const templateDir = join50(projectRoot, ".github", "ISSUE_TEMPLATE");
+  if (!existsSync52(templateDir)) {
     return engineError("E_NOT_FOUND", `Issue template directory not found: ${templateDir}`);
   }
   let files;
@@ -31159,26 +31452,26 @@ var init_check = __esm({
 });
 
 // src/core/adrs/validate.ts
-import { readFileSync as readFileSync40, readdirSync as readdirSync13, existsSync as existsSync52 } from "node:fs";
-import { join as join50 } from "node:path";
+import { readFileSync as readFileSync41, readdirSync as readdirSync13, existsSync as existsSync53 } from "node:fs";
+import { join as join51 } from "node:path";
 import AjvModule3 from "ajv";
 async function validateAllAdrs(projectRoot) {
-  const adrsDir = join50(projectRoot, ".cleo", "adrs");
-  const schemaPath = join50(projectRoot, "schemas", "adr-frontmatter.schema.json");
-  if (!existsSync52(schemaPath)) {
+  const adrsDir = join51(projectRoot, ".cleo", "adrs");
+  const schemaPath = join51(projectRoot, "schemas", "adr-frontmatter.schema.json");
+  if (!existsSync53(schemaPath)) {
     return {
       valid: false,
       errors: [{ file: "schemas/adr-frontmatter.schema.json", field: "schema", message: "Schema file not found" }],
       checked: 0
     };
   }
-  if (!existsSync52(adrsDir)) {
+  if (!existsSync53(adrsDir)) {
     return { valid: true, errors: [], checked: 0 };
   }
-  const schema = JSON.parse(readFileSync40(schemaPath, "utf-8"));
+  const schema = JSON.parse(readFileSync41(schemaPath, "utf-8"));
   const ajv = new Ajv3({ allErrors: true });
   const validate = ajv.compile(schema);
-  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join50(adrsDir, f));
+  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join51(adrsDir, f));
   const errors = [];
   for (const filePath of files) {
     const record = parseAdrFile(filePath, projectRoot);
@@ -31205,15 +31498,15 @@ var init_validate = __esm({
 });
 
 // src/core/adrs/list.ts
-import { readdirSync as readdirSync14, existsSync as existsSync53 } from "node:fs";
-import { join as join51 } from "node:path";
+import { readdirSync as readdirSync14, existsSync as existsSync54 } from "node:fs";
+import { join as join52 } from "node:path";
 async function listAdrs(projectRoot, opts) {
-  const adrsDir = join51(projectRoot, ".cleo", "adrs");
-  if (!existsSync53(adrsDir)) {
+  const adrsDir = join52(projectRoot, ".cleo", "adrs");
+  if (!existsSync54(adrsDir)) {
     return { adrs: [], total: 0 };
   }
   const files = readdirSync14(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
-  const records = files.map((f) => parseAdrFile(join51(adrsDir, f), projectRoot));
+  const records = files.map((f) => parseAdrFile(join52(adrsDir, f), projectRoot));
   const filtered = records.filter((r) => {
     if (opts?.status && r.frontmatter.Status !== opts.status) return false;
     if (opts?.since && r.frontmatter.Date < opts.since) return false;
@@ -31238,14 +31531,14 @@ var init_list2 = __esm({
 });
 
 // src/core/adrs/show.ts
-import { existsSync as existsSync54, readdirSync as readdirSync15 } from "node:fs";
-import { join as join52 } from "node:path";
+import { existsSync as existsSync55, readdirSync as readdirSync15 } from "node:fs";
+import { join as join53 } from "node:path";
 async function showAdr(projectRoot, adrId) {
-  const adrsDir = join52(projectRoot, ".cleo", "adrs");
-  if (!existsSync54(adrsDir)) return null;
+  const adrsDir = join53(projectRoot, ".cleo", "adrs");
+  if (!existsSync55(adrsDir)) return null;
   const files = readdirSync15(adrsDir).filter((f) => f.startsWith(adrId) && f.endsWith(".md"));
   if (files.length === 0) return null;
-  const filePath = join52(adrsDir, files[0]);
+  const filePath = join53(adrsDir, files[0]);
   return parseAdrFile(filePath, projectRoot);
 }
 var init_show2 = __esm({
@@ -31256,8 +31549,8 @@ var init_show2 = __esm({
 });
 
 // src/core/adrs/find.ts
-import { readdirSync as readdirSync16, existsSync as existsSync55 } from "node:fs";
-import { join as join53 } from "node:path";
+import { readdirSync as readdirSync16, existsSync as existsSync56 } from "node:fs";
+import { join as join54 } from "node:path";
 function normalise(s) {
   return s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -31274,8 +31567,8 @@ function matchedTerms(target, terms) {
   return terms.filter((term) => t.includes(term));
 }
 async function findAdrs(projectRoot, query, opts) {
-  const adrsDir = join53(projectRoot, ".cleo", "adrs");
-  if (!existsSync55(adrsDir)) {
+  const adrsDir = join54(projectRoot, ".cleo", "adrs");
+  if (!existsSync56(adrsDir)) {
     return { adrs: [], query, total: 0 };
   }
   const files = readdirSync16(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
@@ -31284,7 +31577,7 @@ async function findAdrs(projectRoot, query, opts) {
   const filterKeywords = opts?.keywords ? parseTags(opts.keywords) : null;
   const results = [];
   for (const file of files) {
-    const record = parseAdrFile(join53(adrsDir, file), projectRoot);
+    const record = parseAdrFile(join54(adrsDir, file), projectRoot);
     const fm = record.frontmatter;
     if (opts?.status && fm.Status !== opts.status) continue;
     if (filterTopics && filterTopics.length > 0) {
@@ -31362,12 +31655,12 @@ var init_adrs = __esm({
 });
 
 // src/core/admin/sync.ts
-import { join as join54 } from "node:path";
+import { join as join55 } from "node:path";
 import { rm as rm2, rmdir, stat as stat2 } from "node:fs/promises";
 async function getSyncStatus(projectRoot) {
   try {
     const cleoDir = getCleoDir(projectRoot);
-    const stateFile = join54(cleoDir, "sync", "todowrite-session.json");
+    const stateFile = join55(cleoDir, "sync", "todowrite-session.json");
     const sessionState = await readJson(stateFile);
     if (!sessionState) {
       return {
@@ -31411,8 +31704,8 @@ async function getSyncStatus(projectRoot) {
 async function clearSyncState(projectRoot, dryRun) {
   try {
     const cleoDir = getCleoDir(projectRoot);
-    const syncDir = join54(cleoDir, "sync");
-    const stateFile = join54(syncDir, "todowrite-session.json");
+    const syncDir = join55(cleoDir, "sync");
+    const stateFile = join55(syncDir, "todowrite-session.json");
     let exists = false;
     try {
       await stat2(stateFile);
@@ -32179,8 +32472,8 @@ var init_import_tasks = __esm({
 // src/core/snapshot/index.ts
 import { createHash as createHash8 } from "node:crypto";
 import { readFile as readFile13, writeFile as writeFile10, mkdir as mkdir10 } from "node:fs/promises";
-import { existsSync as existsSync56 } from "node:fs";
-import { join as join55, dirname as dirname14 } from "node:path";
+import { existsSync as existsSync57 } from "node:fs";
+import { join as join56, dirname as dirname14 } from "node:path";
 function toSnapshotTask(task) {
   return {
     id: task.id,
@@ -32233,7 +32526,7 @@ async function exportSnapshot(cwd) {
 }
 async function writeSnapshot(snapshot, outputPath) {
   const dir = dirname14(outputPath);
-  if (!existsSync56(dir)) {
+  if (!existsSync57(dir)) {
     await mkdir10(dir, { recursive: true });
   }
   await writeFile10(outputPath, JSON.stringify(snapshot, null, 2) + "\n");
@@ -32249,7 +32542,7 @@ async function readSnapshot(inputPath) {
 function getDefaultSnapshotPath(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  return join55(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
+  return join56(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);
@@ -32692,15 +32985,15 @@ var init_field_filter = __esm({
 });
 
 // src/core/project-info.ts
-import { readFileSync as readFileSync41, existsSync as existsSync57 } from "node:fs";
-import { join as join56 } from "node:path";
+import { readFileSync as readFileSync42, existsSync as existsSync58 } from "node:fs";
+import { join as join57 } from "node:path";
 function getProjectInfoSync(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join56(cleoDir, "project-info.json");
-  if (!existsSync57(infoPath)) return null;
+  const infoPath = join57(cleoDir, "project-info.json");
+  if (!existsSync58(infoPath)) return null;
   try {
-    const raw = readFileSync41(infoPath, "utf-8");
+    const raw = readFileSync42(infoPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.projectHash !== "string" || data.projectHash.length === 0) {
       return null;
@@ -32928,13 +33221,13 @@ var init_field_context = __esm({
 });
 
 // src/core/sessions/context-alert.ts
-import { existsSync as existsSync58, readFileSync as readFileSync42, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join57 } from "node:path";
+import { existsSync as existsSync59, readFileSync as readFileSync43, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join58 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join57(getCleoDir(cwd), ".current-session");
-  if (existsSync58(sessionFile)) {
-    return readFileSync42(sessionFile, "utf-8").trim() || null;
+  const sessionFile = join58(getCleoDir(cwd), ".current-session");
+  if (existsSync59(sessionFile)) {
+    return readFileSync43(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -33982,7 +34275,7 @@ async function stopTask2(sessionId, cwd) {
 }
 async function workHistory(sessionId, limit = 50, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(taskWorkHistory).where(eq16(taskWorkHistory.sessionId, sessionId)).orderBy(desc5(taskWorkHistory.setAt)).limit(limit).all();
+  const rows = await db.select().from(taskWorkHistory).where(eq16(taskWorkHistory.sessionId, sessionId)).orderBy(desc5(taskWorkHistory.setAt), desc5(taskWorkHistory.id)).limit(limit).all();
   return rows.map((r) => ({
     taskId: r.taskId,
     setAt: r.setAt,
@@ -34335,8 +34628,8 @@ __export(session_grade_exports, {
   gradeSession: () => gradeSession,
   readGrades: () => readGrades
 });
-import { join as join58 } from "node:path";
-import { existsSync as existsSync59 } from "node:fs";
+import { join as join59 } from "node:path";
+import { existsSync as existsSync60 } from "node:fs";
 import { readFile as readFile14, appendFile, mkdir as mkdir11 } from "node:fs/promises";
 async function gradeSession(sessionId, cwd) {
   const sessionEntries = await queryAudit({ sessionId });
@@ -34516,9 +34809,9 @@ function detectDuplicateCreates(entries) {
 async function appendGradeResult(result, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const metricsDir = join58(cleoDir, "metrics");
+    const metricsDir = join59(cleoDir, "metrics");
     await mkdir11(metricsDir, { recursive: true });
-    const gradesPath = join58(metricsDir, "GRADES.jsonl");
+    const gradesPath = join59(metricsDir, "GRADES.jsonl");
     const line = JSON.stringify({ ...result, evaluator: "auto" }) + "\n";
     await appendFile(gradesPath, line, "utf8");
   } catch {
@@ -34527,8 +34820,8 @@ async function appendGradeResult(result, cwd) {
 async function readGrades(sessionId, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const gradesPath = join58(cleoDir, "metrics", "GRADES.jsonl");
-    if (!existsSync59(gradesPath)) return [];
+    const gradesPath = join59(cleoDir, "metrics", "GRADES.jsonl");
+    if (!existsSync60(gradesPath)) return [];
     const content = await readFile14(gradesPath, "utf8");
     const results = content.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
     return sessionId ? results.filter((r) => r.sessionId === sessionId) : results;
@@ -36882,6 +37175,7 @@ var init_pipeline2 = __esm({
             "release.push",
             "release.gates.run",
             "release.rollback",
+            "release.cancel",
             "release.ship",
             "manifest.append",
             "manifest.archive",
@@ -37246,6 +37540,20 @@ var init_pipeline2 = __esm({
             const result = await releaseRollback(version, reason, this.projectRoot);
             return this.wrapEngineResult(result, "mutate", "release.rollback", startTime);
           }
+          case "cancel": {
+            const version = params?.version;
+            if (!version) {
+              return this.errorResponse(
+                "mutate",
+                "release.cancel",
+                "E_INVALID_INPUT",
+                "version is required",
+                startTime
+              );
+            }
+            const result = await releaseCancel(version, this.projectRoot);
+            return this.wrapEngineResult(result, "mutate", "release.cancel", startTime);
+          }
           case "ship": {
             const version = params?.version;
             const epicId = params?.epicId;
@@ -37260,8 +37568,9 @@ var init_pipeline2 = __esm({
             }
             const remote = params?.remote;
             const dryRun = params?.dryRun;
+            const bump = params?.bump;
             const result = await releaseShip(
-              { version, epicId, remote, dryRun },
+              { version, epicId, remote, dryRun, bump },
               this.projectRoot
             );
             return this.wrapEngineResult(result, "mutate", "release.ship", startTime);
@@ -37787,7 +38096,7 @@ var init_build_config = __esm({
     "use strict";
     BUILD_CONFIG = {
       "name": "@cleocode/cleo",
-      "version": "2026.3.17",
+      "version": "2026.3.19",
       "description": "CLEO V2 - TypeScript task management CLI for AI coding agents",
       "repository": {
         "owner": "kryptobaseddev",
@@ -37796,7 +38105,7 @@ var init_build_config = __esm({
         "url": "https://github.com/kryptobaseddev/cleo.git",
         "issuesUrl": "https://github.com/kryptobaseddev/cleo/issues"
       },
-      "buildDate": "2026-03-07T07:08:25.337Z",
+      "buildDate": "2026-03-07T20:22:23.104Z",
       "templates": {
         "issueTemplatesDir": "templates/issue-templates"
       }
@@ -37805,8 +38114,8 @@ var init_build_config = __esm({
 });
 
 // src/core/issue/template-parser.ts
-import { existsSync as existsSync60, readFileSync as readFileSync43, readdirSync as readdirSync17, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join59, basename as basename10 } from "node:path";
+import { existsSync as existsSync61, readFileSync as readFileSync44, readdirSync as readdirSync17, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join60, basename as basename10 } from "node:path";
 function extractYamlField(content, field) {
   const regex = new RegExp(`^${field}:\\s*["']?(.+?)["']?\\s*$`, "m");
   const match = content.match(regex);
@@ -37838,9 +38147,9 @@ function extractYamlArray(content, field) {
   return items;
 }
 function parseTemplateFile2(filePath) {
-  if (!existsSync60(filePath)) return null;
+  if (!existsSync61(filePath)) return null;
   try {
-    const content = readFileSync43(filePath, "utf-8");
+    const content = readFileSync44(filePath, "utf-8");
     const fileName = basename10(filePath);
     const stem = fileName.replace(/\.ya?ml$/, "");
     const name = extractYamlField(content, "name");
@@ -37857,12 +38166,12 @@ function parseTemplateFile2(filePath) {
 function parseIssueTemplates2(projectDir) {
   try {
     const packageRoot = getPackageRoot();
-    const packagedTemplateDir = join59(packageRoot, PACKAGED_TEMPLATE_DIR);
-    if (existsSync60(packagedTemplateDir)) {
+    const packagedTemplateDir = join60(packageRoot, PACKAGED_TEMPLATE_DIR);
+    if (existsSync61(packagedTemplateDir)) {
       const templates3 = [];
       for (const file of readdirSync17(packagedTemplateDir)) {
         if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-        const template = parseTemplateFile2(join59(packagedTemplateDir, file));
+        const template = parseTemplateFile2(join60(packagedTemplateDir, file));
         if (template) templates3.push(template);
       }
       if (templates3.length > 0) return templates3;
@@ -37870,12 +38179,12 @@ function parseIssueTemplates2(projectDir) {
   } catch {
   }
   const dir = projectDir ?? getProjectRoot();
-  const templateDir = join59(dir, TEMPLATE_DIR);
-  if (!existsSync60(templateDir)) return [];
+  const templateDir = join60(dir, TEMPLATE_DIR);
+  if (!existsSync61(templateDir)) return [];
   const templates2 = [];
   for (const file of readdirSync17(templateDir)) {
     if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-    const template = parseTemplateFile2(join59(templateDir, file));
+    const template = parseTemplateFile2(join60(templateDir, file));
     if (template) templates2.push(template);
   }
   return templates2;
@@ -37884,10 +38193,10 @@ function getTemplateConfig(cwd) {
   const projectDir = cwd ?? getProjectRoot();
   const liveTemplates = parseIssueTemplates2(projectDir);
   if (liveTemplates.length > 0) return liveTemplates;
-  const cachePath = join59(getCleoDir(cwd), CACHE_FILE);
-  if (existsSync60(cachePath)) {
+  const cachePath = join60(getCleoDir(cwd), CACHE_FILE);
+  if (existsSync61(cachePath)) {
     try {
-      const cached = JSON.parse(readFileSync43(cachePath, "utf-8"));
+      const cached = JSON.parse(readFileSync44(cachePath, "utf-8"));
       if (cached.templates?.length > 0) return cached.templates;
     } catch {
     }
@@ -38946,8 +39255,8 @@ var init_tools = __esm({
 });
 
 // src/core/nexus/query.ts
-import { join as join60, basename as basename11 } from "node:path";
-import { existsSync as existsSync61, readFileSync as readFileSync44 } from "node:fs";
+import { join as join61, basename as basename11 } from "node:path";
+import { existsSync as existsSync62, readFileSync as readFileSync45 } from "node:fs";
 import { z as z3 } from "zod";
 function validateSyntax(query) {
   if (!query) return false;
@@ -38983,9 +39292,9 @@ function getCurrentProject() {
     return process.env["NEXUS_CURRENT_PROJECT"];
   }
   try {
-    const infoPath = join60(process.cwd(), ".cleo", "project-info.json");
-    if (existsSync61(infoPath)) {
-      const data = JSON.parse(readFileSync44(infoPath, "utf-8"));
+    const infoPath = join61(process.cwd(), ".cleo", "project-info.json");
+    if (existsSync62(infoPath)) {
+      const data = JSON.parse(readFileSync45(infoPath, "utf-8"));
       if (typeof data.name === "string" && data.name.length > 0) {
         return data.name;
       }
@@ -39021,7 +39330,7 @@ async function resolveProjectPath2(projectName) {
   return project.path;
 }
 async function readProjectTasks(projectPath) {
-  const tasksDbPath = join60(projectPath, ".cleo", "tasks.db");
+  const tasksDbPath = join61(projectPath, ".cleo", "tasks.db");
   try {
     const accessor = await getAccessor(projectPath);
     const taskFile = await accessor.loadTaskFile();
@@ -39435,8 +39744,8 @@ var init_deps2 = __esm({
 
 // src/core/nexus/sharing/index.ts
 import { readFile as readFile15, writeFile as writeFile11 } from "node:fs/promises";
-import { existsSync as existsSync62, readdirSync as readdirSync18, statSync as statSync9 } from "node:fs";
-import { join as join61, relative as relative5 } from "node:path";
+import { existsSync as existsSync63, readdirSync as readdirSync18, statSync as statSync9 } from "node:fs";
+import { join as join62, relative as relative5 } from "node:path";
 function matchesPattern(filePath, pattern) {
   const normalizedPath = filePath.replace(/^\/+|\/+$/g, "");
   const normalizedPattern = pattern.replace(/^\/+|\/+$/g, "");
@@ -39461,7 +39770,7 @@ function collectCleoFiles(cleoDir) {
     const entries = readdirSync18(dir);
     for (const entry of entries) {
       if (entry === ".git") continue;
-      const fullPath = join61(dir, entry);
+      const fullPath = join62(dir, entry);
       const relPath = relative5(cleoDir, fullPath);
       try {
         const stat3 = statSync9(fullPath);
@@ -39521,7 +39830,7 @@ function generateGitignoreEntries(sharing) {
 async function syncGitignore(cwd) {
   const config = await loadConfig2(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const gitignorePath = join61(projectRoot, ".gitignore");
+  const gitignorePath = join62(projectRoot, ".gitignore");
   const entries = generateGitignoreEntries(config.sharing);
   const managedSection = [
     "",
@@ -39531,7 +39840,7 @@ async function syncGitignore(cwd) {
     ""
   ].join("\n");
   let content = "";
-  if (existsSync62(gitignorePath)) {
+  if (existsSync63(gitignorePath)) {
     content = await readFile15(gitignorePath, "utf-8");
   }
   const startIdx = content.indexOf(GITIGNORE_START);
@@ -43649,7 +43958,7 @@ init_logger();
 init_project_info();
 init_scaffold();
 init_audit_prune();
-import { join as join62 } from "node:path";
+import { join as join63 } from "node:path";
 var serverState = null;
 var startupLog = getLogger("mcp:startup");
 async function main() {
@@ -43719,7 +44028,7 @@ async function main() {
     }
     const config = loadConfig();
     const projectInfo = getProjectInfoSync();
-    const cleoDir = join62(process.cwd(), ".cleo");
+    const cleoDir = join63(process.cwd(), ".cleo");
     initLogger(cleoDir, {
       level: config.logLevel ?? "info",
       filePath: "logs/cleo.log",