@cleocode/cleo 2026.3.17 → 2026.3.19

package/dist/cli/index.js

@@ -1803,6 +1803,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",
@@ -1863,6 +1873,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",
@@ -19690,10 +19710,10 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join77 } = await import("node:path");
-    const { existsSync: existsSync72 } = await import("node:fs");
-    const dbPath = join77(projectRoot, ".cleo", "tasks.db");
-    if (!existsSync72(dbPath)) {
+    const { join: join78 } = await import("node:path");
+    const { existsSync: existsSync73 } = await import("node:fs");
+    const dbPath = join78(projectRoot, ".cleo", "tasks.db");
+    if (!existsSync73(dbPath)) {
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
       return {
@@ -20549,10 +20569,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync53, existsSync: existsSync72 } = await import("node:fs");
+    const { readFileSync: readFileSync54, existsSync: existsSync73 } = await import("node:fs");
     const infoPath = join33(projectPath, ".cleo", "project-info.json");
-    if (!existsSync72(infoPath)) return "";
-    const data = JSON.parse(readFileSync53(infoPath, "utf-8"));
+    if (!existsSync73(infoPath)) return "";
+    const data = JSON.parse(readFileSync54(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -28477,7 +28497,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();
@@ -28494,23 +28515,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";
@@ -28521,6 +28548,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);
@@ -28578,7 +28609,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,
@@ -28651,7 +28682,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");
   }
@@ -28699,23 +28730,31 @@ async function runReleaseGates(version, loadTasksFn, cwd) {
       message: existsSync49(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 {
@@ -28775,6 +28814,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");
@@ -28849,7 +28910,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)."
       );
@@ -28981,6 +29043,179 @@ var init_guards = __esm({
   }
 });
 
+// src/core/release/version-bump.ts
+import { existsSync as existsSync50, readFileSync as readFileSync39, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join48 } from "node:path";
+function readConfigValueSync2(path, defaultValue, cwd) {
+  try {
+    const configPath = join48(getCleoDir(cwd), "config.json");
+    if (!existsSync50(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 = join48(projectRoot, target.file);
+  if (!existsSync50(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() {
@@ -29103,6 +29338,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);
@@ -29146,7 +29398,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");
   }
@@ -29154,30 +29406,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 {
@@ -29197,7 +29470,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);
@@ -29208,13 +29481,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(
@@ -29223,39 +29496,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();
@@ -29272,15 +29544,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 {
@@ -29291,26 +29572,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,
@@ -29337,24 +29618,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 }
         });
@@ -29372,6 +29663,7 @@ async function releaseShip(params, projectRoot) {
         pushedAt,
         changelog: changelogPath,
         channel: resolvedChannel,
+        steps,
         ...prResult ? {
           pr: {
             mode: prResult.mode,
@@ -29396,13 +29688,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 existsSync50 } from "fs";
-import { join as join48 } from "path";
+import { readFileSync as readFileSync40, readdirSync as readdirSync12, existsSync as existsSync51 } from "fs";
+import { join as join49 } from "path";
 import { parse as parseYaml } from "yaml";
 function deriveSubcommand(filename) {
   let stem = filename.replace(/\.ya?ml$/i, "");
@@ -29416,8 +29709,8 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile(templateDir, filename) {
-  const filePath = join48(templateDir, filename);
-  const raw = readFileSync39(filePath, "utf-8");
+  const filePath = join49(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 : "";
@@ -29466,8 +29759,8 @@ function parseTemplateFile(templateDir, filename) {
   };
 }
 function parseIssueTemplates(projectRoot) {
-  const templateDir = join48(projectRoot, ".github", "ISSUE_TEMPLATE");
-  if (!existsSync50(templateDir)) {
+  const templateDir = join49(projectRoot, ".github", "ISSUE_TEMPLATE");
+  if (!existsSync51(templateDir)) {
     return engineError("E_NOT_FOUND", `Issue template directory not found: ${templateDir}`);
   }
   let files;
@@ -31146,26 +31439,26 @@ var init_check = __esm({
 });
 
 // src/core/adrs/validate.ts
-import { readFileSync as readFileSync40, readdirSync as readdirSync13, existsSync as existsSync51 } from "node:fs";
-import { join as join49 } from "node:path";
+import { readFileSync as readFileSync41, readdirSync as readdirSync13, existsSync as existsSync52 } from "node:fs";
+import { join as join50 } from "node:path";
 import AjvModule3 from "ajv";
 async function validateAllAdrs(projectRoot) {
-  const adrsDir = join49(projectRoot, ".cleo", "adrs");
-  const schemaPath = join49(projectRoot, "schemas", "adr-frontmatter.schema.json");
-  if (!existsSync51(schemaPath)) {
+  const adrsDir = join50(projectRoot, ".cleo", "adrs");
+  const schemaPath = join50(projectRoot, "schemas", "adr-frontmatter.schema.json");
+  if (!existsSync52(schemaPath)) {
     return {
       valid: false,
       errors: [{ file: "schemas/adr-frontmatter.schema.json", field: "schema", message: "Schema file not found" }],
       checked: 0
     };
   }
-  if (!existsSync51(adrsDir)) {
+  if (!existsSync52(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) => join49(adrsDir, f));
+  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join50(adrsDir, f));
   const errors = [];
   for (const filePath of files) {
     const record = parseAdrFile(filePath, projectRoot);
@@ -31192,15 +31485,15 @@ var init_validate = __esm({
 });
 
 // src/core/adrs/list.ts
-import { readdirSync as readdirSync14, existsSync as existsSync52 } from "node:fs";
-import { join as join50 } from "node:path";
+import { readdirSync as readdirSync14, existsSync as existsSync53 } from "node:fs";
+import { join as join51 } from "node:path";
 async function listAdrs(projectRoot, opts) {
-  const adrsDir = join50(projectRoot, ".cleo", "adrs");
-  if (!existsSync52(adrsDir)) {
+  const adrsDir = join51(projectRoot, ".cleo", "adrs");
+  if (!existsSync53(adrsDir)) {
     return { adrs: [], total: 0 };
   }
   const files = readdirSync14(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
-  const records = files.map((f) => parseAdrFile(join50(adrsDir, f), projectRoot));
+  const records = files.map((f) => parseAdrFile(join51(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;
@@ -31225,14 +31518,14 @@ var init_list2 = __esm({
 });
 
 // src/core/adrs/show.ts
-import { existsSync as existsSync53, readdirSync as readdirSync15 } from "node:fs";
-import { join as join51 } from "node:path";
+import { existsSync as existsSync54, readdirSync as readdirSync15 } from "node:fs";
+import { join as join52 } from "node:path";
 async function showAdr(projectRoot, adrId) {
-  const adrsDir = join51(projectRoot, ".cleo", "adrs");
-  if (!existsSync53(adrsDir)) return null;
+  const adrsDir = join52(projectRoot, ".cleo", "adrs");
+  if (!existsSync54(adrsDir)) return null;
   const files = readdirSync15(adrsDir).filter((f) => f.startsWith(adrId) && f.endsWith(".md"));
   if (files.length === 0) return null;
-  const filePath = join51(adrsDir, files[0]);
+  const filePath = join52(adrsDir, files[0]);
   return parseAdrFile(filePath, projectRoot);
 }
 var init_show2 = __esm({
@@ -31243,8 +31536,8 @@ var init_show2 = __esm({
 });
 
 // src/core/adrs/find.ts
-import { readdirSync as readdirSync16, existsSync as existsSync54 } from "node:fs";
-import { join as join52 } from "node:path";
+import { readdirSync as readdirSync16, existsSync as existsSync55 } from "node:fs";
+import { join as join53 } from "node:path";
 function normalise(s) {
   return s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -31261,8 +31554,8 @@ function matchedTerms(target, terms) {
   return terms.filter((term) => t.includes(term));
 }
 async function findAdrs(projectRoot, query, opts) {
-  const adrsDir = join52(projectRoot, ".cleo", "adrs");
-  if (!existsSync54(adrsDir)) {
+  const adrsDir = join53(projectRoot, ".cleo", "adrs");
+  if (!existsSync55(adrsDir)) {
     return { adrs: [], query, total: 0 };
   }
   const files = readdirSync16(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
@@ -31271,7 +31564,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(join52(adrsDir, file), projectRoot);
+    const record = parseAdrFile(join53(adrsDir, file), projectRoot);
     const fm = record.frontmatter;
     if (opts?.status && fm.Status !== opts.status) continue;
     if (filterTopics && filterTopics.length > 0) {
@@ -31349,12 +31642,12 @@ var init_adrs = __esm({
 });
 
 // src/core/admin/sync.ts
-import { join as join53 } from "node:path";
+import { join as join54 } 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 = join53(cleoDir, "sync", "todowrite-session.json");
+    const stateFile = join54(cleoDir, "sync", "todowrite-session.json");
     const sessionState = await readJson(stateFile);
     if (!sessionState) {
       return {
@@ -31398,8 +31691,8 @@ async function getSyncStatus(projectRoot) {
 async function clearSyncState(projectRoot, dryRun) {
   try {
     const cleoDir = getCleoDir(projectRoot);
-    const syncDir = join53(cleoDir, "sync");
-    const stateFile = join53(syncDir, "todowrite-session.json");
+    const syncDir = join54(cleoDir, "sync");
+    const stateFile = join54(syncDir, "todowrite-session.json");
     let exists = false;
     try {
       await stat2(stateFile);
@@ -32166,8 +32459,8 @@ var init_import_tasks = __esm({
 // src/core/snapshot/index.ts
 import { createHash as createHash6 } from "node:crypto";
 import { readFile as readFile13, writeFile as writeFile10, mkdir as mkdir10 } from "node:fs/promises";
-import { existsSync as existsSync55 } from "node:fs";
-import { join as join54, dirname as dirname14 } from "node:path";
+import { existsSync as existsSync56 } from "node:fs";
+import { join as join55, dirname as dirname14 } from "node:path";
 function toSnapshotTask(task) {
   return {
     id: task.id,
@@ -32220,7 +32513,7 @@ async function exportSnapshot(cwd) {
 }
 async function writeSnapshot(snapshot, outputPath) {
   const dir = dirname14(outputPath);
-  if (!existsSync55(dir)) {
+  if (!existsSync56(dir)) {
     await mkdir10(dir, { recursive: true });
   }
   await writeFile10(outputPath, JSON.stringify(snapshot, null, 2) + "\n");
@@ -32236,7 +32529,7 @@ async function readSnapshot(inputPath) {
 function getDefaultSnapshotPath(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  return join54(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
+  return join55(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);
@@ -32534,15 +32827,15 @@ var init_archive_stats2 = __esm({
 });
 
 // src/core/project-info.ts
-import { readFileSync as readFileSync41, existsSync as existsSync56 } from "node:fs";
-import { join as join55 } from "node:path";
+import { readFileSync as readFileSync42, existsSync as existsSync57 } from "node:fs";
+import { join as join56 } from "node:path";
 function getProjectInfoSync(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join55(cleoDir, "project-info.json");
-  if (!existsSync56(infoPath)) return null;
+  const infoPath = join56(cleoDir, "project-info.json");
+  if (!existsSync57(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;
@@ -32629,8 +32922,8 @@ var init_defaults = __esm({
 });
 
 // src/mcp/lib/config.ts
-import { readFileSync as readFileSync42, existsSync as existsSync57 } from "fs";
-import { join as join56 } from "path";
+import { readFileSync as readFileSync43, existsSync as existsSync58 } from "fs";
+import { join as join57 } from "path";
 function loadFromEnv(key) {
   const envKey = `${ENV_PREFIX}${key.toUpperCase()}`;
   return process.env[envKey];
@@ -32651,12 +32944,12 @@ function parseEnvValue2(key, value) {
 }
 function loadFromFile(projectRoot) {
   const root = projectRoot || process.cwd();
-  const configPath = join56(root, ".cleo", "config.json");
-  if (!existsSync57(configPath)) {
+  const configPath = join57(root, ".cleo", "config.json");
+  if (!existsSync58(configPath)) {
     return {};
   }
   try {
-    const content = readFileSync42(configPath, "utf-8");
+    const content = readFileSync43(configPath, "utf-8");
     const config = JSON.parse(content);
     const result = {};
     if (config.mcp) {
@@ -32996,8 +33289,8 @@ __export(session_grade_exports, {
   gradeSession: () => gradeSession,
   readGrades: () => readGrades
 });
-import { join as join57 } from "node:path";
-import { existsSync as existsSync58 } from "node:fs";
+import { join as join58 } from "node:path";
+import { existsSync as existsSync59 } 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 });
@@ -33177,9 +33470,9 @@ function detectDuplicateCreates(entries) {
 async function appendGradeResult(result, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const metricsDir = join57(cleoDir, "metrics");
+    const metricsDir = join58(cleoDir, "metrics");
     await mkdir11(metricsDir, { recursive: true });
-    const gradesPath = join57(metricsDir, "GRADES.jsonl");
+    const gradesPath = join58(metricsDir, "GRADES.jsonl");
     const line = JSON.stringify({ ...result, evaluator: "auto" }) + "\n";
     await appendFile(gradesPath, line, "utf8");
   } catch {
@@ -33188,8 +33481,8 @@ async function appendGradeResult(result, cwd) {
 async function readGrades(sessionId, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const gradesPath = join57(cleoDir, "metrics", "GRADES.jsonl");
-    if (!existsSync58(gradesPath)) return [];
+    const gradesPath = join58(cleoDir, "metrics", "GRADES.jsonl");
+    if (!existsSync59(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;
@@ -35543,6 +35836,7 @@ var init_pipeline2 = __esm({
             "release.push",
             "release.gates.run",
             "release.rollback",
+            "release.cancel",
             "release.ship",
             "manifest.append",
             "manifest.archive",
@@ -35907,6 +36201,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;
@@ -35921,8 +36229,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);
@@ -36448,7 +36757,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",
@@ -36457,7 +36766,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"
       }
@@ -36466,8 +36775,8 @@ var init_build_config = __esm({
 });
 
 // src/core/issue/template-parser.ts
-import { existsSync as existsSync59, readFileSync as readFileSync43, readdirSync as readdirSync17, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join58, basename as basename10 } from "node:path";
+import { existsSync as existsSync60, readFileSync as readFileSync44, readdirSync as readdirSync17, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join59, basename as basename10 } from "node:path";
 function extractYamlField(content, field) {
   const regex = new RegExp(`^${field}:\\s*["']?(.+?)["']?\\s*$`, "m");
   const match = content.match(regex);
@@ -36499,9 +36808,9 @@ function extractYamlArray(content, field) {
   return items;
 }
 function parseTemplateFile2(filePath) {
-  if (!existsSync59(filePath)) return null;
+  if (!existsSync60(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");
@@ -36518,12 +36827,12 @@ function parseTemplateFile2(filePath) {
 function parseIssueTemplates2(projectDir) {
   try {
     const packageRoot = getPackageRoot();
-    const packagedTemplateDir = join58(packageRoot, PACKAGED_TEMPLATE_DIR);
-    if (existsSync59(packagedTemplateDir)) {
+    const packagedTemplateDir = join59(packageRoot, PACKAGED_TEMPLATE_DIR);
+    if (existsSync60(packagedTemplateDir)) {
       const templates3 = [];
       for (const file of readdirSync17(packagedTemplateDir)) {
         if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-        const template = parseTemplateFile2(join58(packagedTemplateDir, file));
+        const template = parseTemplateFile2(join59(packagedTemplateDir, file));
         if (template) templates3.push(template);
       }
       if (templates3.length > 0) return templates3;
@@ -36531,12 +36840,12 @@ function parseIssueTemplates2(projectDir) {
   } catch {
   }
   const dir = projectDir ?? getProjectRoot();
-  const templateDir = join58(dir, TEMPLATE_DIR);
-  if (!existsSync59(templateDir)) return [];
+  const templateDir = join59(dir, TEMPLATE_DIR);
+  if (!existsSync60(templateDir)) return [];
   const templates2 = [];
   for (const file of readdirSync17(templateDir)) {
     if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-    const template = parseTemplateFile2(join58(templateDir, file));
+    const template = parseTemplateFile2(join59(templateDir, file));
     if (template) templates2.push(template);
   }
   return templates2;
@@ -36545,10 +36854,10 @@ function getTemplateConfig(cwd) {
   const projectDir = cwd ?? getProjectRoot();
   const liveTemplates = parseIssueTemplates2(projectDir);
   if (liveTemplates.length > 0) return liveTemplates;
-  const cachePath = join58(getCleoDir(cwd), CACHE_FILE);
-  if (existsSync59(cachePath)) {
+  const cachePath = join59(getCleoDir(cwd), CACHE_FILE);
+  if (existsSync60(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 {
     }
@@ -37607,8 +37916,8 @@ var init_tools = __esm({
 });
 
 // src/core/nexus/query.ts
-import { join as join59, basename as basename11 } from "node:path";
-import { existsSync as existsSync60, readFileSync as readFileSync44 } from "node:fs";
+import { join as join60, basename as basename11 } from "node:path";
+import { existsSync as existsSync61, readFileSync as readFileSync45 } from "node:fs";
 import { z as z3 } from "zod";
 function validateSyntax(query) {
   if (!query) return false;
@@ -37644,9 +37953,9 @@ function getCurrentProject() {
     return process.env["NEXUS_CURRENT_PROJECT"];
   }
   try {
-    const infoPath = join59(process.cwd(), ".cleo", "project-info.json");
-    if (existsSync60(infoPath)) {
-      const data = JSON.parse(readFileSync44(infoPath, "utf-8"));
+    const infoPath = join60(process.cwd(), ".cleo", "project-info.json");
+    if (existsSync61(infoPath)) {
+      const data = JSON.parse(readFileSync45(infoPath, "utf-8"));
       if (typeof data.name === "string" && data.name.length > 0) {
         return data.name;
       }
@@ -37682,7 +37991,7 @@ async function resolveProjectPath2(projectName) {
   return project.path;
 }
 async function readProjectTasks(projectPath) {
-  const tasksDbPath = join59(projectPath, ".cleo", "tasks.db");
+  const tasksDbPath = join60(projectPath, ".cleo", "tasks.db");
   try {
     const accessor = await getAccessor(projectPath);
     const taskFile = await accessor.loadTaskFile();
@@ -38096,8 +38405,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 existsSync61, readdirSync as readdirSync18, statSync as statSync8 } from "node:fs";
-import { join as join60, relative as relative4 } from "node:path";
+import { existsSync as existsSync62, readdirSync as readdirSync18, statSync as statSync8 } from "node:fs";
+import { join as join61, relative as relative4 } from "node:path";
 function matchesPattern(filePath, pattern) {
   const normalizedPath = filePath.replace(/^\/+|\/+$/g, "");
   const normalizedPattern = pattern.replace(/^\/+|\/+$/g, "");
@@ -38122,7 +38431,7 @@ function collectCleoFiles(cleoDir) {
     const entries = readdirSync18(dir);
     for (const entry of entries) {
       if (entry === ".git") continue;
-      const fullPath = join60(dir, entry);
+      const fullPath = join61(dir, entry);
       const relPath = relative4(cleoDir, fullPath);
       try {
         const stat5 = statSync8(fullPath);
@@ -38182,7 +38491,7 @@ function generateGitignoreEntries(sharing) {
 async function syncGitignore(cwd) {
   const config = await loadConfig(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const gitignorePath = join60(projectRoot, ".gitignore");
+  const gitignorePath = join61(projectRoot, ".gitignore");
   const entries = generateGitignoreEntries(config.sharing);
   const managedSection = [
     "",
@@ -38192,7 +38501,7 @@ async function syncGitignore(cwd) {
     ""
   ].join("\n");
   let content = "";
-  if (existsSync61(gitignorePath)) {
+  if (existsSync62(gitignorePath)) {
     content = await readFile15(gitignorePath, "utf-8");
   }
   const startIdx = content.indexOf(GITIGNORE_START);
@@ -40114,13 +40423,13 @@ var init_field_context = __esm({
 });
 
 // src/core/sessions/context-alert.ts
-import { existsSync as existsSync62, readFileSync as readFileSync45, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join61 } from "node:path";
+import { existsSync as existsSync63, readFileSync as readFileSync46, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join62 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join61(getCleoDir(cwd), ".current-session");
-  if (existsSync62(sessionFile)) {
-    return readFileSync45(sessionFile, "utf-8").trim() || null;
+  const sessionFile = join62(getCleoDir(cwd), ".current-session");
+  if (existsSync63(sessionFile)) {
+    return readFileSync46(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -41183,7 +41492,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,
@@ -41367,14 +41676,14 @@ __export(logger_exports, {
   logFileExists: () => logFileExists,
   readMigrationLog: () => readMigrationLog
 });
-import { existsSync as existsSync65, mkdirSync as mkdirSync16, statSync as statSync9, appendFileSync as appendFileSync4 } from "node:fs";
-import { join as join68, dirname as dirname16, relative as relative6 } from "node:path";
+import { existsSync as existsSync66, mkdirSync as mkdirSync16, statSync as statSync9, appendFileSync as appendFileSync4 } from "node:fs";
+import { join as join69, dirname as dirname16, relative as relative6 } from "node:path";
 function createMigrationLogger(cleoDir, config) {
   return new MigrationLogger(cleoDir, config);
 }
 function readMigrationLog(logPath) {
-  const { readFileSync: readFileSync53 } = __require("node:fs");
-  const content = readFileSync53(logPath, "utf-8");
+  const { readFileSync: readFileSync54 } = __require("node:fs");
+  const content = readFileSync54(logPath, "utf-8");
   return content.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
 }
 function logFileExists(logPath) {
@@ -41389,14 +41698,14 @@ function logFileExists(logPath) {
 function getLatestMigrationLog(cleoDir) {
   try {
     const { readdirSync: readdirSync21, statSync: statSync10 } = __require("node:fs");
-    const logsDir = join68(cleoDir, "logs");
-    if (!existsSync65(logsDir)) {
+    const logsDir = join69(cleoDir, "logs");
+    if (!existsSync66(logsDir)) {
       return null;
     }
     const files = readdirSync21(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
       name: f,
-      path: join68(logsDir, f),
-      mtime: statSync10(join68(logsDir, f)).mtime.getTime()
+      path: join69(logsDir, f),
+      mtime: statSync10(join69(logsDir, f)).mtime.getTime()
     })).sort((a, b) => b.mtime - a.mtime);
     return files.length > 0 ? files[0].path : null;
   } catch {
@@ -41426,9 +41735,9 @@ var init_logger2 = __esm({
           consoleOutput: config.consoleOutput ?? false
         };
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        this.logPath = join68(cleoDir, "logs", `migration-${timestamp}.jsonl`);
+        this.logPath = join69(cleoDir, "logs", `migration-${timestamp}.jsonl`);
         const logsDir = dirname16(this.logPath);
-        if (!existsSync65(logsDir)) {
+        if (!existsSync66(logsDir)) {
           mkdirSync16(logsDir, { recursive: true });
         }
         this.startTime = Date.now();
@@ -41517,7 +41826,7 @@ var init_logger2 = __esm({
           sourcePath: relative6(this.cleoDir, sourcePath),
           ...additionalData
         };
-        if (existsSync65(sourcePath)) {
+        if (existsSync66(sourcePath)) {
           try {
             const stats2 = statSync9(sourcePath);
             data.sourceSize = stats2.size;
@@ -41527,7 +41836,7 @@ var init_logger2 = __esm({
         }
         if (targetPath) {
           data.targetPath = relative6(this.cleoDir, targetPath);
-          if (existsSync65(targetPath)) {
+          if (existsSync66(targetPath)) {
             try {
               const stats2 = statSync9(targetPath);
               data.targetSize = stats2.size;
@@ -41596,15 +41905,15 @@ var init_logger2 = __esm({
        */
       cleanupOldLogs() {
         try {
-          const logsDir = join68(this.cleoDir, "logs");
-          if (!existsSync65(logsDir)) {
+          const logsDir = join69(this.cleoDir, "logs");
+          if (!existsSync66(logsDir)) {
             return;
           }
           const { readdirSync: readdirSync21, unlinkSync: unlinkSync5 } = __require("node:fs");
           const files = readdirSync21(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
             name: f,
-            path: join68(logsDir, f),
-            mtime: statSync9(join68(logsDir, f)).mtime.getTime()
+            path: join69(logsDir, f),
+            mtime: statSync9(join69(logsDir, f)).mtime.getTime()
           })).sort((a, b) => b.mtime - a.mtime);
           const filesToRemove = files.slice(this.config.maxLogFiles);
           for (const file of filesToRemove) {
@@ -41700,8 +42009,8 @@ __export(state_exports, {
   verifySourceIntegrity: () => verifySourceIntegrity
 });
 import { readFile as readFile19, writeFile as writeFile13, unlink as unlink5 } from "node:fs/promises";
-import { join as join69 } from "node:path";
-import { existsSync as existsSync66 } from "node:fs";
+import { join as join70 } from "node:path";
+import { existsSync as existsSync67 } from "node:fs";
 import { createHash as createHash8 } from "node:crypto";
 async function computeFileChecksum(filePath) {
   try {
@@ -41723,8 +42032,8 @@ async function countRecords(filePath, key) {
 async function createMigrationState(cleoDir, sourceFiles) {
   const files = sourceFiles ?? {};
   if (!files.todoJson) {
-    const todoPath = join69(cleoDir, "todo.json");
-    if (existsSync66(todoPath)) {
+    const todoPath = join70(cleoDir, "todo.json");
+    if (existsSync67(todoPath)) {
       files.todoJson = {
         path: todoPath,
         checksum: await computeFileChecksum(todoPath),
@@ -41733,8 +42042,8 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.sessionsJson) {
-    const sessionsPath = join69(cleoDir, "sessions.json");
-    if (existsSync66(sessionsPath)) {
+    const sessionsPath = join70(cleoDir, "sessions.json");
+    if (existsSync67(sessionsPath)) {
       files.sessionsJson = {
         path: sessionsPath,
         checksum: await computeFileChecksum(sessionsPath),
@@ -41743,8 +42052,8 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.archiveJson) {
-    const archivePath = join69(cleoDir, "todo-archive.json");
-    if (existsSync66(archivePath)) {
+    const archivePath = join70(cleoDir, "todo-archive.json");
+    if (existsSync67(archivePath)) {
       files.archiveJson = {
         path: archivePath,
         checksum: await computeFileChecksum(archivePath),
@@ -41772,7 +42081,7 @@ async function createMigrationState(cleoDir, sourceFiles) {
   return state;
 }
 async function writeMigrationState(cleoDir, state) {
-  const statePath = join69(cleoDir, STATE_FILENAME);
+  const statePath = join70(cleoDir, STATE_FILENAME);
   const tempPath = `${statePath}.tmp`;
   await writeFile13(tempPath, JSON.stringify(state, null, 2));
   await writeFile13(statePath, await readFile19(tempPath));
@@ -41847,7 +42156,7 @@ async function addMigrationWarning(cleoDir, warning) {
 }
 async function loadMigrationState(cleoDir) {
   try {
-    const statePath = join69(cleoDir, STATE_FILENAME);
+    const statePath = join70(cleoDir, STATE_FILENAME);
     const content = await readFile19(statePath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -41889,7 +42198,7 @@ async function failMigration(cleoDir, error) {
 }
 async function clearMigrationState(cleoDir) {
   try {
-    const statePath = join69(cleoDir, STATE_FILENAME);
+    const statePath = join70(cleoDir, STATE_FILENAME);
     await unlink5(statePath);
   } catch {
   }
@@ -41929,7 +42238,7 @@ async function verifySourceIntegrity(cleoDir) {
   const missing = [];
   for (const [key, fileInfo] of Object.entries(state.sourceFiles)) {
     if (!fileInfo) continue;
-    if (!existsSync66(fileInfo.path)) {
+    if (!existsSync67(fileInfo.path)) {
       missing.push(key);
       continue;
     }
@@ -41960,8 +42269,8 @@ __export(migration_sqlite_exports, {
   migrateJsonToSqlite: () => migrateJsonToSqlite2,
   migrateJsonToSqliteAtomic: () => migrateJsonToSqliteAtomic
 });
-import { existsSync as existsSync67, readFileSync as readFileSync48 } from "node:fs";
-import { join as join70, dirname as dirname17 } from "node:path";
+import { existsSync as existsSync68, readFileSync as readFileSync49 } from "node:fs";
+import { join as join71, dirname as dirname17 } from "node:path";
 import { mkdirSync as mkdirSync17 } from "node:fs";
 import { drizzle as drizzle4 } from "drizzle-orm/sqlite-proxy";
 import { migrate as migrate4 } from "drizzle-orm/sqlite-proxy/migrator";
@@ -41999,26 +42308,26 @@ function countJsonRecords(cleoDir) {
   let tasks2 = 0;
   let archived = 0;
   let sessions2 = 0;
-  const todoPath = join70(cleoDir, "todo.json");
-  if (existsSync67(todoPath)) {
+  const todoPath = join71(cleoDir, "todo.json");
+  if (existsSync68(todoPath)) {
     try {
-      const data = JSON.parse(readFileSync48(todoPath, "utf-8"));
+      const data = JSON.parse(readFileSync49(todoPath, "utf-8"));
       tasks2 = (data.tasks ?? []).length;
     } catch {
     }
   }
-  const archivePath = join70(cleoDir, "todo-archive.json");
-  if (existsSync67(archivePath)) {
+  const archivePath = join71(cleoDir, "todo-archive.json");
+  if (existsSync68(archivePath)) {
     try {
-      const data = JSON.parse(readFileSync48(archivePath, "utf-8"));
+      const data = JSON.parse(readFileSync49(archivePath, "utf-8"));
       archived = (data.tasks ?? data.archivedTasks ?? []).length;
     } catch {
     }
   }
-  const sessionsPath = join70(cleoDir, "sessions.json");
-  if (existsSync67(sessionsPath)) {
+  const sessionsPath = join71(cleoDir, "sessions.json");
+  if (existsSync68(sessionsPath)) {
     try {
-      const data = JSON.parse(readFileSync48(sessionsPath, "utf-8"));
+      const data = JSON.parse(readFileSync49(sessionsPath, "utf-8"));
       sessions2 = (data.sessions ?? []).length;
     } catch {
     }
@@ -42095,13 +42404,13 @@ async function migrateJsonToSqliteAtomic(cwd, tempDbPath, logger) {
   }
 }
 async function runMigrationDataImport(db, cleoDir, result, logger) {
-  const todoPath = join70(cleoDir, "todo.json");
-  if (existsSync67(todoPath)) {
+  const todoPath = join71(cleoDir, "todo.json");
+  if (existsSync68(todoPath)) {
     try {
       logger?.info("import", "read-todo", "Reading todo.json", {
         path: todoPath.replace(cleoDir, ".")
       });
-      const todoData = JSON.parse(readFileSync48(todoPath, "utf-8"));
+      const todoData = JSON.parse(readFileSync49(todoPath, "utf-8"));
       const tasks2 = topoSortTasks(todoData.tasks ?? []);
       const totalTasks = tasks2.length;
       logger?.info("import", "tasks-start", `Starting import of ${totalTasks} tasks`, {
@@ -42170,13 +42479,13 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
     result.warnings.push("todo.json not found, skipping task import");
     logger?.warn("import", "todo-missing", "todo.json not found, skipping task import");
   }
-  const archivePath = join70(cleoDir, "todo-archive.json");
-  if (existsSync67(archivePath)) {
+  const archivePath = join71(cleoDir, "todo-archive.json");
+  if (existsSync68(archivePath)) {
     try {
       logger?.info("import", "read-archive", "Reading todo-archive.json", {
         path: archivePath.replace(cleoDir, ".")
       });
-      const archiveData = JSON.parse(readFileSync48(archivePath, "utf-8"));
+      const archiveData = JSON.parse(readFileSync49(archivePath, "utf-8"));
       const archivedTasks = topoSortTasks(archiveData.tasks ?? archiveData.archivedTasks ?? []);
       const totalArchived = archivedTasks.length;
       logger?.info("import", "archive-start", `Starting import of ${totalArchived} archived tasks`, {
@@ -42229,13 +42538,13 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
       logger?.error("import", "parse-archive", errorMsg);
     }
   }
-  const sessionsPath = join70(cleoDir, "sessions.json");
-  if (existsSync67(sessionsPath)) {
+  const sessionsPath = join71(cleoDir, "sessions.json");
+  if (existsSync68(sessionsPath)) {
     try {
       logger?.info("import", "read-sessions", "Reading sessions.json", {
         path: sessionsPath.replace(cleoDir, ".")
       });
-      const sessionsData = JSON.parse(readFileSync48(sessionsPath, "utf-8"));
+      const sessionsData = JSON.parse(readFileSync49(sessionsPath, "utf-8"));
       const sessions2 = sessionsData.sessions ?? [];
       const totalSessions = sessions2.length;
       logger?.info("import", "sessions-start", `Starting import of ${totalSessions} sessions`, {
@@ -42367,10 +42676,10 @@ async function migrateJsonToSqlite2(cwd, options) {
     return result;
   }
   const db = await getDb(cwd);
-  const todoPath = join70(cleoDir, "todo.json");
-  if (existsSync67(todoPath)) {
+  const todoPath = join71(cleoDir, "todo.json");
+  if (existsSync68(todoPath)) {
     try {
-      const todoData = JSON.parse(readFileSync48(todoPath, "utf-8"));
+      const todoData = JSON.parse(readFileSync49(todoPath, "utf-8"));
       const tasks2 = topoSortTasks(todoData.tasks ?? []);
       for (const task of tasks2) {
         try {
@@ -42419,10 +42728,10 @@ async function migrateJsonToSqlite2(cwd, options) {
   } else {
     result.warnings.push("todo.json not found, skipping task import");
   }
-  const archivePath = join70(cleoDir, "todo-archive.json");
-  if (existsSync67(archivePath)) {
+  const archivePath = join71(cleoDir, "todo-archive.json");
+  if (existsSync68(archivePath)) {
     try {
-      const archiveData = JSON.parse(readFileSync48(archivePath, "utf-8"));
+      const archiveData = JSON.parse(readFileSync49(archivePath, "utf-8"));
       const archivedTasks = topoSortTasks(archiveData.tasks ?? archiveData.archivedTasks ?? []);
       for (const task of archivedTasks) {
         try {
@@ -42459,11 +42768,11 @@ async function migrateJsonToSqlite2(cwd, options) {
       result.errors.push(`Failed to parse todo-archive.json: ${String(err)}`);
     }
   }
-  const sessionsPath = join70(cleoDir, "sessions.json");
-  if (existsSync67(sessionsPath)) {
+  const sessionsPath = join71(cleoDir, "sessions.json");
+  if (existsSync68(sessionsPath)) {
     try {
       const sessionsData = JSON.parse(
-        readFileSync48(sessionsPath, "utf-8")
+        readFileSync49(sessionsPath, "utf-8")
       );
       const sessions2 = sessionsData.sessions ?? [];
       for (const session of sessions2) {
@@ -42531,8 +42840,8 @@ var init_migration_sqlite = __esm({
 
 // src/cli/index.ts
 import { Command, Help } from "commander";
-import { readFileSync as readFileSync52 } from "node:fs";
-import { join as join76 } from "node:path";
+import { readFileSync as readFileSync53 } from "node:fs";
+import { join as join77 } from "node:path";
 
 // src/cli/commands/add.ts
 init_cli();
@@ -43147,12 +43456,13 @@ function registerReleaseCommand(program2) {
       notes: opts["notes"]
     }, { command: "release" });
   });
-  release2.command("ship <version>").description("Ship a release: gates \u2192 changelog \u2192 commit \u2192 tag \u2192 push").requiredOption("--epic <id>", "Epic task ID for commit message (e.g. T5576)").option("--dry-run", "Preview all actions without writing anything").option("--no-push", "Commit and tag but skip git push").option("--remote <remote>", "Git remote to push to (default: origin)").action(async (version, opts) => {
+  release2.command("ship <version>").description("Ship a release: gates \u2192 changelog \u2192 commit \u2192 tag \u2192 push").requiredOption("--epic <id>", "Epic task ID for commit message (e.g. T5576)").option("--dry-run", "Preview all actions without writing anything").option("--no-push", "Commit and tag but skip git push").option("--no-bump", "Skip version file bumping (default: bump if configured)").option("--remote <remote>", "Git remote to push to (default: origin)").action(async (version, opts) => {
     await dispatchFromCli("mutate", "pipeline", "release.ship", {
       version,
       epicId: opts["epic"],
       dryRun: opts["dryRun"],
       push: opts["push"] !== false,
+      bump: opts["bump"] !== false,
       remote: opts["remote"]
     }, { command: "release" });
   });
@@ -43165,6 +43475,9 @@ function registerReleaseCommand(program2) {
   release2.command("changelog <version>").description("Generate changelog for a release").action(async (version) => {
     await dispatchFromCli("mutate", "pipeline", "release.changelog", { version }, { command: "release" });
   });
+  release2.command("cancel <version>").description("Cancel and remove a release in draft or prepared state").action(async (version) => {
+    await dispatchFromCli("mutate", "pipeline", "release.cancel", { version }, { command: "release" });
+  });
 }
 
 // src/cli/commands/env.ts
@@ -43382,14 +43695,14 @@ init_errors();
 init_exit_codes();
 init_paths();
 init_json();
-import { join as join62 } from "node:path";
+import { join as join63 } from "node:path";
 var VALID_CATEGORIES = ["write", "read", "sync", "maintenance"];
 var VALID_RELEVANCE = ["critical", "high", "medium", "low"];
 async function locateCommandsIndex() {
   const cleoHome = getCleoHome();
   const paths = [
-    join62(cleoHome, "docs", "commands", "COMMANDS-INDEX.json"),
-    join62(process.cwd(), "docs", "commands", "COMMANDS-INDEX.json")
+    join63(cleoHome, "docs", "commands", "COMMANDS-INDEX.json"),
+    join63(process.cwd(), "docs", "commands", "COMMANDS-INDEX.json")
   ];
   for (const p of paths) {
     const data = await readJson(p);
@@ -43470,9 +43783,9 @@ init_errors();
 init_json();
 init_paths();
 import { readdir as readdir2, readFile as readFile16 } from "node:fs/promises";
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 async function getScriptNames(projectRoot) {
-  const scriptsDir = join63(projectRoot, "scripts");
+  const scriptsDir = join64(projectRoot, "scripts");
   try {
     const files = await readdir2(scriptsDir);
     return files.filter((f) => f.endsWith(".sh")).map((f) => f.replace(".sh", "")).sort();
@@ -43481,7 +43794,7 @@ async function getScriptNames(projectRoot) {
   }
 }
 async function getIndexedCommands(projectRoot) {
-  const indexPath = join63(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
+  const indexPath = join64(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
   const index5 = await readJson(indexPath);
   if (!index5) return [];
   return index5.commands.map((c) => c.name).sort();
@@ -43514,7 +43827,7 @@ async function runGapCheck(_projectRoot, filterId) {
     const reviewFiles = files.filter((f) => f.endsWith(".md"));
     for (const file of reviewFiles) {
       if (filterId && !file.includes(filterId)) continue;
-      const filePath = join63(reviewDir, file);
+      const filePath = join64(reviewDir, file);
       const content = await readFile16(filePath, "utf-8");
       const taskMatch = file.match(/^(T\d+)/);
       const taskId = taskMatch ? taskMatch[1] : "UNKNOWN";
@@ -43618,7 +43931,7 @@ init_paths();
 init_json();
 init_data_accessor();
 import { readFile as readFile17, rm as rm3, stat as stat3 } from "node:fs/promises";
-import { join as join64 } from "node:path";
+import { join as join65 } from "node:path";
 function parseTaskId(content) {
   const match = content.match(/^\[T(\d+)\]/);
   return match ? `T${match[1]}` : null;
@@ -43674,7 +43987,7 @@ function registerExtractCommand(program2) {
       const accessor = await getAccessor();
       const taskData = await accessor.loadTaskFile();
       const cleoDir = getCleoDir();
-      const stateFile = join64(cleoDir, "sync", "todowrite-session.json");
+      const stateFile = join65(cleoDir, "sync", "todowrite-session.json");
       let sessionState = null;
       try {
         sessionState = await readJson(stateFile);
@@ -43862,15 +44175,15 @@ init_exit_codes();
 init_paths();
 import { spawn as spawn2, execFileSync as execFileSync12 } from "node:child_process";
 import { readFile as readFile18, writeFile as writeFile12, mkdir as mkdir12, rm as rm4, stat as stat4 } from "node:fs/promises";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 var DEFAULT_PORT = 3456;
 var DEFAULT_HOST = "127.0.0.1";
 function getWebPaths() {
   const cleoHome = getCleoHome();
   return {
-    pidFile: join65(cleoHome, "web-server.pid"),
-    configFile: join65(cleoHome, "web-server.json"),
-    logFile: join65(cleoHome, "logs", "web-server.log")
+    pidFile: join66(cleoHome, "web-server.pid"),
+    configFile: join66(cleoHome, "web-server.json"),
+    logFile: join66(cleoHome, "logs", "web-server.log")
   };
 }
 function isProcessRunning(pid) {
@@ -43914,14 +44227,14 @@ function registerWebCommand(program2) {
         throw new CleoError(1 /* GENERAL_ERROR */, `Server already running (PID: ${status.pid})`);
       }
       const projectRoot = process.env["CLEO_ROOT"] ?? process.cwd();
-      const distMcpDir = join65(projectRoot, "dist", "mcp");
-      await mkdir12(join65(getCleoHome(), "logs"), { recursive: true });
+      const distMcpDir = join66(projectRoot, "dist", "mcp");
+      await mkdir12(join66(getCleoHome(), "logs"), { recursive: true });
       await writeFile12(configFile, JSON.stringify({
         port,
         host,
         startedAt: (/* @__PURE__ */ new Date()).toISOString()
       }));
-      const webIndexPath = join65(distMcpDir, "index.js");
+      const webIndexPath = join66(distMcpDir, "index.js");
       try {
         await stat4(webIndexPath);
       } catch {
@@ -44145,13 +44458,13 @@ init_renderers();
 init_errors();
 init_exit_codes();
 init_paths();
-import { existsSync as existsSync63, readFileSync as readFileSync46, writeFileSync as writeFileSync10, mkdirSync as mkdirSync15 } from "node:fs";
+import { existsSync as existsSync64, readFileSync as readFileSync47, writeFileSync as writeFileSync11, mkdirSync as mkdirSync15 } from "node:fs";
 import { execFileSync as execFileSync13 } from "node:child_process";
-import { join as join66, dirname as dirname15 } from "node:path";
+import { join as join67, dirname as dirname15 } from "node:path";
 function getChangelogSource(cwd) {
   const configPath = getConfigPath(cwd);
   try {
-    const config = JSON.parse(readFileSync46(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync47(configPath, "utf-8"));
     return config?.release?.changelog?.source ?? "CHANGELOG.md";
   } catch {
     return "CHANGELOG.md";
@@ -44160,7 +44473,7 @@ function getChangelogSource(cwd) {
 function getEnabledPlatforms(cwd) {
   const configPath = getConfigPath(cwd);
   try {
-    const config = JSON.parse(readFileSync46(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync47(configPath, "utf-8"));
     const outputs = config?.release?.changelog?.outputs ?? [];
     return outputs.filter((o) => o.enabled);
   } catch {
@@ -44287,11 +44600,11 @@ function registerGenerateChangelogCommand(program2) {
       const targetPlatform = opts["platform"];
       const dryRun = !!opts["dryRun"];
       const sourceFile = getChangelogSource();
-      const sourcePath = join66(getProjectRoot(), sourceFile);
-      if (!existsSync63(sourcePath)) {
+      const sourcePath = join67(getProjectRoot(), sourceFile);
+      if (!existsSync64(sourcePath)) {
         throw new CleoError(4 /* NOT_FOUND */, `Changelog source not found: ${sourcePath}`);
       }
-      const sourceContent = readFileSync46(sourcePath, "utf-8");
+      const sourceContent = readFileSync47(sourcePath, "utf-8");
       const repoSlug = getGitHubRepoSlug();
       const results = [];
       if (targetPlatform) {
@@ -44300,9 +44613,9 @@ function registerGenerateChangelogCommand(program2) {
         const outputPath = platformConfig?.path ?? getDefaultOutputPath(targetPlatform);
         const content = generateForPlatform(targetPlatform, sourceContent, repoSlug, limit);
         if (!dryRun) {
-          const fullPath = join66(getProjectRoot(), outputPath);
+          const fullPath = join67(getProjectRoot(), outputPath);
           mkdirSync15(dirname15(fullPath), { recursive: true });
-          writeFileSync10(fullPath, content, "utf-8");
+          writeFileSync11(fullPath, content, "utf-8");
         }
         results.push({ platform: targetPlatform, path: outputPath, written: !dryRun });
       } else {
@@ -44321,9 +44634,9 @@ function registerGenerateChangelogCommand(program2) {
             limit
           );
           if (!dryRun) {
-            const fullPath = join66(getProjectRoot(), platformConfig.path);
+            const fullPath = join67(getProjectRoot(), platformConfig.path);
             mkdirSync15(dirname15(fullPath), { recursive: true });
-            writeFileSync10(fullPath, content, "utf-8");
+            writeFileSync11(fullPath, content, "utf-8");
           }
           results.push({
             platform: platformConfig.platform,
@@ -45076,22 +45389,22 @@ function registerPlanCommand(program2) {
 }
 
 // src/core/otel/index.ts
-import { readFileSync as readFileSync47, existsSync as existsSync64, writeFileSync as writeFileSync11, copyFileSync as copyFileSync4 } from "node:fs";
-import { join as join67 } from "node:path";
+import { readFileSync as readFileSync48, existsSync as existsSync65, writeFileSync as writeFileSync12, copyFileSync as copyFileSync4 } from "node:fs";
+import { join as join68 } from "node:path";
 function getProjectRoot2() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (existsSync64(join67(dir, ".cleo", "config.json"))) return dir;
-    dir = join67(dir, "..");
+    if (existsSync65(join68(dir, ".cleo", "config.json"))) return dir;
+    dir = join68(dir, "..");
   }
   return process.cwd();
 }
 function getTokenFilePath() {
-  return join67(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
+  return join68(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
 }
 function readJsonlFile(filePath) {
-  if (!existsSync64(filePath)) return [];
-  const content = readFileSync47(filePath, "utf-8").trim();
+  if (!existsSync65(filePath)) return [];
+  const content = readFileSync48(filePath, "utf-8").trim();
   if (!content) return [];
   return content.split("\n").map((line) => JSON.parse(line));
 }
@@ -45173,10 +45486,10 @@ async function getRealTokenUsage(_opts) {
 }
 async function clearOtelData() {
   const tokenFile = getTokenFilePath();
-  if (existsSync64(tokenFile)) {
+  if (existsSync65(tokenFile)) {
     const backup = `${tokenFile}.backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
     copyFileSync4(tokenFile, backup);
-    writeFileSync11(tokenFile, "");
+    writeFileSync12(tokenFile, "");
     return { message: "Token tracking cleared", backup };
   }
   return { message: "No token file to clear" };
@@ -45538,8 +45851,8 @@ init_storage_preflight();
 init_paths();
 init_storage_preflight();
 init_agent_outputs();
-import { existsSync as existsSync68, readFileSync as readFileSync49, writeFileSync as writeFileSync12, mkdirSync as mkdirSync18, readdirSync as readdirSync19, copyFileSync as copyFileSync5 } from "node:fs";
-import { join as join71 } from "node:path";
+import { existsSync as existsSync69, readFileSync as readFileSync50, writeFileSync as writeFileSync13, mkdirSync as mkdirSync18, readdirSync as readdirSync19, copyFileSync as copyFileSync5 } from "node:fs";
+import { join as join72 } from "node:path";
 
 // src/store/index.ts
 init_atomic();
@@ -45575,8 +45888,8 @@ async function runUpgrade(options = {}) {
     return { success: false, upToDate: false, dryRun: isDryRun, actions, applied: 0, errors: [String(err)] };
   }
   const cleoDir = getCleoDirAbsolute(options.cwd);
-  const dbPath = join71(cleoDir, "tasks.db");
-  const dbExists2 = existsSync68(dbPath);
+  const dbPath = join72(cleoDir, "tasks.db");
+  const dbExists2 = existsSync69(dbPath);
   const legacyRecordCount = preflight.details.todoJsonTaskCount + preflight.details.archiveJsonTaskCount + preflight.details.sessionsJsonCount;
   const needsMigration = !dbExists2 && legacyRecordCount > 0;
   const needsCleanup = dbExists2 && preflight.migrationNeeded;
@@ -45592,7 +45905,7 @@ async function runUpgrade(options = {}) {
       let migrationLock = null;
       try {
         const cleoDir2 = getCleoDirAbsolute(options.cwd);
-        const dbPath2 = join71(cleoDir2, "tasks.db");
+        const dbPath2 = join72(cleoDir2, "tasks.db");
         try {
           migrationLock = await acquireLock(dbPath2, { stale: 3e4, retries: 0 });
         } catch {
@@ -45617,23 +45930,23 @@ async function runUpgrade(options = {}) {
         } = await Promise.resolve().then(() => (init_state(), state_exports));
         const logger = new MigrationLogger2(cleoDir2);
         await createMigrationState2(cleoDir2, {
-          todoJson: { path: join71(cleoDir2, "todo.json"), checksum: "" },
-          sessionsJson: { path: join71(cleoDir2, "sessions.json"), checksum: "" },
-          archiveJson: { path: join71(cleoDir2, "todo-archive.json"), checksum: "" }
+          todoJson: { path: join72(cleoDir2, "todo.json"), checksum: "" },
+          sessionsJson: { path: join72(cleoDir2, "sessions.json"), checksum: "" },
+          archiveJson: { path: join72(cleoDir2, "todo-archive.json"), checksum: "" }
         });
         await updateMigrationPhase2(cleoDir2, "backup");
         logger.info("init", "start", "Migration state initialized");
-        const dbBackupPath = join71(cleoDir2, "backups", "safety", `tasks.db.pre-migration.${Date.now()}`);
-        const dbTempPath = join71(cleoDir2, "tasks.db.migrating");
-        if (existsSync68(dbPath2)) {
-          const backupDir = join71(cleoDir2, "backups", "safety");
-          if (!existsSync68(backupDir)) {
+        const dbBackupPath = join72(cleoDir2, "backups", "safety", `tasks.db.pre-migration.${Date.now()}`);
+        const dbTempPath = join72(cleoDir2, "tasks.db.migrating");
+        if (existsSync69(dbPath2)) {
+          const backupDir = join72(cleoDir2, "backups", "safety");
+          if (!existsSync69(backupDir)) {
             mkdirSync18(backupDir, { recursive: true });
           }
           copyFileSync5(dbPath2, dbBackupPath);
           const { createHash: createHash9 } = await import("node:crypto");
-          const origChecksum = createHash9("sha256").update(readFileSync49(dbPath2)).digest("hex");
-          const backupChecksum = createHash9("sha256").update(readFileSync49(dbBackupPath)).digest("hex");
+          const origChecksum = createHash9("sha256").update(readFileSync50(dbPath2)).digest("hex");
+          const backupChecksum = createHash9("sha256").update(readFileSync50(dbBackupPath)).digest("hex");
           if (origChecksum !== backupChecksum) {
             throw new Error(
               `Backup verification failed: checksum mismatch. Aborting migration to prevent data loss.`
@@ -45648,14 +45961,14 @@ async function runUpgrade(options = {}) {
           }
           logger.info("backup", "verified", "Backup integrity verified", { checksum: origChecksum });
         }
-        if (existsSync68(dbTempPath)) {
+        if (existsSync69(dbTempPath)) {
           const { unlinkSync: unlinkSync5 } = await import("node:fs");
           unlinkSync5(dbTempPath);
         }
-        const configPath = join71(cleoDir2, "config.json");
+        const configPath = join72(cleoDir2, "config.json");
         let configBackup = null;
-        if (existsSync68(configPath)) {
-          configBackup = readFileSync49(configPath, "utf-8");
+        if (existsSync69(configPath)) {
+          configBackup = readFileSync50(configPath, "utf-8");
         }
         const { resetDbState: resetDbState2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
         resetDbState2();
@@ -45681,10 +45994,10 @@ async function runUpgrade(options = {}) {
         resetDbState2();
         if (result.success) {
           const totalImported = result.tasksImported + result.archivedImported;
-          if (totalImported === 0 && existsSync68(dbBackupPath)) {
+          if (totalImported === 0 && existsSync69(dbBackupPath)) {
             copyFileSync5(dbBackupPath, dbPath2);
             if (configBackup) {
-              writeFileSync12(configPath, configBackup);
+              writeFileSync13(configPath, configBackup);
             }
             actions.push({
               action: "storage_migration",
@@ -45695,9 +46008,9 @@ async function runUpgrade(options = {}) {
             errors.push("Migration imported 0 tasks \u2014 restored from backup to prevent data loss");
           } else {
             let config = {};
-            if (existsSync68(configPath)) {
+            if (existsSync69(configPath)) {
               try {
-                config = JSON.parse(readFileSync49(configPath, "utf-8"));
+                config = JSON.parse(readFileSync50(configPath, "utf-8"));
               } catch {
               }
             }
@@ -45705,7 +46018,7 @@ async function runUpgrade(options = {}) {
               config.storage = {};
             }
             config.storage.engine = "sqlite";
-            writeFileSync12(configPath, JSON.stringify(config, null, 2));
+            writeFileSync13(configPath, JSON.stringify(config, null, 2));
             actions.push({
               action: "storage_migration",
               status: "applied",
@@ -45723,11 +46036,11 @@ async function runUpgrade(options = {}) {
             logger.info("complete", "finish", "Migration completed successfully");
           }
         } else {
-          if (existsSync68(dbBackupPath)) {
+          if (existsSync69(dbBackupPath)) {
             copyFileSync5(dbBackupPath, dbPath2);
           }
           if (configBackup) {
-            writeFileSync12(configPath, configBackup);
+            writeFileSync13(configPath, configBackup);
           }
           await updateMigrationPhase2(cleoDir2, "failed");
           for (const error of result.errors) {
@@ -45746,12 +46059,12 @@ async function runUpgrade(options = {}) {
       } catch (err) {
         try {
           const cleoDir2 = getCleoDirAbsolute(options.cwd);
-          const dbPath2 = join71(cleoDir2, "tasks.db");
-          const safetyDir = join71(cleoDir2, "backups", "safety");
-          if (existsSync68(safetyDir)) {
+          const dbPath2 = join72(cleoDir2, "tasks.db");
+          const safetyDir = join72(cleoDir2, "backups", "safety");
+          if (existsSync69(safetyDir)) {
             const backups = readdirSync19(safetyDir).filter((f) => f.startsWith("tasks.db.pre-migration.")).sort().reverse();
-            if (backups.length > 0 && !existsSync68(dbPath2)) {
-              copyFileSync5(join71(safetyDir, backups[0]), dbPath2);
+            if (backups.length > 0 && !existsSync69(dbPath2)) {
+              copyFileSync5(join72(safetyDir, backups[0]), dbPath2);
             }
           }
         } catch {
@@ -45786,7 +46099,7 @@ async function runUpgrade(options = {}) {
       details: preflight.summary
     });
   }
-  if (existsSync68(dbPath)) {
+  if (existsSync69(dbPath)) {
     try {
       const { runAllRepairs: runAllRepairs2 } = await Promise.resolve().then(() => (init_repair(), repair_exports));
       const repairActions = await runAllRepairs2(options.cwd, isDryRun);
@@ -45796,8 +46109,8 @@ async function runUpgrade(options = {}) {
     } catch {
     }
   }
-  if (existsSync68(dbPath)) {
-    const legacySequenceFiles = [".sequence", ".sequence.json"].filter((f) => existsSync68(join71(cleoDir, f)));
+  if (existsSync69(dbPath)) {
+    const legacySequenceFiles = [".sequence", ".sequence.json"].filter((f) => existsSync69(join72(cleoDir, f)));
     if (legacySequenceFiles.length > 0) {
       if (isDryRun) {
         actions.push({
@@ -45826,7 +46139,7 @@ async function runUpgrade(options = {}) {
   }
   if (needsCleanup) {
     const staleJsonFiles = ["todo.json", "sessions.json", "todo-archive.json", ".sequence", ".sequence.json"];
-    const foundStale = staleJsonFiles.filter((f) => existsSync68(join71(cleoDir, f)));
+    const foundStale = staleJsonFiles.filter((f) => existsSync69(join72(cleoDir, f)));
     if (foundStale.length > 0) {
       if (isDryRun) {
         actions.push({
@@ -45836,15 +46149,15 @@ async function runUpgrade(options = {}) {
         });
       } else {
         try {
-          const backupDir = join71(cleoDir, ".backups", `legacy-json-${Date.now()}`);
+          const backupDir = join72(cleoDir, ".backups", `legacy-json-${Date.now()}`);
           mkdirSync18(backupDir, { recursive: true });
           for (const f of foundStale) {
-            const src = join71(cleoDir, f);
-            copyFileSync5(src, join71(backupDir, f));
+            const src = join72(cleoDir, f);
+            copyFileSync5(src, join72(backupDir, f));
           }
           const { unlinkSync: unlinkSync5 } = await import("node:fs");
           for (const f of foundStale) {
-            unlinkSync5(join71(cleoDir, f));
+            unlinkSync5(join72(cleoDir, f));
           }
           actions.push({
             action: "stale_json_cleanup",
@@ -45864,7 +46177,7 @@ async function runUpgrade(options = {}) {
   if (options.includeGlobal) {
     try {
       const globalDir = getCleoHome();
-      const globalPreflight = checkStorageMigration(join71(globalDir, ".."));
+      const globalPreflight = checkStorageMigration(join72(globalDir, ".."));
       if (globalPreflight.migrationNeeded) {
         actions.push({
           action: "global_storage_check",
@@ -45885,8 +46198,8 @@ async function runUpgrade(options = {}) {
   try {
     const projectRoot = getProjectRoot(options.cwd);
     if (isDryRun) {
-      const gitignorePath = join71(cleoDir, ".gitignore");
-      if (!existsSync68(gitignorePath)) {
+      const gitignorePath = join72(cleoDir, ".gitignore");
+      if (!existsSync69(gitignorePath)) {
         actions.push({ action: "gitignore_integrity", status: "preview", details: "Would create .cleo/.gitignore from template" });
       } else {
         actions.push({ action: "gitignore_integrity", status: "preview", details: "Would verify .cleo/.gitignore matches template" });
@@ -45929,12 +46242,12 @@ async function runUpgrade(options = {}) {
   try {
     const projectRootForContext = getProjectRoot(options.cwd);
     if (isDryRun) {
-      const contextPath = join71(cleoDir, "project-context.json");
-      if (!existsSync68(contextPath)) {
+      const contextPath = join72(cleoDir, "project-context.json");
+      if (!existsSync69(contextPath)) {
         actions.push({ action: "project_context_detection", status: "preview", details: "Would detect and create project-context.json" });
       } else {
         try {
-          const context = JSON.parse(readFileSync49(contextPath, "utf-8"));
+          const context = JSON.parse(readFileSync50(contextPath, "utf-8"));
           if (context.detectedAt) {
             const daysSince = (Date.now() - new Date(context.detectedAt).getTime()) / (1e3 * 60 * 60 * 24);
             if (daysSince > 30) {
@@ -46095,7 +46408,7 @@ async function runUpgrade(options = {}) {
 init_runtime();
 import { readFile as readFile20 } from "node:fs/promises";
 import * as readline from "node:readline";
-import { join as join72 } from "node:path";
+import { join as join73 } from "node:path";
 import { execFile as execFile7 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
 init_build_config();
@@ -46104,7 +46417,7 @@ var GITHUB_REPO = BUILD_CONFIG.repository.fullName;
 async function getCurrentVersion() {
   const cleoHome = getCleoHome();
   try {
-    const content = await readFile20(join72(cleoHome, "VERSION"), "utf-8");
+    const content = await readFile20(join73(cleoHome, "VERSION"), "utf-8");
     return (content.split("\n")[0] ?? "unknown").trim();
   } catch {
     return "unknown";
@@ -46151,7 +46464,7 @@ async function writeRuntimeVersionMetadata(mode, source, version) {
     `installed=${(/* @__PURE__ */ new Date()).toISOString()}`
   ];
   await import("node:fs/promises").then(
-    ({ writeFile: writeFile15, mkdir: mkdir14 }) => mkdir14(cleoHome, { recursive: true }).then(() => writeFile15(join72(cleoHome, "VERSION"), `${lines.join("\n")}
+    ({ writeFile: writeFile15, mkdir: mkdir14 }) => mkdir14(cleoHome, { recursive: true }).then(() => writeFile15(join73(cleoHome, "VERSION"), `${lines.join("\n")}
 `, "utf-8"))
   );
 }
@@ -46510,14 +46823,14 @@ function registerVerifyCommand(program2) {
 
 // src/cli/commands/detect-drift.ts
 init_renderers();
-import { readFileSync as readFileSync50, existsSync as existsSync69, readdirSync as readdirSync20 } from "node:fs";
-import { join as join73, dirname as dirname18 } from "node:path";
+import { readFileSync as readFileSync51, existsSync as existsSync70, readdirSync as readdirSync20 } from "node:fs";
+import { join as join74, dirname as dirname18 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function findProjectRoot() {
   const currentFile = fileURLToPath5(import.meta.url);
   let currentDir = dirname18(currentFile);
   while (currentDir !== "/") {
-    if (existsSync69(join73(currentDir, "package.json"))) {
+    if (existsSync70(join74(currentDir, "package.json"))) {
       return currentDir;
     }
     const parent = dirname18(currentDir);
@@ -46555,16 +46868,16 @@ function registerDetectDriftCommand(program2) {
     };
     const safeRead = (path) => {
       try {
-        return readFileSync50(path, "utf-8");
+        return readFileSync51(path, "utf-8");
       } catch {
         return "";
       }
     };
     try {
-      const specPath = join73(projectRoot, "docs", "specs", "CLEO-OPERATIONS-REFERENCE.md");
-      const queryPath = join73(projectRoot, "src", "mcp", "gateways", "query.ts");
-      const mutatePath = join73(projectRoot, "src", "mcp", "gateways", "mutate.ts");
-      if (!existsSync69(specPath)) {
+      const specPath = join74(projectRoot, "docs", "specs", "CLEO-OPERATIONS-REFERENCE.md");
+      const queryPath = join74(projectRoot, "src", "mcp", "gateways", "query.ts");
+      const mutatePath = join74(projectRoot, "src", "mcp", "gateways", "mutate.ts");
+      if (!existsSync70(specPath)) {
         addCheck("Gateway-to-spec sync", "fail", "CLEO-OPERATIONS-REFERENCE.md missing", [{
           severity: "error",
           category: "spec",
@@ -46572,7 +46885,7 @@ function registerDetectDriftCommand(program2) {
           file: specPath,
           recommendation: "Create docs/specs/CLEO-OPERATIONS-REFERENCE.md with canonical operation definitions"
         }]);
-      } else if (!existsSync69(queryPath) || !existsSync69(mutatePath)) {
+      } else if (!existsSync70(queryPath) || !existsSync70(mutatePath)) {
         addCheck("Gateway-to-spec sync", "fail", "MCP gateway files missing", [{
           severity: "error",
           category: "implementation",
@@ -46626,16 +46939,16 @@ function registerDetectDriftCommand(program2) {
       }]);
     }
     try {
-      const cliDir = join73(projectRoot, "src", "cli", "commands");
-      const coreDir = join73(projectRoot, "src", "core");
-      if (!existsSync69(cliDir)) {
+      const cliDir = join74(projectRoot, "src", "cli", "commands");
+      const coreDir = join74(projectRoot, "src", "core");
+      if (!existsSync70(cliDir)) {
         addCheck("CLI-to-core sync", "fail", "CLI commands directory missing", [{
           severity: "error",
           category: "structure",
           message: "src/cli/commands/ directory not found",
           recommendation: "Verify TypeScript source structure is intact"
         }]);
-      } else if (!existsSync69(coreDir)) {
+      } else if (!existsSync70(coreDir)) {
         addCheck("CLI-to-core sync", "fail", "Core directory missing", [{
           severity: "error",
           category: "structure",
@@ -46650,8 +46963,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("CLI-to-core sync", "fail", `Error: ${e.message}`);
     }
     try {
-      const domainsDir = join73(projectRoot, "src", "mcp", "domains");
-      if (!existsSync69(domainsDir)) {
+      const domainsDir = join74(projectRoot, "src", "mcp", "domains");
+      if (!existsSync70(domainsDir)) {
         addCheck("Domain handler coverage", "fail", "MCP domains directory missing", [{
           severity: "error",
           category: "structure",
@@ -46666,8 +46979,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Domain handler coverage", "fail", `Error: ${e.message}`);
     }
     try {
-      const matrixPath = join73(projectRoot, "src", "dispatch", "lib", "capability-matrix.ts");
-      if (!existsSync69(matrixPath)) {
+      const matrixPath = join74(projectRoot, "src", "dispatch", "lib", "capability-matrix.ts");
+      if (!existsSync70(matrixPath)) {
         addCheck("Capability matrix", "fail", "Capability matrix missing", [{
           severity: "error",
           category: "configuration",
@@ -46681,8 +46994,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Capability matrix", "fail", `Error: ${e.message}`);
     }
     try {
-      const schemaPath = join73(projectRoot, "src", "store", "schema.ts");
-      if (!existsSync69(schemaPath)) {
+      const schemaPath = join74(projectRoot, "src", "store", "schema.ts");
+      if (!existsSync70(schemaPath)) {
         addCheck("Schema validation", "fail", "Schema definition missing", [{
           severity: "error",
           category: "data-model",
@@ -46707,10 +47020,10 @@ function registerDetectDriftCommand(program2) {
       addCheck("Schema validation", "fail", `Error: ${e.message}`);
     }
     try {
-      const visionPath = join73(projectRoot, "docs", "concepts", "CLEO-VISION.md");
-      const specPath = join73(projectRoot, "docs", "specs", "PORTABLE-BRAIN-SPEC.md");
+      const visionPath = join74(projectRoot, "docs", "concepts", "CLEO-VISION.md");
+      const specPath = join74(projectRoot, "docs", "specs", "PORTABLE-BRAIN-SPEC.md");
       const issues = [];
-      if (!existsSync69(visionPath)) {
+      if (!existsSync70(visionPath)) {
         issues.push({
           severity: "error",
           category: "vision",
@@ -46719,7 +47032,7 @@ function registerDetectDriftCommand(program2) {
           recommendation: "Create docs/concepts/CLEO-VISION.md with project vision"
         });
       }
-      if (!existsSync69(specPath)) {
+      if (!existsSync70(specPath)) {
         issues.push({
           severity: "error",
           category: "spec",
@@ -46756,8 +47069,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Canonical identity", "fail", `Error: ${e.message}`);
     }
     try {
-      const injectionPath = join73(projectRoot, ".cleo", "templates", "CLEO-INJECTION.md");
-      if (!existsSync69(injectionPath)) {
+      const injectionPath = join74(projectRoot, ".cleo", "templates", "CLEO-INJECTION.md");
+      if (!existsSync70(injectionPath)) {
         addCheck("Agent injection", "fail", "Agent injection template missing", [{
           severity: "error",
           category: "agent-support",
@@ -46782,8 +47095,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Agent injection", "fail", `Error: ${e.message}`);
     }
     try {
-      const exitCodesPath = join73(projectRoot, "src", "types", "exit-codes.ts");
-      if (!existsSync69(exitCodesPath)) {
+      const exitCodesPath = join74(projectRoot, "src", "types", "exit-codes.ts");
+      if (!existsSync70(exitCodesPath)) {
         addCheck("Exit codes", "fail", "Exit codes definition missing", [{
           severity: "error",
           category: "protocol",
@@ -47022,8 +47335,8 @@ function registerRemoteCommand(program2) {
 init_renderers();
 init_paths();
 import { mkdir as mkdir13, writeFile as writeFile14, readFile as readFile21 } from "node:fs/promises";
-import { existsSync as existsSync70, readFileSync as readFileSync51 } from "node:fs";
-import { join as join74, resolve as resolve10, dirname as dirname19 } from "node:path";
+import { existsSync as existsSync71, readFileSync as readFileSync52 } from "node:fs";
+import { join as join75, resolve as resolve10, dirname as dirname19 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function registerInstallGlobalCommand(program2) {
@@ -47033,17 +47346,17 @@ function registerInstallGlobalCommand(program2) {
     const warnings = [];
     try {
       const cleoHome = getCleoHome();
-      const globalTemplatesDir = join74(cleoHome, "templates");
+      const globalTemplatesDir = join75(cleoHome, "templates");
       if (!isDryRun) {
         await mkdir13(globalTemplatesDir, { recursive: true });
       }
       try {
         const thisFile = fileURLToPath6(import.meta.url);
         const packageRoot = resolve10(dirname19(thisFile), "..", "..", "..");
-        const templatePath = join74(packageRoot, "templates", "CLEO-INJECTION.md");
-        if (existsSync70(templatePath)) {
-          const content = readFileSync51(templatePath, "utf-8");
-          const globalPath = join74(globalTemplatesDir, "CLEO-INJECTION.md");
+        const templatePath = join75(packageRoot, "templates", "CLEO-INJECTION.md");
+        if (existsSync71(templatePath)) {
+          const content = readFileSync52(templatePath, "utf-8");
+          const globalPath = join75(globalTemplatesDir, "CLEO-INJECTION.md");
           if (!isDryRun) {
             await writeFile14(globalPath, content);
           }
@@ -47053,12 +47366,12 @@ function registerInstallGlobalCommand(program2) {
         warnings.push("Could not refresh CLEO-INJECTION.md template");
       }
       const globalAgentsDir = getAgentsHome();
-      const globalAgentsMd = join74(globalAgentsDir, "AGENTS.md");
+      const globalAgentsMd = join75(globalAgentsDir, "AGENTS.md");
       try {
         const { inject, getInstalledProviders: getInstalledProviders3, injectAll: injectAll2, buildInjectionContent: buildInjectionContent2 } = await import("@cleocode/caamp");
         if (!isDryRun) {
           await mkdir13(globalAgentsDir, { recursive: true });
-          if (existsSync70(globalAgentsMd)) {
+          if (existsSync71(globalAgentsMd)) {
             const content = await readFile21(globalAgentsMd, "utf8");
             const stripped = content.replace(/\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g, "");
             if (stripped !== content) {
@@ -47077,8 +47390,8 @@ function registerInstallGlobalCommand(program2) {
           const injectionContent = buildInjectionContent2({ references: ["@~/.agents/AGENTS.md"] });
           if (!isDryRun) {
             for (const provider of providers) {
-              const instructFilePath = join74(provider.pathGlobal, provider.instructFile);
-              if (existsSync70(instructFilePath)) {
+              const instructFilePath = join75(provider.pathGlobal, provider.instructFile);
+              if (existsSync71(instructFilePath)) {
                 const fileContent = await readFile21(instructFilePath, "utf8");
                 const stripped = fileContent.replace(/\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g, "");
                 if (stripped !== fileContent) {
@@ -47093,7 +47406,7 @@ function registerInstallGlobalCommand(program2) {
             }
           } else {
             for (const p of providers) {
-              const displayPath = join74(p.pathGlobal, p.instructFile).replace(homedir4(), "~");
+              const displayPath = join75(p.pathGlobal, p.instructFile).replace(homedir4(), "~");
               created.push(`${displayPath} (would update CAAMP block)`);
             }
           }
@@ -47299,7 +47612,7 @@ init_paths();
 init_paths();
 init_brain_sqlite();
 init_brain_search();
-import { existsSync as existsSync71 } from "node:fs";
+import { existsSync as existsSync72 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 var _require5 = createRequire5(import.meta.url);
 var { DatabaseSync: DatabaseSync3 } = _require5("node:sqlite");
@@ -47343,7 +47656,7 @@ async function migrateClaudeMem(projectRoot, options = {}) {
     errors: [],
     dryRun
   };
-  if (!existsSync71(sourcePath)) {
+  if (!existsSync72(sourcePath)) {
     throw new Error(
       `claude-mem database not found at: ${sourcePath}
 Expected location: ~/.claude-mem/claude-mem.db
@@ -47745,10 +48058,10 @@ init_config();
 // src/cli/logger-bootstrap.ts
 init_logger();
 init_project_info();
-import { join as join75 } from "node:path";
+import { join as join76 } from "node:path";
 function initCliLogger(cwd, loggingConfig) {
   const projectInfo = getProjectInfoSync(cwd);
-  initLogger(join75(cwd, ".cleo"), loggingConfig, projectInfo?.projectHash);
+  initLogger(join76(cwd, ".cleo"), loggingConfig, projectInfo?.projectHash);
 }
 
 // src/cli/index.ts
@@ -47981,8 +48294,8 @@ Upgrade options:
 }
 function getPackageVersion() {
   try {
-    const moduleRoot = join76(import.meta.dirname ?? "", "..", "..");
-    const pkg = JSON.parse(readFileSync52(join76(moduleRoot, "package.json"), "utf-8"));
+    const moduleRoot = join77(import.meta.dirname ?? "", "..", "..");
+    const pkg = JSON.parse(readFileSync53(join77(moduleRoot, "package.json"), "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -48093,7 +48406,7 @@ program.hook("preAction", async () => {
     const config = await loadConfig();
     initCliLogger(process.cwd(), config.logging);
     const { pruneAuditLog: pruneAuditLog2 } = await Promise.resolve().then(() => (init_audit_prune(), audit_prune_exports));
-    pruneAuditLog2(join76(process.cwd(), ".cleo"), config.logging).catch(() => {
+    pruneAuditLog2(join77(process.cwd(), ".cleo"), config.logging).catch(() => {
     });
   } catch {
   }
@@ -48133,7 +48446,7 @@ program.hook("preAction", (thisCommand) => {
   }
 });
 if (process.argv[2] === "mcp") {
-  const mcpPath = join76(import.meta.dirname ?? "", "..", "mcp", "index.js");
+  const mcpPath = join77(import.meta.dirname ?? "", "..", "mcp", "index.js");
   const { spawn: spawn3 } = await import("node:child_process");
   const child = spawn3(
     process.execPath,