@cleocode/cleo 2026.3.16 → 2026.3.18

package/dist/mcp/index.js

@@ -1809,6 +1809,16 @@ var init_registry = __esm({
         sessionRequired: false,
         requiredParams: ["version"]
       },
+      {
+        gateway: "query",
+        domain: "pipeline",
+        operation: "release.channel.show",
+        description: "Show the current release channel based on git branch (latest/beta/alpha)",
+        tier: 0,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: []
+      },
       {
         gateway: "mutate",
         domain: "pipeline",
@@ -1869,6 +1879,16 @@ var init_registry = __esm({
         sessionRequired: false,
         requiredParams: []
       },
+      {
+        gateway: "mutate",
+        domain: "pipeline",
+        operation: "release.cancel",
+        description: "pipeline.release.cancel (mutate)",
+        tier: 0,
+        idempotent: false,
+        sessionRequired: false,
+        requiredParams: ["version"]
+      },
       {
         gateway: "mutate",
         domain: "pipeline",
@@ -4895,13 +4915,13 @@ async function getDb(cwd) {
     if (!_gitTrackingChecked) {
       _gitTrackingChecked = true;
       try {
-        const { execFileSync: execFileSync10 } = await import("node:child_process");
+        const { execFileSync: execFileSync12 } = 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 {
-            execFileSync10("git", ["ls-files", "--error-unmatch", fileToCheck], {
+            execFileSync12("git", ["ls-files", "--error-unmatch", fileToCheck], {
               cwd: gitCwd,
               stdio: "pipe"
             });
@@ -15585,6 +15605,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);
@@ -15601,11 +15622,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,
@@ -15617,7 +15672,7 @@ async function getProjectStats(opts, accessor) {
       completedInPeriod,
       archivedInPeriod
     },
-    allTime: { totalCreated, totalCompleted, totalArchived }
+    allTime: { totalCreated, totalCompleted, totalCancelled, totalArchived, archivedCompleted }
   };
 }
 function rankBlockedTask(task, allTasks, focusTask) {
@@ -15661,7 +15716,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;
@@ -15669,7 +15735,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 ?? "");
@@ -15682,6 +15748,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;
     }
@@ -15690,7 +15757,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: {
@@ -19811,7 +19878,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,
@@ -19831,17 +19900,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;
     }
@@ -19871,7 +19941,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,
@@ -19896,10 +19968,10 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join62 } = await import("node:path");
-    const { existsSync: existsSync62 } = await import("node:fs");
-    const dbPath = join62(projectRoot, ".cleo", "tasks.db");
-    if (!existsSync62(dbPath)) {
+    const { join: join64 } = await import("node:path");
+    const { existsSync: existsSync64 } = await import("node:fs");
+    const dbPath = join64(projectRoot, ".cleo", "tasks.db");
+    if (!existsSync64(dbPath)) {
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
       return {
@@ -20643,10 +20715,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync44, existsSync: existsSync62 } = await import("node:fs");
+    const { readFileSync: readFileSync46, existsSync: existsSync64 } = await import("node:fs");
     const infoPath = join34(projectPath, ".cleo", "project-info.json");
-    if (!existsSync62(infoPath)) return "";
-    const data = JSON.parse(readFileSync44(infoPath, "utf-8"));
+    if (!existsSync64(infoPath)) return "";
+    const data = JSON.parse(readFileSync46(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -27991,11 +28063,353 @@ var init_changelog_writer = __esm({
   }
 });
 
-// src/core/release/release-manifest.ts
-import { existsSync as existsSync49, 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 stderr = apiErr instanceof Error && "stderr" in apiErr ? String(apiErr.stderr ?? "") : "";
+          if (stderr.includes("404") || stderr.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 stderr = pushErr instanceof Error && "stderr" in pushErr ? String(pushErr.stderr ?? "") : pushErr instanceof Error ? pushErr.message : String(pushErr);
+    if (stderr.includes("protected branch") || stderr.includes("GH006") || stderr.includes("refusing to allow")) {
+      return { protected: true, detectionMethod: "push-dry-run" };
+    }
+    return {
+      protected: false,
+      detectionMethod: "unknown",
+      error: stderr
+    };
+  }
+}
+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 stderr = err instanceof Error && "stderr" in err ? String(err.stderr ?? "") : err instanceof Error ? err.message : String(err);
+    if (stderr.includes("already exists")) {
+      const urlMatch = stderr.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: stderr
+    };
+  }
+}
+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 existsSync49, readFileSync as readFileSync38 } from "node:fs";
 import { join as join47 } from "node:path";
+function readConfigValueSync(path, defaultValue, cwd) {
+  try {
+    const configPath = join47(getCleoDir(cwd), "config.json");
+    if (!existsSync49(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 existsSync50, 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 join48 } 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);
@@ -28087,25 +28501,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];
@@ -28140,14 +28607,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 = join47(cwd ?? process.cwd(), "CHANGELOG.md");
+  const changelogPath = join48(cwd ?? process.cwd(), "CHANGELOG.md");
   let existingChangelogContent = "";
   try {
     existingChangelogContent = await readFile10(changelogPath, "utf8");
@@ -28155,7 +28622,7 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
   }
   const { customBlocks } = parseChangelogBlocks(existingChangelogContent);
   const changelogBody = sections.slice(2).join("\n");
-  await writeChangelogSection(normalizedVersion, changelogBody, customBlocks, changelogPath);
+  await writeChangelogSection(normalizedVersion.replace(/^v/, ""), changelogBody, customBlocks, changelogPath);
   return {
     version: normalizedVersion,
     changelog,
@@ -28166,7 +28633,7 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
       docs: docs.length,
       tests: tests.length,
       chores: chores.length,
-      other: other.length
+      changes: changes.length
     }
   };
 }
@@ -28228,7 +28695,7 @@ async function tagRelease(version, cwd) {
   await db.update(releaseManifests).set({ status: "tagged", taggedAt }).where(eq14(releaseManifests.version, normalizedVersion)).run();
   return { version: normalizedVersion, status: "tagged", taggedAt };
 }
-async function runReleaseGates(version, loadTasksFn, cwd) {
+async function runReleaseGates(version, loadTasksFn, cwd, opts) {
   if (!version) {
     throw new Error("version is required");
   }
@@ -28267,58 +28734,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 = join47(projectRoot, "dist", "cli", "index.js");
-  const isNodeProject = existsSync49(join47(projectRoot, "package.json"));
+  const distPath = join48(projectRoot, "dist", "cli", "index.js");
+  const isNodeProject = existsSync50(join48(projectRoot, "package.json"));
   if (isNodeProject) {
     gates.push({
       name: "build_artifact",
-      status: existsSync49(distPath) ? "passed" : "failed",
-      message: existsSync49(distPath) ? "dist/cli/index.js present" : "dist/ not built \u2014 run: npm run build"
+      status: existsSync50(distPath) ? "passed" : "failed",
+      message: existsSync50(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");
@@ -28339,7 +28869,7 @@ async function rollbackRelease(version, reason, cwd) {
   };
 }
 async function readPushPolicy(cwd) {
-  const configPath = join47(getCleoDirAbsolute(cwd), "config.json");
+  const configPath = join48(getCleoDirAbsolute(cwd), "config.json");
   const config = await readJson(configPath);
   if (!config) return void 0;
   const release2 = config.release;
@@ -28353,6 +28883,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."
@@ -28360,20 +28917,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",
@@ -28385,7 +28943,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",
@@ -28416,6 +28974,9 @@ var init_release_manifest = __esm({
     init_paths();
     init_json();
     init_changelog_writer();
+    init_github_pr();
+    init_channel();
+    init_release_config();
   }
 });
 
@@ -28495,8 +29056,181 @@ var init_guards = __esm({
   }
 });
 
+// src/core/release/version-bump.ts
+import { existsSync as existsSync51, readFileSync as readFileSync39, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join49 } from "node:path";
+function readConfigValueSync2(path, defaultValue, cwd) {
+  try {
+    const configPath = join49(getCleoDir(cwd), "config.json");
+    if (!existsSync51(configPath)) return defaultValue;
+    const config = JSON.parse(readFileSync39(configPath, "utf-8"));
+    const keys = path.split(".");
+    let value = config;
+    for (const key of keys) {
+      if (value == null || typeof value !== "object") return defaultValue;
+      value = value[key];
+    }
+    return value ?? defaultValue;
+  } catch {
+    return defaultValue;
+  }
+}
+function validateVersionFormat(version) {
+  return VERSION_WITH_PRERELEASE.test(version);
+}
+function getVersionBumpConfig(cwd) {
+  try {
+    const raw = readConfigValueSync2("release.versionBump.files", [], cwd);
+    return raw.map((entry) => ({
+      file: entry.path ?? entry.file ?? "",
+      strategy: entry.strategy,
+      field: entry.jsonPath?.replace(/^\./, "") ?? entry.field,
+      key: entry.key,
+      section: entry.section,
+      pattern: entry.sedPattern ?? entry.pattern
+    })).filter((t) => t.file !== "");
+  } catch {
+    return [];
+  }
+}
+function bumpFile(target, newVersion, projectRoot) {
+  const filePath = join49(projectRoot, target.file);
+  if (!existsSync51(filePath)) {
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: false,
+      error: `File not found: ${target.file}`
+    };
+  }
+  try {
+    const content = readFileSync39(filePath, "utf-8");
+    let previousVersion;
+    let newContent;
+    switch (target.strategy) {
+      case "plain": {
+        previousVersion = content.trim();
+        newContent = newVersion + "\n";
+        break;
+      }
+      case "json": {
+        const field = target.field ?? "version";
+        const json = JSON.parse(content);
+        previousVersion = getNestedField(json, field);
+        setNestedField(json, field, newVersion);
+        newContent = JSON.stringify(json, null, 2) + "\n";
+        break;
+      }
+      case "toml": {
+        const key = target.key ?? "version";
+        const versionRegex = new RegExp(`^(${key}\\s*=\\s*")([^"]+)(")`, "m");
+        const match = content.match(versionRegex);
+        previousVersion = match?.[2];
+        newContent = content.replace(versionRegex, `$1${newVersion}$3`);
+        break;
+      }
+      case "sed": {
+        const pattern = target.pattern ?? "";
+        if (!pattern.includes("{{VERSION}}")) {
+          return {
+            file: target.file,
+            strategy: target.strategy,
+            success: false,
+            error: "sed strategy requires {{VERSION}} placeholder in pattern"
+          };
+        }
+        const regex = new RegExp(pattern.replace("{{VERSION}}", "([\\d.]+)"));
+        const match = content.match(regex);
+        previousVersion = match?.[1];
+        newContent = content.replace(
+          regex,
+          pattern.replace("{{VERSION}}", newVersion)
+        );
+        break;
+      }
+      default:
+        return {
+          file: target.file,
+          strategy: target.strategy,
+          success: false,
+          error: `Unknown strategy: ${target.strategy}`
+        };
+    }
+    writeFileSync8(filePath, newContent, "utf-8");
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: true,
+      previousVersion,
+      newVersion
+    };
+  } catch (err) {
+    return {
+      file: target.file,
+      strategy: target.strategy,
+      success: false,
+      error: String(err)
+    };
+  }
+}
+function bumpVersionFromConfig(newVersion, options = {}, cwd) {
+  if (!validateVersionFormat(newVersion)) {
+    throw new CleoError(
+      6 /* VALIDATION_ERROR */,
+      `Invalid version: '${newVersion}' (expected X.Y.Z or YYYY.M.patch)`
+    );
+  }
+  const targets = getVersionBumpConfig(cwd);
+  if (targets.length === 0) {
+    throw new CleoError(
+      1 /* GENERAL_ERROR */,
+      "No version bump targets configured. Add release.versionBump.files to .cleo/config.json"
+    );
+  }
+  const projectRoot = getProjectRoot(cwd);
+  const results = [];
+  if (options.dryRun) {
+    for (const target of targets) {
+      results.push({
+        file: target.file,
+        strategy: target.strategy,
+        success: true,
+        newVersion
+      });
+    }
+    return { results, allSuccess: true };
+  }
+  for (const target of targets) {
+    results.push(bumpFile(target, newVersion, projectRoot));
+  }
+  const allSuccess = results.every((r) => r.success);
+  return { results, allSuccess };
+}
+function getNestedField(obj, path) {
+  return path.split(".").reduce((acc, key) => acc?.[key], obj);
+}
+function setNestedField(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (typeof current[parts[i]] !== "object") current[parts[i]] = {};
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+var VERSION_WITH_PRERELEASE;
+var init_version_bump = __esm({
+  "src/core/release/version-bump.ts"() {
+    "use strict";
+    init_paths();
+    init_errors();
+    init_exit_codes();
+    VERSION_WITH_PRERELEASE = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
+  }
+});
+
 // src/dispatch/engines/release-engine.ts
-import { execFileSync as 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"]);
 }
@@ -28617,6 +29351,23 @@ async function releaseRollback(version, reason, projectRoot) {
     return engineError(code, message);
   }
 }
+async function releaseCancel(version, projectRoot) {
+  if (!version) {
+    return engineError("E_INVALID_INPUT", "version is required");
+  }
+  try {
+    const result = await cancelRelease(version, projectRoot);
+    if (!result.success) {
+      const code = result.message.includes("not found") ? "E_NOT_FOUND" : "E_INVALID_STATE";
+      return engineError(code, result.message);
+    }
+    return { success: true, data: result };
+  } catch (err) {
+    const message = err.message;
+    const code = message.includes("not found") ? "E_NOT_FOUND" : "E_CANCEL_FAILED";
+    return engineError(code, message);
+  }
+}
 async function releasePush(version, remote, projectRoot, opts) {
   if (isAgentContext()) {
     const hasEntry = await hasManifestEntry(version, projectRoot);
@@ -28638,7 +29389,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"
@@ -28660,7 +29411,7 @@ async function releasePush(version, remote, projectRoot, opts) {
   }
 }
 async function releaseShip(params, projectRoot) {
-  const { version, epicId, remote, dryRun = false } = params;
+  const { version, epicId, remote, dryRun = false, bump = true } = params;
   if (!version) {
     return engineError("E_INVALID_INPUT", "version is required");
   }
@@ -28668,18 +29419,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);
@@ -28690,10 +29494,13 @@ async function releaseShip(params, projectRoot) {
     const epicCheck = await checkEpicCompleteness(releaseTaskIds, projectRoot, epicAccessor);
     if (epicCheck.hasIncomplete) {
       const incomplete = epicCheck.epics.filter((e) => e.missingChildren.length > 0).map((e) => `${e.epicId}: missing ${e.missingChildren.map((c) => c.id).join(", ")}`).join("; ");
+      logStep(2, 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(
@@ -28702,73 +29509,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 });
@@ -28780,7 +29674,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) {
@@ -28793,15 +29697,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 existsSync50 } from "fs";
-import { join as join48 } from "path";
+import { readFileSync as readFileSync40, readdirSync as readdirSync12, existsSync as existsSync52 } from "fs";
+import { join as join50 } from "path";
 import { parse as parseYaml } from "yaml";
 function deriveSubcommand(filename) {
   let stem = filename.replace(/\.ya?ml$/i, "");
@@ -28815,8 +29722,8 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile(templateDir, filename) {
-  const filePath = join48(templateDir, filename);
-  const raw = readFileSync38(filePath, "utf-8");
+  const filePath = join50(templateDir, filename);
+  const raw = readFileSync40(filePath, "utf-8");
   const parsed = parseYaml(raw);
   const name = typeof parsed.name === "string" ? parsed.name : filename;
   const titlePrefix = typeof parsed.title === "string" ? parsed.title : "";
@@ -28865,8 +29772,8 @@ function parseTemplateFile(templateDir, filename) {
   };
 }
 function parseIssueTemplates(projectRoot) {
-  const templateDir = join48(projectRoot, ".github", "ISSUE_TEMPLATE");
-  if (!existsSync50(templateDir)) {
+  const templateDir = join50(projectRoot, ".github", "ISSUE_TEMPLATE");
+  if (!existsSync52(templateDir)) {
     return engineError("E_NOT_FOUND", `Issue template directory not found: ${templateDir}`);
   }
   let files;
@@ -30545,26 +31452,26 @@ var init_check = __esm({
 });
 
 // src/core/adrs/validate.ts
-import { readFileSync as readFileSync39, readdirSync as readdirSync13, existsSync as existsSync51 } from "node:fs";
-import { join as join49 } from "node:path";
+import { readFileSync as readFileSync41, readdirSync as readdirSync13, existsSync as existsSync53 } from "node:fs";
+import { join as join51 } from "node:path";
 import AjvModule3 from "ajv";
 async function validateAllAdrs(projectRoot) {
-  const adrsDir = join49(projectRoot, ".cleo", "adrs");
-  const schemaPath = join49(projectRoot, "schemas", "adr-frontmatter.schema.json");
-  if (!existsSync51(schemaPath)) {
+  const adrsDir = join51(projectRoot, ".cleo", "adrs");
+  const schemaPath = join51(projectRoot, "schemas", "adr-frontmatter.schema.json");
+  if (!existsSync53(schemaPath)) {
     return {
       valid: false,
       errors: [{ file: "schemas/adr-frontmatter.schema.json", field: "schema", message: "Schema file not found" }],
       checked: 0
     };
   }
-  if (!existsSync51(adrsDir)) {
+  if (!existsSync53(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) => join49(adrsDir, f));
+  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join51(adrsDir, f));
   const errors = [];
   for (const filePath of files) {
     const record = parseAdrFile(filePath, projectRoot);
@@ -30591,15 +31498,15 @@ var init_validate = __esm({
 });
 
 // src/core/adrs/list.ts
-import { readdirSync as readdirSync14, existsSync as existsSync52 } from "node:fs";
-import { join as join50 } from "node:path";
+import { readdirSync as readdirSync14, existsSync as existsSync54 } from "node:fs";
+import { join as join52 } from "node:path";
 async function listAdrs(projectRoot, opts) {
-  const adrsDir = join50(projectRoot, ".cleo", "adrs");
-  if (!existsSync52(adrsDir)) {
+  const adrsDir = join52(projectRoot, ".cleo", "adrs");
+  if (!existsSync54(adrsDir)) {
     return { adrs: [], total: 0 };
   }
   const files = readdirSync14(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
-  const records = files.map((f) => parseAdrFile(join50(adrsDir, f), projectRoot));
+  const records = files.map((f) => parseAdrFile(join52(adrsDir, f), projectRoot));
   const filtered = records.filter((r) => {
     if (opts?.status && r.frontmatter.Status !== opts.status) return false;
     if (opts?.since && r.frontmatter.Date < opts.since) return false;
@@ -30624,14 +31531,14 @@ var init_list2 = __esm({
 });
 
 // src/core/adrs/show.ts
-import { existsSync as existsSync53, readdirSync as readdirSync15 } from "node:fs";
-import { join as join51 } from "node:path";
+import { existsSync as existsSync55, readdirSync as readdirSync15 } from "node:fs";
+import { join as join53 } from "node:path";
 async function showAdr(projectRoot, adrId) {
-  const adrsDir = join51(projectRoot, ".cleo", "adrs");
-  if (!existsSync53(adrsDir)) return null;
+  const adrsDir = join53(projectRoot, ".cleo", "adrs");
+  if (!existsSync55(adrsDir)) return null;
   const files = readdirSync15(adrsDir).filter((f) => f.startsWith(adrId) && f.endsWith(".md"));
   if (files.length === 0) return null;
-  const filePath = join51(adrsDir, files[0]);
+  const filePath = join53(adrsDir, files[0]);
   return parseAdrFile(filePath, projectRoot);
 }
 var init_show2 = __esm({
@@ -30642,8 +31549,8 @@ var init_show2 = __esm({
 });
 
 // src/core/adrs/find.ts
-import { readdirSync as readdirSync16, existsSync as existsSync54 } from "node:fs";
-import { join as join52 } from "node:path";
+import { readdirSync as readdirSync16, existsSync as existsSync56 } from "node:fs";
+import { join as join54 } from "node:path";
 function normalise(s) {
   return s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -30660,8 +31567,8 @@ function matchedTerms(target, terms) {
   return terms.filter((term) => t.includes(term));
 }
 async function findAdrs(projectRoot, query, opts) {
-  const adrsDir = join52(projectRoot, ".cleo", "adrs");
-  if (!existsSync54(adrsDir)) {
+  const adrsDir = join54(projectRoot, ".cleo", "adrs");
+  if (!existsSync56(adrsDir)) {
     return { adrs: [], query, total: 0 };
   }
   const files = readdirSync16(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
@@ -30670,7 +31577,7 @@ async function findAdrs(projectRoot, query, opts) {
   const filterKeywords = opts?.keywords ? parseTags(opts.keywords) : null;
   const results = [];
   for (const file of files) {
-    const record = parseAdrFile(join52(adrsDir, file), projectRoot);
+    const record = parseAdrFile(join54(adrsDir, file), projectRoot);
     const fm = record.frontmatter;
     if (opts?.status && fm.Status !== opts.status) continue;
     if (filterTopics && filterTopics.length > 0) {
@@ -30748,12 +31655,12 @@ var init_adrs = __esm({
 });
 
 // src/core/admin/sync.ts
-import { join as join53 } from "node:path";
+import { join as join55 } from "node:path";
 import { rm as rm2, rmdir, stat as stat2 } from "node:fs/promises";
 async function getSyncStatus(projectRoot) {
   try {
     const cleoDir = getCleoDir(projectRoot);
-    const stateFile = join53(cleoDir, "sync", "todowrite-session.json");
+    const stateFile = join55(cleoDir, "sync", "todowrite-session.json");
     const sessionState = await readJson(stateFile);
     if (!sessionState) {
       return {
@@ -30797,8 +31704,8 @@ async function getSyncStatus(projectRoot) {
 async function clearSyncState(projectRoot, dryRun) {
   try {
     const cleoDir = getCleoDir(projectRoot);
-    const syncDir = join53(cleoDir, "sync");
-    const stateFile = join53(syncDir, "todowrite-session.json");
+    const syncDir = join55(cleoDir, "sync");
+    const stateFile = join55(syncDir, "todowrite-session.json");
     let exists = false;
     try {
       await stat2(stateFile);
@@ -31565,8 +32472,8 @@ var init_import_tasks = __esm({
 // src/core/snapshot/index.ts
 import { createHash as createHash8 } from "node:crypto";
 import { readFile as readFile13, writeFile as writeFile10, mkdir as mkdir10 } from "node:fs/promises";
-import { existsSync as existsSync55 } from "node:fs";
-import { join as join54, dirname as dirname14 } from "node:path";
+import { existsSync as existsSync57 } from "node:fs";
+import { join as join56, dirname as dirname14 } from "node:path";
 function toSnapshotTask(task) {
   return {
     id: task.id,
@@ -31619,7 +32526,7 @@ async function exportSnapshot(cwd) {
 }
 async function writeSnapshot(snapshot, outputPath) {
   const dir = dirname14(outputPath);
-  if (!existsSync55(dir)) {
+  if (!existsSync57(dir)) {
     await mkdir10(dir, { recursive: true });
   }
   await writeFile10(outputPath, JSON.stringify(snapshot, null, 2) + "\n");
@@ -31635,7 +32542,7 @@ async function readSnapshot(inputPath) {
 function getDefaultSnapshotPath(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  return join54(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
+  return join56(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);
@@ -31767,40 +32674,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 resolve8, normalize, relative as relative4, 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) {
-    throw new SecurityError(
-      "Task ID cannot be empty",
-      "E_INVALID_TASK_ID",
-      "taskId"
-    );
-  }
-  if (!TASK_ID_PATTERN.test(trimmed)) {
+  const normalized = normalizeTaskId(value);
+  if (normalized === null) {
     throw new SecurityError(
-      `Invalid task ID format: "${trimmed}". Must match pattern T[0-9]+ (e.g., T123)`,
+      `Invalid task ID format: ${value}`,
       "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") {
@@ -31899,14 +32815,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);
@@ -31956,10 +32872,11 @@ function sanitizeParams(params, projectRoot, context) {
   }
   return sanitized;
 }
-var SecurityError, TASK_ID_PATTERN, 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 {
@@ -31970,7 +32887,6 @@ var init_security = __esm({
         this.name = "SecurityError";
       }
     };
-    TASK_ID_PATTERN = /^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;
@@ -32069,15 +32985,15 @@ var init_field_filter = __esm({
 });
 
 // src/core/project-info.ts
-import { readFileSync as readFileSync40, existsSync as existsSync56 } from "node:fs";
-import { join as join55 } from "node:path";
+import { readFileSync as readFileSync42, existsSync as existsSync58 } from "node:fs";
+import { join as join57 } from "node:path";
 function getProjectInfoSync(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join55(cleoDir, "project-info.json");
-  if (!existsSync56(infoPath)) return null;
+  const infoPath = join57(cleoDir, "project-info.json");
+  if (!existsSync58(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;
@@ -32305,13 +33221,13 @@ var init_field_context = __esm({
 });
 
 // src/core/sessions/context-alert.ts
-import { existsSync as existsSync57, readFileSync as readFileSync41, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join56 } from "node:path";
+import { existsSync as existsSync59, readFileSync as readFileSync43, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join58 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join56(getCleoDir(cwd), ".current-session");
-  if (existsSync57(sessionFile)) {
-    return readFileSync41(sessionFile, "utf-8").trim() || null;
+  const sessionFile = join58(getCleoDir(cwd), ".current-session");
+  if (existsSync59(sessionFile)) {
+    return readFileSync43(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -33359,7 +34275,7 @@ async function stopTask2(sessionId, cwd) {
 }
 async function workHistory(sessionId, limit = 50, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(taskWorkHistory).where(eq16(taskWorkHistory.sessionId, sessionId)).orderBy(desc5(taskWorkHistory.setAt)).limit(limit).all();
+  const rows = await db.select().from(taskWorkHistory).where(eq16(taskWorkHistory.sessionId, sessionId)).orderBy(desc5(taskWorkHistory.setAt), desc5(taskWorkHistory.id)).limit(limit).all();
   return rows.map((r) => ({
     taskId: r.taskId,
     setAt: r.setAt,
@@ -33712,8 +34628,8 @@ __export(session_grade_exports, {
   gradeSession: () => gradeSession,
   readGrades: () => readGrades
 });
-import { join as join57 } from "node:path";
-import { existsSync as existsSync58 } from "node:fs";
+import { join as join59 } from "node:path";
+import { existsSync as existsSync60 } from "node:fs";
 import { readFile as readFile14, appendFile, mkdir as mkdir11 } from "node:fs/promises";
 async function gradeSession(sessionId, cwd) {
   const sessionEntries = await queryAudit({ sessionId });
@@ -33893,9 +34809,9 @@ function detectDuplicateCreates(entries) {
 async function appendGradeResult(result, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const metricsDir = join57(cleoDir, "metrics");
+    const metricsDir = join59(cleoDir, "metrics");
     await mkdir11(metricsDir, { recursive: true });
-    const gradesPath = join57(metricsDir, "GRADES.jsonl");
+    const gradesPath = join59(metricsDir, "GRADES.jsonl");
     const line = JSON.stringify({ ...result, evaluator: "auto" }) + "\n";
     await appendFile(gradesPath, line, "utf8");
   } catch {
@@ -33904,8 +34820,8 @@ async function appendGradeResult(result, cwd) {
 async function readGrades(sessionId, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const gradesPath = join57(cleoDir, "metrics", "GRADES.jsonl");
-    if (!existsSync58(gradesPath)) return [];
+    const gradesPath = join59(cleoDir, "metrics", "GRADES.jsonl");
+    if (!existsSync60(gradesPath)) return [];
     const content = await readFile14(gradesPath, "utf8");
     const results = content.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
     return sessionId ? results.filter((r) => r.sessionId === sessionId) : results;
@@ -35113,7 +36029,7 @@ function validateVariableType(name, varDef, value) {
       if (typeof value !== "string") {
         throw new Error(`Invalid variable type for "${name}": expected ${varDef.type}, got ${valueType(value)}`);
       }
-      if (!TASK_ID_PATTERN2.test(value)) {
+      if (!TASK_ID_PATTERN.test(value)) {
         throw new Error(`Invalid variable format for "${name}": expected ${varDef.type} like "T1234", got "${value}"`);
       }
       return;
@@ -35271,7 +36187,7 @@ function showTessera(id) {
   ensureDefaults();
   return templates.get(id) ?? null;
 }
-var DEFAULT_TESSERA_ID, TASK_ID_PATTERN2, PLACEHOLDER_EXACT, PLACEHOLDER_GLOBAL, templates;
+var DEFAULT_TESSERA_ID, TASK_ID_PATTERN, PLACEHOLDER_EXACT, PLACEHOLDER_GLOBAL, templates;
 var init_tessera_engine = __esm({
   "src/core/lifecycle/tessera-engine.ts"() {
     "use strict";
@@ -35279,7 +36195,7 @@ var init_tessera_engine = __esm({
     init_chain_validation();
     init_chain_store();
     DEFAULT_TESSERA_ID = "tessera-rcasd";
-    TASK_ID_PATTERN2 = /^T\d+$/;
+    TASK_ID_PATTERN = /^T\d+$/;
     PLACEHOLDER_EXACT = /^\{\{\s*([A-Za-z0-9_]+)\s*\}\}$/;
     PLACEHOLDER_GLOBAL = /\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g;
     templates = /* @__PURE__ */ new Map();
@@ -36142,6 +37058,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"() {
@@ -36152,6 +37069,7 @@ var init_pipeline2 = __esm({
     init_data_accessor();
     init_engine();
     init_release_engine();
+    init_channel();
     init_phase();
     init_phases();
     init_pipeline_manifest_sqlite();
@@ -36237,6 +37155,7 @@ var init_pipeline2 = __esm({
             "manifest.stats",
             "release.list",
             "release.show",
+            "release.channel.show",
             "phase.show",
             "phase.list",
             "chain.show",
@@ -36256,6 +37175,7 @@ var init_pipeline2 = __esm({
             "release.push",
             "release.gates.run",
             "release.rollback",
+            "release.cancel",
             "release.ship",
             "manifest.append",
             "manifest.archive",
@@ -36479,6 +37399,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",
@@ -36597,6 +37540,20 @@ var init_pipeline2 = __esm({
             const result = await releaseRollback(version, reason, this.projectRoot);
             return this.wrapEngineResult(result, "mutate", "release.rollback", startTime);
           }
+          case "cancel": {
+            const version = params?.version;
+            if (!version) {
+              return this.errorResponse(
+                "mutate",
+                "release.cancel",
+                "E_INVALID_INPUT",
+                "version is required",
+                startTime
+              );
+            }
+            const result = await releaseCancel(version, this.projectRoot);
+            return this.wrapEngineResult(result, "mutate", "release.cancel", startTime);
+          }
           case "ship": {
             const version = params?.version;
             const epicId = params?.epicId;
@@ -36611,8 +37568,9 @@ var init_pipeline2 = __esm({
             }
             const remote = params?.remote;
             const dryRun = params?.dryRun;
+            const bump = params?.bump;
             const result = await releaseShip(
-              { version, epicId, remote, dryRun },
+              { version, epicId, remote, dryRun, bump },
               this.projectRoot
             );
             return this.wrapEngineResult(result, "mutate", "release.ship", startTime);
@@ -37083,11 +38041,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();
@@ -37138,7 +38096,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",
@@ -37147,7 +38105,7 @@ var init_build_config = __esm({
         "url": "https://github.com/kryptobaseddev/cleo.git",
         "issuesUrl": "https://github.com/kryptobaseddev/cleo/issues"
       },
-      "buildDate": "2026-03-07T05:25:13.762Z",
+      "buildDate": "2026-03-07T20:24:31.815Z",
       "templates": {
         "issueTemplatesDir": "templates/issue-templates"
       }
@@ -37156,8 +38114,8 @@ var init_build_config = __esm({
 });
 
 // src/core/issue/template-parser.ts
-import { existsSync as existsSync59, readFileSync as readFileSync42, readdirSync as readdirSync17, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join58, basename as basename10 } from "node:path";
+import { existsSync as existsSync61, readFileSync as readFileSync44, readdirSync as readdirSync17, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join60, basename as basename10 } from "node:path";
 function extractYamlField(content, field) {
   const regex = new RegExp(`^${field}:\\s*["']?(.+?)["']?\\s*$`, "m");
   const match = content.match(regex);
@@ -37189,9 +38147,9 @@ function extractYamlArray(content, field) {
   return items;
 }
 function parseTemplateFile2(filePath) {
-  if (!existsSync59(filePath)) return null;
+  if (!existsSync61(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");
@@ -37208,12 +38166,12 @@ function parseTemplateFile2(filePath) {
 function parseIssueTemplates2(projectDir) {
   try {
     const packageRoot = getPackageRoot();
-    const packagedTemplateDir = join58(packageRoot, PACKAGED_TEMPLATE_DIR);
-    if (existsSync59(packagedTemplateDir)) {
+    const packagedTemplateDir = join60(packageRoot, PACKAGED_TEMPLATE_DIR);
+    if (existsSync61(packagedTemplateDir)) {
       const templates3 = [];
       for (const file of readdirSync17(packagedTemplateDir)) {
         if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-        const template = parseTemplateFile2(join58(packagedTemplateDir, file));
+        const template = parseTemplateFile2(join60(packagedTemplateDir, file));
         if (template) templates3.push(template);
       }
       if (templates3.length > 0) return templates3;
@@ -37221,12 +38179,12 @@ function parseIssueTemplates2(projectDir) {
   } catch {
   }
   const dir = projectDir ?? getProjectRoot();
-  const templateDir = join58(dir, TEMPLATE_DIR);
-  if (!existsSync59(templateDir)) return [];
+  const templateDir = join60(dir, TEMPLATE_DIR);
+  if (!existsSync61(templateDir)) return [];
   const templates2 = [];
   for (const file of readdirSync17(templateDir)) {
     if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-    const template = parseTemplateFile2(join58(templateDir, file));
+    const template = parseTemplateFile2(join60(templateDir, file));
     if (template) templates2.push(template);
   }
   return templates2;
@@ -37235,10 +38193,10 @@ function getTemplateConfig(cwd) {
   const projectDir = cwd ?? getProjectRoot();
   const liveTemplates = parseIssueTemplates2(projectDir);
   if (liveTemplates.length > 0) return liveTemplates;
-  const cachePath = join58(getCleoDir(cwd), CACHE_FILE);
-  if (existsSync59(cachePath)) {
+  const cachePath = join60(getCleoDir(cwd), CACHE_FILE);
+  if (existsSync61(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 {
     }
@@ -37294,7 +38252,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";
@@ -37313,7 +38271,7 @@ function buildIssueBody(subcommand, rawBody, severity, area) {
 }
 function checkGhCli() {
   try {
-    execFileSync9("gh", ["--version"], {
+    execFileSync11("gh", ["--version"], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -37323,7 +38281,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"]
     });
@@ -37335,7 +38293,7 @@ function checkGhCli() {
 }
 function addGhIssue(title, body, labels) {
   try {
-    const result = execFileSync9("gh", [
+    const result = execFileSync11("gh", [
       "issue",
       "create",
       "--repo",
@@ -38297,8 +39255,8 @@ var init_tools = __esm({
 });
 
 // src/core/nexus/query.ts
-import { join as join59, basename as basename11 } from "node:path";
-import { existsSync as existsSync60, readFileSync as readFileSync43 } from "node:fs";
+import { join as join61, basename as basename11 } from "node:path";
+import { existsSync as existsSync62, readFileSync as readFileSync45 } from "node:fs";
 import { z as z3 } from "zod";
 function validateSyntax(query) {
   if (!query) return false;
@@ -38334,9 +39292,9 @@ function getCurrentProject() {
     return process.env["NEXUS_CURRENT_PROJECT"];
   }
   try {
-    const infoPath = join59(process.cwd(), ".cleo", "project-info.json");
-    if (existsSync60(infoPath)) {
-      const data = JSON.parse(readFileSync43(infoPath, "utf-8"));
+    const infoPath = join61(process.cwd(), ".cleo", "project-info.json");
+    if (existsSync62(infoPath)) {
+      const data = JSON.parse(readFileSync45(infoPath, "utf-8"));
       if (typeof data.name === "string" && data.name.length > 0) {
         return data.name;
       }
@@ -38372,7 +39330,7 @@ async function resolveProjectPath2(projectName) {
   return project.path;
 }
 async function readProjectTasks(projectPath) {
-  const tasksDbPath = join59(projectPath, ".cleo", "tasks.db");
+  const tasksDbPath = join61(projectPath, ".cleo", "tasks.db");
   try {
     const accessor = await getAccessor(projectPath);
     const taskFile = await accessor.loadTaskFile();
@@ -38786,8 +39744,8 @@ var init_deps2 = __esm({
 
 // src/core/nexus/sharing/index.ts
 import { readFile as readFile15, writeFile as writeFile11 } from "node:fs/promises";
-import { existsSync as existsSync61, readdirSync as readdirSync18, statSync as statSync9 } from "node:fs";
-import { join as join60, relative as relative5 } from "node:path";
+import { existsSync as existsSync63, readdirSync as readdirSync18, statSync as statSync9 } from "node:fs";
+import { join as join62, relative as relative5 } from "node:path";
 function matchesPattern(filePath, pattern) {
   const normalizedPath = filePath.replace(/^\/+|\/+$/g, "");
   const normalizedPattern = pattern.replace(/^\/+|\/+$/g, "");
@@ -38812,7 +39770,7 @@ function collectCleoFiles(cleoDir) {
     const entries = readdirSync18(dir);
     for (const entry of entries) {
       if (entry === ".git") continue;
-      const fullPath = join60(dir, entry);
+      const fullPath = join62(dir, entry);
       const relPath = relative5(cleoDir, fullPath);
       try {
         const stat3 = statSync9(fullPath);
@@ -38872,7 +39830,7 @@ function generateGitignoreEntries(sharing) {
 async function syncGitignore(cwd) {
   const config = await loadConfig2(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const gitignorePath = join60(projectRoot, ".gitignore");
+  const gitignorePath = join62(projectRoot, ".gitignore");
   const entries = generateGitignoreEntries(config.sharing);
   const managedSection = [
     "",
@@ -38882,7 +39840,7 @@ async function syncGitignore(cwd) {
     ""
   ].join("\n");
   let content = "";
-  if (existsSync61(gitignorePath)) {
+  if (existsSync63(gitignorePath)) {
     content = await readFile15(gitignorePath, "utf-8");
   }
   const startIdx = content.indexOf(GITIGNORE_START);
@@ -42075,7 +43033,22 @@ async function validateLayer1Schema(context) {
   }
   if (context.params?.status) {
     const status = context.params.status;
-    if (!TASK_STATUSES.includes(status)) {
+    const validStatuses = (() => {
+      if (context.domain === "pipeline" && context.operation === "stage.record") {
+        return LIFECYCLE_STAGE_STATUSES;
+      }
+      if (context.domain === "admin" && context.operation?.startsWith("adr.")) {
+        return ADR_STATUSES;
+      }
+      if (context.domain === "session") {
+        return SESSION_STATUSES;
+      }
+      if (context.domain === "pipeline" && context.operation?.startsWith("manifest.")) {
+        return MANIFEST_STATUSES;
+      }
+      return TASK_STATUSES;
+    })();
+    if (!validStatuses.includes(status)) {
       violations.push({
         layer: 1 /* SCHEMA */,
         severity: "error" /* ERROR */,
@@ -42083,8 +43056,8 @@ async function validateLayer1Schema(context) {
         message: `Invalid status: ${status}`,
         field: "status",
         value: status,
-        constraint: `Must be one of: ${TASK_STATUSES.join(", ")}`,
-        fix: `Use one of: ${TASK_STATUSES.join(", ")}`
+        constraint: `Must be one of: ${validStatuses.join(", ")}`,
+        fix: `Use one of: ${validStatuses.join(", ")}`
       });
     }
   }
@@ -42985,7 +43958,7 @@ init_logger();
 init_project_info();
 init_scaffold();
 init_audit_prune();
-import { join as join61 } from "node:path";
+import { join as join63 } from "node:path";
 var serverState = null;
 var startupLog = getLogger("mcp:startup");
 async function main() {
@@ -43055,7 +44028,7 @@ async function main() {
     }
     const config = loadConfig();
     const projectInfo = getProjectInfoSync();
-    const cleoDir = join61(process.cwd(), ".cleo");
+    const cleoDir = join63(process.cwd(), ".cleo");
     initLogger(cleoDir, {
       level: config.logLevel ?? "info",
       filePath: "logs/cleo.log",