@cleocode/cleo 2026.3.16 → 2026.3.17

package/dist/cli/index.js

@@ -4626,13 +4626,13 @@ async function getDb(cwd) {
     if (!_gitTrackingChecked) {
       _gitTrackingChecked = true;
       try {
-        const { execFileSync: execFileSync13 } = await import("node:child_process");
+        const { execFileSync: execFileSync15 } = await import("node:child_process");
         const gitCwd = resolve3(dbPath, "..", "..");
         const filesToCheck = [dbPath, dbPath + "-wal", dbPath + "-shm"];
         const log7 = getLogger("sqlite");
         for (const fileToCheck of filesToCheck) {
           try {
-            execFileSync13("git", ["ls-files", "--error-unmatch", fileToCheck], {
+            execFileSync15("git", ["ls-files", "--error-unmatch", fileToCheck], {
               cwd: gitCwd,
               stdio: "pipe"
             });
@@ -15396,6 +15396,7 @@ async function getProjectStats(opts, accessor) {
   const active = tasks2.filter((t) => t.status === "active").length;
   const done = tasks2.filter((t) => t.status === "done").length;
   const blocked = tasks2.filter((t) => t.status === "blocked").length;
+  const cancelled = tasks2.filter((t) => t.status === "cancelled").length;
   const totalActive = tasks2.length;
   const cutoff = new Date(Date.now() - periodDays * 864e5).toISOString();
   const entries = await queryAuditEntries(opts.cwd);
@@ -15412,11 +15413,45 @@ async function getProjectStats(opts, accessor) {
     (e) => isArchive(e) && e.timestamp >= cutoff
   ).length;
   const completionRate = createdInPeriod > 0 ? Math.round(completedInPeriod / createdInPeriod * 1e4) / 100 : 0;
-  const totalCreated = entries.filter(isCreate).length;
-  const totalCompleted = entries.filter(isComplete).length;
-  const totalArchived = entries.filter(isArchive).length;
+  let totalCreated = 0;
+  let totalCompleted = 0;
+  let totalCancelled = 0;
+  let totalArchived = 0;
+  let archivedCompleted = 0;
+  let archivedCount = 0;
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
+    const { count: dbCount, eq: dbEq, and: dbAnd } = await import("drizzle-orm");
+    const { tasks: tasksTable } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+    const db = await getDb2(opts.cwd);
+    const statusRows = await db.select({ status: tasksTable.status, c: dbCount() }).from(tasksTable).groupBy(tasksTable.status).all();
+    const statusMap = {};
+    for (const row of statusRows) {
+      statusMap[row.status] = row.c;
+    }
+    archivedCount = statusMap["archived"] ?? 0;
+    totalCreated = Object.values(statusMap).reduce((sum, n) => sum + n, 0);
+    totalCancelled = statusMap["cancelled"] ?? 0;
+    totalArchived = archivedCount;
+    const archivedDoneRow = await db.select({ c: dbCount() }).from(tasksTable).where(dbAnd(dbEq(tasksTable.status, "archived"), dbEq(tasksTable.archiveReason, "completed"))).get();
+    archivedCompleted = archivedDoneRow?.c ?? 0;
+    totalCompleted = (statusMap["done"] ?? 0) + archivedCompleted;
+  } catch {
+    totalCreated = entries.filter(isCreate).length;
+    totalCompleted = entries.filter(isComplete).length;
+    totalArchived = entries.filter(isArchive).length;
+  }
   return {
-    currentState: { pending, active, done, blocked, totalActive },
+    currentState: {
+      pending,
+      active,
+      done,
+      blocked,
+      cancelled,
+      totalActive,
+      archived: archivedCount,
+      grandTotal: totalActive + archivedCount
+    },
     completionMetrics: {
       periodDays,
       completedInPeriod,
@@ -15428,7 +15463,7 @@ async function getProjectStats(opts, accessor) {
       completedInPeriod,
       archivedInPeriod
     },
-    allTime: { totalCreated, totalCompleted, totalArchived }
+    allTime: { totalCreated, totalCompleted, totalCancelled, totalArchived, archivedCompleted }
   };
 }
 function rankBlockedTask(task, allTasks, focusTask) {
@@ -15472,7 +15507,18 @@ async function getDashboard(opts, accessor) {
   const active = tasks2.filter((t) => t.status === "active").length;
   const done = tasks2.filter((t) => t.status === "done").length;
   const blocked = tasks2.filter((t) => t.status === "blocked").length;
+  const cancelled = tasks2.filter((t) => t.status === "cancelled").length;
   const total = tasks2.length;
+  let archived = 0;
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
+    const { count: dbCount, eq: dbEq } = await import("drizzle-orm");
+    const { tasks: tasksTable } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+    const db = await getDb2(opts.cwd);
+    const row = await db.select({ c: dbCount() }).from(tasksTable).where(dbEq(tasksTable.status, "archived")).get();
+    archived = row?.c ?? 0;
+  } catch {
+  }
   const project = data.project?.name ?? "Unknown Project";
   const currentPhase = data.project?.currentPhase ?? null;
   const focusId = data.focus?.currentTask ?? null;
@@ -15480,7 +15526,7 @@ async function getDashboard(opts, accessor) {
   if (focusId) {
     focusTask = tasks2.find((t) => t.id === focusId) ?? null;
   }
-  const highPriority = tasks2.filter((t) => (t.priority === "critical" || t.priority === "high") && t.status !== "done").sort((a, b) => {
+  const highPriority = tasks2.filter((t) => (t.priority === "critical" || t.priority === "high") && t.status !== "done" && t.status !== "cancelled").sort((a, b) => {
     const pDiff = (PRIORITY_ORDER[a.priority ?? "low"] ?? 9) - (PRIORITY_ORDER[b.priority ?? "low"] ?? 9);
     if (pDiff !== 0) return pDiff;
     return (a.createdAt ?? "").localeCompare(b.createdAt ?? "");
@@ -15493,6 +15539,7 @@ async function getDashboard(opts, accessor) {
   }).map((r) => r.task);
   const labelMap = {};
   for (const t of tasks2) {
+    if (t.status === "cancelled") continue;
     for (const label of t.labels ?? []) {
       labelMap[label] = (labelMap[label] ?? 0) + 1;
     }
@@ -15501,7 +15548,7 @@ async function getDashboard(opts, accessor) {
   return {
     project,
     currentPhase,
-    summary: { pending, active, blocked, done, total },
+    summary: { pending, active, blocked, done, cancelled, total, archived, grandTotal: total + archived },
     focus: { currentTask: focusId, task: focusTask },
     highPriority: { count: highPriority.length, tasks: highPriority.slice(0, 5) },
     blockedTasks: {
@@ -19553,7 +19600,9 @@ async function systemDash(projectRoot, params) {
           blocked: summary.blocked,
           done: summary.done,
           cancelled: summary.cancelled ?? 0,
-          total: summary.total
+          total: summary.total,
+          archived: summary.archived ?? 0,
+          grandTotal: summary.grandTotal ?? summary.total
         },
         taskWork: data.focus ?? data.taskWork,
         activeSession: data.activeSession ?? null,
@@ -19573,17 +19622,18 @@ async function systemStats(projectRoot, params) {
     const result = await getProjectStats({ period: String(params?.period ?? 30), cwd: projectRoot }, accessor);
     const taskData = await accessor.loadTaskFile();
     const tasks2 = taskData?.tasks ?? [];
+    const activeTasks = tasks2.filter((t) => t.status !== "cancelled");
     const byPriority = {};
-    for (const t of tasks2) {
+    for (const t of activeTasks) {
       byPriority[t.priority] = (byPriority[t.priority] ?? 0) + 1;
     }
     const byType = {};
-    for (const t of tasks2) {
+    for (const t of activeTasks) {
       const type = t.type || "task";
       byType[type] = (byType[type] ?? 0) + 1;
     }
     const byPhase = {};
-    for (const t of tasks2) {
+    for (const t of activeTasks) {
       const phase = t.phase || "unassigned";
       byPhase[phase] = (byPhase[phase] ?? 0) + 1;
     }
@@ -19613,7 +19663,9 @@ async function systemStats(projectRoot, params) {
           done: currentState.done,
           blocked: currentState.blocked,
           cancelled: tasks2.filter((t) => t.status === "cancelled").length,
-          totalActive: currentState.totalActive
+          totalActive: currentState.totalActive,
+          archived: currentState.archived ?? 0,
+          grandTotal: currentState.grandTotal ?? currentState.totalActive
         },
         byPriority,
         byType,
@@ -19638,10 +19690,10 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join76 } = await import("node:path");
-    const { existsSync: existsSync71 } = await import("node:fs");
-    const dbPath = join76(projectRoot, ".cleo", "tasks.db");
-    if (!existsSync71(dbPath)) {
+    const { join: join77 } = await import("node:path");
+    const { existsSync: existsSync72 } = await import("node:fs");
+    const dbPath = join77(projectRoot, ".cleo", "tasks.db");
+    if (!existsSync72(dbPath)) {
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
       return {
@@ -20497,10 +20549,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync52, existsSync: existsSync71 } = await import("node:fs");
+    const { readFileSync: readFileSync53, existsSync: existsSync72 } = await import("node:fs");
     const infoPath = join33(projectPath, ".cleo", "project-info.json");
-    if (!existsSync71(infoPath)) return "";
-    const data = JSON.parse(readFileSync52(infoPath, "utf-8"));
+    if (!existsSync72(infoPath)) return "";
+    const data = JSON.parse(readFileSync53(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -27978,11 +28030,353 @@ var init_changelog_writer = __esm({
   }
 });
 
-// src/core/release/release-manifest.ts
-import { existsSync as existsSync48, renameSync as renameSync7 } from "node:fs";
-import { readFile as readFile10 } from "node:fs/promises";
+// src/core/release/github-pr.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
+function isGhCliAvailable() {
+  try {
+    execFileSync6("gh", ["--version"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractRepoOwnerAndName(remote) {
+  const trimmed = remote.trim();
+  const httpsMatch = trimmed.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  const sshMatch = trimmed.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+  return null;
+}
+async function detectBranchProtection(branch, remote, projectRoot) {
+  const cwdOpts = projectRoot ? { cwd: projectRoot } : {};
+  if (isGhCliAvailable()) {
+    try {
+      const remoteUrl = execFileSync6("git", ["remote", "get-url", remote], {
+        encoding: "utf-8",
+        stdio: "pipe",
+        ...cwdOpts
+      }).trim();
+      const identity = extractRepoOwnerAndName(remoteUrl);
+      if (identity) {
+        const { owner, repo } = identity;
+        try {
+          execFileSync6(
+            "gh",
+            ["api", `/repos/${owner}/${repo}/branches/${branch}/protection`],
+            {
+              encoding: "utf-8",
+              stdio: "pipe",
+              ...cwdOpts
+            }
+          );
+          return { protected: true, detectionMethod: "gh-api" };
+        } catch (apiErr) {
+          const stderr2 = apiErr instanceof Error && "stderr" in apiErr ? String(apiErr.stderr ?? "") : "";
+          if (stderr2.includes("404") || stderr2.includes("Not Found")) {
+            return { protected: false, detectionMethod: "gh-api" };
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const result = execFileSync6(
+      "git",
+      ["push", "--dry-run", remote, `HEAD:${branch}`],
+      {
+        encoding: "utf-8",
+        stdio: "pipe",
+        ...cwdOpts
+      }
+    );
+    const output = typeof result === "string" ? result : "";
+    if (output.includes("protected branch") || output.includes("GH006") || output.includes("refusing to allow")) {
+      return { protected: true, detectionMethod: "push-dry-run" };
+    }
+    return { protected: false, detectionMethod: "push-dry-run" };
+  } catch (pushErr) {
+    const stderr2 = pushErr instanceof Error && "stderr" in pushErr ? String(pushErr.stderr ?? "") : pushErr instanceof Error ? pushErr.message : String(pushErr);
+    if (stderr2.includes("protected branch") || stderr2.includes("GH006") || stderr2.includes("refusing to allow")) {
+      return { protected: true, detectionMethod: "push-dry-run" };
+    }
+    return {
+      protected: false,
+      detectionMethod: "unknown",
+      error: stderr2
+    };
+  }
+}
+function buildPRBody(opts) {
+  const epicLine = opts.epicId ? `**Epic**: ${opts.epicId}
+
+` : "";
+  return [
+    `## Release v${opts.version}`,
+    "",
+    `${epicLine}This PR merges the ${opts.head} branch into ${opts.base} to publish the release.`,
+    "",
+    "### Checklist",
+    "- [ ] CHANGELOG.md updated",
+    "- [ ] All release tasks complete",
+    "- [ ] Version bump committed",
+    "",
+    "---",
+    "*Created by CLEO release pipeline*"
+  ].join("\n");
+}
+function formatManualPRInstructions(opts) {
+  const epicSuffix = opts.epicId ? ` (${opts.epicId})` : "";
+  return [
+    "Branch protection detected or gh CLI unavailable. Create the PR manually:",
+    "",
+    `  gh pr create \\`,
+    `    --base ${opts.base} \\`,
+    `    --head ${opts.head} \\`,
+    `    --title "${opts.title}" \\`,
+    `    --body "Release v${opts.version}${epicSuffix}"`,
+    "",
+    `Or visit: https://github.com/[owner]/[repo]/compare/${opts.base}...${opts.head}`,
+    "",
+    "After merging, CI will automatically publish to npm."
+  ].join("\n");
+}
+async function createPullRequest(opts) {
+  if (!isGhCliAvailable()) {
+    return {
+      mode: "manual",
+      instructions: formatManualPRInstructions(opts)
+    };
+  }
+  const body = buildPRBody(opts);
+  const args = [
+    "pr",
+    "create",
+    "--base",
+    opts.base,
+    "--head",
+    opts.head,
+    "--title",
+    opts.title,
+    "--body",
+    body
+  ];
+  if (opts.labels && opts.labels.length > 0) {
+    for (const label of opts.labels) {
+      args.push("--label", label);
+    }
+  }
+  try {
+    const output = execFileSync6("gh", args, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      ...opts.projectRoot ? { cwd: opts.projectRoot } : {}
+    });
+    const prUrl = output.trim();
+    const numberMatch = prUrl.match(/\/pull\/(\d+)$/);
+    const prNumber = numberMatch ? parseInt(numberMatch[1], 10) : void 0;
+    return {
+      mode: "created",
+      prUrl,
+      prNumber
+    };
+  } catch (err) {
+    const stderr2 = err instanceof Error && "stderr" in err ? String(err.stderr ?? "") : err instanceof Error ? err.message : String(err);
+    if (stderr2.includes("already exists")) {
+      const urlMatch = stderr2.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/);
+      const existingUrl = urlMatch ? urlMatch[0] : void 0;
+      return {
+        mode: "skipped",
+        prUrl: existingUrl,
+        instructions: "PR already exists"
+      };
+    }
+    return {
+      mode: "manual",
+      instructions: formatManualPRInstructions(opts),
+      error: stderr2
+    };
+  }
+}
+var init_github_pr = __esm({
+  "src/core/release/github-pr.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/release/channel.ts
+function getDefaultChannelConfig() {
+  return {
+    main: "main",
+    develop: "develop",
+    feature: "feature/"
+  };
+}
+function resolveChannelFromBranch(branch, config) {
+  const cfg = config ?? getDefaultChannelConfig();
+  if (cfg.custom) {
+    if (Object.prototype.hasOwnProperty.call(cfg.custom, branch)) {
+      return cfg.custom[branch];
+    }
+    let bestPrefix = "";
+    let bestChannel;
+    for (const [key, channel] of Object.entries(cfg.custom)) {
+      if (branch.startsWith(key) && key.length > bestPrefix.length) {
+        bestPrefix = key;
+        bestChannel = channel;
+      }
+    }
+    if (bestChannel !== void 0) {
+      return bestChannel;
+    }
+  }
+  if (branch === cfg.main) {
+    return "latest";
+  }
+  if (branch === cfg.develop) {
+    return "beta";
+  }
+  const alphaPrefixes = ["feature/", "hotfix/", "release/"];
+  if (cfg.feature && !alphaPrefixes.includes(cfg.feature)) {
+    alphaPrefixes.push(cfg.feature);
+  }
+  for (const prefix of alphaPrefixes) {
+    if (branch.startsWith(prefix)) {
+      return "alpha";
+    }
+  }
+  return "alpha";
+}
+function channelToDistTag(channel) {
+  const tags = {
+    latest: "latest",
+    beta: "beta",
+    alpha: "alpha"
+  };
+  return tags[channel];
+}
+function describeChannel(channel) {
+  const descriptions = {
+    latest: "stable release published to npm @latest",
+    beta: "pre-release published to npm @beta (develop branch)",
+    alpha: "early pre-release published to npm @alpha (feature/hotfix branches)"
+  };
+  return descriptions[channel];
+}
+var init_channel = __esm({
+  "src/core/release/channel.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/release/release-config.ts
+import { existsSync as existsSync48, readFileSync as readFileSync38 } from "node:fs";
 import { join as join46 } from "node:path";
+function readConfigValueSync(path, defaultValue, cwd) {
+  try {
+    const configPath = join46(getCleoDir(cwd), "config.json");
+    if (!existsSync48(configPath)) return defaultValue;
+    const config = JSON.parse(readFileSync38(configPath, "utf-8"));
+    const keys = path.split(".");
+    let value = config;
+    for (const key of keys) {
+      if (value == null || typeof value !== "object") return defaultValue;
+      value = value[key];
+    }
+    return value ?? defaultValue;
+  } catch {
+    return defaultValue;
+  }
+}
+function loadReleaseConfig(cwd) {
+  return {
+    versioningScheme: readConfigValueSync("release.versioning.scheme", DEFAULTS2.versioningScheme, cwd),
+    tagPrefix: readConfigValueSync("release.versioning.tagPrefix", DEFAULTS2.tagPrefix, cwd),
+    changelogFormat: readConfigValueSync("release.changelog.format", DEFAULTS2.changelogFormat, cwd),
+    changelogFile: readConfigValueSync("release.changelog.file", DEFAULTS2.changelogFile, cwd),
+    artifactType: readConfigValueSync("release.artifact.type", DEFAULTS2.artifactType, cwd),
+    gates: readConfigValueSync("release.gates", [], cwd),
+    versionBump: {
+      files: readConfigValueSync("release.versionBump.files", [], cwd)
+    },
+    security: {
+      enableProvenance: readConfigValueSync("release.security.enableProvenance", false, cwd),
+      slsaLevel: readConfigValueSync("release.security.slsaLevel", 3, cwd),
+      requireSignedCommits: readConfigValueSync("release.security.requireSignedCommits", false, cwd)
+    }
+  };
+}
+function getDefaultGitFlowConfig() {
+  return {
+    enabled: true,
+    branches: {
+      main: "main",
+      develop: "develop",
+      featurePrefix: "feature/",
+      hotfixPrefix: "hotfix/",
+      releasePrefix: "release/"
+    }
+  };
+}
+function getGitFlowConfig(config) {
+  const defaults = getDefaultGitFlowConfig();
+  if (!config.gitflow) return defaults;
+  return {
+    enabled: config.gitflow.enabled ?? defaults.enabled,
+    branches: {
+      main: config.gitflow.branches?.main ?? defaults.branches.main,
+      develop: config.gitflow.branches?.develop ?? defaults.branches.develop,
+      featurePrefix: config.gitflow.branches?.featurePrefix ?? defaults.branches.featurePrefix,
+      hotfixPrefix: config.gitflow.branches?.hotfixPrefix ?? defaults.branches.hotfixPrefix,
+      releasePrefix: config.gitflow.branches?.releasePrefix ?? defaults.branches.releasePrefix
+    }
+  };
+}
+function getDefaultChannelConfig2() {
+  return {
+    main: "latest",
+    develop: "beta",
+    feature: "alpha"
+  };
+}
+function getChannelConfig(config) {
+  const defaults = getDefaultChannelConfig2();
+  if (!config.channels) return defaults;
+  return {
+    main: config.channels.main ?? defaults.main,
+    develop: config.channels.develop ?? defaults.develop,
+    feature: config.channels.feature ?? defaults.feature,
+    custom: config.channels.custom
+  };
+}
+function getPushMode(config) {
+  return config.push?.mode ?? "auto";
+}
+var DEFAULTS2;
+var init_release_config = __esm({
+  "src/core/release/release-config.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULTS2 = {
+      versioningScheme: "calver",
+      tagPrefix: "v",
+      changelogFormat: "keepachangelog",
+      changelogFile: "CHANGELOG.md",
+      artifactType: "generic-tarball"
+    };
+  }
+});
+
+// src/core/release/release-manifest.ts
+import { existsSync as existsSync49, renameSync as renameSync7 } from "node:fs";
+import { readFile as readFile10 } from "node:fs/promises";
+import { execFileSync as execFileSync7 } from "node:child_process";
+import { join as join47 } from "node:path";
 import { eq as eq14, desc as desc4 } from "drizzle-orm";
 function isValidVersion(version) {
   return /^v?\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(version);
@@ -28074,25 +28468,67 @@ 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 desc6 = task.description?.trim();
+    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 labels = task.labels ?? [];
+    const titleLower = stripConventionalPrefix(task.title).toLowerCase();
+    const rawTitleLower = task.title.toLowerCase();
+    if (/^feat(\([^)]+\))?:/.test(task.title.toLowerCase())) return "features";
+    if (/^fix(\([^)]+\))?:/.test(task.title.toLowerCase())) return "fixes";
+    if (/^docs?(\([^)]+\))?:/.test(task.title.toLowerCase())) return "docs";
+    if (/^test(\([^)]+\))?:/.test(task.title.toLowerCase())) return "tests";
+    if (/^(chore|refactor|style|ci|build|perf)(\([^)]+\))?:/.test(task.title.toLowerCase())) return "chores";
+    if (labels.some((l) => ["feat", "feature", "enhancement", "add"].includes(l.toLowerCase()))) return "features";
+    if (labels.some((l) => ["fix", "bug", "bugfix", "regression"].includes(l.toLowerCase()))) return "fixes";
+    if (labels.some((l) => ["docs", "documentation"].includes(l.toLowerCase()))) return "docs";
+    if (labels.some((l) => ["test", "testing"].includes(l.toLowerCase()))) return "tests";
+    if (labels.some((l) => ["chore", "refactor", "cleanup", "maintenance"].includes(l.toLowerCase()))) return "chores";
+    if (titleLower.startsWith("add ") || titleLower.includes("implement") || titleLower.startsWith("create ") || titleLower.startsWith("introduce ")) return "features";
+    if (titleLower.includes("bug") || titleLower.startsWith("fix") || titleLower.includes("regression") || titleLower.includes("broken")) return "fixes";
+    if (titleLower.startsWith("doc") || titleLower.includes("documentation") || titleLower.includes("readme") || titleLower.includes("changelog")) return "docs";
+    if (titleLower.startsWith("test") || titleLower.includes("test") && titleLower.includes("add")) return "tests";
+    if (titleLower.startsWith("chore") || titleLower.includes("refactor") || titleLower.includes("cleanup") || titleLower.includes("migrate") || titleLower.includes("upgrade") || titleLower.includes("remove ") || titleLower.startsWith("audit")) return "chores";
+    if (rawTitleLower.startsWith("feat")) return "features";
+    return "changes";
+  }
   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 category = categorizeTask(task);
+    const entry = buildEntry(task);
+    if (category === "features") features.push(entry);
+    else if (category === "fixes") fixes.push(entry);
+    else if (category === "docs") docs.push(entry);
+    else if (category === "tests") tests.push(entry);
+    else if (category === "chores") chores.push(entry);
+    else changes.push(entry);
   }
   const sections = [];
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -28127,14 +28563,14 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
     sections.push(...chores);
     sections.push("");
   }
-  if (other.length > 0) {
-    sections.push("### Other");
-    sections.push(...other);
+  if (changes.length > 0) {
+    sections.push("### Changes");
+    sections.push(...changes);
     sections.push("");
   }
   const changelog = sections.join("\n");
   await db.update(releaseManifests).set({ changelog }).where(eq14(releaseManifests.version, normalizedVersion)).run();
-  const changelogPath = join46(cwd ?? process.cwd(), "CHANGELOG.md");
+  const changelogPath = join47(cwd ?? process.cwd(), "CHANGELOG.md");
   let existingChangelogContent = "";
   try {
     existingChangelogContent = await readFile10(changelogPath, "utf8");
@@ -28153,7 +28589,7 @@ async function generateReleaseChangelog(version, loadTasksFn, cwd) {
       docs: docs.length,
       tests: tests.length,
       chores: chores.length,
-      other: other.length
+      changes: changes.length
     }
   };
 }
@@ -28254,19 +28690,19 @@ async function runReleaseGates(version, loadTasksFn, cwd) {
     message: incompleteTasks.length === 0 ? "All tasks completed" : `${incompleteTasks.length} tasks not completed: ${incompleteTasks.join(", ")}`
   });
   const projectRoot = cwd ?? getProjectRoot();
-  const distPath = join46(projectRoot, "dist", "cli", "index.js");
-  const isNodeProject = existsSync48(join46(projectRoot, "package.json"));
+  const distPath = join47(projectRoot, "dist", "cli", "index.js");
+  const isNodeProject = existsSync49(join47(projectRoot, "package.json"));
   if (isNodeProject) {
     gates.push({
       name: "build_artifact",
-      status: existsSync48(distPath) ? "passed" : "failed",
-      message: existsSync48(distPath) ? "dist/cli/index.js present" : "dist/ not built \u2014 run: npm run build"
+      status: existsSync49(distPath) ? "passed" : "failed",
+      message: existsSync49(distPath) ? "dist/cli/index.js present" : "dist/ not built \u2014 run: npm run build"
     });
   }
   let workingTreeClean = true;
   let dirtyFiles = [];
   try {
-    const porcelain = execFileSync6("git", ["status", "--porcelain"], {
+    const porcelain = execFileSync7("git", ["status", "--porcelain"], {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: "pipe"
@@ -28283,27 +28719,60 @@ async function runReleaseGates(version, loadTasksFn, cwd) {
   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 rollbackRelease(version, reason, cwd) {
@@ -28326,7 +28795,7 @@ async function rollbackRelease(version, reason, cwd) {
   };
 }
 async function readPushPolicy(cwd) {
-  const configPath = join46(getCleoDirAbsolute(cwd), "config.json");
+  const configPath = join47(getCleoDirAbsolute(cwd), "config.json");
   const config = await readJson(configPath);
   if (!config) return void 0;
   const release2 = config.release;
@@ -28340,6 +28809,33 @@ async function pushRelease(version, remote, cwd, opts) {
   const normalizedVersion = normalizeVersion(version);
   const projectRoot = getProjectRoot(cwd);
   const pushPolicy = await readPushPolicy(cwd);
+  const configPushMode = getPushMode(loadReleaseConfig(cwd));
+  const effectivePushMode = opts?.mode ?? pushPolicy?.mode ?? configPushMode;
+  if (effectivePushMode === "pr" || effectivePushMode === "auto") {
+    const targetRemoteForCheck = remote ?? pushPolicy?.remote ?? "origin";
+    let branchIsProtected = effectivePushMode === "pr";
+    if (effectivePushMode === "auto") {
+      try {
+        const protection = await detectBranchProtection(
+          pushPolicy?.allowedBranches?.[0] ?? "main",
+          targetRemoteForCheck,
+          projectRoot
+        );
+        branchIsProtected = protection.protected;
+      } catch {
+        branchIsProtected = false;
+      }
+    }
+    if (branchIsProtected) {
+      return {
+        version: normalizedVersion,
+        status: "requires_pr",
+        remote: targetRemoteForCheck,
+        pushedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        requiresPR: true
+      };
+    }
+  }
   if (pushPolicy && pushPolicy.enabled === false && !opts?.explicitPush) {
     throw new Error(
       "Push is disabled by config (release.push.enabled=false). Use --push to override."
@@ -28347,7 +28843,7 @@ 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",
@@ -28360,7 +28856,7 @@ async function pushRelease(version, remote, cwd, opts) {
     }
   }
   if (pushPolicy?.allowedBranches && pushPolicy.allowedBranches.length > 0) {
-    const currentBranch = execFileSync6("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    const currentBranch = execFileSync7("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: projectRoot,
       timeout: 1e4,
       encoding: "utf-8",
@@ -28372,7 +28868,7 @@ async function pushRelease(version, remote, cwd, opts) {
       );
     }
   }
-  execFileSync6("git", ["push", targetRemote, "--follow-tags"], {
+  execFileSync7("git", ["push", targetRemote, "--follow-tags"], {
     cwd: projectRoot,
     timeout: 6e4,
     encoding: "utf-8",
@@ -28403,6 +28899,9 @@ var init_release_manifest = __esm({
     init_paths();
     init_json();
     init_changelog_writer();
+    init_github_pr();
+    init_channel();
+    init_release_config();
   }
 });
 
@@ -28483,7 +28982,7 @@ var init_guards = __esm({
 });
 
 // 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"]);
 }
@@ -28625,7 +29124,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"
@@ -28655,7 +29154,17 @@ async function releaseShip(params, projectRoot) {
     return engineError("E_INVALID_INPUT", "epicId is required");
   }
   const cwd = projectRoot ?? resolveProjectRoot();
+  const logStep = (n, total, label, done, error) => {
+    if (done === void 0) {
+      console.log(`[Step ${n}/${total}] ${label}...`);
+    } else if (done) {
+      console.log(`  \u2713 ${label}`);
+    } else {
+      console.log(`  \u2717 ${label}: ${error ?? "failed"}`);
+    }
+  };
   try {
+    logStep(1, 7, "Validate release gates");
     const gatesResult = await runReleaseGates(
       version,
       () => loadTasks2(projectRoot),
@@ -28663,10 +29172,32 @@ async function releaseShip(params, projectRoot) {
     );
     if (gatesResult && !gatesResult.allPassed) {
       const failedGates = gatesResult.gates.filter((g) => g.status === "failed");
+      logStep(1, 7, "Validate release gates", false, failedGates.map((g) => g.name).join(", "));
       return engineError("E_LIFECYCLE_GATE_FAILED", `Release gates failed for ${version}: ${failedGates.map((g) => g.name).join(", ")}`, {
         details: { gates: gatesResult.gates, failedCount: gatesResult.failedCount }
       });
     }
+    logStep(1, 7, "Validate release gates", true);
+    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, 7, "Check epic completeness");
     let releaseTaskIds = [];
     try {
       const manifest = await showManifestRelease(version, projectRoot);
@@ -28677,10 +29208,13 @@ async function releaseShip(params, projectRoot) {
     const epicCheck = await checkEpicCompleteness(releaseTaskIds, projectRoot, epicAccessor);
     if (epicCheck.hasIncomplete) {
       const incomplete = epicCheck.epics.filter((e) => e.missingChildren.length > 0).map((e) => `${e.epicId}: missing ${e.missingChildren.map((c) => c.id).join(", ")}`).join("; ");
+      logStep(2, 7, "Check epic completeness", false, incomplete);
       return engineError("E_LIFECYCLE_GATE_FAILED", `Epic completeness check failed: ${incomplete}`, {
         details: { epics: epicCheck.epics }
       });
     }
+    logStep(2, 7, "Check epic completeness", true);
+    logStep(3, 7, "Check task double-listing");
     const allReleases = await listManifestReleases(projectRoot);
     const existingReleases = (allReleases.releases ?? []).filter((r) => r.version !== version);
     const doubleCheck = checkDoubleListing(
@@ -28689,10 +29223,13 @@ async function releaseShip(params, projectRoot) {
     );
     if (doubleCheck.hasDoubleListing) {
       const dupes = doubleCheck.duplicates.map((d) => `${d.taskId} (in ${d.releases.join(", ")})`).join("; ");
+      logStep(3, 7, "Check task double-listing", false, dupes);
       return engineError("E_VALIDATION", `Double-listing detected: ${dupes}`, {
         details: { duplicates: doubleCheck.duplicates }
       });
     }
+    logStep(3, 7, "Check task double-listing", true);
+    logStep(4, 7, "Generate CHANGELOG");
     const changelogResult = await generateReleaseChangelog(
       version,
       () => loadTasks2(projectRoot),
@@ -28700,62 +29237,128 @@ async function releaseShip(params, projectRoot) {
     );
     const changelogPath = `${cwd}/CHANGELOG.md`;
     const generatedContent = changelogResult.changelog ?? "";
+    logStep(4, 7, "Generate CHANGELOG", true);
+    const loadedConfig = loadReleaseConfig(cwd);
+    const pushMode = getPushMode(loadedConfig);
+    const gitflowCfg = getGitFlowConfig(loadedConfig);
+    const targetBranch = targetBranchFromGates ?? gitflowCfg.branches.main;
     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(...)"
-          ]
-        }
+      const wouldCreatePR = requiresPRFromGates || pushMode === "pr";
+      const dryRunOutput = {
+        version,
+        epicId,
+        dryRun: true,
+        channel: resolvedChannel,
+        pushMode,
+        wouldDo: [
+          `write CHANGELOG section for ${version} (${generatedContent.length} chars)`,
+          "git add CHANGELOG.md",
+          `git commit -m "release: ship v${version} (${epicId})"`,
+          `git tag -a v${version} -m "Release v${version}"`
+        ]
       };
+      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 };
     }
-    await writeChangelogSection(version, generatedContent, [], changelogPath);
+    logStep(5, 7, "Commit release");
     const gitCwd = { cwd, encoding: "utf-8", stdio: "pipe" };
     try {
-      execFileSync7("git", ["add", "CHANGELOG.md"], gitCwd);
+      execFileSync8("git", ["add", "CHANGELOG.md"], gitCwd);
     } catch (err) {
       const msg = err.message ?? String(err);
+      logStep(5, 7, "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, 7, "Commit release", false, `git commit failed: ${msg}`);
       return engineError("E_GENERAL", `git commit failed: ${msg}`);
     }
+    logStep(5, 7, "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, 7, "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, 7, "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, 7, "Tag release", true);
+    logStep(7, 7, "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") {
+        console.log(`  \u2713 Push / create PR`);
+        console.log(`  PR created: ${prResult.prUrl}`);
+        console.log(`  \u2192 Next: merge the PR, then CI will publish to npm @${resolvedChannel}`);
+      } else if (prResult.mode === "skipped") {
+        console.log(`  \u2713 Push / create PR`);
+        console.log(`  PR already exists: ${prResult.prUrl}`);
+      } else {
+        console.log(`  ! Push / create PR \u2014 manual PR required:`);
+        console.log(prResult.instructions);
+      }
+    } else {
+      try {
+        execFileSync8("git", ["push", remote ?? "origin", "--follow-tags"], gitCwd);
+        logStep(7, 7, "Push / create PR", true);
+      } catch (err) {
+        const execError = err;
+        const msg = (execError.stderr ?? execError.message ?? "").slice(0, 500);
+        logStep(7, 7, "Push / create PR", false, `git push failed: ${msg}`);
+        return engineError("E_GENERAL", `git push failed: ${msg}`, {
+          details: { exitCode: execError.status }
+        });
+      }
     }
     const pushedAt = (/* @__PURE__ */ new Date()).toISOString();
     await markReleasePushed(version, pushedAt, projectRoot, { commitSha, gitTag });
@@ -28767,7 +29370,16 @@ async function releaseShip(params, projectRoot) {
         commitSha,
         gitTag,
         pushedAt,
-        changelog: changelogPath
+        changelog: changelogPath,
+        channel: resolvedChannel,
+        ...prResult ? {
+          pr: {
+            mode: prResult.mode,
+            prUrl: prResult.prUrl,
+            prNumber: prResult.prNumber,
+            instructions: prResult.instructions
+          }
+        } : {}
       }
     };
   } catch (err) {
@@ -28780,15 +29392,17 @@ 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_error();
   }
 });
 
 // src/dispatch/engines/template-parser.ts
-import { readFileSync as readFileSync38, readdirSync as readdirSync12, existsSync as existsSync49 } from "fs";
-import { join as join47 } from "path";
+import { readFileSync as readFileSync39, readdirSync as readdirSync12, existsSync as existsSync50 } from "fs";
+import { join as join48 } from "path";
 import { parse as parseYaml } from "yaml";
 function deriveSubcommand(filename) {
   let stem = filename.replace(/\.ya?ml$/i, "");
@@ -28802,8 +29416,8 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile(templateDir, filename) {
-  const filePath = join47(templateDir, filename);
-  const raw = readFileSync38(filePath, "utf-8");
+  const filePath = join48(templateDir, filename);
+  const raw = readFileSync39(filePath, "utf-8");
   const parsed = parseYaml(raw);
   const name = typeof parsed.name === "string" ? parsed.name : filename;
   const titlePrefix = typeof parsed.title === "string" ? parsed.title : "";
@@ -28852,8 +29466,8 @@ function parseTemplateFile(templateDir, filename) {
   };
 }
 function parseIssueTemplates(projectRoot) {
-  const templateDir = join47(projectRoot, ".github", "ISSUE_TEMPLATE");
-  if (!existsSync49(templateDir)) {
+  const templateDir = join48(projectRoot, ".github", "ISSUE_TEMPLATE");
+  if (!existsSync50(templateDir)) {
     return engineError("E_NOT_FOUND", `Issue template directory not found: ${templateDir}`);
   }
   let files;
@@ -30532,26 +31146,26 @@ var init_check = __esm({
 });
 
 // src/core/adrs/validate.ts
-import { readFileSync as readFileSync39, readdirSync as readdirSync13, existsSync as existsSync50 } from "node:fs";
-import { join as join48 } from "node:path";
+import { readFileSync as readFileSync40, readdirSync as readdirSync13, existsSync as existsSync51 } from "node:fs";
+import { join as join49 } from "node:path";
 import AjvModule3 from "ajv";
 async function validateAllAdrs(projectRoot) {
-  const adrsDir = join48(projectRoot, ".cleo", "adrs");
-  const schemaPath = join48(projectRoot, "schemas", "adr-frontmatter.schema.json");
-  if (!existsSync50(schemaPath)) {
+  const adrsDir = join49(projectRoot, ".cleo", "adrs");
+  const schemaPath = join49(projectRoot, "schemas", "adr-frontmatter.schema.json");
+  if (!existsSync51(schemaPath)) {
     return {
       valid: false,
       errors: [{ file: "schemas/adr-frontmatter.schema.json", field: "schema", message: "Schema file not found" }],
       checked: 0
     };
   }
-  if (!existsSync50(adrsDir)) {
+  if (!existsSync51(adrsDir)) {
     return { valid: true, errors: [], checked: 0 };
   }
-  const schema = JSON.parse(readFileSync39(schemaPath, "utf-8"));
+  const schema = JSON.parse(readFileSync40(schemaPath, "utf-8"));
   const ajv = new Ajv3({ allErrors: true });
   const validate = ajv.compile(schema);
-  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join48(adrsDir, f));
+  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join49(adrsDir, f));
   const errors = [];
   for (const filePath of files) {
     const record = parseAdrFile(filePath, projectRoot);
@@ -30578,15 +31192,15 @@ var init_validate = __esm({
 });
 
 // src/core/adrs/list.ts
-import { readdirSync as readdirSync14, existsSync as existsSync51 } from "node:fs";
-import { join as join49 } from "node:path";
+import { readdirSync as readdirSync14, existsSync as existsSync52 } from "node:fs";
+import { join as join50 } from "node:path";
 async function listAdrs(projectRoot, opts) {
-  const adrsDir = join49(projectRoot, ".cleo", "adrs");
-  if (!existsSync51(adrsDir)) {
+  const adrsDir = join50(projectRoot, ".cleo", "adrs");
+  if (!existsSync52(adrsDir)) {
     return { adrs: [], total: 0 };
   }
   const files = readdirSync14(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
-  const records = files.map((f) => parseAdrFile(join49(adrsDir, f), projectRoot));
+  const records = files.map((f) => parseAdrFile(join50(adrsDir, f), projectRoot));
   const filtered = records.filter((r) => {
     if (opts?.status && r.frontmatter.Status !== opts.status) return false;
     if (opts?.since && r.frontmatter.Date < opts.since) return false;
@@ -30611,14 +31225,14 @@ var init_list2 = __esm({
 });
 
 // src/core/adrs/show.ts
-import { existsSync as existsSync52, readdirSync as readdirSync15 } from "node:fs";
-import { join as join50 } from "node:path";
+import { existsSync as existsSync53, readdirSync as readdirSync15 } from "node:fs";
+import { join as join51 } from "node:path";
 async function showAdr(projectRoot, adrId) {
-  const adrsDir = join50(projectRoot, ".cleo", "adrs");
-  if (!existsSync52(adrsDir)) return null;
+  const adrsDir = join51(projectRoot, ".cleo", "adrs");
+  if (!existsSync53(adrsDir)) return null;
   const files = readdirSync15(adrsDir).filter((f) => f.startsWith(adrId) && f.endsWith(".md"));
   if (files.length === 0) return null;
-  const filePath = join50(adrsDir, files[0]);
+  const filePath = join51(adrsDir, files[0]);
   return parseAdrFile(filePath, projectRoot);
 }
 var init_show2 = __esm({
@@ -30629,8 +31243,8 @@ var init_show2 = __esm({
 });
 
 // src/core/adrs/find.ts
-import { readdirSync as readdirSync16, existsSync as existsSync53 } from "node:fs";
-import { join as join51 } from "node:path";
+import { readdirSync as readdirSync16, existsSync as existsSync54 } from "node:fs";
+import { join as join52 } from "node:path";
 function normalise(s) {
   return s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -30647,8 +31261,8 @@ function matchedTerms(target, terms) {
   return terms.filter((term) => t.includes(term));
 }
 async function findAdrs(projectRoot, query, opts) {
-  const adrsDir = join51(projectRoot, ".cleo", "adrs");
-  if (!existsSync53(adrsDir)) {
+  const adrsDir = join52(projectRoot, ".cleo", "adrs");
+  if (!existsSync54(adrsDir)) {
     return { adrs: [], query, total: 0 };
   }
   const files = readdirSync16(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
@@ -30657,7 +31271,7 @@ async function findAdrs(projectRoot, query, opts) {
   const filterKeywords = opts?.keywords ? parseTags(opts.keywords) : null;
   const results = [];
   for (const file of files) {
-    const record = parseAdrFile(join51(adrsDir, file), projectRoot);
+    const record = parseAdrFile(join52(adrsDir, file), projectRoot);
     const fm = record.frontmatter;
     if (opts?.status && fm.Status !== opts.status) continue;
     if (filterTopics && filterTopics.length > 0) {
@@ -30735,12 +31349,12 @@ var init_adrs = __esm({
 });
 
 // src/core/admin/sync.ts
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 import { rm as rm2, rmdir, stat as stat2 } from "node:fs/promises";
 async function getSyncStatus(projectRoot) {
   try {
     const cleoDir = getCleoDir(projectRoot);
-    const stateFile = join52(cleoDir, "sync", "todowrite-session.json");
+    const stateFile = join53(cleoDir, "sync", "todowrite-session.json");
     const sessionState = await readJson(stateFile);
     if (!sessionState) {
       return {
@@ -30784,8 +31398,8 @@ async function getSyncStatus(projectRoot) {
 async function clearSyncState(projectRoot, dryRun) {
   try {
     const cleoDir = getCleoDir(projectRoot);
-    const syncDir = join52(cleoDir, "sync");
-    const stateFile = join52(syncDir, "todowrite-session.json");
+    const syncDir = join53(cleoDir, "sync");
+    const stateFile = join53(syncDir, "todowrite-session.json");
     let exists = false;
     try {
       await stat2(stateFile);
@@ -31552,8 +32166,8 @@ var init_import_tasks = __esm({
 // src/core/snapshot/index.ts
 import { createHash as createHash6 } from "node:crypto";
 import { readFile as readFile13, writeFile as writeFile10, mkdir as mkdir10 } from "node:fs/promises";
-import { existsSync as existsSync54 } from "node:fs";
-import { join as join53, dirname as dirname14 } from "node:path";
+import { existsSync as existsSync55 } from "node:fs";
+import { join as join54, dirname as dirname14 } from "node:path";
 function toSnapshotTask(task) {
   return {
     id: task.id,
@@ -31606,7 +32220,7 @@ async function exportSnapshot(cwd) {
 }
 async function writeSnapshot(snapshot, outputPath) {
   const dir = dirname14(outputPath);
-  if (!existsSync54(dir)) {
+  if (!existsSync55(dir)) {
     await mkdir10(dir, { recursive: true });
   }
   await writeFile10(outputPath, JSON.stringify(snapshot, null, 2) + "\n");
@@ -31622,7 +32236,7 @@ async function readSnapshot(inputPath) {
 function getDefaultSnapshotPath(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  return join53(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
+  return join54(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);
@@ -31920,15 +32534,15 @@ var init_archive_stats2 = __esm({
 });
 
 // src/core/project-info.ts
-import { readFileSync as readFileSync40, existsSync as existsSync55 } from "node:fs";
-import { join as join54 } from "node:path";
+import { readFileSync as readFileSync41, existsSync as existsSync56 } from "node:fs";
+import { join as join55 } from "node:path";
 function getProjectInfoSync(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join54(cleoDir, "project-info.json");
-  if (!existsSync55(infoPath)) return null;
+  const infoPath = join55(cleoDir, "project-info.json");
+  if (!existsSync56(infoPath)) return null;
   try {
-    const raw = readFileSync40(infoPath, "utf-8");
+    const raw = readFileSync41(infoPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.projectHash !== "string" || data.projectHash.length === 0) {
       return null;
@@ -32015,8 +32629,8 @@ var init_defaults = __esm({
 });
 
 // src/mcp/lib/config.ts
-import { readFileSync as readFileSync41, existsSync as existsSync56 } from "fs";
-import { join as join55 } from "path";
+import { readFileSync as readFileSync42, existsSync as existsSync57 } from "fs";
+import { join as join56 } from "path";
 function loadFromEnv(key) {
   const envKey = `${ENV_PREFIX}${key.toUpperCase()}`;
   return process.env[envKey];
@@ -32037,12 +32651,12 @@ function parseEnvValue2(key, value) {
 }
 function loadFromFile(projectRoot) {
   const root = projectRoot || process.cwd();
-  const configPath = join55(root, ".cleo", "config.json");
-  if (!existsSync56(configPath)) {
+  const configPath = join56(root, ".cleo", "config.json");
+  if (!existsSync57(configPath)) {
     return {};
   }
   try {
-    const content = readFileSync41(configPath, "utf-8");
+    const content = readFileSync42(configPath, "utf-8");
     const config = JSON.parse(content);
     const result = {};
     if (config.mcp) {
@@ -32382,8 +32996,8 @@ __export(session_grade_exports, {
   gradeSession: () => gradeSession,
   readGrades: () => readGrades
 });
-import { join as join56 } from "node:path";
-import { existsSync as existsSync57 } from "node:fs";
+import { join as join57 } from "node:path";
+import { existsSync as existsSync58 } from "node:fs";
 import { readFile as readFile14, appendFile, mkdir as mkdir11 } from "node:fs/promises";
 async function gradeSession(sessionId, cwd) {
   const sessionEntries = await queryAudit({ sessionId });
@@ -32563,9 +33177,9 @@ function detectDuplicateCreates(entries) {
 async function appendGradeResult(result, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const metricsDir = join56(cleoDir, "metrics");
+    const metricsDir = join57(cleoDir, "metrics");
     await mkdir11(metricsDir, { recursive: true });
-    const gradesPath = join56(metricsDir, "GRADES.jsonl");
+    const gradesPath = join57(metricsDir, "GRADES.jsonl");
     const line = JSON.stringify({ ...result, evaluator: "auto" }) + "\n";
     await appendFile(gradesPath, line, "utf8");
   } catch {
@@ -32574,8 +33188,8 @@ async function appendGradeResult(result, cwd) {
 async function readGrades(sessionId, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const gradesPath = join56(cleoDir, "metrics", "GRADES.jsonl");
-    if (!existsSync57(gradesPath)) return [];
+    const gradesPath = join57(cleoDir, "metrics", "GRADES.jsonl");
+    if (!existsSync58(gradesPath)) return [];
     const content = await readFile14(gradesPath, "utf8");
     const results = content.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
     return sessionId ? results.filter((r) => r.sessionId === sessionId) : results;
@@ -34812,6 +35426,7 @@ var init_phase = __esm({
 });
 
 // src/dispatch/domains/pipeline.ts
+import { execFileSync as execFileSync9 } from "node:child_process";
 var PipelineHandler;
 var init_pipeline2 = __esm({
   "src/dispatch/domains/pipeline.ts"() {
@@ -34822,6 +35437,7 @@ var init_pipeline2 = __esm({
     init_data_accessor();
     init_engine();
     init_release_engine();
+    init_channel();
     init_phase();
     init_phases();
     init_pipeline_manifest_sqlite();
@@ -34907,6 +35523,7 @@ var init_pipeline2 = __esm({
             "manifest.stats",
             "release.list",
             "release.show",
+            "release.channel.show",
             "phase.show",
             "phase.list",
             "chain.show",
@@ -35149,6 +35766,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",
@@ -35753,11 +36393,11 @@ var init_pipeline2 = __esm({
 });
 
 // src/core/issue/diagnostics.ts
-import { execFileSync as execFileSync8 } from "node:child_process";
+import { execFileSync as execFileSync10 } from "node:child_process";
 function collectDiagnostics() {
   const getVersion3 = (cmd, args) => {
     try {
-      return execFileSync8(cmd, args, {
+      return execFileSync10(cmd, args, {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
@@ -35808,7 +36448,7 @@ var init_build_config = __esm({
     "use strict";
     BUILD_CONFIG = {
       "name": "@cleocode/cleo",
-      "version": "2026.3.16",
+      "version": "2026.3.17",
       "description": "CLEO V2 - TypeScript task management CLI for AI coding agents",
       "repository": {
         "owner": "kryptobaseddev",
@@ -35817,7 +36457,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-07T07:08:25.337Z",
       "templates": {
         "issueTemplatesDir": "templates/issue-templates"
       }
@@ -35826,8 +36466,8 @@ var init_build_config = __esm({
 });
 
 // src/core/issue/template-parser.ts
-import { existsSync as existsSync58, readFileSync as readFileSync42, readdirSync as readdirSync17, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join57, basename as basename10 } from "node:path";
+import { existsSync as existsSync59, readFileSync as readFileSync43, readdirSync as readdirSync17, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join58, basename as basename10 } from "node:path";
 function extractYamlField(content, field) {
   const regex = new RegExp(`^${field}:\\s*["']?(.+?)["']?\\s*$`, "m");
   const match = content.match(regex);
@@ -35859,9 +36499,9 @@ function extractYamlArray(content, field) {
   return items;
 }
 function parseTemplateFile2(filePath) {
-  if (!existsSync58(filePath)) return null;
+  if (!existsSync59(filePath)) return null;
   try {
-    const content = readFileSync42(filePath, "utf-8");
+    const content = readFileSync43(filePath, "utf-8");
     const fileName = basename10(filePath);
     const stem = fileName.replace(/\.ya?ml$/, "");
     const name = extractYamlField(content, "name");
@@ -35878,12 +36518,12 @@ function parseTemplateFile2(filePath) {
 function parseIssueTemplates2(projectDir) {
   try {
     const packageRoot = getPackageRoot();
-    const packagedTemplateDir = join57(packageRoot, PACKAGED_TEMPLATE_DIR);
-    if (existsSync58(packagedTemplateDir)) {
+    const packagedTemplateDir = join58(packageRoot, PACKAGED_TEMPLATE_DIR);
+    if (existsSync59(packagedTemplateDir)) {
       const templates3 = [];
       for (const file of readdirSync17(packagedTemplateDir)) {
         if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-        const template = parseTemplateFile2(join57(packagedTemplateDir, file));
+        const template = parseTemplateFile2(join58(packagedTemplateDir, file));
         if (template) templates3.push(template);
       }
       if (templates3.length > 0) return templates3;
@@ -35891,12 +36531,12 @@ function parseIssueTemplates2(projectDir) {
   } catch {
   }
   const dir = projectDir ?? getProjectRoot();
-  const templateDir = join57(dir, TEMPLATE_DIR);
-  if (!existsSync58(templateDir)) return [];
+  const templateDir = join58(dir, TEMPLATE_DIR);
+  if (!existsSync59(templateDir)) return [];
   const templates2 = [];
   for (const file of readdirSync17(templateDir)) {
     if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-    const template = parseTemplateFile2(join57(templateDir, file));
+    const template = parseTemplateFile2(join58(templateDir, file));
     if (template) templates2.push(template);
   }
   return templates2;
@@ -35905,10 +36545,10 @@ function getTemplateConfig(cwd) {
   const projectDir = cwd ?? getProjectRoot();
   const liveTemplates = parseIssueTemplates2(projectDir);
   if (liveTemplates.length > 0) return liveTemplates;
-  const cachePath = join57(getCleoDir(cwd), CACHE_FILE);
-  if (existsSync58(cachePath)) {
+  const cachePath = join58(getCleoDir(cwd), CACHE_FILE);
+  if (existsSync59(cachePath)) {
     try {
-      const cached = JSON.parse(readFileSync42(cachePath, "utf-8"));
+      const cached = JSON.parse(readFileSync43(cachePath, "utf-8"));
       if (cached.templates?.length > 0) return cached.templates;
     } catch {
     }
@@ -35964,7 +36604,7 @@ var init_template_parser2 = __esm({
 });
 
 // src/core/issue/create.ts
-import { execFileSync as execFileSync9 } from "node:child_process";
+import { execFileSync as execFileSync11 } from "node:child_process";
 function buildIssueBody(subcommand, rawBody, severity, area) {
   const template = getTemplateForSubcommand2(subcommand);
   const sectionLabel = template?.name ?? "Description";
@@ -35983,7 +36623,7 @@ function buildIssueBody(subcommand, rawBody, severity, area) {
 }
 function checkGhCli() {
   try {
-    execFileSync9("gh", ["--version"], {
+    execFileSync11("gh", ["--version"], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -35993,7 +36633,7 @@ function checkGhCli() {
     });
   }
   try {
-    execFileSync9("gh", ["auth", "status", "--hostname", "github.com"], {
+    execFileSync11("gh", ["auth", "status", "--hostname", "github.com"], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -36005,7 +36645,7 @@ function checkGhCli() {
 }
 function addGhIssue(title, body, labels) {
   try {
-    const result = execFileSync9("gh", [
+    const result = execFileSync11("gh", [
       "issue",
       "create",
       "--repo",
@@ -36967,8 +37607,8 @@ var init_tools = __esm({
 });
 
 // src/core/nexus/query.ts
-import { join as join58, basename as basename11 } from "node:path";
-import { existsSync as existsSync59, readFileSync as readFileSync43 } from "node:fs";
+import { join as join59, basename as basename11 } from "node:path";
+import { existsSync as existsSync60, readFileSync as readFileSync44 } from "node:fs";
 import { z as z3 } from "zod";
 function validateSyntax(query) {
   if (!query) return false;
@@ -37004,9 +37644,9 @@ function getCurrentProject() {
     return process.env["NEXUS_CURRENT_PROJECT"];
   }
   try {
-    const infoPath = join58(process.cwd(), ".cleo", "project-info.json");
-    if (existsSync59(infoPath)) {
-      const data = JSON.parse(readFileSync43(infoPath, "utf-8"));
+    const infoPath = join59(process.cwd(), ".cleo", "project-info.json");
+    if (existsSync60(infoPath)) {
+      const data = JSON.parse(readFileSync44(infoPath, "utf-8"));
       if (typeof data.name === "string" && data.name.length > 0) {
         return data.name;
       }
@@ -37042,7 +37682,7 @@ async function resolveProjectPath2(projectName) {
   return project.path;
 }
 async function readProjectTasks(projectPath) {
-  const tasksDbPath = join58(projectPath, ".cleo", "tasks.db");
+  const tasksDbPath = join59(projectPath, ".cleo", "tasks.db");
   try {
     const accessor = await getAccessor(projectPath);
     const taskFile = await accessor.loadTaskFile();
@@ -37456,8 +38096,8 @@ var init_deps2 = __esm({
 
 // src/core/nexus/sharing/index.ts
 import { readFile as readFile15, writeFile as writeFile11 } from "node:fs/promises";
-import { existsSync as existsSync60, readdirSync as readdirSync18, statSync as statSync8 } from "node:fs";
-import { join as join59, relative as relative4 } from "node:path";
+import { existsSync as existsSync61, readdirSync as readdirSync18, statSync as statSync8 } from "node:fs";
+import { join as join60, relative as relative4 } from "node:path";
 function matchesPattern(filePath, pattern) {
   const normalizedPath = filePath.replace(/^\/+|\/+$/g, "");
   const normalizedPattern = pattern.replace(/^\/+|\/+$/g, "");
@@ -37482,7 +38122,7 @@ function collectCleoFiles(cleoDir) {
     const entries = readdirSync18(dir);
     for (const entry of entries) {
       if (entry === ".git") continue;
-      const fullPath = join59(dir, entry);
+      const fullPath = join60(dir, entry);
       const relPath = relative4(cleoDir, fullPath);
       try {
         const stat5 = statSync8(fullPath);
@@ -37542,7 +38182,7 @@ function generateGitignoreEntries(sharing) {
 async function syncGitignore(cwd) {
   const config = await loadConfig(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const gitignorePath = join59(projectRoot, ".gitignore");
+  const gitignorePath = join60(projectRoot, ".gitignore");
   const entries = generateGitignoreEntries(config.sharing);
   const managedSection = [
     "",
@@ -37552,7 +38192,7 @@ async function syncGitignore(cwd) {
     ""
   ].join("\n");
   let content = "";
-  if (existsSync60(gitignorePath)) {
+  if (existsSync61(gitignorePath)) {
     content = await readFile15(gitignorePath, "utf-8");
   }
   const startIdx = content.indexOf(GITIGNORE_START);
@@ -39114,40 +39754,49 @@ var init_session_resolver = __esm({
   }
 });
 
+// src/core/tasks/id-generator.ts
+function normalizeTaskId(input) {
+  if (typeof input !== "string") return null;
+  const trimmed = input.trim();
+  if (trimmed === "") return null;
+  const match = trimmed.match(/^[Tt]?(\d+)(?:_.*)?$/);
+  if (!match) return null;
+  return `T${match[1]}`;
+}
+var init_id_generator = __esm({
+  "src/core/tasks/id-generator.ts"() {
+    "use strict";
+    init_data_accessor();
+  }
+});
+
 // src/dispatch/lib/security.ts
 import { resolve as resolve9, normalize, relative as relative5, isAbsolute as isAbsolute2 } from "path";
-function sanitizeTaskId(id) {
-  if (typeof id !== "string") {
+function sanitizeTaskId(value) {
+  if (typeof value !== "string") {
     throw new SecurityError(
       "Task ID must be a string",
       "E_INVALID_TASK_ID",
       "taskId"
     );
   }
-  const trimmed = id.trim();
-  if (trimmed.length === 0) {
-    throw new SecurityError(
-      "Task ID cannot be empty",
-      "E_INVALID_TASK_ID",
-      "taskId"
-    );
-  }
-  if (!TASK_ID_PATTERN2.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") {
@@ -39246,14 +39895,14 @@ function sanitizeParams(params, projectRoot, context) {
     if (value === void 0 || value === null) {
       continue;
     }
-    if (typeof value === "string" && (key === "taskId" || key === "parent" || key === "epicId")) {
+    if (typeof value === "string" && (key === "taskId" || key === "parent" || key === "epicId" || key === "parentId" || key === "newParentId" || key === "relatedId" || key === "targetId")) {
       if (key === "parent" && value === "") {
         continue;
       }
       sanitized[key] = sanitizeTaskId(value);
       continue;
     }
-    if (key === "depends" && Array.isArray(value)) {
+    if ((key === "depends" || key === "addDepends" || key === "removeDepends") && Array.isArray(value)) {
       sanitized[key] = value.map((v) => {
         if (typeof v === "string") {
           return sanitizeTaskId(v);
@@ -39303,10 +39952,11 @@ function sanitizeParams(params, projectRoot, context) {
   }
   return sanitized;
 }
-var SecurityError, TASK_ID_PATTERN2, MAX_TASK_ID_NUMBER, CONTROL_CHAR_PATTERN, DEFAULT_MAX_CONTENT_LENGTH, ALL_VALID_STATUSES, VALID_PRIORITIES2, ARRAY_PARAMS;
+var SecurityError, MAX_TASK_ID_NUMBER, CONTROL_CHAR_PATTERN, DEFAULT_MAX_CONTENT_LENGTH, ALL_VALID_STATUSES, VALID_PRIORITIES2, ARRAY_PARAMS;
 var init_security = __esm({
   "src/dispatch/lib/security.ts"() {
     "use strict";
+    init_id_generator();
     init_schema();
     init_status_registry();
     SecurityError = class extends Error {
@@ -39317,7 +39967,6 @@ var init_security = __esm({
         this.name = "SecurityError";
       }
     };
-    TASK_ID_PATTERN2 = /^T[0-9]+$/;
     MAX_TASK_ID_NUMBER = 999999;
     CONTROL_CHAR_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g;
     DEFAULT_MAX_CONTENT_LENGTH = 64 * 1024;
@@ -39465,13 +40114,13 @@ var init_field_context = __esm({
 });
 
 // src/core/sessions/context-alert.ts
-import { existsSync as existsSync61, readFileSync as readFileSync44, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join60 } from "node:path";
+import { existsSync as existsSync62, readFileSync as readFileSync45, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join61 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join60(getCleoDir(cwd), ".current-session");
-  if (existsSync61(sessionFile)) {
-    return readFileSync44(sessionFile, "utf-8").trim() || null;
+  const sessionFile = join61(getCleoDir(cwd), ".current-session");
+  if (existsSync62(sessionFile)) {
+    return readFileSync45(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -40718,14 +41367,14 @@ __export(logger_exports, {
   logFileExists: () => logFileExists,
   readMigrationLog: () => readMigrationLog
 });
-import { existsSync as existsSync64, mkdirSync as mkdirSync16, statSync as statSync9, appendFileSync as appendFileSync4 } from "node:fs";
-import { join as join67, dirname as dirname16, relative as relative6 } from "node:path";
+import { existsSync as existsSync65, mkdirSync as mkdirSync16, statSync as statSync9, appendFileSync as appendFileSync4 } from "node:fs";
+import { join as join68, dirname as dirname16, relative as relative6 } from "node:path";
 function createMigrationLogger(cleoDir, config) {
   return new MigrationLogger(cleoDir, config);
 }
 function readMigrationLog(logPath) {
-  const { readFileSync: readFileSync52 } = __require("node:fs");
-  const content = readFileSync52(logPath, "utf-8");
+  const { readFileSync: readFileSync53 } = __require("node:fs");
+  const content = readFileSync53(logPath, "utf-8");
   return content.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
 }
 function logFileExists(logPath) {
@@ -40740,14 +41389,14 @@ function logFileExists(logPath) {
 function getLatestMigrationLog(cleoDir) {
   try {
     const { readdirSync: readdirSync21, statSync: statSync10 } = __require("node:fs");
-    const logsDir = join67(cleoDir, "logs");
-    if (!existsSync64(logsDir)) {
+    const logsDir = join68(cleoDir, "logs");
+    if (!existsSync65(logsDir)) {
       return null;
     }
     const files = readdirSync21(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
       name: f,
-      path: join67(logsDir, f),
-      mtime: statSync10(join67(logsDir, f)).mtime.getTime()
+      path: join68(logsDir, f),
+      mtime: statSync10(join68(logsDir, f)).mtime.getTime()
     })).sort((a, b) => b.mtime - a.mtime);
     return files.length > 0 ? files[0].path : null;
   } catch {
@@ -40777,9 +41426,9 @@ var init_logger2 = __esm({
           consoleOutput: config.consoleOutput ?? false
         };
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        this.logPath = join67(cleoDir, "logs", `migration-${timestamp}.jsonl`);
+        this.logPath = join68(cleoDir, "logs", `migration-${timestamp}.jsonl`);
         const logsDir = dirname16(this.logPath);
-        if (!existsSync64(logsDir)) {
+        if (!existsSync65(logsDir)) {
           mkdirSync16(logsDir, { recursive: true });
         }
         this.startTime = Date.now();
@@ -40868,7 +41517,7 @@ var init_logger2 = __esm({
           sourcePath: relative6(this.cleoDir, sourcePath),
           ...additionalData
         };
-        if (existsSync64(sourcePath)) {
+        if (existsSync65(sourcePath)) {
           try {
             const stats2 = statSync9(sourcePath);
             data.sourceSize = stats2.size;
@@ -40878,7 +41527,7 @@ var init_logger2 = __esm({
         }
         if (targetPath) {
           data.targetPath = relative6(this.cleoDir, targetPath);
-          if (existsSync64(targetPath)) {
+          if (existsSync65(targetPath)) {
             try {
               const stats2 = statSync9(targetPath);
               data.targetSize = stats2.size;
@@ -40947,15 +41596,15 @@ var init_logger2 = __esm({
        */
       cleanupOldLogs() {
         try {
-          const logsDir = join67(this.cleoDir, "logs");
-          if (!existsSync64(logsDir)) {
+          const logsDir = join68(this.cleoDir, "logs");
+          if (!existsSync65(logsDir)) {
             return;
           }
           const { readdirSync: readdirSync21, unlinkSync: unlinkSync5 } = __require("node:fs");
           const files = readdirSync21(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
             name: f,
-            path: join67(logsDir, f),
-            mtime: statSync9(join67(logsDir, f)).mtime.getTime()
+            path: join68(logsDir, f),
+            mtime: statSync9(join68(logsDir, f)).mtime.getTime()
           })).sort((a, b) => b.mtime - a.mtime);
           const filesToRemove = files.slice(this.config.maxLogFiles);
           for (const file of filesToRemove) {
@@ -41051,8 +41700,8 @@ __export(state_exports, {
   verifySourceIntegrity: () => verifySourceIntegrity
 });
 import { readFile as readFile19, writeFile as writeFile13, unlink as unlink5 } from "node:fs/promises";
-import { join as join68 } from "node:path";
-import { existsSync as existsSync65 } from "node:fs";
+import { join as join69 } from "node:path";
+import { existsSync as existsSync66 } from "node:fs";
 import { createHash as createHash8 } from "node:crypto";
 async function computeFileChecksum(filePath) {
   try {
@@ -41074,8 +41723,8 @@ async function countRecords(filePath, key) {
 async function createMigrationState(cleoDir, sourceFiles) {
   const files = sourceFiles ?? {};
   if (!files.todoJson) {
-    const todoPath = join68(cleoDir, "todo.json");
-    if (existsSync65(todoPath)) {
+    const todoPath = join69(cleoDir, "todo.json");
+    if (existsSync66(todoPath)) {
       files.todoJson = {
         path: todoPath,
         checksum: await computeFileChecksum(todoPath),
@@ -41084,8 +41733,8 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.sessionsJson) {
-    const sessionsPath = join68(cleoDir, "sessions.json");
-    if (existsSync65(sessionsPath)) {
+    const sessionsPath = join69(cleoDir, "sessions.json");
+    if (existsSync66(sessionsPath)) {
       files.sessionsJson = {
         path: sessionsPath,
         checksum: await computeFileChecksum(sessionsPath),
@@ -41094,8 +41743,8 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.archiveJson) {
-    const archivePath = join68(cleoDir, "todo-archive.json");
-    if (existsSync65(archivePath)) {
+    const archivePath = join69(cleoDir, "todo-archive.json");
+    if (existsSync66(archivePath)) {
       files.archiveJson = {
         path: archivePath,
         checksum: await computeFileChecksum(archivePath),
@@ -41123,7 +41772,7 @@ async function createMigrationState(cleoDir, sourceFiles) {
   return state;
 }
 async function writeMigrationState(cleoDir, state) {
-  const statePath = join68(cleoDir, STATE_FILENAME);
+  const statePath = join69(cleoDir, STATE_FILENAME);
   const tempPath = `${statePath}.tmp`;
   await writeFile13(tempPath, JSON.stringify(state, null, 2));
   await writeFile13(statePath, await readFile19(tempPath));
@@ -41198,7 +41847,7 @@ async function addMigrationWarning(cleoDir, warning) {
 }
 async function loadMigrationState(cleoDir) {
   try {
-    const statePath = join68(cleoDir, STATE_FILENAME);
+    const statePath = join69(cleoDir, STATE_FILENAME);
     const content = await readFile19(statePath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -41240,7 +41889,7 @@ async function failMigration(cleoDir, error) {
 }
 async function clearMigrationState(cleoDir) {
   try {
-    const statePath = join68(cleoDir, STATE_FILENAME);
+    const statePath = join69(cleoDir, STATE_FILENAME);
     await unlink5(statePath);
   } catch {
   }
@@ -41280,7 +41929,7 @@ async function verifySourceIntegrity(cleoDir) {
   const missing = [];
   for (const [key, fileInfo] of Object.entries(state.sourceFiles)) {
     if (!fileInfo) continue;
-    if (!existsSync65(fileInfo.path)) {
+    if (!existsSync66(fileInfo.path)) {
       missing.push(key);
       continue;
     }
@@ -41311,8 +41960,8 @@ __export(migration_sqlite_exports, {
   migrateJsonToSqlite: () => migrateJsonToSqlite2,
   migrateJsonToSqliteAtomic: () => migrateJsonToSqliteAtomic
 });
-import { existsSync as existsSync66, readFileSync as readFileSync47 } from "node:fs";
-import { join as join69, dirname as dirname17 } from "node:path";
+import { existsSync as existsSync67, readFileSync as readFileSync48 } from "node:fs";
+import { join as join70, dirname as dirname17 } from "node:path";
 import { mkdirSync as mkdirSync17 } from "node:fs";
 import { drizzle as drizzle4 } from "drizzle-orm/sqlite-proxy";
 import { migrate as migrate4 } from "drizzle-orm/sqlite-proxy/migrator";
@@ -41350,26 +41999,26 @@ function countJsonRecords(cleoDir) {
   let tasks2 = 0;
   let archived = 0;
   let sessions2 = 0;
-  const todoPath = join69(cleoDir, "todo.json");
-  if (existsSync66(todoPath)) {
+  const todoPath = join70(cleoDir, "todo.json");
+  if (existsSync67(todoPath)) {
     try {
-      const data = JSON.parse(readFileSync47(todoPath, "utf-8"));
+      const data = JSON.parse(readFileSync48(todoPath, "utf-8"));
       tasks2 = (data.tasks ?? []).length;
     } catch {
     }
   }
-  const archivePath = join69(cleoDir, "todo-archive.json");
-  if (existsSync66(archivePath)) {
+  const archivePath = join70(cleoDir, "todo-archive.json");
+  if (existsSync67(archivePath)) {
     try {
-      const data = JSON.parse(readFileSync47(archivePath, "utf-8"));
+      const data = JSON.parse(readFileSync48(archivePath, "utf-8"));
       archived = (data.tasks ?? data.archivedTasks ?? []).length;
     } catch {
     }
   }
-  const sessionsPath = join69(cleoDir, "sessions.json");
-  if (existsSync66(sessionsPath)) {
+  const sessionsPath = join70(cleoDir, "sessions.json");
+  if (existsSync67(sessionsPath)) {
     try {
-      const data = JSON.parse(readFileSync47(sessionsPath, "utf-8"));
+      const data = JSON.parse(readFileSync48(sessionsPath, "utf-8"));
       sessions2 = (data.sessions ?? []).length;
     } catch {
     }
@@ -41446,13 +42095,13 @@ async function migrateJsonToSqliteAtomic(cwd, tempDbPath, logger) {
   }
 }
 async function runMigrationDataImport(db, cleoDir, result, logger) {
-  const todoPath = join69(cleoDir, "todo.json");
-  if (existsSync66(todoPath)) {
+  const todoPath = join70(cleoDir, "todo.json");
+  if (existsSync67(todoPath)) {
     try {
       logger?.info("import", "read-todo", "Reading todo.json", {
         path: todoPath.replace(cleoDir, ".")
       });
-      const todoData = JSON.parse(readFileSync47(todoPath, "utf-8"));
+      const todoData = JSON.parse(readFileSync48(todoPath, "utf-8"));
       const tasks2 = topoSortTasks(todoData.tasks ?? []);
       const totalTasks = tasks2.length;
       logger?.info("import", "tasks-start", `Starting import of ${totalTasks} tasks`, {
@@ -41521,13 +42170,13 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
     result.warnings.push("todo.json not found, skipping task import");
     logger?.warn("import", "todo-missing", "todo.json not found, skipping task import");
   }
-  const archivePath = join69(cleoDir, "todo-archive.json");
-  if (existsSync66(archivePath)) {
+  const archivePath = join70(cleoDir, "todo-archive.json");
+  if (existsSync67(archivePath)) {
     try {
       logger?.info("import", "read-archive", "Reading todo-archive.json", {
         path: archivePath.replace(cleoDir, ".")
       });
-      const archiveData = JSON.parse(readFileSync47(archivePath, "utf-8"));
+      const archiveData = JSON.parse(readFileSync48(archivePath, "utf-8"));
       const archivedTasks = topoSortTasks(archiveData.tasks ?? archiveData.archivedTasks ?? []);
       const totalArchived = archivedTasks.length;
       logger?.info("import", "archive-start", `Starting import of ${totalArchived} archived tasks`, {
@@ -41580,13 +42229,13 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
       logger?.error("import", "parse-archive", errorMsg);
     }
   }
-  const sessionsPath = join69(cleoDir, "sessions.json");
-  if (existsSync66(sessionsPath)) {
+  const sessionsPath = join70(cleoDir, "sessions.json");
+  if (existsSync67(sessionsPath)) {
     try {
       logger?.info("import", "read-sessions", "Reading sessions.json", {
         path: sessionsPath.replace(cleoDir, ".")
       });
-      const sessionsData = JSON.parse(readFileSync47(sessionsPath, "utf-8"));
+      const sessionsData = JSON.parse(readFileSync48(sessionsPath, "utf-8"));
       const sessions2 = sessionsData.sessions ?? [];
       const totalSessions = sessions2.length;
       logger?.info("import", "sessions-start", `Starting import of ${totalSessions} sessions`, {
@@ -41718,10 +42367,10 @@ async function migrateJsonToSqlite2(cwd, options) {
     return result;
   }
   const db = await getDb(cwd);
-  const todoPath = join69(cleoDir, "todo.json");
-  if (existsSync66(todoPath)) {
+  const todoPath = join70(cleoDir, "todo.json");
+  if (existsSync67(todoPath)) {
     try {
-      const todoData = JSON.parse(readFileSync47(todoPath, "utf-8"));
+      const todoData = JSON.parse(readFileSync48(todoPath, "utf-8"));
       const tasks2 = topoSortTasks(todoData.tasks ?? []);
       for (const task of tasks2) {
         try {
@@ -41770,10 +42419,10 @@ async function migrateJsonToSqlite2(cwd, options) {
   } else {
     result.warnings.push("todo.json not found, skipping task import");
   }
-  const archivePath = join69(cleoDir, "todo-archive.json");
-  if (existsSync66(archivePath)) {
+  const archivePath = join70(cleoDir, "todo-archive.json");
+  if (existsSync67(archivePath)) {
     try {
-      const archiveData = JSON.parse(readFileSync47(archivePath, "utf-8"));
+      const archiveData = JSON.parse(readFileSync48(archivePath, "utf-8"));
       const archivedTasks = topoSortTasks(archiveData.tasks ?? archiveData.archivedTasks ?? []);
       for (const task of archivedTasks) {
         try {
@@ -41810,11 +42459,11 @@ async function migrateJsonToSqlite2(cwd, options) {
       result.errors.push(`Failed to parse todo-archive.json: ${String(err)}`);
     }
   }
-  const sessionsPath = join69(cleoDir, "sessions.json");
-  if (existsSync66(sessionsPath)) {
+  const sessionsPath = join70(cleoDir, "sessions.json");
+  if (existsSync67(sessionsPath)) {
     try {
       const sessionsData = JSON.parse(
-        readFileSync47(sessionsPath, "utf-8")
+        readFileSync48(sessionsPath, "utf-8")
       );
       const sessions2 = sessionsData.sessions ?? [];
       for (const session of sessions2) {
@@ -41882,8 +42531,8 @@ var init_migration_sqlite = __esm({
 
 // src/cli/index.ts
 import { Command, Help } from "commander";
-import { readFileSync as readFileSync51 } from "node:fs";
-import { join as join75 } from "node:path";
+import { readFileSync as readFileSync52 } from "node:fs";
+import { join as join76 } from "node:path";
 
 // src/cli/commands/add.ts
 init_cli();
@@ -42733,14 +43382,14 @@ init_errors();
 init_exit_codes();
 init_paths();
 init_json();
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 var VALID_CATEGORIES = ["write", "read", "sync", "maintenance"];
 var VALID_RELEVANCE = ["critical", "high", "medium", "low"];
 async function locateCommandsIndex() {
   const cleoHome = getCleoHome();
   const paths = [
-    join61(cleoHome, "docs", "commands", "COMMANDS-INDEX.json"),
-    join61(process.cwd(), "docs", "commands", "COMMANDS-INDEX.json")
+    join62(cleoHome, "docs", "commands", "COMMANDS-INDEX.json"),
+    join62(process.cwd(), "docs", "commands", "COMMANDS-INDEX.json")
   ];
   for (const p of paths) {
     const data = await readJson(p);
@@ -42821,9 +43470,9 @@ init_errors();
 init_json();
 init_paths();
 import { readdir as readdir2, readFile as readFile16 } from "node:fs/promises";
-import { join as join62 } from "node:path";
+import { join as join63 } from "node:path";
 async function getScriptNames(projectRoot) {
-  const scriptsDir = join62(projectRoot, "scripts");
+  const scriptsDir = join63(projectRoot, "scripts");
   try {
     const files = await readdir2(scriptsDir);
     return files.filter((f) => f.endsWith(".sh")).map((f) => f.replace(".sh", "")).sort();
@@ -42832,7 +43481,7 @@ async function getScriptNames(projectRoot) {
   }
 }
 async function getIndexedCommands(projectRoot) {
-  const indexPath = join62(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
+  const indexPath = join63(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
   const index5 = await readJson(indexPath);
   if (!index5) return [];
   return index5.commands.map((c) => c.name).sort();
@@ -42865,7 +43514,7 @@ async function runGapCheck(_projectRoot, filterId) {
     const reviewFiles = files.filter((f) => f.endsWith(".md"));
     for (const file of reviewFiles) {
       if (filterId && !file.includes(filterId)) continue;
-      const filePath = join62(reviewDir, file);
+      const filePath = join63(reviewDir, file);
       const content = await readFile16(filePath, "utf-8");
       const taskMatch = file.match(/^(T\d+)/);
       const taskId = taskMatch ? taskMatch[1] : "UNKNOWN";
@@ -42969,7 +43618,7 @@ init_paths();
 init_json();
 init_data_accessor();
 import { readFile as readFile17, rm as rm3, stat as stat3 } from "node:fs/promises";
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 function parseTaskId(content) {
   const match = content.match(/^\[T(\d+)\]/);
   return match ? `T${match[1]}` : null;
@@ -43025,7 +43674,7 @@ function registerExtractCommand(program2) {
       const accessor = await getAccessor();
       const taskData = await accessor.loadTaskFile();
       const cleoDir = getCleoDir();
-      const stateFile = join63(cleoDir, "sync", "todowrite-session.json");
+      const stateFile = join64(cleoDir, "sync", "todowrite-session.json");
       let sessionState = null;
       try {
         sessionState = await readJson(stateFile);
@@ -43211,17 +43860,17 @@ init_renderers();
 init_errors();
 init_exit_codes();
 init_paths();
-import { spawn as spawn2, execFileSync as execFileSync10 } from "node:child_process";
+import { spawn as spawn2, execFileSync as execFileSync12 } from "node:child_process";
 import { readFile as readFile18, writeFile as writeFile12, mkdir as mkdir12, rm as rm4, stat as stat4 } from "node:fs/promises";
-import { join as join64 } from "node:path";
+import { join as join65 } from "node:path";
 var DEFAULT_PORT = 3456;
 var DEFAULT_HOST = "127.0.0.1";
 function getWebPaths() {
   const cleoHome = getCleoHome();
   return {
-    pidFile: join64(cleoHome, "web-server.pid"),
-    configFile: join64(cleoHome, "web-server.json"),
-    logFile: join64(cleoHome, "logs", "web-server.log")
+    pidFile: join65(cleoHome, "web-server.pid"),
+    configFile: join65(cleoHome, "web-server.json"),
+    logFile: join65(cleoHome, "logs", "web-server.log")
   };
 }
 function isProcessRunning(pid) {
@@ -43265,19 +43914,19 @@ function registerWebCommand(program2) {
         throw new CleoError(1 /* GENERAL_ERROR */, `Server already running (PID: ${status.pid})`);
       }
       const projectRoot = process.env["CLEO_ROOT"] ?? process.cwd();
-      const distMcpDir = join64(projectRoot, "dist", "mcp");
-      await mkdir12(join64(getCleoHome(), "logs"), { recursive: true });
+      const distMcpDir = join65(projectRoot, "dist", "mcp");
+      await mkdir12(join65(getCleoHome(), "logs"), { recursive: true });
       await writeFile12(configFile, JSON.stringify({
         port,
         host,
         startedAt: (/* @__PURE__ */ new Date()).toISOString()
       }));
-      const webIndexPath = join64(distMcpDir, "index.js");
+      const webIndexPath = join65(distMcpDir, "index.js");
       try {
         await stat4(webIndexPath);
       } catch {
         try {
-          execFileSync10("npm", ["run", "build"], { cwd: projectRoot, stdio: "ignore" });
+          execFileSync12("npm", ["run", "build"], { cwd: projectRoot, stdio: "ignore" });
         } catch {
           throw new CleoError(1 /* GENERAL_ERROR */, `Build failed. Check logs: ${logFile}`);
         }
@@ -43496,13 +44145,13 @@ init_renderers();
 init_errors();
 init_exit_codes();
 init_paths();
-import { existsSync as existsSync62, readFileSync as readFileSync45, writeFileSync as writeFileSync10, mkdirSync as mkdirSync15 } from "node:fs";
-import { execFileSync as execFileSync11 } from "node:child_process";
-import { join as join65, dirname as dirname15 } from "node:path";
+import { existsSync as existsSync63, readFileSync as readFileSync46, writeFileSync as writeFileSync10, mkdirSync as mkdirSync15 } from "node:fs";
+import { execFileSync as execFileSync13 } from "node:child_process";
+import { join as join66, dirname as dirname15 } from "node:path";
 function getChangelogSource(cwd) {
   const configPath = getConfigPath(cwd);
   try {
-    const config = JSON.parse(readFileSync45(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync46(configPath, "utf-8"));
     return config?.release?.changelog?.source ?? "CHANGELOG.md";
   } catch {
     return "CHANGELOG.md";
@@ -43511,7 +44160,7 @@ function getChangelogSource(cwd) {
 function getEnabledPlatforms(cwd) {
   const configPath = getConfigPath(cwd);
   try {
-    const config = JSON.parse(readFileSync45(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync46(configPath, "utf-8"));
     const outputs = config?.release?.changelog?.outputs ?? [];
     return outputs.filter((o) => o.enabled);
   } catch {
@@ -43533,7 +44182,7 @@ function getDefaultOutputPath(platform2) {
 function getGitHubRepoSlug(cwd) {
   const projectRoot = getProjectRoot(cwd);
   try {
-    const remoteUrl = execFileSync11("git", ["remote", "get-url", "origin"], {
+    const remoteUrl = execFileSync13("git", ["remote", "get-url", "origin"], {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -43638,11 +44287,11 @@ function registerGenerateChangelogCommand(program2) {
       const targetPlatform = opts["platform"];
       const dryRun = !!opts["dryRun"];
       const sourceFile = getChangelogSource();
-      const sourcePath = join65(getProjectRoot(), sourceFile);
-      if (!existsSync62(sourcePath)) {
+      const sourcePath = join66(getProjectRoot(), sourceFile);
+      if (!existsSync63(sourcePath)) {
         throw new CleoError(4 /* NOT_FOUND */, `Changelog source not found: ${sourcePath}`);
       }
-      const sourceContent = readFileSync45(sourcePath, "utf-8");
+      const sourceContent = readFileSync46(sourcePath, "utf-8");
       const repoSlug = getGitHubRepoSlug();
       const results = [];
       if (targetPlatform) {
@@ -43651,7 +44300,7 @@ function registerGenerateChangelogCommand(program2) {
         const outputPath = platformConfig?.path ?? getDefaultOutputPath(targetPlatform);
         const content = generateForPlatform(targetPlatform, sourceContent, repoSlug, limit);
         if (!dryRun) {
-          const fullPath = join65(getProjectRoot(), outputPath);
+          const fullPath = join66(getProjectRoot(), outputPath);
           mkdirSync15(dirname15(fullPath), { recursive: true });
           writeFileSync10(fullPath, content, "utf-8");
         }
@@ -43672,7 +44321,7 @@ function registerGenerateChangelogCommand(program2) {
             limit
           );
           if (!dryRun) {
-            const fullPath = join65(getProjectRoot(), platformConfig.path);
+            const fullPath = join66(getProjectRoot(), platformConfig.path);
             mkdirSync15(dirname15(fullPath), { recursive: true });
             writeFileSync10(fullPath, content, "utf-8");
           }
@@ -43703,7 +44352,7 @@ function registerGenerateChangelogCommand(program2) {
 init_cli();
 init_renderers();
 init_build_config();
-import { execFileSync as execFileSync12 } from "node:child_process";
+import { execFileSync as execFileSync14 } from "node:child_process";
 var CLEO_REPO2 = BUILD_CONFIG.repository.fullName;
 function registerIssueCommand(program2) {
   const issueCmd = program2.command("issue").description("File bug reports, feature requests, or questions to CLEO GitHub repo");
@@ -43742,7 +44391,7 @@ async function handleIssueType(issueType, opts) {
   if (opts["open"] && typeof result["url"] === "string" && result["url"].startsWith("https://")) {
     const issueNumber = result["url"].match(/(\d+)$/)?.[1] ?? "unknown";
     try {
-      execFileSync12("gh", ["issue", "view", issueNumber, "--repo", CLEO_REPO2, "--web"], {
+      execFileSync14("gh", ["issue", "view", issueNumber, "--repo", CLEO_REPO2, "--web"], {
         stdio: ["pipe", "pipe", "pipe"]
       });
     } catch {
@@ -44427,22 +45076,22 @@ function registerPlanCommand(program2) {
 }
 
 // src/core/otel/index.ts
-import { readFileSync as readFileSync46, existsSync as existsSync63, writeFileSync as writeFileSync11, copyFileSync as copyFileSync4 } from "node:fs";
-import { join as join66 } from "node:path";
+import { readFileSync as readFileSync47, existsSync as existsSync64, writeFileSync as writeFileSync11, copyFileSync as copyFileSync4 } from "node:fs";
+import { join as join67 } from "node:path";
 function getProjectRoot2() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (existsSync63(join66(dir, ".cleo", "config.json"))) return dir;
-    dir = join66(dir, "..");
+    if (existsSync64(join67(dir, ".cleo", "config.json"))) return dir;
+    dir = join67(dir, "..");
   }
   return process.cwd();
 }
 function getTokenFilePath() {
-  return join66(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
+  return join67(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
 }
 function readJsonlFile(filePath) {
-  if (!existsSync63(filePath)) return [];
-  const content = readFileSync46(filePath, "utf-8").trim();
+  if (!existsSync64(filePath)) return [];
+  const content = readFileSync47(filePath, "utf-8").trim();
   if (!content) return [];
   return content.split("\n").map((line) => JSON.parse(line));
 }
@@ -44524,7 +45173,7 @@ async function getRealTokenUsage(_opts) {
 }
 async function clearOtelData() {
   const tokenFile = getTokenFilePath();
-  if (existsSync63(tokenFile)) {
+  if (existsSync64(tokenFile)) {
     const backup = `${tokenFile}.backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
     copyFileSync4(tokenFile, backup);
     writeFileSync11(tokenFile, "");
@@ -44889,8 +45538,8 @@ init_storage_preflight();
 init_paths();
 init_storage_preflight();
 init_agent_outputs();
-import { existsSync as existsSync67, readFileSync as readFileSync48, writeFileSync as writeFileSync12, mkdirSync as mkdirSync18, readdirSync as readdirSync19, copyFileSync as copyFileSync5 } from "node:fs";
-import { join as join70 } from "node:path";
+import { existsSync as existsSync68, readFileSync as readFileSync49, writeFileSync as writeFileSync12, mkdirSync as mkdirSync18, readdirSync as readdirSync19, copyFileSync as copyFileSync5 } from "node:fs";
+import { join as join71 } from "node:path";
 
 // src/store/index.ts
 init_atomic();
@@ -44926,8 +45575,8 @@ async function runUpgrade(options = {}) {
     return { success: false, upToDate: false, dryRun: isDryRun, actions, applied: 0, errors: [String(err)] };
   }
   const cleoDir = getCleoDirAbsolute(options.cwd);
-  const dbPath = join70(cleoDir, "tasks.db");
-  const dbExists2 = existsSync67(dbPath);
+  const dbPath = join71(cleoDir, "tasks.db");
+  const dbExists2 = existsSync68(dbPath);
   const legacyRecordCount = preflight.details.todoJsonTaskCount + preflight.details.archiveJsonTaskCount + preflight.details.sessionsJsonCount;
   const needsMigration = !dbExists2 && legacyRecordCount > 0;
   const needsCleanup = dbExists2 && preflight.migrationNeeded;
@@ -44943,7 +45592,7 @@ async function runUpgrade(options = {}) {
       let migrationLock = null;
       try {
         const cleoDir2 = getCleoDirAbsolute(options.cwd);
-        const dbPath2 = join70(cleoDir2, "tasks.db");
+        const dbPath2 = join71(cleoDir2, "tasks.db");
         try {
           migrationLock = await acquireLock(dbPath2, { stale: 3e4, retries: 0 });
         } catch {
@@ -44968,23 +45617,23 @@ async function runUpgrade(options = {}) {
         } = await Promise.resolve().then(() => (init_state(), state_exports));
         const logger = new MigrationLogger2(cleoDir2);
         await createMigrationState2(cleoDir2, {
-          todoJson: { path: join70(cleoDir2, "todo.json"), checksum: "" },
-          sessionsJson: { path: join70(cleoDir2, "sessions.json"), checksum: "" },
-          archiveJson: { path: join70(cleoDir2, "todo-archive.json"), checksum: "" }
+          todoJson: { path: join71(cleoDir2, "todo.json"), checksum: "" },
+          sessionsJson: { path: join71(cleoDir2, "sessions.json"), checksum: "" },
+          archiveJson: { path: join71(cleoDir2, "todo-archive.json"), checksum: "" }
         });
         await updateMigrationPhase2(cleoDir2, "backup");
         logger.info("init", "start", "Migration state initialized");
-        const dbBackupPath = join70(cleoDir2, "backups", "safety", `tasks.db.pre-migration.${Date.now()}`);
-        const dbTempPath = join70(cleoDir2, "tasks.db.migrating");
-        if (existsSync67(dbPath2)) {
-          const backupDir = join70(cleoDir2, "backups", "safety");
-          if (!existsSync67(backupDir)) {
+        const dbBackupPath = join71(cleoDir2, "backups", "safety", `tasks.db.pre-migration.${Date.now()}`);
+        const dbTempPath = join71(cleoDir2, "tasks.db.migrating");
+        if (existsSync68(dbPath2)) {
+          const backupDir = join71(cleoDir2, "backups", "safety");
+          if (!existsSync68(backupDir)) {
             mkdirSync18(backupDir, { recursive: true });
           }
           copyFileSync5(dbPath2, dbBackupPath);
           const { createHash: createHash9 } = await import("node:crypto");
-          const origChecksum = createHash9("sha256").update(readFileSync48(dbPath2)).digest("hex");
-          const backupChecksum = createHash9("sha256").update(readFileSync48(dbBackupPath)).digest("hex");
+          const origChecksum = createHash9("sha256").update(readFileSync49(dbPath2)).digest("hex");
+          const backupChecksum = createHash9("sha256").update(readFileSync49(dbBackupPath)).digest("hex");
           if (origChecksum !== backupChecksum) {
             throw new Error(
               `Backup verification failed: checksum mismatch. Aborting migration to prevent data loss.`
@@ -44999,14 +45648,14 @@ async function runUpgrade(options = {}) {
           }
           logger.info("backup", "verified", "Backup integrity verified", { checksum: origChecksum });
         }
-        if (existsSync67(dbTempPath)) {
+        if (existsSync68(dbTempPath)) {
           const { unlinkSync: unlinkSync5 } = await import("node:fs");
           unlinkSync5(dbTempPath);
         }
-        const configPath = join70(cleoDir2, "config.json");
+        const configPath = join71(cleoDir2, "config.json");
         let configBackup = null;
-        if (existsSync67(configPath)) {
-          configBackup = readFileSync48(configPath, "utf-8");
+        if (existsSync68(configPath)) {
+          configBackup = readFileSync49(configPath, "utf-8");
         }
         const { resetDbState: resetDbState2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
         resetDbState2();
@@ -45032,7 +45681,7 @@ async function runUpgrade(options = {}) {
         resetDbState2();
         if (result.success) {
           const totalImported = result.tasksImported + result.archivedImported;
-          if (totalImported === 0 && existsSync67(dbBackupPath)) {
+          if (totalImported === 0 && existsSync68(dbBackupPath)) {
             copyFileSync5(dbBackupPath, dbPath2);
             if (configBackup) {
               writeFileSync12(configPath, configBackup);
@@ -45046,9 +45695,9 @@ async function runUpgrade(options = {}) {
             errors.push("Migration imported 0 tasks \u2014 restored from backup to prevent data loss");
           } else {
             let config = {};
-            if (existsSync67(configPath)) {
+            if (existsSync68(configPath)) {
               try {
-                config = JSON.parse(readFileSync48(configPath, "utf-8"));
+                config = JSON.parse(readFileSync49(configPath, "utf-8"));
               } catch {
               }
             }
@@ -45074,7 +45723,7 @@ async function runUpgrade(options = {}) {
             logger.info("complete", "finish", "Migration completed successfully");
           }
         } else {
-          if (existsSync67(dbBackupPath)) {
+          if (existsSync68(dbBackupPath)) {
             copyFileSync5(dbBackupPath, dbPath2);
           }
           if (configBackup) {
@@ -45097,12 +45746,12 @@ async function runUpgrade(options = {}) {
       } catch (err) {
         try {
           const cleoDir2 = getCleoDirAbsolute(options.cwd);
-          const dbPath2 = join70(cleoDir2, "tasks.db");
-          const safetyDir = join70(cleoDir2, "backups", "safety");
-          if (existsSync67(safetyDir)) {
+          const dbPath2 = join71(cleoDir2, "tasks.db");
+          const safetyDir = join71(cleoDir2, "backups", "safety");
+          if (existsSync68(safetyDir)) {
             const backups = readdirSync19(safetyDir).filter((f) => f.startsWith("tasks.db.pre-migration.")).sort().reverse();
-            if (backups.length > 0 && !existsSync67(dbPath2)) {
-              copyFileSync5(join70(safetyDir, backups[0]), dbPath2);
+            if (backups.length > 0 && !existsSync68(dbPath2)) {
+              copyFileSync5(join71(safetyDir, backups[0]), dbPath2);
             }
           }
         } catch {
@@ -45137,7 +45786,7 @@ async function runUpgrade(options = {}) {
       details: preflight.summary
     });
   }
-  if (existsSync67(dbPath)) {
+  if (existsSync68(dbPath)) {
     try {
       const { runAllRepairs: runAllRepairs2 } = await Promise.resolve().then(() => (init_repair(), repair_exports));
       const repairActions = await runAllRepairs2(options.cwd, isDryRun);
@@ -45147,8 +45796,8 @@ async function runUpgrade(options = {}) {
     } catch {
     }
   }
-  if (existsSync67(dbPath)) {
-    const legacySequenceFiles = [".sequence", ".sequence.json"].filter((f) => existsSync67(join70(cleoDir, f)));
+  if (existsSync68(dbPath)) {
+    const legacySequenceFiles = [".sequence", ".sequence.json"].filter((f) => existsSync68(join71(cleoDir, f)));
     if (legacySequenceFiles.length > 0) {
       if (isDryRun) {
         actions.push({
@@ -45177,7 +45826,7 @@ async function runUpgrade(options = {}) {
   }
   if (needsCleanup) {
     const staleJsonFiles = ["todo.json", "sessions.json", "todo-archive.json", ".sequence", ".sequence.json"];
-    const foundStale = staleJsonFiles.filter((f) => existsSync67(join70(cleoDir, f)));
+    const foundStale = staleJsonFiles.filter((f) => existsSync68(join71(cleoDir, f)));
     if (foundStale.length > 0) {
       if (isDryRun) {
         actions.push({
@@ -45187,15 +45836,15 @@ async function runUpgrade(options = {}) {
         });
       } else {
         try {
-          const backupDir = join70(cleoDir, ".backups", `legacy-json-${Date.now()}`);
+          const backupDir = join71(cleoDir, ".backups", `legacy-json-${Date.now()}`);
           mkdirSync18(backupDir, { recursive: true });
           for (const f of foundStale) {
-            const src = join70(cleoDir, f);
-            copyFileSync5(src, join70(backupDir, f));
+            const src = join71(cleoDir, f);
+            copyFileSync5(src, join71(backupDir, f));
           }
           const { unlinkSync: unlinkSync5 } = await import("node:fs");
           for (const f of foundStale) {
-            unlinkSync5(join70(cleoDir, f));
+            unlinkSync5(join71(cleoDir, f));
           }
           actions.push({
             action: "stale_json_cleanup",
@@ -45215,7 +45864,7 @@ async function runUpgrade(options = {}) {
   if (options.includeGlobal) {
     try {
       const globalDir = getCleoHome();
-      const globalPreflight = checkStorageMigration(join70(globalDir, ".."));
+      const globalPreflight = checkStorageMigration(join71(globalDir, ".."));
       if (globalPreflight.migrationNeeded) {
         actions.push({
           action: "global_storage_check",
@@ -45236,8 +45885,8 @@ async function runUpgrade(options = {}) {
   try {
     const projectRoot = getProjectRoot(options.cwd);
     if (isDryRun) {
-      const gitignorePath = join70(cleoDir, ".gitignore");
-      if (!existsSync67(gitignorePath)) {
+      const gitignorePath = join71(cleoDir, ".gitignore");
+      if (!existsSync68(gitignorePath)) {
         actions.push({ action: "gitignore_integrity", status: "preview", details: "Would create .cleo/.gitignore from template" });
       } else {
         actions.push({ action: "gitignore_integrity", status: "preview", details: "Would verify .cleo/.gitignore matches template" });
@@ -45280,12 +45929,12 @@ async function runUpgrade(options = {}) {
   try {
     const projectRootForContext = getProjectRoot(options.cwd);
     if (isDryRun) {
-      const contextPath = join70(cleoDir, "project-context.json");
-      if (!existsSync67(contextPath)) {
+      const contextPath = join71(cleoDir, "project-context.json");
+      if (!existsSync68(contextPath)) {
         actions.push({ action: "project_context_detection", status: "preview", details: "Would detect and create project-context.json" });
       } else {
         try {
-          const context = JSON.parse(readFileSync48(contextPath, "utf-8"));
+          const context = JSON.parse(readFileSync49(contextPath, "utf-8"));
           if (context.detectedAt) {
             const daysSince = (Date.now() - new Date(context.detectedAt).getTime()) / (1e3 * 60 * 60 * 24);
             if (daysSince > 30) {
@@ -45446,7 +46095,7 @@ async function runUpgrade(options = {}) {
 init_runtime();
 import { readFile as readFile20 } from "node:fs/promises";
 import * as readline from "node:readline";
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 import { execFile as execFile7 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
 init_build_config();
@@ -45455,7 +46104,7 @@ var GITHUB_REPO = BUILD_CONFIG.repository.fullName;
 async function getCurrentVersion() {
   const cleoHome = getCleoHome();
   try {
-    const content = await readFile20(join71(cleoHome, "VERSION"), "utf-8");
+    const content = await readFile20(join72(cleoHome, "VERSION"), "utf-8");
     return (content.split("\n")[0] ?? "unknown").trim();
   } catch {
     return "unknown";
@@ -45502,7 +46151,7 @@ async function writeRuntimeVersionMetadata(mode, source, version) {
     `installed=${(/* @__PURE__ */ new Date()).toISOString()}`
   ];
   await import("node:fs/promises").then(
-    ({ writeFile: writeFile15, mkdir: mkdir14 }) => mkdir14(cleoHome, { recursive: true }).then(() => writeFile15(join71(cleoHome, "VERSION"), `${lines.join("\n")}
+    ({ writeFile: writeFile15, mkdir: mkdir14 }) => mkdir14(cleoHome, { recursive: true }).then(() => writeFile15(join72(cleoHome, "VERSION"), `${lines.join("\n")}
 `, "utf-8"))
   );
 }
@@ -45861,14 +46510,14 @@ function registerVerifyCommand(program2) {
 
 // src/cli/commands/detect-drift.ts
 init_renderers();
-import { readFileSync as readFileSync49, existsSync as existsSync68, readdirSync as readdirSync20 } from "node:fs";
-import { join as join72, dirname as dirname18 } from "node:path";
+import { readFileSync as readFileSync50, existsSync as existsSync69, readdirSync as readdirSync20 } from "node:fs";
+import { join as join73, dirname as dirname18 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function findProjectRoot() {
   const currentFile = fileURLToPath5(import.meta.url);
   let currentDir = dirname18(currentFile);
   while (currentDir !== "/") {
-    if (existsSync68(join72(currentDir, "package.json"))) {
+    if (existsSync69(join73(currentDir, "package.json"))) {
       return currentDir;
     }
     const parent = dirname18(currentDir);
@@ -45906,16 +46555,16 @@ function registerDetectDriftCommand(program2) {
     };
     const safeRead = (path) => {
       try {
-        return readFileSync49(path, "utf-8");
+        return readFileSync50(path, "utf-8");
       } catch {
         return "";
       }
     };
     try {
-      const specPath = join72(projectRoot, "docs", "specs", "CLEO-OPERATIONS-REFERENCE.md");
-      const queryPath = join72(projectRoot, "src", "mcp", "gateways", "query.ts");
-      const mutatePath = join72(projectRoot, "src", "mcp", "gateways", "mutate.ts");
-      if (!existsSync68(specPath)) {
+      const specPath = join73(projectRoot, "docs", "specs", "CLEO-OPERATIONS-REFERENCE.md");
+      const queryPath = join73(projectRoot, "src", "mcp", "gateways", "query.ts");
+      const mutatePath = join73(projectRoot, "src", "mcp", "gateways", "mutate.ts");
+      if (!existsSync69(specPath)) {
         addCheck("Gateway-to-spec sync", "fail", "CLEO-OPERATIONS-REFERENCE.md missing", [{
           severity: "error",
           category: "spec",
@@ -45923,7 +46572,7 @@ function registerDetectDriftCommand(program2) {
           file: specPath,
           recommendation: "Create docs/specs/CLEO-OPERATIONS-REFERENCE.md with canonical operation definitions"
         }]);
-      } else if (!existsSync68(queryPath) || !existsSync68(mutatePath)) {
+      } else if (!existsSync69(queryPath) || !existsSync69(mutatePath)) {
         addCheck("Gateway-to-spec sync", "fail", "MCP gateway files missing", [{
           severity: "error",
           category: "implementation",
@@ -45977,16 +46626,16 @@ function registerDetectDriftCommand(program2) {
       }]);
     }
     try {
-      const cliDir = join72(projectRoot, "src", "cli", "commands");
-      const coreDir = join72(projectRoot, "src", "core");
-      if (!existsSync68(cliDir)) {
+      const cliDir = join73(projectRoot, "src", "cli", "commands");
+      const coreDir = join73(projectRoot, "src", "core");
+      if (!existsSync69(cliDir)) {
         addCheck("CLI-to-core sync", "fail", "CLI commands directory missing", [{
           severity: "error",
           category: "structure",
           message: "src/cli/commands/ directory not found",
           recommendation: "Verify TypeScript source structure is intact"
         }]);
-      } else if (!existsSync68(coreDir)) {
+      } else if (!existsSync69(coreDir)) {
         addCheck("CLI-to-core sync", "fail", "Core directory missing", [{
           severity: "error",
           category: "structure",
@@ -46001,8 +46650,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("CLI-to-core sync", "fail", `Error: ${e.message}`);
     }
     try {
-      const domainsDir = join72(projectRoot, "src", "mcp", "domains");
-      if (!existsSync68(domainsDir)) {
+      const domainsDir = join73(projectRoot, "src", "mcp", "domains");
+      if (!existsSync69(domainsDir)) {
         addCheck("Domain handler coverage", "fail", "MCP domains directory missing", [{
           severity: "error",
           category: "structure",
@@ -46017,8 +46666,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Domain handler coverage", "fail", `Error: ${e.message}`);
     }
     try {
-      const matrixPath = join72(projectRoot, "src", "dispatch", "lib", "capability-matrix.ts");
-      if (!existsSync68(matrixPath)) {
+      const matrixPath = join73(projectRoot, "src", "dispatch", "lib", "capability-matrix.ts");
+      if (!existsSync69(matrixPath)) {
         addCheck("Capability matrix", "fail", "Capability matrix missing", [{
           severity: "error",
           category: "configuration",
@@ -46032,8 +46681,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Capability matrix", "fail", `Error: ${e.message}`);
     }
     try {
-      const schemaPath = join72(projectRoot, "src", "store", "schema.ts");
-      if (!existsSync68(schemaPath)) {
+      const schemaPath = join73(projectRoot, "src", "store", "schema.ts");
+      if (!existsSync69(schemaPath)) {
         addCheck("Schema validation", "fail", "Schema definition missing", [{
           severity: "error",
           category: "data-model",
@@ -46058,10 +46707,10 @@ function registerDetectDriftCommand(program2) {
       addCheck("Schema validation", "fail", `Error: ${e.message}`);
     }
     try {
-      const visionPath = join72(projectRoot, "docs", "concepts", "CLEO-VISION.md");
-      const specPath = join72(projectRoot, "docs", "specs", "PORTABLE-BRAIN-SPEC.md");
+      const visionPath = join73(projectRoot, "docs", "concepts", "CLEO-VISION.md");
+      const specPath = join73(projectRoot, "docs", "specs", "PORTABLE-BRAIN-SPEC.md");
       const issues = [];
-      if (!existsSync68(visionPath)) {
+      if (!existsSync69(visionPath)) {
         issues.push({
           severity: "error",
           category: "vision",
@@ -46070,7 +46719,7 @@ function registerDetectDriftCommand(program2) {
           recommendation: "Create docs/concepts/CLEO-VISION.md with project vision"
         });
       }
-      if (!existsSync68(specPath)) {
+      if (!existsSync69(specPath)) {
         issues.push({
           severity: "error",
           category: "spec",
@@ -46107,8 +46756,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Canonical identity", "fail", `Error: ${e.message}`);
     }
     try {
-      const injectionPath = join72(projectRoot, ".cleo", "templates", "CLEO-INJECTION.md");
-      if (!existsSync68(injectionPath)) {
+      const injectionPath = join73(projectRoot, ".cleo", "templates", "CLEO-INJECTION.md");
+      if (!existsSync69(injectionPath)) {
         addCheck("Agent injection", "fail", "Agent injection template missing", [{
           severity: "error",
           category: "agent-support",
@@ -46133,8 +46782,8 @@ function registerDetectDriftCommand(program2) {
       addCheck("Agent injection", "fail", `Error: ${e.message}`);
     }
     try {
-      const exitCodesPath = join72(projectRoot, "src", "types", "exit-codes.ts");
-      if (!existsSync68(exitCodesPath)) {
+      const exitCodesPath = join73(projectRoot, "src", "types", "exit-codes.ts");
+      if (!existsSync69(exitCodesPath)) {
         addCheck("Exit codes", "fail", "Exit codes definition missing", [{
           severity: "error",
           category: "protocol",
@@ -46373,8 +47022,8 @@ function registerRemoteCommand(program2) {
 init_renderers();
 init_paths();
 import { mkdir as mkdir13, writeFile as writeFile14, readFile as readFile21 } from "node:fs/promises";
-import { existsSync as existsSync69, readFileSync as readFileSync50 } from "node:fs";
-import { join as join73, resolve as resolve10, dirname as dirname19 } from "node:path";
+import { existsSync as existsSync70, readFileSync as readFileSync51 } from "node:fs";
+import { join as join74, resolve as resolve10, dirname as dirname19 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function registerInstallGlobalCommand(program2) {
@@ -46384,17 +47033,17 @@ function registerInstallGlobalCommand(program2) {
     const warnings = [];
     try {
       const cleoHome = getCleoHome();
-      const globalTemplatesDir = join73(cleoHome, "templates");
+      const globalTemplatesDir = join74(cleoHome, "templates");
       if (!isDryRun) {
         await mkdir13(globalTemplatesDir, { recursive: true });
       }
       try {
         const thisFile = fileURLToPath6(import.meta.url);
         const packageRoot = resolve10(dirname19(thisFile), "..", "..", "..");
-        const templatePath = join73(packageRoot, "templates", "CLEO-INJECTION.md");
-        if (existsSync69(templatePath)) {
-          const content = readFileSync50(templatePath, "utf-8");
-          const globalPath = join73(globalTemplatesDir, "CLEO-INJECTION.md");
+        const templatePath = join74(packageRoot, "templates", "CLEO-INJECTION.md");
+        if (existsSync70(templatePath)) {
+          const content = readFileSync51(templatePath, "utf-8");
+          const globalPath = join74(globalTemplatesDir, "CLEO-INJECTION.md");
           if (!isDryRun) {
             await writeFile14(globalPath, content);
           }
@@ -46404,12 +47053,12 @@ function registerInstallGlobalCommand(program2) {
         warnings.push("Could not refresh CLEO-INJECTION.md template");
       }
       const globalAgentsDir = getAgentsHome();
-      const globalAgentsMd = join73(globalAgentsDir, "AGENTS.md");
+      const globalAgentsMd = join74(globalAgentsDir, "AGENTS.md");
       try {
         const { inject, getInstalledProviders: getInstalledProviders3, injectAll: injectAll2, buildInjectionContent: buildInjectionContent2 } = await import("@cleocode/caamp");
         if (!isDryRun) {
           await mkdir13(globalAgentsDir, { recursive: true });
-          if (existsSync69(globalAgentsMd)) {
+          if (existsSync70(globalAgentsMd)) {
             const content = await readFile21(globalAgentsMd, "utf8");
             const stripped = content.replace(/\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g, "");
             if (stripped !== content) {
@@ -46428,8 +47077,8 @@ function registerInstallGlobalCommand(program2) {
           const injectionContent = buildInjectionContent2({ references: ["@~/.agents/AGENTS.md"] });
           if (!isDryRun) {
             for (const provider of providers) {
-              const instructFilePath = join73(provider.pathGlobal, provider.instructFile);
-              if (existsSync69(instructFilePath)) {
+              const instructFilePath = join74(provider.pathGlobal, provider.instructFile);
+              if (existsSync70(instructFilePath)) {
                 const fileContent = await readFile21(instructFilePath, "utf8");
                 const stripped = fileContent.replace(/\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g, "");
                 if (stripped !== fileContent) {
@@ -46444,7 +47093,7 @@ function registerInstallGlobalCommand(program2) {
             }
           } else {
             for (const p of providers) {
-              const displayPath = join73(p.pathGlobal, p.instructFile).replace(homedir4(), "~");
+              const displayPath = join74(p.pathGlobal, p.instructFile).replace(homedir4(), "~");
               created.push(`${displayPath} (would update CAAMP block)`);
             }
           }
@@ -46650,7 +47299,7 @@ init_paths();
 init_paths();
 init_brain_sqlite();
 init_brain_search();
-import { existsSync as existsSync70 } from "node:fs";
+import { existsSync as existsSync71 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 var _require5 = createRequire5(import.meta.url);
 var { DatabaseSync: DatabaseSync3 } = _require5("node:sqlite");
@@ -46694,7 +47343,7 @@ async function migrateClaudeMem(projectRoot, options = {}) {
     errors: [],
     dryRun
   };
-  if (!existsSync70(sourcePath)) {
+  if (!existsSync71(sourcePath)) {
     throw new Error(
       `claude-mem database not found at: ${sourcePath}
 Expected location: ~/.claude-mem/claude-mem.db
@@ -47096,10 +47745,10 @@ init_config();
 // src/cli/logger-bootstrap.ts
 init_logger();
 init_project_info();
-import { join as join74 } from "node:path";
+import { join as join75 } from "node:path";
 function initCliLogger(cwd, loggingConfig) {
   const projectInfo = getProjectInfoSync(cwd);
-  initLogger(join74(cwd, ".cleo"), loggingConfig, projectInfo?.projectHash);
+  initLogger(join75(cwd, ".cleo"), loggingConfig, projectInfo?.projectHash);
 }
 
 // src/cli/index.ts
@@ -47332,8 +47981,8 @@ Upgrade options:
 }
 function getPackageVersion() {
   try {
-    const moduleRoot = join75(import.meta.dirname ?? "", "..", "..");
-    const pkg = JSON.parse(readFileSync51(join75(moduleRoot, "package.json"), "utf-8"));
+    const moduleRoot = join76(import.meta.dirname ?? "", "..", "..");
+    const pkg = JSON.parse(readFileSync52(join76(moduleRoot, "package.json"), "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -47444,7 +48093,7 @@ program.hook("preAction", async () => {
     const config = await loadConfig();
     initCliLogger(process.cwd(), config.logging);
     const { pruneAuditLog: pruneAuditLog2 } = await Promise.resolve().then(() => (init_audit_prune(), audit_prune_exports));
-    pruneAuditLog2(join75(process.cwd(), ".cleo"), config.logging).catch(() => {
+    pruneAuditLog2(join76(process.cwd(), ".cleo"), config.logging).catch(() => {
     });
   } catch {
   }
@@ -47484,7 +48133,7 @@ program.hook("preAction", (thisCommand) => {
   }
 });
 if (process.argv[2] === "mcp") {
-  const mcpPath = join75(import.meta.dirname ?? "", "..", "mcp", "index.js");
+  const mcpPath = join76(import.meta.dirname ?? "", "..", "mcp", "index.js");
   const { spawn: spawn3 } = await import("node:child_process");
   const child = spawn3(
     process.execPath,