@cleocode/cleo 2026.3.16 → 2026.3.18

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",
@@ -4626,13 +4646,13 @@ async function getDb(cwd) {
     if (!_gitTrackingChecked) {
       _gitTrackingChecked = true;
       try {
-        const { execFileSync: execFileSync13 } = await import("node:child_process");
+        const { execFileSync: execFileSync15 } = await import("node:child_process");
         const gitCwd = resolve3(dbPath, "..", "..");
         const filesToCheck = [dbPath, dbPath + "-wal", dbPath + "-shm"];
         const log7 = getLogger("sqlite");
         for (const fileToCheck of filesToCheck) {
           try {
-            execFileSync13("git", ["ls-files", "--error-unmatch", fileToCheck], {
+            execFileSync15("git", ["ls-files", "--error-unmatch", fileToCheck], {
               cwd: gitCwd,
               stdio: "pipe"
             });
@@ -15396,6 +15416,7 @@ async function getProjectStats(opts, accessor) {
   const active = tasks2.filter((t) => t.status === "active").length;
   const done = tasks2.filter((t) => t.status === "done").length;
   const blocked = tasks2.filter((t) => t.status === "blocked").length;
+  const cancelled = tasks2.filter((t) => t.status === "cancelled").length;
   const totalActive = tasks2.length;
   const cutoff = new Date(Date.now() - periodDays * 864e5).toISOString();
   const entries = await queryAuditEntries(opts.cwd);
@@ -15412,11 +15433,45 @@ async function getProjectStats(opts, accessor) {
     (e) => isArchive(e) && e.timestamp >= cutoff
   ).length;
   const completionRate = createdInPeriod > 0 ? Math.round(completedInPeriod / createdInPeriod * 1e4) / 100 : 0;
-  const totalCreated = entries.filter(isCreate).length;
-  const totalCompleted = entries.filter(isComplete).length;
-  const totalArchived = entries.filter(isArchive).length;
+  let totalCreated = 0;
+  let totalCompleted = 0;
+  let totalCancelled = 0;
+  let totalArchived = 0;
+  let archivedCompleted = 0;
+  let archivedCount = 0;
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
+    const { count: dbCount, eq: dbEq, and: dbAnd } = await import("drizzle-orm");
+    const { tasks: tasksTable } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+    const db = await getDb2(opts.cwd);
+    const statusRows = await db.select({ status: tasksTable.status, c: dbCount() }).from(tasksTable).groupBy(tasksTable.status).all();
+    const statusMap = {};
+    for (const row of statusRows) {
+      statusMap[row.status] = row.c;
+    }
+    archivedCount = statusMap["archived"] ?? 0;
+    totalCreated = Object.values(statusMap).reduce((sum, n) => sum + n, 0);
+    totalCancelled = statusMap["cancelled"] ?? 0;
+    totalArchived = archivedCount;
+    const archivedDoneRow = await db.select({ c: dbCount() }).from(tasksTable).where(dbAnd(dbEq(tasksTable.status, "archived"), dbEq(tasksTable.archiveReason, "completed"))).get();
+    archivedCompleted = archivedDoneRow?.c ?? 0;
+    totalCompleted = (statusMap["done"] ?? 0) + archivedCompleted;
+  } catch {
+    totalCreated = entries.filter(isCreate).length;
+    totalCompleted = entries.filter(isComplete).length;
+    totalArchived = entries.filter(isArchive).length;
+  }
   return {
-    currentState: { pending, active, done, blocked, totalActive },
+    currentState: {
+      pending,
+      active,
+      done,
+      blocked,
+      cancelled,
+      totalActive,
+      archived: archivedCount,
+      grandTotal: totalActive + archivedCount
+    },
     completionMetrics: {
       periodDays,
       completedInPeriod,
@@ -15428,7 +15483,7 @@ async function getProjectStats(opts, accessor) {
       completedInPeriod,
       archivedInPeriod
     },
-    allTime: { totalCreated, totalCompleted, totalArchived }
+    allTime: { totalCreated, totalCompleted, totalCancelled, totalArchived, archivedCompleted }
   };
 }
 function rankBlockedTask(task, allTasks, focusTask) {
@@ -15472,7 +15527,18 @@ async function getDashboard(opts, accessor) {
   const active = tasks2.filter((t) => t.status === "active").length;
   const done = tasks2.filter((t) => t.status === "done").length;
   const blocked = tasks2.filter((t) => t.status === "blocked").length;
+  const cancelled = tasks2.filter((t) => t.status === "cancelled").length;
   const total = tasks2.length;
+  let archived = 0;
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
+    const { count: dbCount, eq: dbEq } = await import("drizzle-orm");
+    const { tasks: tasksTable } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+    const db = await getDb2(opts.cwd);
+    const row = await db.select({ c: dbCount() }).from(tasksTable).where(dbEq(tasksTable.status, "archived")).get();
+    archived = row?.c ?? 0;
+  } catch {
+  }
   const project = data.project?.name ?? "Unknown Project";
   const currentPhase = data.project?.currentPhase ?? null;
   const focusId = data.focus?.currentTask ?? null;
@@ -15480,7 +15546,7 @@ async function getDashboard(opts, accessor) {
   if (focusId) {
     focusTask = tasks2.find((t) => t.id === focusId) ?? null;
   }
-  const highPriority = tasks2.filter((t) => (t.priority === "critical" || t.priority === "high") && t.status !== "done").sort((a, b) => {
+  const highPriority = tasks2.filter((t) => (t.priority === "critical" || t.priority === "high") && t.status !== "done" && t.status !== "cancelled").sort((a, b) => {
     const pDiff = (PRIORITY_ORDER[a.priority ?? "low"] ?? 9) - (PRIORITY_ORDER[b.priority ?? "low"] ?? 9);
     if (pDiff !== 0) return pDiff;
     return (a.createdAt ?? "").localeCompare(b.createdAt ?? "");
@@ -15493,6 +15559,7 @@ async function getDashboard(opts, accessor) {
   }).map((r) => r.task);
   const labelMap = {};
   for (const t of tasks2) {
+    if (t.status === "cancelled") continue;
     for (const label of t.labels ?? []) {
       labelMap[label] = (labelMap[label] ?? 0) + 1;
     }
@@ -15501,7 +15568,7 @@ async function getDashboard(opts, accessor) {
   return {
     project,
     currentPhase,
-    summary: { pending, active, blocked, done, total },
+    summary: { pending, active, blocked, done, cancelled, total, archived, grandTotal: total + archived },
     focus: { currentTask: focusId, task: focusTask },
     highPriority: { count: highPriority.length, tasks: highPriority.slice(0, 5) },
     blockedTasks: {
@@ -19553,7 +19620,9 @@ async function systemDash(projectRoot, params) {
           blocked: summary.blocked,
           done: summary.done,
           cancelled: summary.cancelled ?? 0,
-          total: summary.total
+          total: summary.total,
+          archived: summary.archived ?? 0,
+          grandTotal: summary.grandTotal ?? summary.total
         },
         taskWork: data.focus ?? data.taskWork,
         activeSession: data.activeSession ?? null,
@@ -19573,17 +19642,18 @@ async function systemStats(projectRoot, params) {
     const result = await getProjectStats({ period: String(params?.period ?? 30), cwd: projectRoot }, accessor);
     const taskData = await accessor.loadTaskFile();
     const tasks2 = taskData?.tasks ?? [];
+    const activeTasks = tasks2.filter((t) => t.status !== "cancelled");
     const byPriority = {};
-    for (const t of tasks2) {
+    for (const t of activeTasks) {
       byPriority[t.priority] = (byPriority[t.priority] ?? 0) + 1;
     }
     const byType = {};
-    for (const t of tasks2) {
+    for (const t of activeTasks) {
       const type = t.type || "task";
       byType[type] = (byType[type] ?? 0) + 1;
     }
     const byPhase = {};
-    for (const t of tasks2) {
+    for (const t of activeTasks) {
       const phase = t.phase || "unassigned";
       byPhase[phase] = (byPhase[phase] ?? 0) + 1;
     }
@@ -19613,7 +19683,9 @@ async function systemStats(projectRoot, params) {
           done: currentState.done,
           blocked: currentState.blocked,
           cancelled: tasks2.filter((t) => t.status === "cancelled").length,
-          totalActive: currentState.totalActive
+          totalActive: currentState.totalActive,
+          archived: currentState.archived ?? 0,
+          grandTotal: currentState.grandTotal ?? currentState.totalActive
         },
         byPriority,
         byType,
@@ -19638,10 +19710,10 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join76 } = await import("node:path");
-    const { existsSync: existsSync71 } = await import("node:fs");
-    const dbPath = join76(projectRoot, ".cleo", "tasks.db");
-    if (!existsSync71(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 {
@@ -20497,10 +20569,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync52, existsSync: existsSync71 } = await import("node:fs");
+    const { readFileSync: readFileSync54, existsSync: existsSync73 } = await import("node:fs");
     const infoPath = join33(projectPath, ".cleo", "project-info.json");
-    if (!existsSync71(infoPath)) return "";
-    const data = JSON.parse(readFileSync52(infoPath, "utf-8"));
+    if (!existsSync73(infoPath)) return "";
+    const data = JSON.parse(readFileSync54(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -27978,11 +28050,353 @@ var init_changelog_writer = __esm({
   }
 });
 
-// src/core/release/release-manifest.ts
-import { existsSync as existsSync48, renameSync as renameSync7 } from "node:fs";
-import { readFile as readFile10 } from "node:fs/promises";
+// src/core/release/github-pr.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
+function isGhCliAvailable() {
+  try {
+    execFileSync6("gh", ["--version"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractRepoOwnerAndName(remote) {
+  const trimmed = remote.trim();
+  const httpsMatch = trimmed.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  const sshMatch = trimmed.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+  return null;
+}
+async function detectBranchProtection(branch, remote, projectRoot) {
+  const cwdOpts = projectRoot ? { cwd: projectRoot } : {};
+  if (isGhCliAvailable()) {
+    try {
+      const remoteUrl = execFileSync6("git", ["remote", "get-url", remote], {
+        encoding: "utf-8",
+        stdio: "pipe",
+        ...cwdOpts
+      }).trim();
+      const identity = extractRepoOwnerAndName(remoteUrl);
+      if (identity) {
+        const { owner, repo } = identity;
+        try {
+          execFileSync6(
+            "gh",
+            ["api", `/repos/${owner}/${repo}/branches/${branch}/protection`],
+            {
+              encoding: "utf-8",
+              stdio: "pipe",
+              ...cwdOpts
+            }
+          );
+          return { protected: true, detectionMethod: "gh-api" };
+        } catch (apiErr) {
+          const stderr2 = apiErr instanceof Error && "stderr" in apiErr ? String(apiErr.stderr ?? "") : "";
+          if (stderr2.includes("404") || stderr2.includes("Not Found")) {
+            return { protected: false, detectionMethod: "gh-api" };
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const result = execFileSync6(
+      "git",
+      ["push", "--dry-run", remote, `HEAD:${branch}`],
+      {
+        encoding: "utf-8",
+        stdio: "pipe",
+        ...cwdOpts
+      }
+    );
+    const output = typeof result === "string" ? result : "";
+    if (output.includes("protected branch") || output.includes("GH006") || output.includes("refusing to allow")) {
+      return { protected: true, detectionMethod: "push-dry-run" };
+    }
+    return { protected: false, detectionMethod: "push-dry-run" };
+  } catch (pushErr) {
+    const stderr2 = pushErr instanceof Error && "stderr" in pushErr ? String(pushErr.stderr ?? "") : pushErr instanceof Error ? pushErr.message : String(pushErr);
+    if (stderr2.includes("protected branch") || stderr2.includes("GH006") || stderr2.includes("refusing to allow")) {
+      return { protected: true, detectionMethod: "push-dry-run" };
+    }
+    return {
+      protected: false,
+      detectionMethod: "unknown",
+      error: stderr2
+    };
+  }
+}
+function buildPRBody(opts) {
+  const epicLine = opts.epicId ? `**Epic**: ${opts.epicId}
+
+` : "";
+  return [
+    `## Release v${opts.version}`,
+    "",
+    `${epicLine}This PR merges the ${opts.head} branch into ${opts.base} to publish the release.`,
+    "",
+    "### Checklist",
+    "- [ ] CHANGELOG.md updated",
+    "- [ ] All release tasks complete",
+    "- [ ] Version bump committed",
+    "",
+    "---",
+    "*Created by CLEO release pipeline*"
+  ].join("\n");
+}
+function formatManualPRInstructions(opts) {
+  const epicSuffix = opts.epicId ? ` (${opts.epicId})` : "";
+  return [
+    "Branch protection detected or gh CLI unavailable. Create the PR manually:",
+    "",
+    `  gh pr create \\`,
+    `    --base ${opts.base} \\`,
+    `    --head ${opts.head} \\`,
+    `    --title "${opts.title}" \\`,
+    `    --body "Release v${opts.version}${epicSuffix}"`,
+    "",
+    `Or visit: https://github.com/[owner]/[repo]/compare/${opts.base}...${opts.head}`,
+    "",
+    "After merging, CI will automatically publish to npm."
+  ].join("\n");
+}
+async function createPullRequest(opts) {
+  if (!isGhCliAvailable()) {
+    return {
+      mode: "manual",
+      instructions: formatManualPRInstructions(opts)
+    };
+  }
+  const body = buildPRBody(opts);
+  const args = [
+    "pr",
+    "create",
+    "--base",
+    opts.base,
+    "--head",
+    opts.head,
+    "--title",
+    opts.title,
+    "--body",
+    body
+  ];
+  if (opts.labels && opts.labels.length > 0) {
+    for (const label of opts.labels) {
+      args.push("--label", label);
+    }
+  }
+  try {
+    const output = execFileSync6("gh", args, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      ...opts.projectRoot ? { cwd: opts.projectRoot } : {}
+    });
+    const prUrl = output.trim();
+    const numberMatch = prUrl.match(/\/pull\/(\d+)$/);
+    const prNumber = numberMatch ? parseInt(numberMatch[1], 10) : void 0;
+    return {
+      mode: "created",
+      prUrl,
+      prNumber
+    };
+  } catch (err) {
+    const stderr2 = err instanceof Error && "stderr" in err ? String(err.stderr ?? "") : err instanceof Error ? err.message : String(err);
+    if (stderr2.includes("already exists")) {
+      const urlMatch = stderr2.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/);
+      const existingUrl = urlMatch ? urlMatch[0] : void 0;
+      return {
+        mode: "skipped",
+        prUrl: existingUrl,
+        instructions: "PR already exists"
+      };
+    }
+    return {
+      mode: "manual",
+      instructions: formatManualPRInstructions(opts),
+      error: stderr2
+    };
+  }
+}
+var init_github_pr = __esm({
+  "src/core/release/github-pr.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/release/channel.ts
+function getDefaultChannelConfig() {
+  return {
+    main: "main",
+    develop: "develop",
+    feature: "feature/"
+  };
+}
+function resolveChannelFromBranch(branch, config) {
+  const cfg = config ?? getDefaultChannelConfig();
+  if (cfg.custom) {
+    if (Object.prototype.hasOwnProperty.call(cfg.custom, branch)) {
+      return cfg.custom[branch];
+    }
+    let bestPrefix = "";
+    let bestChannel;
+    for (const [key, channel] of Object.entries(cfg.custom)) {
+      if (branch.startsWith(key) && key.length > bestPrefix.length) {
+        bestPrefix = key;
+        bestChannel = channel;
+      }
+    }
+    if (bestChannel !== void 0) {
+      return bestChannel;
+    }
+  }
+  if (branch === cfg.main) {
+    return "latest";
+  }
+  if (branch === cfg.develop) {
+    return "beta";
+  }
+  const alphaPrefixes = ["feature/", "hotfix/", "release/"];
+  if (cfg.feature && !alphaPrefixes.includes(cfg.feature)) {
+    alphaPrefixes.push(cfg.feature);
+  }
+  for (const prefix of alphaPrefixes) {
+    if (branch.startsWith(prefix)) {
+      return "alpha";
+    }
+  }
+  return "alpha";
+}
+function channelToDistTag(channel) {
+  const tags = {
+    latest: "latest",
+    beta: "beta",
+    alpha: "alpha"
+  };
+  return tags[channel];
+}
+function describeChannel(channel) {
+  const descriptions = {
+    latest: "stable release published to npm @latest",
+    beta: "pre-release published to npm @beta (develop branch)",
+    alpha: "early pre-release published to npm @alpha (feature/hotfix branches)"
+  };
+  return descriptions[channel];
+}
+var init_channel = __esm({
+  "src/core/release/channel.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/release/release-config.ts
+import { existsSync as existsSync48, readFileSync as readFileSync38 } from "node:fs";
 import { join as join46 } from "node:path";
+function readConfigValueSync(path, defaultValue, cwd) {
+  try {
+    const configPath = join46(getCleoDir(cwd), "config.json");
+    if (!existsSync48(configPath)) return defaultValue;
+    const config = JSON.parse(readFileSync38(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 loadReleaseConfig(cwd) {
+  return {
+    versioningScheme: readConfigValueSync("release.versioning.scheme", DEFAULTS2.versioningScheme, cwd),
+    tagPrefix: readConfigValueSync("release.versioning.tagPrefix", DEFAULTS2.tagPrefix, cwd),
+    changelogFormat: readConfigValueSync("release.changelog.format", DEFAULTS2.changelogFormat, cwd),
+    changelogFile: readConfigValueSync("release.changelog.file", DEFAULTS2.changelogFile, cwd),
+    artifactType: readConfigValueSync("release.artifact.type", DEFAULTS2.artifactType, cwd),
+    gates: readConfigValueSync("release.gates", [], cwd),
+    versionBump: {
+      files: readConfigValueSync("release.versionBump.files", [], cwd)
+    },
+    security: {
+      enableProvenance: readConfigValueSync("release.security.enableProvenance", false, cwd),
+      slsaLevel: readConfigValueSync("release.security.slsaLevel", 3, cwd),
+      requireSignedCommits: readConfigValueSync("release.security.requireSignedCommits", false, cwd)
+    }
+  };
+}
+function getDefaultGitFlowConfig() {
+  return {
+    enabled: true,
+    branches: {
+      main: "main",
+      develop: "develop",
+      featurePrefix: "feature/",
+      hotfixPrefix: "hotfix/",
+      releasePrefix: "release/"
+    }
+  };
+}
+function getGitFlowConfig(config) {
+  const defaults = getDefaultGitFlowConfig();
+  if (!config.gitflow) return defaults;
+  return {
+    enabled: config.gitflow.enabled ?? defaults.enabled,
+    branches: {
+      main: config.gitflow.branches?.main ?? defaults.branches.main,
+      develop: config.gitflow.branches?.develop ?? defaults.branches.develop,
+      featurePrefix: config.gitflow.branches?.featurePrefix ?? defaults.branches.featurePrefix,
+      hotfixPrefix: config.gitflow.branches?.hotfixPrefix ?? defaults.branches.hotfixPrefix,
+      releasePrefix: config.gitflow.branches?.releasePrefix ?? defaults.branches.releasePrefix
+    }
+  };
+}
+function getDefaultChannelConfig2() {
+  return {
+    main: "latest",
+    develop: "beta",
+    feature: "alpha"
+  };
+}
+function getChannelConfig(config) {
+  const defaults = getDefaultChannelConfig2();
+  if (!config.channels) return defaults;
+  return {
+    main: config.channels.main ?? defaults.main,
+    develop: config.channels.develop ?? defaults.develop,
+    feature: config.channels.feature ?? defaults.feature,
+    custom: config.channels.custom
+  };
+}
+function getPushMode(config) {
+  return config.push?.mode ?? "auto";
+}
+var DEFAULTS2;
+var init_release_config = __esm({
+  "src/core/release/release-config.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULTS2 = {
+      versioningScheme: "calver",
+      tagPrefix: "v",
+      changelogFormat: "keepachangelog",
+      changelogFile: "CHANGELOG.md",
+      artifactType: "generic-tarball"
+    };
+  }
+});
+
+// src/core/release/release-manifest.ts
+import { existsSync as existsSync49, renameSync as renameSync7 } from "node:fs";
+import { readFile as readFile10 } from "node:fs/promises";
+import { execFileSync as execFileSync7 } from "node:child_process";
+import { join as join47 } from "node:path";
 import { eq as eq14, desc as desc4 } from "drizzle-orm";
 function isValidVersion(version) {
   return /^v?\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(version);
@@ -28074,25 +28488,78 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
   const chores = [];
   const docs = [];
   const tests = [];
-  const other = [];
+  const changes = [];
+  function stripConventionalPrefix(title) {
+    return title.replace(/^(feat|fix|docs?|test|chore|refactor|style|ci|build|perf)(\([^)]+\))?:\s*/i, "");
+  }
+  function capitalize(s) {
+    return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+  }
+  function buildEntry(task) {
+    const cleanTitle = capitalize(stripConventionalPrefix(task.title));
+    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();
+      const descNorm = desc6.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
+      if (titleNorm === descNorm) return false;
+      if (descNorm.startsWith(titleNorm) && descNorm.length < titleNorm.length * 1.3) return false;
+      return desc6.length >= 20;
+    })();
+    if (shouldIncludeDesc) {
+      const descDisplay = desc6.length > 150 ? desc6.slice(0, 147) + "..." : desc6;
+      return `- **${cleanTitle}**: ${descDisplay} (${task.id})`;
+    }
+    return `- ${cleanTitle} (${task.id})`;
+  }
+  function categorizeTask(task) {
+    if (task.type === "epic") return "changes";
+    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";
+    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) => ["chore", "refactor", "cleanup", "maintenance"].includes(l.toLowerCase()))) return "chores";
+    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("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";
+  }
   for (const taskId of releaseTasks) {
     const task = taskMap.get(taskId);
     if (!task) continue;
-    const titleLower = task.title.toLowerCase();
-    const entry = `- ${task.title} (${task.id})`;
-    if (titleLower.startsWith("feat") || titleLower.includes("add ") || titleLower.includes("implement")) {
-      features.push(entry);
-    } else if (titleLower.startsWith("fix") || titleLower.includes("bug")) {
-      fixes.push(entry);
-    } else if (titleLower.startsWith("doc") || titleLower.includes("documentation")) {
-      docs.push(entry);
-    } else if (titleLower.startsWith("test") || titleLower.includes("test")) {
-      tests.push(entry);
-    } else if (titleLower.startsWith("chore") || titleLower.includes("refactor")) {
-      chores.push(entry);
-    } else {
-      other.push(entry);
-    }
+    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);
+    else if (category === "fixes") fixes.push(entry);
+    else if (category === "docs") docs.push(entry);
+    else if (category === "tests") tests.push(entry);
+    else if (category === "chores") chores.push(entry);
+    else changes.push(entry);
   }
   const sections = [];
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -28127,14 +28594,14 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
     sections.push(...chores);
     sections.push("");
   }
-  if (other.length > 0) {
-    sections.push("### Other");
-    sections.push(...other);
+  if (changes.length > 0) {
+    sections.push("### Changes");
+    sections.push(...changes);
     sections.push("");
   }
   const changelog = sections.join("\n");
   await db.update(releaseManifests).set({ changelog }).where(eq14(releaseManifests.version, normalizedVersion)).run();
-  const changelogPath = join46(cwd ?? process.cwd(), "CHANGELOG.md");
+  const changelogPath = join47(cwd ?? process.cwd(), "CHANGELOG.md");
   let existingChangelogContent = "";
   try {
     existingChangelogContent = await readFile10(changelogPath, "utf8");
@@ -28142,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,
@@ -28153,7 +28620,7 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
       docs: docs.length,
       tests: tests.length,
       chores: chores.length,
-      other: other.length
+      changes: changes.length
     }
   };
 }
@@ -28215,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");
   }
@@ -28254,58 +28721,121 @@ async function runReleaseGates(version, loadTasksFn, cwd) {
     message: incompleteTasks.length === 0 ? "All tasks completed" : `${incompleteTasks.length} tasks not completed: ${incompleteTasks.join(", ")}`
   });
   const projectRoot = cwd ?? getProjectRoot();
-  const distPath = join46(projectRoot, "dist", "cli", "index.js");
-  const isNodeProject = existsSync48(join46(projectRoot, "package.json"));
+  const distPath = join47(projectRoot, "dist", "cli", "index.js");
+  const isNodeProject = existsSync49(join47(projectRoot, "package.json"));
   if (isNodeProject) {
     gates.push({
       name: "build_artifact",
-      status: existsSync48(distPath) ? "passed" : "failed",
-      message: existsSync48(distPath) ? "dist/cli/index.js present" : "dist/ not built \u2014 run: npm run build"
+      status: existsSync49(distPath) ? "passed" : "failed",
+      message: existsSync49(distPath) ? "dist/cli/index.js present" : "dist/ not built \u2014 run: npm run build"
     });
   }
-  let workingTreeClean = true;
-  let dirtyFiles = [];
-  try {
-    const porcelain = execFileSync6("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 {
-    currentBranch = execFileSync6("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    currentBranch = execFileSync7("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: "pipe"
     }).trim();
   } catch {
   }
-  const expectedBranch = isPreRelease ? "develop" : "main";
-  const branchOk = !currentBranch || currentBranch === expectedBranch || currentBranch === "HEAD";
+  const releaseConfig = loadReleaseConfig(cwd);
+  const gitFlowCfg = getGitFlowConfig(releaseConfig);
+  const channelCfg = getChannelConfig(releaseConfig);
+  const expectedBranch = isPreRelease ? gitFlowCfg.branches.develop : gitFlowCfg.branches.main;
+  const isFeatureBranch = currentBranch.startsWith(gitFlowCfg.branches.featurePrefix) || currentBranch.startsWith(gitFlowCfg.branches.hotfixPrefix) || currentBranch.startsWith(gitFlowCfg.branches.releasePrefix);
+  const branchOk = !currentBranch || currentBranch === "HEAD" || currentBranch === expectedBranch || isPreRelease && isFeatureBranch;
+  const detectedChannel = currentBranch ? resolveChannelFromBranch(currentBranch, channelCfg) : isPreRelease ? "beta" : "latest";
   gates.push({
     name: "branch_target",
     status: branchOk ? "passed" : "failed",
-    message: branchOk ? `On correct branch: ${currentBranch}` : `Expected branch '${expectedBranch}' for ${isPreRelease ? "pre-release" : "stable"} release, but on '${currentBranch}'`
+    message: branchOk ? `On correct branch: ${currentBranch} (channel: ${detectedChannel})` : `Expected branch '${expectedBranch}' for ${isPreRelease ? "pre-release" : "stable"} release, but on '${currentBranch}'`
+  });
+  const pushMode = getPushMode(releaseConfig);
+  let requiresPR = false;
+  if (pushMode === "pr") {
+    requiresPR = true;
+  } else if (pushMode === "auto") {
+    try {
+      const protectionResult = await detectBranchProtection(
+        expectedBranch,
+        "origin",
+        projectRoot
+      );
+      requiresPR = protectionResult.protected;
+    } catch {
+      requiresPR = false;
+    }
+  }
+  gates.push({
+    name: "branch_protection",
+    status: "passed",
+    message: requiresPR ? `Branch '${expectedBranch}' is protected \u2014 release.ship will create a PR` : `Branch '${expectedBranch}' allows direct push`
   });
   const allPassed = gates.every((g) => g.status === "passed");
+  const metadata = {
+    channel: detectedChannel,
+    requiresPR,
+    targetBranch: expectedBranch,
+    currentBranch
+  };
   return {
     version: normalizedVersion,
     allPassed,
     gates,
     passedCount: gates.filter((g) => g.status === "passed").length,
-    failedCount: gates.filter((g) => g.status === "failed").length
+    failedCount: gates.filter((g) => g.status === "failed").length,
+    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");
@@ -28326,7 +28856,7 @@ async function rollbackRelease(version, reason, cwd) {
   };
 }
 async function readPushPolicy(cwd) {
-  const configPath = join46(getCleoDirAbsolute(cwd), "config.json");
+  const configPath = join47(getCleoDirAbsolute(cwd), "config.json");
   const config = await readJson(configPath);
   if (!config) return void 0;
   const release2 = config.release;
@@ -28340,6 +28870,33 @@ async function pushRelease(version, remote, cwd, opts) {
   const normalizedVersion = normalizeVersion(version);
   const projectRoot = getProjectRoot(cwd);
   const pushPolicy = await readPushPolicy(cwd);
+  const configPushMode = getPushMode(loadReleaseConfig(cwd));
+  const effectivePushMode = opts?.mode ?? pushPolicy?.mode ?? configPushMode;
+  if (effectivePushMode === "pr" || effectivePushMode === "auto") {
+    const targetRemoteForCheck = remote ?? pushPolicy?.remote ?? "origin";
+    let branchIsProtected = effectivePushMode === "pr";
+    if (effectivePushMode === "auto") {
+      try {
+        const protection = await detectBranchProtection(
+          pushPolicy?.allowedBranches?.[0] ?? "main",
+          targetRemoteForCheck,
+          projectRoot
+        );
+        branchIsProtected = protection.protected;
+      } catch {
+        branchIsProtected = false;
+      }
+    }
+    if (branchIsProtected) {
+      return {
+        version: normalizedVersion,
+        status: "requires_pr",
+        remote: targetRemoteForCheck,
+        pushedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        requiresPR: true
+      };
+    }
+  }
   if (pushPolicy && pushPolicy.enabled === false && !opts?.explicitPush) {
     throw new Error(
       "Push is disabled by config (release.push.enabled=false). Use --push to override."
@@ -28347,20 +28904,21 @@ async function pushRelease(version, remote, cwd, opts) {
   }
   const targetRemote = remote ?? pushPolicy?.remote ?? "origin";
   if (pushPolicy?.requireCleanTree) {
-    const statusOutput = execFileSync6("git", ["status", "--porcelain"], {
+    const statusOutput = execFileSync7("git", ["status", "--porcelain"], {
       cwd: projectRoot,
       timeout: 1e4,
       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)."
       );
     }
   }
   if (pushPolicy?.allowedBranches && pushPolicy.allowedBranches.length > 0) {
-    const currentBranch = execFileSync6("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    const currentBranch = execFileSync7("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: projectRoot,
       timeout: 1e4,
       encoding: "utf-8",
@@ -28372,7 +28930,7 @@ async function pushRelease(version, remote, cwd, opts) {
       );
     }
   }
-  execFileSync6("git", ["push", targetRemote, "--follow-tags"], {
+  execFileSync7("git", ["push", targetRemote, "--follow-tags"], {
     cwd: projectRoot,
     timeout: 6e4,
     encoding: "utf-8",
@@ -28403,6 +28961,9 @@ var init_release_manifest = __esm({
     init_paths();
     init_json();
     init_changelog_writer();
+    init_github_pr();
+    init_channel();
+    init_release_config();
   }
 });
 
@@ -28482,8 +29043,181 @@ 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 execFileSync7 } from "node:child_process";
+import { execFileSync as execFileSync8 } from "node:child_process";
 function isAgentContext() {
   return !!(process.env["CLEO_SESSION_ID"] || process.env["CLAUDE_AGENT_TYPE"]);
 }
@@ -28604,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);
@@ -28625,7 +29376,7 @@ async function releasePush(version, remote, projectRoot, opts) {
     const result = await pushRelease(version, remote, projectRoot, opts);
     let commitSha;
     try {
-      commitSha = execFileSync7("git", ["rev-parse", "HEAD"], {
+      commitSha = execFileSync8("git", ["rev-parse", "HEAD"], {
         cwd: projectRoot ?? process.cwd(),
         encoding: "utf-8",
         stdio: "pipe"
@@ -28647,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");
   }
@@ -28655,18 +29406,71 @@ 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) {
+      msg = `[Step ${n}/${total}] ${label}...`;
+    } else if (done) {
+      msg = `  \u2713 ${label}`;
+    } else {
+      msg = `  \u2717 ${label}: ${error ?? "failed"}`;
+    }
+    steps.push(msg);
+    console.log(msg);
+  };
+  const bumpTargets = getVersionBumpConfig(cwd);
+  const shouldBump = bump && bumpTargets.length > 0;
   try {
+    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, 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, 8, "Validate release gates", true);
+    let resolvedChannel = "latest";
+    let currentBranchForPR = "HEAD";
+    try {
+      const branchName = execFileSync8("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: "pipe"
+      }).trim();
+      currentBranchForPR = branchName;
+      const channelEnum = resolveChannelFromBranch(branchName);
+      resolvedChannel = channelToDistTag(channelEnum);
+    } catch {
+    }
+    const gateMetadata = gatesResult.metadata;
+    const requiresPRFromGates = gateMetadata?.requiresPR ?? false;
+    const targetBranchFromGates = gateMetadata?.targetBranch;
+    if (gateMetadata?.currentBranch) {
+      currentBranchForPR = gateMetadata.currentBranch;
+    }
+    logStep(2, 8, "Check epic completeness");
     let releaseTaskIds = [];
     try {
       const manifest = await showManifestRelease(version, projectRoot);
@@ -28677,10 +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, 8, "Check epic completeness", false, incomplete);
       return engineError("E_LIFECYCLE_GATE_FAILED", `Epic completeness check failed: ${incomplete}`, {
         details: { epics: epicCheck.epics }
       });
     }
+    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(
@@ -28689,73 +29496,160 @@ async function releaseShip(params, projectRoot) {
     );
     if (doubleCheck.hasDoubleListing) {
       const dupes = doubleCheck.duplicates.map((d) => `${d.taskId} (in ${d.releases.join(", ")})`).join("; ");
+      logStep(3, 8, "Check task double-listing", false, dupes);
       return engineError("E_VALIDATION", `Double-listing detected: ${dupes}`, {
         details: { duplicates: doubleCheck.duplicates }
       });
     }
-    const changelogResult = await generateReleaseChangelog(
+    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
+      };
+      if (wouldCreatePR) {
+        const ghAvailable = isGhCliAvailable();
+        dryRunOutput["wouldDo"].push(
+          ghAvailable ? `gh pr create --base ${targetBranch} --head ${currentBranchForPR} --title "release: ship v${version}"` : `manual PR: ${currentBranchForPR} \u2192 ${targetBranch} (gh CLI not available)`
+        );
+        dryRunOutput["wouldCreatePR"] = true;
+        dryRunOutput["prTitle"] = `release: ship v${version}`;
+        dryRunOutput["prTargetBranch"] = targetBranch;
+      } else {
+        dryRunOutput["wouldDo"].push(
+          `git push ${remote ?? "origin"} --follow-tags`
+        );
+        dryRunOutput["wouldCreatePR"] = false;
+      }
+      dryRunOutput["wouldDo"].push("markReleasePushed(...)");
+      return { success: true, data: { ...dryRunOutput, steps } };
+    }
+    logStep(4, 8, "Generate CHANGELOG");
+    await generateReleaseChangelog(
       version,
       () => loadTasks2(projectRoot),
       projectRoot
     );
     const changelogPath = `${cwd}/CHANGELOG.md`;
-    const generatedContent = changelogResult.changelog ?? "";
-    if (dryRun) {
-      return {
-        success: true,
-        data: {
-          version,
-          epicId,
-          dryRun: true,
-          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}"`,
-            `git push ${remote ?? "origin"} --follow-tags`,
-            "markReleasePushed(...)"
-          ]
-        }
-      };
-    }
-    await writeChangelogSection(version, generatedContent, [], changelogPath);
+    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 {
-      execFileSync7("git", ["add", "CHANGELOG.md"], gitCwd);
+      execFileSync8("git", ["add", ...filesToStage], gitCwd);
     } catch (err) {
       const msg = err.message ?? String(err);
+      logStep(5, 8, "Commit release", false, `git add failed: ${msg}`);
       return engineError("E_GENERAL", `git add failed: ${msg}`);
     }
     try {
-      execFileSync7(
+      execFileSync8(
         "git",
         ["commit", "-m", `release: ship v${version} (${epicId})`],
         gitCwd
       );
     } catch (err) {
       const msg = err.stderr ?? err.message ?? String(err);
+      logStep(5, 8, "Commit release", false, `git commit failed: ${msg}`);
       return engineError("E_GENERAL", `git commit failed: ${msg}`);
     }
+    logStep(5, 8, "Commit release", true);
     let commitSha;
     try {
-      commitSha = execFileSync7("git", ["rev-parse", "HEAD"], gitCwd).toString().trim();
+      commitSha = execFileSync8("git", ["rev-parse", "HEAD"], gitCwd).toString().trim();
     } catch {
     }
+    logStep(6, 8, "Tag release");
     const gitTag = `v${version.replace(/^v/, "")}`;
     try {
-      execFileSync7("git", ["tag", "-a", gitTag, "-m", `Release ${gitTag}`], gitCwd);
+      execFileSync8("git", ["tag", "-a", gitTag, "-m", `Release ${gitTag}`], gitCwd);
     } catch (err) {
       const msg = err.stderr ?? err.message ?? String(err);
+      logStep(6, 8, "Tag release", false, `git tag failed: ${msg}`);
       return engineError("E_GENERAL", `git tag failed: ${msg}`);
     }
-    try {
-      execFileSync7("git", ["push", remote ?? "origin", "--follow-tags"], gitCwd);
-    } catch (err) {
-      const execError = err;
-      const msg = (execError.stderr ?? execError.message ?? "").slice(0, 500);
-      return engineError("E_GENERAL", `git push failed: ${msg}`, {
-        details: { exitCode: execError.status }
+    logStep(6, 8, "Tag release", true);
+    logStep(7, 8, "Push / create PR");
+    let prResult = null;
+    const pushResult = await pushRelease(version, remote, projectRoot, {
+      explicitPush: true,
+      mode: pushMode
+    });
+    if (pushResult.requiresPR || requiresPRFromGates) {
+      const prBody = buildPRBody({
+        base: targetBranch,
+        head: currentBranchForPR,
+        title: `release: ship v${version}`,
+        body: "",
+        version,
+        epicId,
+        projectRoot: cwd
       });
+      prResult = await createPullRequest({
+        base: targetBranch,
+        head: currentBranchForPR,
+        title: `release: ship v${version}`,
+        body: prBody,
+        labels: ["release", resolvedChannel],
+        version,
+        epicId,
+        projectRoot: cwd
+      });
+      if (prResult.mode === "created") {
+        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") {
+        const m1 = `  \u2713 Push / create PR`;
+        const m2 = `  PR already exists: ${prResult.prUrl}`;
+        steps.push(m1, m2);
+        console.log(m1);
+        console.log(m2);
+      } else {
+        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, 8, "Push / create PR", true);
+      } catch (err) {
+        const execError = err;
+        const msg = (execError.stderr ?? execError.message ?? "").slice(0, 500);
+        logStep(7, 8, "Push / create PR", false, `git push failed: ${msg}`);
+        return engineError("E_GENERAL", `git push failed: ${msg}`, {
+          details: { exitCode: execError.status }
+        });
+      }
     }
     const pushedAt = (/* @__PURE__ */ new Date()).toISOString();
     await markReleasePushed(version, pushedAt, projectRoot, { commitSha, gitTag });
@@ -28767,7 +29661,17 @@ async function releaseShip(params, projectRoot) {
         commitSha,
         gitTag,
         pushedAt,
-        changelog: changelogPath
+        changelog: changelogPath,
+        channel: resolvedChannel,
+        steps,
+        ...prResult ? {
+          pr: {
+            mode: prResult.mode,
+            prUrl: prResult.prUrl,
+            prNumber: prResult.prNumber,
+            instructions: prResult.instructions
+          }
+        } : {}
       }
     };
   } catch (err) {
@@ -28780,15 +29684,18 @@ var init_release_engine = __esm({
     init_platform();
     init_data_accessor();
     init_release_manifest();
-    init_changelog_writer();
     init_guards();
+    init_github_pr();
+    init_channel();
+    init_release_config();
+    init_version_bump();
     init_error();
   }
 });
 
 // src/dispatch/engines/template-parser.ts
-import { readFileSync as readFileSync38, readdirSync as readdirSync12, existsSync as existsSync49 } from "fs";
-import { join as join47 } 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, "");
@@ -28802,8 +29709,8 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile(templateDir, filename) {
-  const filePath = join47(templateDir, filename);
-  const raw = readFileSync38(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 : "";
@@ -28852,8 +29759,8 @@ function parseTemplateFile(templateDir, filename) {
   };
 }
 function parseIssueTemplates(projectRoot) {
-  const templateDir = join47(projectRoot, ".github", "ISSUE_TEMPLATE");
-  if (!existsSync49(templateDir)) {
+  const templateDir = join49(projectRoot, ".github", "ISSUE_TEMPLATE");
+  if (!existsSync51(templateDir)) {
     return engineError("E_NOT_FOUND", `Issue template directory not found: ${templateDir}`);
   }
   let files;
@@ -30532,26 +31439,26 @@ var init_check = __esm({
 });
 
 // src/core/adrs/validate.ts
-import { readFileSync as readFileSync39, readdirSync as readdirSync13, existsSync as existsSync50 } from "node:fs";
-import { join as join48 } 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 = join48(projectRoot, ".cleo", "adrs");
-  const schemaPath = join48(projectRoot, "schemas", "adr-frontmatter.schema.json");
-  if (!existsSync50(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 (!existsSync50(adrsDir)) {
+  if (!existsSync52(adrsDir)) {
     return { valid: true, errors: [], checked: 0 };
   }
-  const schema = JSON.parse(readFileSync39(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) => join48(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);
@@ -30578,15 +31485,15 @@ var init_validate = __esm({
 });
 
 // src/core/adrs/list.ts
-import { readdirSync as readdirSync14, existsSync as existsSync51 } from "node:fs";
-import { join as join49 } 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 = join49(projectRoot, ".cleo", "adrs");
-  if (!existsSync51(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(join49(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;
@@ -30611,14 +31518,14 @@ var init_list2 = __esm({
 });
 
 // src/core/adrs/show.ts
-import { existsSync as existsSync52, readdirSync as readdirSync15 } from "node:fs";
-import { join as join50 } 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 = join50(projectRoot, ".cleo", "adrs");
-  if (!existsSync52(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 = join50(adrsDir, files[0]);
+  const filePath = join52(adrsDir, files[0]);
   return parseAdrFile(filePath, projectRoot);
 }
 var init_show2 = __esm({
@@ -30629,8 +31536,8 @@ var init_show2 = __esm({
 });
 
 // src/core/adrs/find.ts
-import { readdirSync as readdirSync16, existsSync as existsSync53 } from "node:fs";
-import { join as join51 } 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();
 }
@@ -30647,8 +31554,8 @@ function matchedTerms(target, terms) {
   return terms.filter((term) => t.includes(term));
 }
 async function findAdrs(projectRoot, query, opts) {
-  const adrsDir = join51(projectRoot, ".cleo", "adrs");
-  if (!existsSync53(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();
@@ -30657,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(join51(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) {
@@ -30735,12 +31642,12 @@ var init_adrs = __esm({
 });
 
 // src/core/admin/sync.ts
-import { join as join52 } 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 = join52(cleoDir, "sync", "todowrite-session.json");
+    const stateFile = join54(cleoDir, "sync", "todowrite-session.json");
     const sessionState = await readJson(stateFile);
     if (!sessionState) {
       return {
@@ -30784,8 +31691,8 @@ async function getSyncStatus(projectRoot) {
 async function clearSyncState(projectRoot, dryRun) {
   try {
     const cleoDir = getCleoDir(projectRoot);
-    const syncDir = join52(cleoDir, "sync");
-    const stateFile = join52(syncDir, "todowrite-session.json");
+    const syncDir = join54(cleoDir, "sync");
+    const stateFile = join54(syncDir, "todowrite-session.json");
     let exists = false;
     try {
       await stat2(stateFile);
@@ -31552,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 existsSync54 } from "node:fs";
-import { join as join53, 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,
@@ -31606,7 +32513,7 @@ async function exportSnapshot(cwd) {
 }
 async function writeSnapshot(snapshot, outputPath) {
   const dir = dirname14(outputPath);
-  if (!existsSync54(dir)) {
+  if (!existsSync56(dir)) {
     await mkdir10(dir, { recursive: true });
   }
   await writeFile10(outputPath, JSON.stringify(snapshot, null, 2) + "\n");
@@ -31622,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 join53(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
+  return join55(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);
@@ -31920,15 +32827,15 @@ var init_archive_stats2 = __esm({
 });
 
 // src/core/project-info.ts
-import { readFileSync as readFileSync40, existsSync as existsSync55 } from "node:fs";
-import { join as join54 } 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 = join54(cleoDir, "project-info.json");
-  if (!existsSync55(infoPath)) return null;
+  const infoPath = join56(cleoDir, "project-info.json");
+  if (!existsSync57(infoPath)) return null;
   try {
-    const raw = readFileSync40(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;
@@ -32015,8 +32922,8 @@ var init_defaults = __esm({
 });
 
 // src/mcp/lib/config.ts
-import { readFileSync as readFileSync41, existsSync as existsSync56 } from "fs";
-import { join as join55 } 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];
@@ -32037,12 +32944,12 @@ function parseEnvValue2(key, value) {
 }
 function loadFromFile(projectRoot) {
   const root = projectRoot || process.cwd();
-  const configPath = join55(root, ".cleo", "config.json");
-  if (!existsSync56(configPath)) {
+  const configPath = join57(root, ".cleo", "config.json");
+  if (!existsSync58(configPath)) {
     return {};
   }
   try {
-    const content = readFileSync41(configPath, "utf-8");
+    const content = readFileSync43(configPath, "utf-8");
     const config = JSON.parse(content);
     const result = {};
     if (config.mcp) {
@@ -32382,8 +33289,8 @@ __export(session_grade_exports, {
   gradeSession: () => gradeSession,
   readGrades: () => readGrades
 });
-import { join as join56 } from "node:path";
-import { existsSync as existsSync57 } 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 });
@@ -32563,9 +33470,9 @@ function detectDuplicateCreates(entries) {
 async function appendGradeResult(result, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const metricsDir = join56(cleoDir, "metrics");
+    const metricsDir = join58(cleoDir, "metrics");
     await mkdir11(metricsDir, { recursive: true });
-    const gradesPath = join56(metricsDir, "GRADES.jsonl");
+    const gradesPath = join58(metricsDir, "GRADES.jsonl");
     const line = JSON.stringify({ ...result, evaluator: "auto" }) + "\n";
     await appendFile(gradesPath, line, "utf8");
   } catch {
@@ -32574,8 +33481,8 @@ async function appendGradeResult(result, cwd) {
 async function readGrades(sessionId, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const gradesPath = join56(cleoDir, "metrics", "GRADES.jsonl");
-    if (!existsSync57(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;
@@ -34812,6 +35719,7 @@ var init_phase = __esm({
 });
 
 // src/dispatch/domains/pipeline.ts
+import { execFileSync as execFileSync9 } from "node:child_process";
 var PipelineHandler;
 var init_pipeline2 = __esm({
   "src/dispatch/domains/pipeline.ts"() {
@@ -34822,6 +35730,7 @@ var init_pipeline2 = __esm({
     init_data_accessor();
     init_engine();
     init_release_engine();
+    init_channel();
     init_phase();
     init_phases();
     init_pipeline_manifest_sqlite();
@@ -34907,6 +35816,7 @@ var init_pipeline2 = __esm({
             "manifest.stats",
             "release.list",
             "release.show",
+            "release.channel.show",
             "phase.show",
             "phase.list",
             "chain.show",
@@ -34926,6 +35836,7 @@ var init_pipeline2 = __esm({
             "release.push",
             "release.gates.run",
             "release.rollback",
+            "release.cancel",
             "release.ship",
             "manifest.append",
             "manifest.archive",
@@ -35149,6 +36060,29 @@ var init_pipeline2 = __esm({
             const result = await releaseShow(version, this.projectRoot);
             return this.wrapEngineResult(result, "query", "release.show", startTime);
           }
+          case "channel.show": {
+            let currentBranch = "unknown";
+            try {
+              currentBranch = execFileSync9("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+                encoding: "utf-8",
+                stdio: "pipe",
+                cwd: this.projectRoot
+              }).trim();
+            } catch {
+            }
+            const resolvedChannel = resolveChannelFromBranch(currentBranch);
+            const distTag = channelToDistTag(resolvedChannel);
+            const description = describeChannel(resolvedChannel);
+            return this.wrapEngineResult({
+              success: true,
+              data: {
+                branch: currentBranch,
+                channel: resolvedChannel,
+                distTag,
+                description
+              }
+            }, "query", "release.channel.show", startTime);
+          }
           default:
             return this.errorResponse(
               "query",
@@ -35267,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;
@@ -35281,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);
@@ -35753,11 +36702,11 @@ var init_pipeline2 = __esm({
 });
 
 // src/core/issue/diagnostics.ts
-import { execFileSync as execFileSync8 } from "node:child_process";
+import { execFileSync as execFileSync10 } from "node:child_process";
 function collectDiagnostics() {
   const getVersion3 = (cmd, args) => {
     try {
-      return execFileSync8(cmd, args, {
+      return execFileSync10(cmd, args, {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -35808,7 +36757,7 @@ var init_build_config = __esm({
     "use strict";
     BUILD_CONFIG = {
       "name": "@cleocode/cleo",
-      "version": "2026.3.16",
+      "version": "2026.3.18",
       "description": "CLEO V2 - TypeScript task management CLI for AI coding agents",
       "repository": {
         "owner": "kryptobaseddev",
@@ -35817,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-07T05:25:13.762Z",
+      "buildDate": "2026-03-07T20:24:31.815Z",
       "templates": {
         "issueTemplatesDir": "templates/issue-templates"
       }
@@ -35826,8 +36775,8 @@ var init_build_config = __esm({
 });
 
 // src/core/issue/template-parser.ts
-import { existsSync as existsSync58, readFileSync as readFileSync42, readdirSync as readdirSync17, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join57, 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);
@@ -35859,9 +36808,9 @@ function extractYamlArray(content, field) {
   return items;
 }
 function parseTemplateFile2(filePath) {
-  if (!existsSync58(filePath)) return null;
+  if (!existsSync60(filePath)) return null;
   try {
-    const content = readFileSync42(filePath, "utf-8");
+    const content = readFileSync44(filePath, "utf-8");
     const fileName = basename10(filePath);
     const stem = fileName.replace(/\.ya?ml$/, "");
     const name = extractYamlField(content, "name");
@@ -35878,12 +36827,12 @@ function parseTemplateFile2(filePath) {
 function parseIssueTemplates2(projectDir) {
   try {
     const packageRoot = getPackageRoot();
-    const packagedTemplateDir = join57(packageRoot, PACKAGED_TEMPLATE_DIR);
-    if (existsSync58(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(join57(packagedTemplateDir, file));
+        const template = parseTemplateFile2(join59(packagedTemplateDir, file));
         if (template) templates3.push(template);
       }
       if (templates3.length > 0) return templates3;
@@ -35891,12 +36840,12 @@ function parseIssueTemplates2(projectDir) {
   } catch {
   }
   const dir = projectDir ?? getProjectRoot();
-  const templateDir = join57(dir, TEMPLATE_DIR);
-  if (!existsSync58(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(join57(templateDir, file));
+    const template = parseTemplateFile2(join59(templateDir, file));
     if (template) templates2.push(template);
   }
   return templates2;
@@ -35905,10 +36854,10 @@ function getTemplateConfig(cwd) {
   const projectDir = cwd ?? getProjectRoot();
   const liveTemplates = parseIssueTemplates2(projectDir);
   if (liveTemplates.length > 0) return liveTemplates;
-  const cachePath = join57(getCleoDir(cwd), CACHE_FILE);
-  if (existsSync58(cachePath)) {
+  const cachePath = join59(getCleoDir(cwd), CACHE_FILE);
+  if (existsSync60(cachePath)) {
     try {
-      const cached = JSON.parse(readFileSync42(cachePath, "utf-8"));
+      const cached = JSON.parse(readFileSync44(cachePath, "utf-8"));
       if (cached.templates?.length > 0) return cached.templates;
     } catch {
     }
@@ -35964,7 +36913,7 @@ var init_template_parser2 = __esm({
 });
 
 // src/core/issue/create.ts
-import { execFileSync as execFileSync9 } from "node:child_process";
+import { execFileSync as execFileSync11 } from "node:child_process";
 function buildIssueBody(subcommand, rawBody, severity, area) {
   const template = getTemplateForSubcommand2(subcommand);
   const sectionLabel = template?.name ?? "Description";
@@ -35983,7 +36932,7 @@ function buildIssueBody(subcommand, rawBody, severity, area) {
 }
 function checkGhCli() {
   try {
-    execFileSync9("gh", ["--version"], {
+    execFileSync11("gh", ["--version"], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -35993,7 +36942,7 @@ function checkGhCli() {
     });
   }
   try {
-    execFileSync9("gh", ["auth", "status", "--hostname", "github.com"], {
+    execFileSync11("gh", ["auth", "status", "--hostname", "github.com"], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -36005,7 +36954,7 @@ function checkGhCli() {
 }
 function addGhIssue(title, body, labels) {
   try {
-    const result = execFileSync9("gh", [
+    const result = execFileSync11("gh", [
       "issue",
       "create",
       "--repo",
@@ -36967,8 +37916,8 @@ var init_tools = __esm({
 });
 
 // src/core/nexus/query.ts
-import { join as join58, basename as basename11 } from "node:path";
-import { existsSync as existsSync59, readFileSync as readFileSync43 } 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;
@@ -37004,9 +37953,9 @@ function getCurrentProject() {
     return process.env["NEXUS_CURRENT_PROJECT"];
   }
   try {
-    const infoPath = join58(process.cwd(), ".cleo", "project-info.json");
-    if (existsSync59(infoPath)) {
-      const data = JSON.parse(readFileSync43(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;
       }
@@ -37042,7 +37991,7 @@ async function resolveProjectPath2(projectName) {
   return project.path;
 }
 async function readProjectTasks(projectPath) {
-  const tasksDbPath = join58(projectPath, ".cleo", "tasks.db");
+  const tasksDbPath = join60(projectPath, ".cleo", "tasks.db");
   try {
     const accessor = await getAccessor(projectPath);
     const taskFile = await accessor.loadTaskFile();
@@ -37456,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 existsSync60, readdirSync as readdirSync18, statSync as statSync8 } from "node:fs";
-import { join as join59, 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, "");
@@ -37482,7 +38431,7 @@ function collectCleoFiles(cleoDir) {
     const entries = readdirSync18(dir);
     for (const entry of entries) {
       if (entry === ".git") continue;
-      const fullPath = join59(dir, entry);
+      const fullPath = join61(dir, entry);
       const relPath = relative4(cleoDir, fullPath);
       try {
         const stat5 = statSync8(fullPath);
@@ -37542,7 +38491,7 @@ function generateGitignoreEntries(sharing) {
 async function syncGitignore(cwd) {
   const config = await loadConfig(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const gitignorePath = join59(projectRoot, ".gitignore");
+  const gitignorePath = join61(projectRoot, ".gitignore");
   const entries = generateGitignoreEntries(config.sharing);
   const managedSection = [
     "",
@@ -37552,7 +38501,7 @@ async function syncGitignore(cwd) {
     ""
   ].join("\n");
   let content = "";
-  if (existsSync60(gitignorePath)) {
+  if (existsSync62(gitignorePath)) {
     content = await readFile15(gitignorePath, "utf-8");
   }
   const startIdx = content.indexOf(GITIGNORE_START);
@@ -39114,40 +40063,49 @@ var init_session_resolver = __esm({
   }
 });
 
+// src/core/tasks/id-generator.ts
+function normalizeTaskId(input) {
+  if (typeof input !== "string") return null;
+  const trimmed = input.trim();
+  if (trimmed === "") return null;
+  const match = trimmed.match(/^[Tt]?(\d+)(?:_.*)?$/);
+  if (!match) return null;
+  return `T${match[1]}`;
+}
+var init_id_generator = __esm({
+  "src/core/tasks/id-generator.ts"() {
+    "use strict";
+    init_data_accessor();
+  }
+});
+
 // src/dispatch/lib/security.ts
 import { resolve as resolve9, normalize, relative as relative5, isAbsolute as isAbsolute2 } from "path";
-function sanitizeTaskId(id) {
-  if (typeof id !== "string") {
+function sanitizeTaskId(value) {
+  if (typeof value !== "string") {
     throw new SecurityError(
       "Task ID must be a string",
       "E_INVALID_TASK_ID",
       "taskId"
     );
   }
-  const trimmed = id.trim();
-  if (trimmed.length === 0) {
+  const normalized = normalizeTaskId(value);
+  if (normalized === null) {
     throw new SecurityError(
-      "Task ID cannot be empty",
+      `Invalid task ID format: ${value}`,
       "E_INVALID_TASK_ID",
       "taskId"
     );
   }
-  if (!TASK_ID_PATTERN2.test(trimmed)) {
-    throw new SecurityError(
-      `Invalid task ID format: "${trimmed}". Must match pattern T[0-9]+ (e.g., T123)`,
-      "E_INVALID_TASK_ID",
-      "taskId"
-    );
-  }
-  const numericPart = parseInt(trimmed.slice(1), 10);
+  const numericPart = parseInt(normalized.slice(1), 10);
   if (numericPart > MAX_TASK_ID_NUMBER) {
     throw new SecurityError(
-      `Task ID numeric value exceeds maximum (${MAX_TASK_ID_NUMBER}): ${trimmed}`,
+      `Task ID exceeds maximum value: ${value}`,
       "E_INVALID_TASK_ID",
       "taskId"
     );
   }
-  return trimmed;
+  return normalized;
 }
 function sanitizePath(path, projectRoot) {
   if (typeof path !== "string") {
@@ -39246,14 +40204,14 @@ function sanitizeParams(params, projectRoot, context) {
     if (value === void 0 || value === null) {
       continue;
     }
-    if (typeof value === "string" && (key === "taskId" || key === "parent" || key === "epicId")) {
+    if (typeof value === "string" && (key === "taskId" || key === "parent" || key === "epicId" || key === "parentId" || key === "newParentId" || key === "relatedId" || key === "targetId")) {
       if (key === "parent" && value === "") {
         continue;
       }
       sanitized[key] = sanitizeTaskId(value);
       continue;
     }
-    if (key === "depends" && Array.isArray(value)) {
+    if ((key === "depends" || key === "addDepends" || key === "removeDepends") && Array.isArray(value)) {
       sanitized[key] = value.map((v) => {
         if (typeof v === "string") {
           return sanitizeTaskId(v);
@@ -39303,10 +40261,11 @@ function sanitizeParams(params, projectRoot, context) {
   }
   return sanitized;
 }
-var SecurityError, TASK_ID_PATTERN2, MAX_TASK_ID_NUMBER, CONTROL_CHAR_PATTERN, DEFAULT_MAX_CONTENT_LENGTH, ALL_VALID_STATUSES, VALID_PRIORITIES2, ARRAY_PARAMS;
+var SecurityError, MAX_TASK_ID_NUMBER, CONTROL_CHAR_PATTERN, DEFAULT_MAX_CONTENT_LENGTH, ALL_VALID_STATUSES, VALID_PRIORITIES2, ARRAY_PARAMS;
 var init_security = __esm({
   "src/dispatch/lib/security.ts"() {
     "use strict";
+    init_id_generator();
     init_schema();
     init_status_registry();
     SecurityError = class extends Error {
@@ -39317,7 +40276,6 @@ var init_security = __esm({
         this.name = "SecurityError";
       }
     };
-    TASK_ID_PATTERN2 = /^T[0-9]+$/;
     MAX_TASK_ID_NUMBER = 999999;
     CONTROL_CHAR_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g;
     DEFAULT_MAX_CONTENT_LENGTH = 64 * 1024;
@@ -39465,13 +40423,13 @@ var init_field_context = __esm({
 });
 
 // src/core/sessions/context-alert.ts
-import { existsSync as existsSync61, readFileSync as readFileSync44, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join60 } 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 = join60(getCleoDir(cwd), ".current-session");
-  if (existsSync61(sessionFile)) {
-    return readFileSync44(sessionFile, "utf-8").trim() || null;
+  const sessionFile = join62(getCleoDir(cwd), ".current-session");
+  if (existsSync63(sessionFile)) {
+    return readFileSync46(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -40534,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,
@@ -40718,14 +41676,14 @@ __export(logger_exports, {
   logFileExists: () => logFileExists,
   readMigrationLog: () => readMigrationLog
 });
-import { existsSync as existsSync64, mkdirSync as mkdirSync16, statSync as statSync9, appendFileSync as appendFileSync4 } from "node:fs";
-import { join as join67, 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: readFileSync52 } = __require("node:fs");
-  const content = readFileSync52(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) {
@@ -40740,14 +41698,14 @@ function logFileExists(logPath) {
 function getLatestMigrationLog(cleoDir) {
   try {
     const { readdirSync: readdirSync21, statSync: statSync10 } = __require("node:fs");
-    const logsDir = join67(cleoDir, "logs");
-    if (!existsSync64(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: join67(logsDir, f),
-      mtime: statSync10(join67(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 {
@@ -40777,9 +41735,9 @@ var init_logger2 = __esm({
           consoleOutput: config.consoleOutput ?? false
         };
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        this.logPath = join67(cleoDir, "logs", `migration-${timestamp}.jsonl`);
+        this.logPath = join69(cleoDir, "logs", `migration-${timestamp}.jsonl`);
         const logsDir = dirname16(this.logPath);
-        if (!existsSync64(logsDir)) {
+        if (!existsSync66(logsDir)) {
           mkdirSync16(logsDir, { recursive: true });
         }
         this.startTime = Date.now();
@@ -40868,7 +41826,7 @@ var init_logger2 = __esm({
           sourcePath: relative6(this.cleoDir, sourcePath),
           ...additionalData
         };
-        if (existsSync64(sourcePath)) {
+        if (existsSync66(sourcePath)) {
           try {
             const stats2 = statSync9(sourcePath);
             data.sourceSize = stats2.size;
@@ -40878,7 +41836,7 @@ var init_logger2 = __esm({
         }
         if (targetPath) {
           data.targetPath = relative6(this.cleoDir, targetPath);
-          if (existsSync64(targetPath)) {
+          if (existsSync66(targetPath)) {
             try {
               const stats2 = statSync9(targetPath);
               data.targetSize = stats2.size;
@@ -40947,15 +41905,15 @@ var init_logger2 = __esm({
        */
       cleanupOldLogs() {
         try {
-          const logsDir = join67(this.cleoDir, "logs");
-          if (!existsSync64(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: join67(logsDir, f),
-            mtime: statSync9(join67(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) {
@@ -41051,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 join68 } from "node:path";
-import { existsSync as existsSync65 } 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 {
@@ -41074,8 +42032,8 @@ async function countRecords(filePath, key) {
 async function createMigrationState(cleoDir, sourceFiles) {
   const files = sourceFiles ?? {};
   if (!files.todoJson) {
-    const todoPath = join68(cleoDir, "todo.json");
-    if (existsSync65(todoPath)) {
+    const todoPath = join70(cleoDir, "todo.json");
+    if (existsSync67(todoPath)) {
       files.todoJson = {
         path: todoPath,
         checksum: await computeFileChecksum(todoPath),
@@ -41084,8 +42042,8 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.sessionsJson) {
-    const sessionsPath = join68(cleoDir, "sessions.json");
-    if (existsSync65(sessionsPath)) {
+    const sessionsPath = join70(cleoDir, "sessions.json");
+    if (existsSync67(sessionsPath)) {
       files.sessionsJson = {
         path: sessionsPath,
         checksum: await computeFileChecksum(sessionsPath),
@@ -41094,8 +42052,8 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.archiveJson) {
-    const archivePath = join68(cleoDir, "todo-archive.json");
-    if (existsSync65(archivePath)) {
+    const archivePath = join70(cleoDir, "todo-archive.json");
+    if (existsSync67(archivePath)) {
       files.archiveJson = {
         path: archivePath,
         checksum: await computeFileChecksum(archivePath),
@@ -41123,7 +42081,7 @@ async function createMigrationState(cleoDir, sourceFiles) {
   return state;
 }
 async function writeMigrationState(cleoDir, state) {
-  const statePath = join68(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));
@@ -41198,7 +42156,7 @@ async function addMigrationWarning(cleoDir, warning) {
 }
 async function loadMigrationState(cleoDir) {
   try {
-    const statePath = join68(cleoDir, STATE_FILENAME);
+    const statePath = join70(cleoDir, STATE_FILENAME);
     const content = await readFile19(statePath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -41240,7 +42198,7 @@ async function failMigration(cleoDir, error) {
 }
 async function clearMigrationState(cleoDir) {
   try {
-    const statePath = join68(cleoDir, STATE_FILENAME);
+    const statePath = join70(cleoDir, STATE_FILENAME);
     await unlink5(statePath);
   } catch {
   }
@@ -41280,7 +42238,7 @@ async function verifySourceIntegrity(cleoDir) {
   const missing = [];
   for (const [key, fileInfo] of Object.entries(state.sourceFiles)) {
     if (!fileInfo) continue;
-    if (!existsSync65(fileInfo.path)) {
+    if (!existsSync67(fileInfo.path)) {
       missing.push(key);
       continue;
     }
@@ -41311,8 +42269,8 @@ __export(migration_sqlite_exports, {
   migrateJsonToSqlite: () => migrateJsonToSqlite2,
   migrateJsonToSqliteAtomic: () => migrateJsonToSqliteAtomic
 });
-import { existsSync as existsSync66, readFileSync as readFileSync47 } from "node:fs";
-import { join as join69, 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";
@@ -41350,26 +42308,26 @@ function countJsonRecords(cleoDir) {
   let tasks2 = 0;
   let archived = 0;
   let sessions2 = 0;
-  const todoPath = join69(cleoDir, "todo.json");
-  if (existsSync66(todoPath)) {
+  const todoPath = join71(cleoDir, "todo.json");
+  if (existsSync68(todoPath)) {
     try {
-      const data = JSON.parse(readFileSync47(todoPath, "utf-8"));
+      const data = JSON.parse(readFileSync49(todoPath, "utf-8"));
       tasks2 = (data.tasks ?? []).length;
     } catch {
     }
   }
-  const archivePath = join69(cleoDir, "todo-archive.json");
-  if (existsSync66(archivePath)) {
+  const archivePath = join71(cleoDir, "todo-archive.json");
+  if (existsSync68(archivePath)) {
     try {
-      const data = JSON.parse(readFileSync47(archivePath, "utf-8"));
+      const data = JSON.parse(readFileSync49(archivePath, "utf-8"));
       archived = (data.tasks ?? data.archivedTasks ?? []).length;
     } catch {
     }
   }
-  const sessionsPath = join69(cleoDir, "sessions.json");
-  if (existsSync66(sessionsPath)) {
+  const sessionsPath = join71(cleoDir, "sessions.json");
+  if (existsSync68(sessionsPath)) {
     try {
-      const data = JSON.parse(readFileSync47(sessionsPath, "utf-8"));
+      const data = JSON.parse(readFileSync49(sessionsPath, "utf-8"));
       sessions2 = (data.sessions ?? []).length;
     } catch {
     }
@@ -41446,13 +42404,13 @@ async function migrateJsonToSqliteAtomic(cwd, tempDbPath, logger) {
   }
 }
 async function runMigrationDataImport(db, cleoDir, result, logger) {
-  const todoPath = join69(cleoDir, "todo.json");
-  if (existsSync66(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(readFileSync47(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`, {
@@ -41521,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 = join69(cleoDir, "todo-archive.json");
-  if (existsSync66(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(readFileSync47(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`, {
@@ -41580,13 +42538,13 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
       logger?.error("import", "parse-archive", errorMsg);
     }
   }
-  const sessionsPath = join69(cleoDir, "sessions.json");
-  if (existsSync66(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(readFileSync47(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`, {
@@ -41718,10 +42676,10 @@ async function migrateJsonToSqlite2(cwd, options) {
     return result;
   }
   const db = await getDb(cwd);
-  const todoPath = join69(cleoDir, "todo.json");
-  if (existsSync66(todoPath)) {
+  const todoPath = join71(cleoDir, "todo.json");
+  if (existsSync68(todoPath)) {
     try {
-      const todoData = JSON.parse(readFileSync47(todoPath, "utf-8"));
+      const todoData = JSON.parse(readFileSync49(todoPath, "utf-8"));
       const tasks2 = topoSortTasks(todoData.tasks ?? []);
       for (const task of tasks2) {
         try {
@@ -41770,10 +42728,10 @@ async function migrateJsonToSqlite2(cwd, options) {
   } else {
     result.warnings.push("todo.json not found, skipping task import");
   }
-  const archivePath = join69(cleoDir, "todo-archive.json");
-  if (existsSync66(archivePath)) {
+  const archivePath = join71(cleoDir, "todo-archive.json");
+  if (existsSync68(archivePath)) {
     try {
-      const archiveData = JSON.parse(readFileSync47(archivePath, "utf-8"));
+      const archiveData = JSON.parse(readFileSync49(archivePath, "utf-8"));
       const archivedTasks = topoSortTasks(archiveData.tasks ?? archiveData.archivedTasks ?? []);
       for (const task of archivedTasks) {
         try {
@@ -41810,11 +42768,11 @@ async function migrateJsonToSqlite2(cwd, options) {
       result.errors.push(`Failed to parse todo-archive.json: ${String(err)}`);
     }
   }
-  const sessionsPath = join69(cleoDir, "sessions.json");
-  if (existsSync66(sessionsPath)) {
+  const sessionsPath = join71(cleoDir, "sessions.json");
+  if (existsSync68(sessionsPath)) {
     try {
       const sessionsData = JSON.parse(
-        readFileSync47(sessionsPath, "utf-8")
+        readFileSync49(sessionsPath, "utf-8")
       );
       const sessions2 = sessionsData.sessions ?? [];
       for (const session of sessions2) {
@@ -41882,8 +42840,8 @@ var init_migration_sqlite = __esm({
 
 // src/cli/index.ts
 import { Command, Help } from "commander";
-import { readFileSync as readFileSync51 } from "node:fs";
-import { join as join75 } from "node:path";
+import { readFileSync as readFileSync53 } from "node:fs";
+import { join as join77 } from "node:path";
 
 // src/cli/commands/add.ts
 init_cli();
@@ -42498,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" });
   });
@@ -42516,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
@@ -42733,14 +43695,14 @@ init_errors();
 init_exit_codes();
 init_paths();
 init_json();
-import { join as join61 } 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 = [
-    join61(cleoHome, "docs", "commands", "COMMANDS-INDEX.json"),
-    join61(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);
@@ -42821,9 +43783,9 @@ init_errors();
 init_json();
 init_paths();
 import { readdir as readdir2, readFile as readFile16 } from "node:fs/promises";
-import { join as join62 } from "node:path";
+import { join as join64 } from "node:path";
 async function getScriptNames(projectRoot) {
-  const scriptsDir = join62(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();
@@ -42832,7 +43794,7 @@ async function getScriptNames(projectRoot) {
   }
 }
 async function getIndexedCommands(projectRoot) {
-  const indexPath = join62(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();
@@ -42865,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 = join62(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";
@@ -42969,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 join63 } 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;
@@ -43025,7 +43987,7 @@ function registerExtractCommand(program2) {
       const accessor = await getAccessor();
       const taskData = await accessor.loadTaskFile();
       const cleoDir = getCleoDir();
-      const stateFile = join63(cleoDir, "sync", "todowrite-session.json");
+      const stateFile = join65(cleoDir, "sync", "todowrite-session.json");
       let sessionState = null;
       try {
         sessionState = await readJson(stateFile);
@@ -43211,17 +44173,17 @@ init_renderers();
 init_errors();
 init_exit_codes();
 init_paths();
-import { spawn as spawn2, execFileSync as execFileSync10 } from "node:child_process";
+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 join64 } 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: join64(cleoHome, "web-server.pid"),
-    configFile: join64(cleoHome, "web-server.json"),
-    logFile: join64(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) {
@@ -43265,19 +44227,19 @@ 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 = join64(projectRoot, "dist", "mcp");
-      await mkdir12(join64(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 = join64(distMcpDir, "index.js");
+      const webIndexPath = join66(distMcpDir, "index.js");
       try {
         await stat4(webIndexPath);
       } catch {
         try {
-          execFileSync10("npm", ["run", "build"], { cwd: projectRoot, stdio: "ignore" });
+          execFileSync12("npm", ["run", "build"], { cwd: projectRoot, stdio: "ignore" });
         } catch {
           throw new CleoError(1 /* GENERAL_ERROR */, `Build failed. Check logs: ${logFile}`);
         }
@@ -43496,13 +44458,13 @@ init_renderers();
 init_errors();
 init_exit_codes();
 init_paths();
-import { existsSync as existsSync62, readFileSync as readFileSync45, writeFileSync as writeFileSync10, mkdirSync as mkdirSync15 } from "node:fs";
-import { execFileSync as execFileSync11 } from "node:child_process";
-import { join as join65, dirname as dirname15 } from "node:path";
+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 join67, dirname as dirname15 } from "node:path";
 function getChangelogSource(cwd) {
   const configPath = getConfigPath(cwd);
   try {
-    const config = JSON.parse(readFileSync45(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync47(configPath, "utf-8"));
     return config?.release?.changelog?.source ?? "CHANGELOG.md";
   } catch {
     return "CHANGELOG.md";
@@ -43511,7 +44473,7 @@ function getChangelogSource(cwd) {
 function getEnabledPlatforms(cwd) {
   const configPath = getConfigPath(cwd);
   try {
-    const config = JSON.parse(readFileSync45(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync47(configPath, "utf-8"));
     const outputs = config?.release?.changelog?.outputs ?? [];
     return outputs.filter((o) => o.enabled);
   } catch {
@@ -43533,7 +44495,7 @@ function getDefaultOutputPath(platform2) {
 function getGitHubRepoSlug(cwd) {
   const projectRoot = getProjectRoot(cwd);
   try {
-    const remoteUrl = execFileSync11("git", ["remote", "get-url", "origin"], {
+    const remoteUrl = execFileSync13("git", ["remote", "get-url", "origin"], {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -43638,11 +44600,11 @@ function registerGenerateChangelogCommand(program2) {
       const targetPlatform = opts["platform"];
       const dryRun = !!opts["dryRun"];
       const sourceFile = getChangelogSource();
-      const sourcePath = join65(getProjectRoot(), sourceFile);
-      if (!existsSync62(sourcePath)) {
+      const sourcePath = join67(getProjectRoot(), sourceFile);
+      if (!existsSync64(sourcePath)) {
         throw new CleoError(4 /* NOT_FOUND */, `Changelog source not found: ${sourcePath}`);
       }
-      const sourceContent = readFileSync45(sourcePath, "utf-8");
+      const sourceContent = readFileSync47(sourcePath, "utf-8");
       const repoSlug = getGitHubRepoSlug();
       const results = [];
       if (targetPlatform) {
@@ -43651,9 +44613,9 @@ function registerGenerateChangelogCommand(program2) {
         const outputPath = platformConfig?.path ?? getDefaultOutputPath(targetPlatform);
         const content = generateForPlatform(targetPlatform, sourceContent, repoSlug, limit);
         if (!dryRun) {
-          const fullPath = join65(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 {
@@ -43672,9 +44634,9 @@ function registerGenerateChangelogCommand(program2) {
             limit
           );
           if (!dryRun) {
-            const fullPath = join65(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,
@@ -43703,7 +44665,7 @@ function registerGenerateChangelogCommand(program2) {
 init_cli();
 init_renderers();
 init_build_config();
-import { execFileSync as execFileSync12 } from "node:child_process";
+import { execFileSync as execFileSync14 } from "node:child_process";
 var CLEO_REPO2 = BUILD_CONFIG.repository.fullName;
 function registerIssueCommand(program2) {
   const issueCmd = program2.command("issue").description("File bug reports, feature requests, or questions to CLEO GitHub repo");
@@ -43742,7 +44704,7 @@ async function handleIssueType(issueType, opts) {
   if (opts["open"] && typeof result["url"] === "string" && result["url"].startsWith("https://")) {
     const issueNumber = result["url"].match(/(\d+)$/)?.[1] ?? "unknown";
     try {
-      execFileSync12("gh", ["issue", "view", issueNumber, "--repo", CLEO_REPO2, "--web"], {
+      execFileSync14("gh", ["issue", "view", issueNumber, "--repo", CLEO_REPO2, "--web"], {
         stdio: ["pipe", "pipe", "pipe"]
       });
     } catch {
@@ -44427,22 +45389,22 @@ function registerPlanCommand(program2) {
 }
 
 // src/core/otel/index.ts
-import { readFileSync as readFileSync46, existsSync as existsSync63, writeFileSync as writeFileSync11, copyFileSync as copyFileSync4 } from "node:fs";
-import { join as join66 } 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 (existsSync63(join66(dir, ".cleo", "config.json"))) return dir;
-    dir = join66(dir, "..");
+    if (existsSync65(join68(dir, ".cleo", "config.json"))) return dir;
+    dir = join68(dir, "..");
   }
   return process.cwd();
 }
 function getTokenFilePath() {
-  return join66(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
+  return join68(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
 }
 function readJsonlFile(filePath) {
-  if (!existsSync63(filePath)) return [];
-  const content = readFileSync46(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));
 }
@@ -44524,10 +45486,10 @@ async function getRealTokenUsage(_opts) {
 }
 async function clearOtelData() {
   const tokenFile = getTokenFilePath();
-  if (existsSync63(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" };
@@ -44889,8 +45851,8 @@ init_storage_preflight();
 init_paths();
 init_storage_preflight();
 init_agent_outputs();
-import { existsSync as existsSync67, readFileSync as readFileSync48, writeFileSync as writeFileSync12, mkdirSync as mkdirSync18, readdirSync as readdirSync19, copyFileSync as copyFileSync5 } from "node:fs";
-import { join as join70 } 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();
@@ -44926,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 = join70(cleoDir, "tasks.db");
-  const dbExists2 = existsSync67(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;
@@ -44943,7 +45905,7 @@ async function runUpgrade(options = {}) {
       let migrationLock = null;
       try {
         const cleoDir2 = getCleoDirAbsolute(options.cwd);
-        const dbPath2 = join70(cleoDir2, "tasks.db");
+        const dbPath2 = join72(cleoDir2, "tasks.db");
         try {
           migrationLock = await acquireLock(dbPath2, { stale: 3e4, retries: 0 });
         } catch {
@@ -44968,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: join70(cleoDir2, "todo.json"), checksum: "" },
-          sessionsJson: { path: join70(cleoDir2, "sessions.json"), checksum: "" },
-          archiveJson: { path: join70(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 = join70(cleoDir2, "backups", "safety", `tasks.db.pre-migration.${Date.now()}`);
-        const dbTempPath = join70(cleoDir2, "tasks.db.migrating");
-        if (existsSync67(dbPath2)) {
-          const backupDir = join70(cleoDir2, "backups", "safety");
-          if (!existsSync67(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(readFileSync48(dbPath2)).digest("hex");
-          const backupChecksum = createHash9("sha256").update(readFileSync48(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.`
@@ -44999,14 +45961,14 @@ async function runUpgrade(options = {}) {
           }
           logger.info("backup", "verified", "Backup integrity verified", { checksum: origChecksum });
         }
-        if (existsSync67(dbTempPath)) {
+        if (existsSync69(dbTempPath)) {
           const { unlinkSync: unlinkSync5 } = await import("node:fs");
           unlinkSync5(dbTempPath);
         }
-        const configPath = join70(cleoDir2, "config.json");
+        const configPath = join72(cleoDir2, "config.json");
         let configBackup = null;
-        if (existsSync67(configPath)) {
-          configBackup = readFileSync48(configPath, "utf-8");
+        if (existsSync69(configPath)) {
+          configBackup = readFileSync50(configPath, "utf-8");
         }
         const { resetDbState: resetDbState2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
         resetDbState2();
@@ -45032,10 +45994,10 @@ async function runUpgrade(options = {}) {
         resetDbState2();
         if (result.success) {
           const totalImported = result.tasksImported + result.archivedImported;
-          if (totalImported === 0 && existsSync67(dbBackupPath)) {
+          if (totalImported === 0 && existsSync69(dbBackupPath)) {
             copyFileSync5(dbBackupPath, dbPath2);
             if (configBackup) {
-              writeFileSync12(configPath, configBackup);
+              writeFileSync13(configPath, configBackup);
             }
             actions.push({
               action: "storage_migration",
@@ -45046,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 (existsSync67(configPath)) {
+            if (existsSync69(configPath)) {
               try {
-                config = JSON.parse(readFileSync48(configPath, "utf-8"));
+                config = JSON.parse(readFileSync50(configPath, "utf-8"));
               } catch {
               }
             }
@@ -45056,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",
@@ -45074,11 +46036,11 @@ async function runUpgrade(options = {}) {
             logger.info("complete", "finish", "Migration completed successfully");
           }
         } else {
-          if (existsSync67(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) {
@@ -45097,12 +46059,12 @@ async function runUpgrade(options = {}) {
       } catch (err) {
         try {
           const cleoDir2 = getCleoDirAbsolute(options.cwd);
-          const dbPath2 = join70(cleoDir2, "tasks.db");
-          const safetyDir = join70(cleoDir2, "backups", "safety");
-          if (existsSync67(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 && !existsSync67(dbPath2)) {
-              copyFileSync5(join70(safetyDir, backups[0]), dbPath2);
+            if (backups.length > 0 && !existsSync69(dbPath2)) {
+              copyFileSync5(join72(safetyDir, backups[0]), dbPath2);
             }
           }
         } catch {
@@ -45137,7 +46099,7 @@ async function runUpgrade(options = {}) {
       details: preflight.summary
     });
   }
-  if (existsSync67(dbPath)) {
+  if (existsSync69(dbPath)) {
     try {
       const { runAllRepairs: runAllRepairs2 } = await Promise.resolve().then(() => (init_repair(), repair_exports));
       const repairActions = await runAllRepairs2(options.cwd, isDryRun);
@@ -45147,8 +46109,8 @@ async function runUpgrade(options = {}) {
     } catch {
     }
   }
-  if (existsSync67(dbPath)) {
-    const legacySequenceFiles = [".sequence", ".sequence.json"].filter((f) => existsSync67(join70(cleoDir, f)));
+  if (existsSync69(dbPath)) {
+    const legacySequenceFiles = [".sequence", ".sequence.json"].filter((f) => existsSync69(join72(cleoDir, f)));
     if (legacySequenceFiles.length > 0) {
       if (isDryRun) {
         actions.push({
@@ -45177,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) => existsSync67(join70(cleoDir, f)));
+    const foundStale = staleJsonFiles.filter((f) => existsSync69(join72(cleoDir, f)));
     if (foundStale.length > 0) {
       if (isDryRun) {
         actions.push({
@@ -45187,15 +46149,15 @@ async function runUpgrade(options = {}) {
         });
       } else {
         try {
-          const backupDir = join70(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 = join70(cleoDir, f);
-            copyFileSync5(src, join70(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(join70(cleoDir, f));
+            unlinkSync5(join72(cleoDir, f));
           }
           actions.push({
             action: "stale_json_cleanup",
@@ -45215,7 +46177,7 @@ async function runUpgrade(options = {}) {
   if (options.includeGlobal) {
     try {
       const globalDir = getCleoHome();
-      const globalPreflight = checkStorageMigration(join70(globalDir, ".."));
+      const globalPreflight = checkStorageMigration(join72(globalDir, ".."));
       if (globalPreflight.migrationNeeded) {
         actions.push({
           action: "global_storage_check",
@@ -45236,8 +46198,8 @@ async function runUpgrade(options = {}) {
   try {
     const projectRoot = getProjectRoot(options.cwd);
     if (isDryRun) {
-      const gitignorePath = join70(cleoDir, ".gitignore");
-      if (!existsSync67(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" });
@@ -45280,12 +46242,12 @@ async function runUpgrade(options = {}) {
   try {
     const projectRootForContext = getProjectRoot(options.cwd);
     if (isDryRun) {
-      const contextPath = join70(cleoDir, "project-context.json");
-      if (!existsSync67(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(readFileSync48(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) {
@@ -45446,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 join71 } 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();
@@ -45455,7 +46417,7 @@ var GITHUB_REPO = BUILD_CONFIG.repository.fullName;
 async function getCurrentVersion() {
   const cleoHome = getCleoHome();
   try {
-    const content = await readFile20(join71(cleoHome, "VERSION"), "utf-8");
+    const content = await readFile20(join73(cleoHome, "VERSION"), "utf-8");
     return (content.split("\n")[0] ?? "unknown").trim();
   } catch {
     return "unknown";
@@ -45502,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(join71(cleoHome, "VERSION"), `${lines.join("\n")}
+    ({ writeFile: writeFile15, mkdir: mkdir14 }) => mkdir14(cleoHome, { recursive: true }).then(() => writeFile15(join73(cleoHome, "VERSION"), `${lines.join("\n")}
 `, "utf-8"))
   );
 }
@@ -45861,14 +46823,14 @@ function registerVerifyCommand(program2) {
 
 // src/cli/commands/detect-drift.ts
 init_renderers();
-import { readFileSync as readFileSync49, existsSync as existsSync68, readdirSync as readdirSync20 } from "node:fs";
-import { join as join72, 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 (existsSync68(join72(currentDir, "package.json"))) {
+    if (existsSync70(join74(currentDir, "package.json"))) {
       return currentDir;
     }
     const parent = dirname18(currentDir);
@@ -45906,16 +46868,16 @@ function registerDetectDriftCommand(program2) {
     };
     const safeRead = (path) => {
       try {
-        return readFileSync49(path, "utf-8");
+        return readFileSync51(path, "utf-8");
       } catch {
         return "";
       }
     };
     try {
-      const specPath = join72(projectRoot, "docs", "specs", "CLEO-OPERATIONS-REFERENCE.md");
-      const queryPath = join72(projectRoot, "src", "mcp", "gateways", "query.ts");
-      const mutatePath = join72(projectRoot, "src", "mcp", "gateways", "mutate.ts");
-      if (!existsSync68(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",
@@ -45923,7 +46885,7 @@ function registerDetectDriftCommand(program2) {
           file: specPath,
           recommendation: "Create docs/specs/CLEO-OPERATIONS-REFERENCE.md with canonical operation definitions"
         }]);
-      } else if (!existsSync68(queryPath) || !existsSync68(mutatePath)) {
+      } else if (!existsSync70(queryPath) || !existsSync70(mutatePath)) {
         addCheck("Gateway-to-spec sync", "fail", "MCP gateway files missing", [{
           severity: "error",
           category: "implementation",
@@ -45977,16 +46939,16 @@ function registerDetectDriftCommand(program2) {
       }]);
     }
     try {
-      const cliDir = join72(projectRoot, "src", "cli", "commands");
-      const coreDir = join72(projectRoot, "src", "core");
-      if (!existsSync68(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 (!existsSync68(coreDir)) {
+      } else if (!existsSync70(coreDir)) {
         addCheck("CLI-to-core sync", "fail", "Core directory missing", [{
           severity: "error",
           category: "structure",
@@ -46001,8 +46963,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("CLI-to-core sync", "fail", `Error: ${e.message}`);
     }
     try {
-      const domainsDir = join72(projectRoot, "src", "mcp", "domains");
-      if (!existsSync68(domainsDir)) {
+      const domainsDir = join74(projectRoot, "src", "mcp", "domains");
+      if (!existsSync70(domainsDir)) {
         addCheck("Domain handler coverage", "fail", "MCP domains directory missing", [{
           severity: "error",
           category: "structure",
@@ -46017,8 +46979,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Domain handler coverage", "fail", `Error: ${e.message}`);
     }
     try {
-      const matrixPath = join72(projectRoot, "src", "dispatch", "lib", "capability-matrix.ts");
-      if (!existsSync68(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",
@@ -46032,8 +46994,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Capability matrix", "fail", `Error: ${e.message}`);
     }
     try {
-      const schemaPath = join72(projectRoot, "src", "store", "schema.ts");
-      if (!existsSync68(schemaPath)) {
+      const schemaPath = join74(projectRoot, "src", "store", "schema.ts");
+      if (!existsSync70(schemaPath)) {
         addCheck("Schema validation", "fail", "Schema definition missing", [{
           severity: "error",
           category: "data-model",
@@ -46058,10 +47020,10 @@ function registerDetectDriftCommand(program2) {
       addCheck("Schema validation", "fail", `Error: ${e.message}`);
     }
     try {
-      const visionPath = join72(projectRoot, "docs", "concepts", "CLEO-VISION.md");
-      const specPath = join72(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 (!existsSync68(visionPath)) {
+      if (!existsSync70(visionPath)) {
         issues.push({
           severity: "error",
           category: "vision",
@@ -46070,7 +47032,7 @@ function registerDetectDriftCommand(program2) {
           recommendation: "Create docs/concepts/CLEO-VISION.md with project vision"
         });
       }
-      if (!existsSync68(specPath)) {
+      if (!existsSync70(specPath)) {
         issues.push({
           severity: "error",
           category: "spec",
@@ -46107,8 +47069,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Canonical identity", "fail", `Error: ${e.message}`);
     }
     try {
-      const injectionPath = join72(projectRoot, ".cleo", "templates", "CLEO-INJECTION.md");
-      if (!existsSync68(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",
@@ -46133,8 +47095,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Agent injection", "fail", `Error: ${e.message}`);
     }
     try {
-      const exitCodesPath = join72(projectRoot, "src", "types", "exit-codes.ts");
-      if (!existsSync68(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",
@@ -46373,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 existsSync69, readFileSync as readFileSync50 } from "node:fs";
-import { join as join73, 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) {
@@ -46384,17 +47346,17 @@ function registerInstallGlobalCommand(program2) {
     const warnings = [];
     try {
       const cleoHome = getCleoHome();
-      const globalTemplatesDir = join73(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 = join73(packageRoot, "templates", "CLEO-INJECTION.md");
-        if (existsSync69(templatePath)) {
-          const content = readFileSync50(templatePath, "utf-8");
-          const globalPath = join73(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);
           }
@@ -46404,12 +47366,12 @@ function registerInstallGlobalCommand(program2) {
         warnings.push("Could not refresh CLEO-INJECTION.md template");
       }
       const globalAgentsDir = getAgentsHome();
-      const globalAgentsMd = join73(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 (existsSync69(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) {
@@ -46428,8 +47390,8 @@ function registerInstallGlobalCommand(program2) {
           const injectionContent = buildInjectionContent2({ references: ["@~/.agents/AGENTS.md"] });
           if (!isDryRun) {
             for (const provider of providers) {
-              const instructFilePath = join73(provider.pathGlobal, provider.instructFile);
-              if (existsSync69(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) {
@@ -46444,7 +47406,7 @@ function registerInstallGlobalCommand(program2) {
             }
           } else {
             for (const p of providers) {
-              const displayPath = join73(p.pathGlobal, p.instructFile).replace(homedir4(), "~");
+              const displayPath = join75(p.pathGlobal, p.instructFile).replace(homedir4(), "~");
               created.push(`${displayPath} (would update CAAMP block)`);
             }
           }
@@ -46650,7 +47612,7 @@ init_paths();
 init_paths();
 init_brain_sqlite();
 init_brain_search();
-import { existsSync as existsSync70 } 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");
@@ -46694,7 +47656,7 @@ async function migrateClaudeMem(projectRoot, options = {}) {
     errors: [],
     dryRun
   };
-  if (!existsSync70(sourcePath)) {
+  if (!existsSync72(sourcePath)) {
     throw new Error(
       `claude-mem database not found at: ${sourcePath}
 Expected location: ~/.claude-mem/claude-mem.db
@@ -47096,10 +48058,10 @@ init_config();
 // src/cli/logger-bootstrap.ts
 init_logger();
 init_project_info();
-import { join as join74 } from "node:path";
+import { join as join76 } from "node:path";
 function initCliLogger(cwd, loggingConfig) {
   const projectInfo = getProjectInfoSync(cwd);
-  initLogger(join74(cwd, ".cleo"), loggingConfig, projectInfo?.projectHash);
+  initLogger(join76(cwd, ".cleo"), loggingConfig, projectInfo?.projectHash);
 }
 
 // src/cli/index.ts
@@ -47332,8 +48294,8 @@ Upgrade options:
 }
 function getPackageVersion() {
   try {
-    const moduleRoot = join75(import.meta.dirname ?? "", "..", "..");
-    const pkg = JSON.parse(readFileSync51(join75(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";
@@ -47444,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(join75(process.cwd(), ".cleo"), config.logging).catch(() => {
+    pruneAuditLog2(join77(process.cwd(), ".cleo"), config.logging).catch(() => {
     });
   } catch {
   }
@@ -47484,7 +48446,7 @@ program.hook("preAction", (thisCommand) => {
   }
 });
 if (process.argv[2] === "mcp") {
-  const mcpPath = join75(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,