contribute-now 0.2.0-dev.2621ffa → 0.2.0-dev.69b11fd

package/dist/index.js

@@ -3,11 +3,27 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-import { defineCommand as defineCommand14, runMain } from "citty";
+import { defineCommand as defineCommand12, runMain } from "citty";
 
-// src/commands/branch.ts
+// src/commands/clean.ts
 import { defineCommand } from "citty";
-import pc2 from "picocolors";
+import pc4 from "picocolors";
+
+// src/utils/branch.ts
+var DEFAULT_PREFIXES = ["feature", "fix", "docs", "chore", "test", "refactor"];
+function hasPrefix(branchName, prefixes = DEFAULT_PREFIXES) {
+  return prefixes.some((p) => branchName.startsWith(`${p}/`));
+}
+function formatBranchName(prefix, name) {
+  const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${prefix}/${sanitized}`;
+}
+function isValidBranchName(name) {
+  return /^[a-zA-Z0-9._/-]+$/.test(name) && !name.startsWith("/") && !name.endsWith("/");
+}
+function looksLikeNaturalLanguage(input) {
+  return input.includes(" ") && !input.includes("/");
+}
 
 // src/utils/config.ts
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -64,623 +80,9 @@ function getDefaultConfig() {
   };
 }
 
-// src/utils/git.ts
-import { execFile as execFileCb } from "node:child_process";
-import { readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-function run(args) {
-  return new Promise((resolve) => {
-    execFileCb("git", args, (error, stdout, stderr) => {
-      resolve({
-        exitCode: error ? error.code === "ENOENT" ? 127 : error.status ?? 1 : 0,
-        stdout: stdout ?? "",
-        stderr: stderr ?? ""
-      });
-    });
-  });
-}
-async function isGitRepo() {
-  const { exitCode } = await run(["rev-parse", "--is-inside-work-tree"]);
-  return exitCode === 0;
-}
-async function getCurrentBranch() {
-  const { exitCode, stdout } = await run(["rev-parse", "--abbrev-ref", "HEAD"]);
-  if (exitCode !== 0)
-    return null;
-  return stdout.trim() || null;
-}
-async function getRemotes() {
-  const { exitCode, stdout } = await run(["remote"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).map((r) => r.trim()).filter(Boolean);
-}
-async function getRemoteUrl(remote) {
-  const { exitCode, stdout } = await run(["remote", "get-url", remote]);
-  if (exitCode !== 0)
-    return null;
-  return stdout.trim() || null;
-}
-async function hasUncommittedChanges() {
-  const { exitCode, stdout } = await run(["status", "--porcelain"]);
-  if (exitCode !== 0)
-    return false;
-  return stdout.trim().length > 0;
-}
-async function fetchRemote(remote) {
-  return run(["fetch", remote]);
-}
-async function fetchAll() {
-  return run(["fetch", "--all", "--quiet"]);
-}
-async function checkoutBranch2(branch) {
-  return run(["checkout", branch]);
-}
-async function createBranch(branch, from) {
-  const args = from ? ["checkout", "-b", branch, from] : ["checkout", "-b", branch];
-  return run(args);
-}
-async function resetHard(ref) {
-  return run(["reset", "--hard", ref]);
-}
-async function updateLocalBranch(branch, target) {
-  const current = await getCurrentBranch();
-  if (current === branch) {
-    return resetHard(target);
-  }
-  return run(["branch", "-f", branch, target]);
-}
-async function pushSetUpstream(remote, branch) {
-  return run(["push", "-u", remote, branch]);
-}
-async function rebase(branch) {
-  return run(["rebase", branch]);
-}
-async function getUpstreamRef() {
-  const { exitCode, stdout } = await run([
-    "rev-parse",
-    "--abbrev-ref",
-    "--symbolic-full-name",
-    "@{u}"
-  ]);
-  if (exitCode !== 0)
-    return null;
-  return stdout.trim() || null;
-}
-async function unsetUpstream() {
-  return run(["branch", "--unset-upstream"]);
-}
-async function rebaseOnto(newBase, oldBase) {
-  return run(["rebase", "--onto", newBase, oldBase]);
-}
-async function getMergeBase(ref1, ref2) {
-  const { exitCode, stdout } = await run(["merge-base", ref1, ref2]);
-  if (exitCode !== 0)
-    return null;
-  return stdout.trim() || null;
-}
-async function getCommitHash(ref) {
-  const { exitCode, stdout } = await run(["rev-parse", ref]);
-  if (exitCode !== 0)
-    return null;
-  return stdout.trim() || null;
-}
-async function determineRebaseStrategy(currentBranch, syncRef) {
-  const upstreamRef = await getUpstreamRef();
-  if (!upstreamRef) {
-    return { strategy: "plain" };
-  }
-  const upstreamHash = await getCommitHash(upstreamRef);
-  if (!upstreamHash) {
-    return { strategy: "plain" };
-  }
-  const slashIdx = upstreamRef.indexOf("/");
-  const upstreamBranchName = slashIdx !== -1 ? upstreamRef.slice(slashIdx + 1) : upstreamRef;
-  if (upstreamBranchName === currentBranch) {
-    return { strategy: "plain" };
-  }
-  const [forkFromUpstream, forkFromSync] = await Promise.all([
-    getMergeBase("HEAD", upstreamRef),
-    getMergeBase("HEAD", syncRef)
-  ]);
-  if (forkFromUpstream && forkFromSync && forkFromUpstream === forkFromSync) {
-    return { strategy: "plain" };
-  }
-  if (forkFromUpstream) {
-    return { strategy: "onto", ontoOldBase: forkFromUpstream };
-  }
-  return { strategy: "plain" };
-}
-async function getStagedDiff() {
-  const { stdout } = await run(["diff", "--cached"]);
-  return stdout;
-}
-async function getStagedFiles() {
-  const { exitCode, stdout } = await run(["diff", "--cached", "--name-only"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).filter(Boolean);
-}
-async function getChangedFiles() {
-  const { exitCode, stdout } = await run(["status", "--porcelain"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trimEnd().split(`
-`).filter(Boolean).map((l) => {
-    const line = l.replace(/\r$/, "");
-    const match = line.match(/^..\s+(.*)/);
-    if (!match)
-      return "";
-    const file = match[1];
-    const renameIdx = file.indexOf(" -> ");
-    return renameIdx !== -1 ? file.slice(renameIdx + 4) : file;
-  }).filter(Boolean);
-}
-async function getDivergence(branch, base) {
-  const { exitCode, stdout } = await run([
-    "rev-list",
-    "--left-right",
-    "--count",
-    `${base}...${branch}`
-  ]);
-  if (exitCode !== 0)
-    return { ahead: 0, behind: 0 };
-  const parts = stdout.trim().split(/\s+/);
-  return {
-    behind: Number.parseInt(parts[0] ?? "0", 10),
-    ahead: Number.parseInt(parts[1] ?? "0", 10)
-  };
-}
-async function getMergedBranches(base) {
-  const { exitCode, stdout } = await run(["branch", "--merged", base]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).map((b) => b.replace(/^\*?\s+/, "").trim()).filter(Boolean);
-}
-async function getGoneBranches() {
-  const { exitCode, stdout } = await run(["branch", "-vv"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trimEnd().split(`
-`).filter((line) => line.includes(": gone]")).map((line) => line.replace(/^\*?\s+/, "").split(/\s+/)[0]).filter(Boolean);
-}
-async function deleteBranch(branch) {
-  return run(["branch", "-d", branch]);
-}
-async function forceDeleteBranch(branch) {
-  return run(["branch", "-D", branch]);
-}
-async function renameBranch(oldName, newName) {
-  return run(["branch", "-m", oldName, newName]);
-}
-async function hasLocalWork(remote, branch) {
-  const uncommitted = await hasUncommittedChanges();
-  const trackingRef = `${remote}/${branch}`;
-  const { exitCode, stdout } = await run(["rev-list", "--count", `${trackingRef}..${branch}`]);
-  const unpushedCommits = exitCode === 0 ? Number.parseInt(stdout.trim(), 10) || 0 : 0;
-  return { uncommitted, unpushedCommits };
-}
-async function deleteRemoteBranch(remote, branch) {
-  return run(["push", remote, "--delete", branch]);
-}
-async function mergeSquash(branch) {
-  return run(["merge", "--squash", branch]);
-}
-async function pushBranch(remote, branch) {
-  return run(["push", remote, branch]);
-}
-async function pruneRemote(remote) {
-  return run(["remote", "prune", remote]);
-}
-async function commitWithMessage(message) {
-  return run(["commit", "-m", message]);
-}
-async function getLogDiff(base, head) {
-  const { stdout } = await run(["diff", `${base}...${head}`]);
-  return stdout;
-}
-async function getLog(base, head) {
-  const { exitCode, stdout } = await run(["log", `${base}..${head}`, "--oneline"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).filter(Boolean);
-}
-async function pullBranch(remote, branch) {
-  return run(["pull", remote, branch]);
-}
-async function stageFiles(files) {
-  return run(["add", "--", ...files]);
-}
-async function unstageFiles(files) {
-  return run(["reset", "HEAD", "--", ...files]);
-}
-async function stageAll() {
-  return run(["add", "-A"]);
-}
-async function getFullDiffForFiles(files) {
-  const [unstaged, staged, untracked] = await Promise.all([
-    run(["diff", "--", ...files]),
-    run(["diff", "--cached", "--", ...files]),
-    getUntrackedFiles()
-  ]);
-  const parts = [staged.stdout, unstaged.stdout].filter(Boolean);
-  const untrackedSet = new Set(untracked);
-  const MAX_FILE_CONTENT = 2000;
-  for (const file of files) {
-    if (untrackedSet.has(file)) {
-      try {
-        const content = readFileSync2(join2(process.cwd(), file), "utf-8");
-        const truncated = content.length > MAX_FILE_CONTENT ? `${content.slice(0, MAX_FILE_CONTENT)}
-... (truncated)` : content;
-        const lines = truncated.split(`
-`).map((l) => `+${l}`);
-        parts.push(`diff --git a/${file} b/${file}
-new file
---- /dev/null
-+++ b/${file}
-${lines.join(`
-`)}`);
-      } catch {}
-    }
-  }
-  return parts.join(`
-`);
-}
-async function getUntrackedFiles() {
-  const { exitCode, stdout } = await run(["ls-files", "--others", "--exclude-standard"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).filter(Boolean);
-}
-async function getFileStatus() {
-  const { exitCode, stdout } = await run(["status", "--porcelain"]);
-  if (exitCode !== 0)
-    return { staged: [], modified: [], untracked: [] };
-  const result = { staged: [], modified: [], untracked: [] };
-  const STATUS_LABELS = {
-    A: "new file",
-    M: "modified",
-    D: "deleted",
-    R: "renamed",
-    C: "copied",
-    T: "type changed"
-  };
-  for (const raw of stdout.trimEnd().split(`
-`).filter(Boolean)) {
-    const line = raw.replace(/\r$/, "");
-    const indexStatus = line[0];
-    const workTreeStatus = line[1];
-    const pathPart = line.slice(3);
-    const renameIdx = pathPart.indexOf(" -> ");
-    const file = renameIdx !== -1 ? pathPart.slice(renameIdx + 4) : pathPart;
-    if (indexStatus === "?" && workTreeStatus === "?") {
-      result.untracked.push(file);
-      continue;
-    }
-    if (indexStatus && indexStatus !== " " && indexStatus !== "?") {
-      result.staged.push({ file, status: STATUS_LABELS[indexStatus] ?? indexStatus });
-    }
-    if (workTreeStatus && workTreeStatus !== " " && workTreeStatus !== "?") {
-      result.modified.push({ file, status: STATUS_LABELS[workTreeStatus] ?? workTreeStatus });
-    }
-  }
-  return result;
-}
-async function getLogGraph(options) {
-  const count = options?.count ?? 20;
-  const args = [
-    "log",
-    "--oneline",
-    "--graph",
-    "--decorate",
-    `--max-count=${count}`,
-    "--color=never"
-  ];
-  if (options?.all) {
-    args.push("--all");
-  }
-  if (options?.branch) {
-    args.push(options.branch);
-  }
-  const { exitCode, stdout } = await run(args);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trimEnd().split(`
-`);
-}
-async function getLogEntries(options) {
-  const count = options?.count ?? 20;
-  const args = [
-    "log",
-    `--format=%h||%s||%D`,
-    `--max-count=${count}`
-  ];
-  if (options?.all) {
-    args.push("--all");
-  }
-  if (options?.branch) {
-    args.push(options.branch);
-  }
-  const { exitCode, stdout } = await run(args);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trimEnd().split(`
-`).filter(Boolean).map((line) => {
-    const [hash = "", subject = "", refs = ""] = line.split("||");
-    return { hash: hash.trim(), subject: subject.trim(), refs: refs.trim() };
-  });
-}
-async function getLocalBranches() {
-  const { exitCode, stdout } = await run(["branch", "-vv", "--no-color"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trimEnd().split(`
-`).filter(Boolean).map((line) => {
-    const isCurrent = line.startsWith("*");
-    const trimmed = line.slice(2);
-    const nameMatch = trimmed.match(/^(\S+)/);
-    const name = nameMatch?.[1] ?? "";
-    const upstreamMatch = trimmed.match(/\[([^\]]+)\]/);
-    let upstream = null;
-    let gone = false;
-    if (upstreamMatch) {
-      const bracketContent = upstreamMatch[1];
-      gone = bracketContent.includes(": gone");
-      upstream = bracketContent.split(":")[0].trim();
-    }
-    return { name, isCurrent, upstream, gone };
-  }).filter((b) => b.name.length > 0);
-}
-async function getRemoteBranches() {
-  const { exitCode, stdout } = await run(["branch", "-r", "--no-color"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trimEnd().split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0 && !line.includes(" -> "));
-}
-
-// src/utils/logger.ts
-import { LogEngine, LogMode } from "@wgtechlabs/log-engine";
-import pc from "picocolors";
-LogEngine.configure({
-  mode: LogMode.INFO,
-  format: {
-    includeIsoTimestamp: false,
-    includeLocalTime: true,
-    includeEmoji: true
-  }
-});
-function success(msg) {
-  LogEngine.log(msg);
-}
-function error(msg) {
-  LogEngine.error(msg);
-}
-function warn(msg) {
-  LogEngine.warn(msg);
-}
-function info(msg) {
-  LogEngine.info(msg);
-}
-function heading(msg) {
-  console.log(`
-${pc.bold(msg)}`);
-}
-
-// src/utils/workflow.ts
-var WORKFLOW_DESCRIPTIONS = {
-  "clean-flow": "Clean Flow — main + dev, squash features into dev, merge dev into main",
-  "github-flow": "GitHub Flow — main + feature branches, squash/merge into main",
-  "git-flow": "Git Flow — main + develop + release + hotfix branches"
-};
-function getBaseBranch(config) {
-  switch (config.workflow) {
-    case "clean-flow":
-    case "git-flow":
-      return config.devBranch ?? "dev";
-    case "github-flow":
-      return config.mainBranch;
-  }
-}
-function hasDevBranch(workflow) {
-  return workflow === "clean-flow" || workflow === "git-flow";
-}
-function getSyncSource(config) {
-  const { workflow, role, mainBranch, origin, upstream } = config;
-  const devBranch = config.devBranch ?? "dev";
-  switch (workflow) {
-    case "clean-flow":
-      if (role === "contributor") {
-        return { remote: upstream, ref: `${upstream}/${devBranch}`, strategy: "pull" };
-      }
-      return { remote: origin, ref: `${origin}/${devBranch}`, strategy: "pull" };
-    case "github-flow":
-      if (role === "contributor") {
-        return { remote: upstream, ref: `${upstream}/${mainBranch}`, strategy: "pull" };
-      }
-      return { remote: origin, ref: `${origin}/${mainBranch}`, strategy: "pull" };
-    case "git-flow":
-      if (role === "contributor") {
-        return { remote: upstream, ref: `${upstream}/${devBranch}`, strategy: "pull" };
-      }
-      return { remote: origin, ref: `${origin}/${devBranch}`, strategy: "pull" };
-  }
-}
-function getProtectedBranches(config) {
-  const branches = [config.mainBranch];
-  if (hasDevBranch(config.workflow) && config.devBranch) {
-    branches.push(config.devBranch);
-  }
-  return branches;
-}
-
-// src/commands/branch.ts
-var branch_default = defineCommand({
-  meta: {
-    name: "branch",
-    description: "List branches with workflow-aware labels and status"
-  },
-  args: {
-    all: {
-      type: "boolean",
-      alias: "a",
-      description: "Show both local and remote branches",
-      default: false
-    },
-    remote: {
-      type: "boolean",
-      alias: "r",
-      description: "Show only remote branches",
-      default: false
-    }
-  },
-  async run({ args }) {
-    if (!await isGitRepo()) {
-      error("Not inside a git repository.");
-      process.exit(1);
-    }
-    const config = readConfig();
-    const protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
-    const currentBranch = await getCurrentBranch();
-    const showRemoteOnly = args.remote;
-    const showAll = args.all;
-    heading("\uD83C\uDF3F branches");
-    console.log();
-    if (!showRemoteOnly) {
-      const localBranches = await getLocalBranches();
-      if (localBranches.length === 0) {
-        console.log(pc2.dim("  No local branches found."));
-      } else {
-        console.log(`  ${pc2.bold("Local")}`);
-        console.log();
-        for (const branch of localBranches) {
-          const parts = [];
-          if (branch.isCurrent) {
-            parts.push(pc2.green("* "));
-          } else {
-            parts.push("  ");
-          }
-          const nameStr = colorBranchName(branch.name, protectedBranches, currentBranch);
-          parts.push(nameStr.padEnd(30));
-          if (branch.gone) {
-            parts.push(pc2.red(" ✗ remote gone"));
-          } else if (branch.upstream) {
-            parts.push(pc2.dim(` → ${branch.upstream}`));
-          } else {
-            parts.push(pc2.dim(" (no remote)"));
-          }
-          const labels = getBranchLabels(branch.name, protectedBranches, config);
-          if (labels.length > 0) {
-            parts.push(`  ${labels.join(" ")}`);
-          }
-          console.log(`  ${parts.join("")}`);
-        }
-      }
-    }
-    if (showRemoteOnly || showAll) {
-      const remoteBranches = await getRemoteBranches();
-      if (!showRemoteOnly) {
-        console.log();
-      }
-      if (remoteBranches.length === 0) {
-        console.log(pc2.dim("  No remote branches found."));
-      } else {
-        const grouped = groupByRemote(remoteBranches);
-        for (const [remote, branches] of Object.entries(grouped)) {
-          console.log(`  ${pc2.bold(`Remote: ${remote}`)}`);
-          console.log();
-          for (const fullRef of branches) {
-            const branchName = fullRef.slice(remote.length + 1);
-            const nameStr = colorBranchName(branchName, protectedBranches, currentBranch);
-            const remotePrefix = pc2.dim(`${remote}/`);
-            console.log(`    ${remotePrefix}${nameStr}`);
-          }
-          console.log();
-        }
-      }
-    }
-    const tips = [];
-    if (!showAll && !showRemoteOnly) {
-      tips.push(`Use ${pc2.bold("contrib branch -a")} to include remote branches`);
-    }
-    if (!showRemoteOnly) {
-      tips.push(`Use ${pc2.bold("contrib start")} to create a new feature branch`);
-      tips.push(`Use ${pc2.bold("contrib clean")} to remove merged/stale branches`);
-    }
-    if (tips.length > 0) {
-      console.log(`  ${pc2.dim("\uD83D\uDCA1 Tip:")}`);
-      for (const tip of tips) {
-        console.log(`     ${pc2.dim(tip)}`);
-      }
-    }
-    console.log();
-  }
-});
-function colorBranchName(name, protectedBranches, currentBranch) {
-  if (name === currentBranch) {
-    return pc2.bold(pc2.green(name));
-  }
-  if (protectedBranches.includes(name)) {
-    return pc2.bold(pc2.red(name));
-  }
-  return name;
-}
-function getBranchLabels(name, protectedBranches, config) {
-  const labels = [];
-  if (protectedBranches.includes(name)) {
-    labels.push(pc2.dim(pc2.red("[protected]")));
-  }
-  if (config) {
-    if (name === config.mainBranch) {
-      labels.push(pc2.dim(pc2.cyan("[main]")));
-    }
-    if (config.devBranch && name === config.devBranch) {
-      labels.push(pc2.dim(pc2.cyan("[dev]")));
-    }
-  }
-  return labels;
-}
-function groupByRemote(branches) {
-  const grouped = {};
-  for (const ref of branches) {
-    const slashIdx = ref.indexOf("/");
-    const remote = slashIdx !== -1 ? ref.slice(0, slashIdx) : "unknown";
-    if (!grouped[remote]) {
-      grouped[remote] = [];
-    }
-    grouped[remote].push(ref);
-  }
-  return grouped;
-}
-
-// src/commands/clean.ts
-import { defineCommand as defineCommand2 } from "citty";
-import pc5 from "picocolors";
-
-// src/utils/branch.ts
-var DEFAULT_PREFIXES = ["feature", "fix", "docs", "chore", "test", "refactor"];
-function hasPrefix(branchName, prefixes = DEFAULT_PREFIXES) {
-  return prefixes.some((p) => branchName.startsWith(`${p}/`));
-}
-function formatBranchName(prefix, name) {
-  const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return `${prefix}/${sanitized}`;
-}
-function isValidBranchName(name) {
-  return /^[a-zA-Z0-9._/-]+$/.test(name) && !name.startsWith("/") && !name.endsWith("/");
-}
-function looksLikeNaturalLanguage(input) {
-  return input.includes(" ") && !input.includes("/");
-}
-
 // src/utils/confirm.ts
 import * as clack from "@clack/prompts";
-import pc3 from "picocolors";
+import pc from "picocolors";
 function handleCancel(value) {
   if (clack.isCancel(value)) {
     clack.cancel("Cancelled.");
@@ -711,7 +113,7 @@ async function inputPrompt(message, defaultValue) {
 }
 async function multiSelectPrompt(message, choices) {
   const result = await clack.multiselect({
-    message: `${message} ${pc3.dim("(space to toggle, enter to confirm)")}`,
+    message: `${message} ${pc.dim("(space to toggle, enter to confirm)")}`,
     options: choices.map((choice) => ({ value: choice, label: choice })),
     required: false
   });
@@ -1030,12 +432,12 @@ ${diffs.slice(0, 4000)}`;
 }
 
 // src/utils/gh.ts
-import { execFile as execFileCb2 } from "node:child_process";
-function run2(args) {
+import { execFile as execFileCb } from "node:child_process";
+function run(args) {
   return new Promise((resolve) => {
-    execFileCb2("gh", args, (error2, stdout, stderr) => {
+    execFileCb("gh", args, (error, stdout, stderr) => {
       resolve({
-        exitCode: error2 ? error2.code === "ENOENT" ? 127 : error2.status ?? 1 : 0,
+        exitCode: error ? error.code === "ENOENT" ? 127 : error.status ?? 1 : 0,
         stdout: stdout ?? "",
         stderr: stderr ?? ""
       });
@@ -1044,7 +446,7 @@ function run2(args) {
 }
 async function checkGhInstalled() {
   try {
-    const { exitCode } = await run2(["--version"]);
+    const { exitCode } = await run(["--version"]);
     return exitCode === 0;
   } catch {
     return false;
@@ -1052,7 +454,7 @@ async function checkGhInstalled() {
 }
 async function checkGhAuth() {
   try {
-    const { exitCode } = await run2(["auth", "status"]);
+    const { exitCode } = await run(["auth", "status"]);
     return exitCode === 0;
   } catch {
     return false;
@@ -1062,7 +464,7 @@ var SAFE_SLUG = /^[\w.-]+$/;
 async function checkRepoPermissions(owner, repo) {
   if (!SAFE_SLUG.test(owner) || !SAFE_SLUG.test(repo))
     return null;
-  const { exitCode, stdout } = await run2(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
+  const { exitCode, stdout } = await run(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
   if (exitCode !== 0)
     return null;
   try {
@@ -1072,7 +474,7 @@ async function checkRepoPermissions(owner, repo) {
   }
 }
 async function isRepoFork() {
-  const { exitCode, stdout } = await run2(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
+  const { exitCode, stdout } = await run(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
   if (exitCode !== 0)
     return null;
   const val = stdout.trim();
@@ -1083,7 +485,7 @@ async function isRepoFork() {
   return null;
 }
 async function getCurrentRepoInfo() {
-  const { exitCode, stdout } = await run2([
+  const { exitCode, stdout } = await run([
     "repo",
     "view",
     "--json",
@@ -1114,16 +516,16 @@ async function createPR(options) {
   ];
   if (options.draft)
     args.push("--draft");
-  return run2(args);
+  return run(args);
 }
 async function createPRFill(base, draft) {
   const args = ["pr", "create", "--base", base, "--fill"];
   if (draft)
     args.push("--draft");
-  return run2(args);
+  return run(args);
 }
 async function getPRForBranch(headBranch) {
-  const { exitCode, stdout } = await run2([
+  const { exitCode, stdout } = await run([
     "pr",
     "list",
     "--head",
@@ -1144,31 +546,367 @@ async function getPRForBranch(headBranch) {
     return null;
   }
 }
-async function getMergedPRForBranch(headBranch) {
-  const { exitCode, stdout } = await run2([
-    "pr",
-    "list",
-    "--head",
-    headBranch,
-    "--state",
-    "merged",
-    "--json",
-    "number,url,title,state",
-    "--limit",
-    "1"
-  ]);
+async function getMergedPRForBranch(headBranch) {
+  const { exitCode, stdout } = await run([
+    "pr",
+    "list",
+    "--head",
+    headBranch,
+    "--state",
+    "merged",
+    "--json",
+    "number,url,title,state",
+    "--limit",
+    "1"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    const prs = JSON.parse(stdout.trim());
+    return prs.length > 0 ? prs[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/git.ts
+import { execFile as execFileCb2 } from "node:child_process";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function run2(args) {
+  return new Promise((resolve) => {
+    execFileCb2("git", args, (error, stdout, stderr) => {
+      resolve({
+        exitCode: error ? error.code === "ENOENT" ? 127 : error.status ?? 1 : 0,
+        stdout: stdout ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
+}
+async function isGitRepo() {
+  const { exitCode } = await run2(["rev-parse", "--is-inside-work-tree"]);
+  return exitCode === 0;
+}
+async function getCurrentBranch() {
+  const { exitCode, stdout } = await run2(["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function getRemotes() {
+  const { exitCode, stdout } = await run2(["remote"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).map((r) => r.trim()).filter(Boolean);
+}
+async function getRemoteUrl(remote) {
+  const { exitCode, stdout } = await run2(["remote", "get-url", remote]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function hasUncommittedChanges() {
+  const { exitCode, stdout } = await run2(["status", "--porcelain"]);
+  if (exitCode !== 0)
+    return false;
+  return stdout.trim().length > 0;
+}
+async function fetchRemote(remote) {
+  return run2(["fetch", remote]);
+}
+async function fetchAll() {
+  return run2(["fetch", "--all", "--quiet"]);
+}
+async function checkoutBranch2(branch) {
+  return run2(["checkout", branch]);
+}
+async function createBranch(branch, from) {
+  const args = from ? ["checkout", "-b", branch, from] : ["checkout", "-b", branch];
+  return run2(args);
+}
+async function resetHard(ref) {
+  return run2(["reset", "--hard", ref]);
+}
+async function updateLocalBranch(branch, target) {
+  const current = await getCurrentBranch();
+  if (current === branch) {
+    return resetHard(target);
+  }
+  return run2(["branch", "-f", branch, target]);
+}
+async function pushSetUpstream(remote, branch) {
+  return run2(["push", "-u", remote, branch]);
+}
+async function rebase(branch) {
+  return run2(["rebase", branch]);
+}
+async function getUpstreamRef() {
+  const { exitCode, stdout } = await run2([
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{u}"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function unsetUpstream() {
+  return run2(["branch", "--unset-upstream"]);
+}
+async function rebaseOnto(newBase, oldBase) {
+  return run2(["rebase", "--onto", newBase, oldBase]);
+}
+async function getMergeBase(ref1, ref2) {
+  const { exitCode, stdout } = await run2(["merge-base", ref1, ref2]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function getCommitHash(ref) {
+  const { exitCode, stdout } = await run2(["rev-parse", ref]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function determineRebaseStrategy(currentBranch, syncRef) {
+  const upstreamRef = await getUpstreamRef();
+  if (!upstreamRef) {
+    return { strategy: "plain" };
+  }
+  const upstreamHash = await getCommitHash(upstreamRef);
+  if (!upstreamHash) {
+    return { strategy: "plain" };
+  }
+  const slashIdx = upstreamRef.indexOf("/");
+  const upstreamBranchName = slashIdx !== -1 ? upstreamRef.slice(slashIdx + 1) : upstreamRef;
+  if (upstreamBranchName === currentBranch) {
+    return { strategy: "plain" };
+  }
+  const [forkFromUpstream, forkFromSync] = await Promise.all([
+    getMergeBase("HEAD", upstreamRef),
+    getMergeBase("HEAD", syncRef)
+  ]);
+  if (forkFromUpstream && forkFromSync && forkFromUpstream === forkFromSync) {
+    return { strategy: "plain" };
+  }
+  if (forkFromUpstream) {
+    return { strategy: "onto", ontoOldBase: forkFromUpstream };
+  }
+  return { strategy: "plain" };
+}
+async function getStagedDiff() {
+  const { stdout } = await run2(["diff", "--cached"]);
+  return stdout;
+}
+async function getStagedFiles() {
+  const { exitCode, stdout } = await run2(["diff", "--cached", "--name-only"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).filter(Boolean);
+}
+async function getChangedFiles() {
+  const { exitCode, stdout } = await run2(["status", "--porcelain"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter(Boolean).map((l) => {
+    const line = l.replace(/\r$/, "");
+    const match = line.match(/^..\s+(.*)/);
+    if (!match)
+      return "";
+    const file = match[1];
+    const renameIdx = file.indexOf(" -> ");
+    return renameIdx !== -1 ? file.slice(renameIdx + 4) : file;
+  }).filter(Boolean);
+}
+async function getDivergence(branch, base) {
+  const { exitCode, stdout } = await run2([
+    "rev-list",
+    "--left-right",
+    "--count",
+    `${base}...${branch}`
+  ]);
+  if (exitCode !== 0)
+    return { ahead: 0, behind: 0 };
+  const parts = stdout.trim().split(/\s+/);
+  return {
+    behind: Number.parseInt(parts[0] ?? "0", 10),
+    ahead: Number.parseInt(parts[1] ?? "0", 10)
+  };
+}
+async function getMergedBranches(base) {
+  const { exitCode, stdout } = await run2(["branch", "--merged", base]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).map((b) => b.replace(/^\*?\s+/, "").trim()).filter(Boolean);
+}
+async function getGoneBranches() {
+  const { exitCode, stdout } = await run2(["branch", "-vv"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter((line) => line.includes(": gone]")).map((line) => line.replace(/^\*?\s+/, "").split(/\s+/)[0]).filter(Boolean);
+}
+async function deleteBranch(branch) {
+  return run2(["branch", "-d", branch]);
+}
+async function forceDeleteBranch(branch) {
+  return run2(["branch", "-D", branch]);
+}
+async function renameBranch(oldName, newName) {
+  return run2(["branch", "-m", oldName, newName]);
+}
+async function hasLocalWork(remote, branch) {
+  const uncommitted = await hasUncommittedChanges();
+  const trackingRef = `${remote}/${branch}`;
+  const { exitCode, stdout } = await run2(["rev-list", "--count", `${trackingRef}..${branch}`]);
+  const unpushedCommits = exitCode === 0 ? Number.parseInt(stdout.trim(), 10) || 0 : 0;
+  return { uncommitted, unpushedCommits };
+}
+async function deleteRemoteBranch(remote, branch) {
+  return run2(["push", remote, "--delete", branch]);
+}
+async function mergeSquash(branch) {
+  return run2(["merge", "--squash", branch]);
+}
+async function pushBranch(remote, branch) {
+  return run2(["push", remote, branch]);
+}
+async function pruneRemote(remote) {
+  return run2(["remote", "prune", remote]);
+}
+async function commitWithMessage(message) {
+  return run2(["commit", "-m", message]);
+}
+async function getLogDiff(base, head) {
+  const { stdout } = await run2(["diff", `${base}...${head}`]);
+  return stdout;
+}
+async function getLog(base, head) {
+  const { exitCode, stdout } = await run2(["log", `${base}..${head}`, "--oneline"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).filter(Boolean);
+}
+async function pullBranch(remote, branch) {
+  return run2(["pull", remote, branch]);
+}
+async function stageFiles(files) {
+  return run2(["add", "--", ...files]);
+}
+async function unstageFiles(files) {
+  return run2(["reset", "HEAD", "--", ...files]);
+}
+async function stageAll() {
+  return run2(["add", "-A"]);
+}
+async function getFullDiffForFiles(files) {
+  const [unstaged, staged, untracked] = await Promise.all([
+    run2(["diff", "--", ...files]),
+    run2(["diff", "--cached", "--", ...files]),
+    getUntrackedFiles()
+  ]);
+  const parts = [staged.stdout, unstaged.stdout].filter(Boolean);
+  const untrackedSet = new Set(untracked);
+  const MAX_FILE_CONTENT = 2000;
+  for (const file of files) {
+    if (untrackedSet.has(file)) {
+      try {
+        const content = readFileSync2(join2(process.cwd(), file), "utf-8");
+        const truncated = content.length > MAX_FILE_CONTENT ? `${content.slice(0, MAX_FILE_CONTENT)}
+... (truncated)` : content;
+        const lines = truncated.split(`
+`).map((l) => `+${l}`);
+        parts.push(`diff --git a/${file} b/${file}
+new file
+--- /dev/null
++++ b/${file}
+${lines.join(`
+`)}`);
+      } catch {}
+    }
+  }
+  return parts.join(`
+`);
+}
+async function getUntrackedFiles() {
+  const { exitCode, stdout } = await run2(["ls-files", "--others", "--exclude-standard"]);
   if (exitCode !== 0)
-    return null;
-  try {
-    const prs = JSON.parse(stdout.trim());
-    return prs.length > 0 ? prs[0] : null;
-  } catch {
-    return null;
+    return [];
+  return stdout.trim().split(`
+`).filter(Boolean);
+}
+async function getFileStatus() {
+  const { exitCode, stdout } = await run2(["status", "--porcelain"]);
+  if (exitCode !== 0)
+    return { staged: [], modified: [], untracked: [] };
+  const result = { staged: [], modified: [], untracked: [] };
+  const STATUS_LABELS = {
+    A: "new file",
+    M: "modified",
+    D: "deleted",
+    R: "renamed",
+    C: "copied",
+    T: "type changed"
+  };
+  for (const raw of stdout.trimEnd().split(`
+`).filter(Boolean)) {
+    const line = raw.replace(/\r$/, "");
+    const indexStatus = line[0];
+    const workTreeStatus = line[1];
+    const pathPart = line.slice(3);
+    const renameIdx = pathPart.indexOf(" -> ");
+    const file = renameIdx !== -1 ? pathPart.slice(renameIdx + 4) : pathPart;
+    if (indexStatus === "?" && workTreeStatus === "?") {
+      result.untracked.push(file);
+      continue;
+    }
+    if (indexStatus && indexStatus !== " " && indexStatus !== "?") {
+      result.staged.push({ file, status: STATUS_LABELS[indexStatus] ?? indexStatus });
+    }
+    if (workTreeStatus && workTreeStatus !== " " && workTreeStatus !== "?") {
+      result.modified.push({ file, status: STATUS_LABELS[workTreeStatus] ?? workTreeStatus });
+    }
+  }
+  return result;
+}
+
+// src/utils/logger.ts
+import { LogEngine, LogMode } from "@wgtechlabs/log-engine";
+import pc2 from "picocolors";
+LogEngine.configure({
+  mode: LogMode.INFO,
+  format: {
+    includeIsoTimestamp: false,
+    includeLocalTime: true,
+    includeEmoji: true
   }
+});
+function success(msg) {
+  LogEngine.log(msg);
+}
+function error(msg) {
+  LogEngine.error(msg);
+}
+function warn(msg) {
+  LogEngine.warn(msg);
+}
+function info(msg) {
+  LogEngine.info(msg);
+}
+function heading(msg) {
+  console.log(`
+${pc2.bold(msg)}`);
 }
 
 // src/utils/spinner.ts
-import pc4 from "picocolors";
+import pc3 from "picocolors";
 var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 function createSpinner(text2) {
   let frameIdx = 0;
@@ -1180,7 +918,7 @@ function createSpinner(text2) {
   const render = () => {
     if (stopped)
       return;
-    const frame = pc4.cyan(FRAMES[frameIdx % FRAMES.length]);
+    const frame = pc3.cyan(FRAMES[frameIdx % FRAMES.length]);
     clearLine();
     process.stderr.write(`${frame} ${currentText}`);
     frameIdx++;
@@ -1200,12 +938,12 @@ function createSpinner(text2) {
     },
     success(msg) {
       stop();
-      process.stderr.write(`${pc4.green("✔")} ${msg}
+      process.stderr.write(`${pc3.green("✔")} ${msg}
 `);
     },
     fail(msg) {
       stop();
-      process.stderr.write(`${pc4.red("✖")} ${msg}
+      process.stderr.write(`${pc3.red("✖")} ${msg}
 `);
     },
     stop() {
@@ -1214,6 +952,53 @@ function createSpinner(text2) {
   };
 }
 
+// src/utils/workflow.ts
+var WORKFLOW_DESCRIPTIONS = {
+  "clean-flow": "Clean Flow — main + dev, squash features into dev, merge dev into main",
+  "github-flow": "GitHub Flow — main + feature branches, squash/merge into main",
+  "git-flow": "Git Flow — main + develop + release + hotfix branches"
+};
+function getBaseBranch(config) {
+  switch (config.workflow) {
+    case "clean-flow":
+    case "git-flow":
+      return config.devBranch ?? "dev";
+    case "github-flow":
+      return config.mainBranch;
+  }
+}
+function hasDevBranch(workflow) {
+  return workflow === "clean-flow" || workflow === "git-flow";
+}
+function getSyncSource(config) {
+  const { workflow, role, mainBranch, origin, upstream } = config;
+  const devBranch = config.devBranch ?? "dev";
+  switch (workflow) {
+    case "clean-flow":
+      if (role === "contributor") {
+        return { remote: upstream, ref: `${upstream}/${devBranch}`, strategy: "pull" };
+      }
+      return { remote: origin, ref: `${origin}/${devBranch}`, strategy: "pull" };
+    case "github-flow":
+      if (role === "contributor") {
+        return { remote: upstream, ref: `${upstream}/${mainBranch}`, strategy: "pull" };
+      }
+      return { remote: origin, ref: `${origin}/${mainBranch}`, strategy: "pull" };
+    case "git-flow":
+      if (role === "contributor") {
+        return { remote: upstream, ref: `${upstream}/${devBranch}`, strategy: "pull" };
+      }
+      return { remote: origin, ref: `${origin}/${devBranch}`, strategy: "pull" };
+  }
+}
+function getProtectedBranches(config) {
+  const branches = [config.mainBranch];
+  if (hasDevBranch(config.workflow) && config.devBranch) {
+    branches.push(config.devBranch);
+  }
+  return branches;
+}
+
 // src/commands/clean.ts
 async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
   if (!config)
@@ -1226,18 +1011,18 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
       warn("You have uncommitted changes in your working tree.");
     }
     if (localWork.unpushedCommits > 0) {
-      warn(`You have ${pc5.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not pushed.`);
+      warn(`You have ${pc4.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not pushed.`);
     }
     const SAVE_NEW_BRANCH = "Save changes to a new branch";
     const DISCARD = "Discard all changes and clean up";
     const CANCEL = "Skip this branch";
-    const action = await selectPrompt(`${pc5.bold(currentBranch)} has local changes. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
+    const action = await selectPrompt(`${pc4.bold(currentBranch)} has local changes. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
     if (action === CANCEL)
       return "skipped";
     if (action === SAVE_NEW_BRANCH) {
       if (!config)
         return "skipped";
-      info(pc5.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
+      info(pc4.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
       const description = await inputPrompt("What are you working on?");
       let newBranchName = description;
       if (looksLikeNaturalLanguage(description)) {
@@ -1246,8 +1031,8 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
         if (suggested) {
           spinner.success("Branch name suggestion ready.");
           console.log(`
-  ${pc5.dim("AI suggestion:")} ${pc5.bold(pc5.cyan(suggested))}`);
-          const accepted = await confirmPrompt(`Use ${pc5.bold(suggested)} as your branch name?`);
+  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(suggested))}`);
+          const accepted = await confirmPrompt(`Use ${pc4.bold(suggested)} as your branch name?`);
           newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
         } else {
           spinner.fail("AI did not return a suggestion.");
@@ -1255,7 +1040,7 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
         }
       }
       if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-        const prefix = await selectPrompt(`Choose a branch type for ${pc5.bold(newBranchName)}:`, config.branchPrefixes);
+        const prefix = await selectPrompt(`Choose a branch type for ${pc4.bold(newBranchName)}:`, config.branchPrefixes);
         newBranchName = formatBranchName(prefix, newBranchName);
       }
       if (!isValidBranchName(newBranchName)) {
@@ -1267,16 +1052,16 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
         error(`Failed to rename branch: ${renameResult.stderr}`);
         return "skipped";
       }
-      success(`Renamed ${pc5.bold(currentBranch)} → ${pc5.bold(newBranchName)}`);
+      success(`Renamed ${pc4.bold(currentBranch)} → ${pc4.bold(newBranchName)}`);
       const syncSource2 = getSyncSource(config);
       await fetchRemote(syncSource2.remote);
       const savedUpstreamRef = await getUpstreamRef();
       const rebaseResult = savedUpstreamRef && savedUpstreamRef !== syncSource2.ref ? await rebaseOnto(syncSource2.ref, savedUpstreamRef) : await rebase(syncSource2.ref);
       if (rebaseResult.exitCode !== 0) {
         warn("Rebase encountered conflicts. Resolve them after cleanup:");
-        info(`  ${pc5.bold(`git checkout ${newBranchName} && git rebase --continue`)}`);
+        info(`  ${pc4.bold(`git checkout ${newBranchName} && git rebase --continue`)}`);
       } else {
-        success(`Rebased ${pc5.bold(newBranchName)} onto ${pc5.bold(syncSource2.ref)}.`);
+        success(`Rebased ${pc4.bold(newBranchName)} onto ${pc4.bold(syncSource2.ref)}.`);
       }
       const coResult2 = await checkoutBranch(baseBranch);
       if (coResult2.exitCode !== 0) {
@@ -1284,12 +1069,12 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
         return "saved";
       }
       await updateLocalBranch(baseBranch, syncSource2.ref);
-      success(`Synced ${pc5.bold(baseBranch)} with ${pc5.bold(syncSource2.ref)}.`);
+      success(`Synced ${pc4.bold(baseBranch)} with ${pc4.bold(syncSource2.ref)}.`);
       return "saved";
     }
   }
   const syncSource = getSyncSource(config);
-  info(`Switching to ${pc5.bold(baseBranch)} and syncing...`);
+  info(`Switching to ${pc4.bold(baseBranch)} and syncing...`);
   await fetchRemote(syncSource.remote);
   const coResult = await checkoutBranch(baseBranch);
   if (coResult.exitCode !== 0) {
@@ -1297,10 +1082,10 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
     return "skipped";
   }
   await updateLocalBranch(baseBranch, syncSource.ref);
-  success(`Synced ${pc5.bold(baseBranch)} with ${pc5.bold(syncSource.ref)}.`);
+  success(`Synced ${pc4.bold(baseBranch)} with ${pc4.bold(syncSource.ref)}.`);
   return "switched";
 }
-var clean_default = defineCommand2({
+var clean_default = defineCommand({
   meta: {
     name: "clean",
     description: "Delete merged branches and prune remote refs"
@@ -1345,21 +1130,21 @@ var clean_default = defineCommand2({
       if (ghInstalled && ghAuthed) {
         const mergedPR = await getMergedPRForBranch(currentBranch);
         if (mergedPR) {
-          warn(`PR #${mergedPR.number} (${pc5.bold(mergedPR.title)}) has already been merged.`);
-          info(`Link: ${pc5.underline(mergedPR.url)}`);
+          warn(`PR #${mergedPR.number} (${pc4.bold(mergedPR.title)}) has already been merged.`);
+          info(`Link: ${pc4.underline(mergedPR.url)}`);
           goneCandidates.push(currentBranch);
         }
       }
     }
     if (mergedCandidates.length > 0) {
       console.log(`
-${pc5.bold("Merged branches to delete:")}`);
+${pc4.bold("Merged branches to delete:")}`);
       for (const b of mergedCandidates) {
-        const marker = b === currentBranch ? pc5.yellow(" (current)") : "";
-        console.log(`  ${pc5.dim("•")} ${b}${marker}`);
+        const marker = b === currentBranch ? pc4.yellow(" (current)") : "";
+        console.log(`  ${pc4.dim("•")} ${b}${marker}`);
       }
       console.log();
-      const ok = args.yes || await confirmPrompt(`Delete ${pc5.bold(String(mergedCandidates.length))} merged branch${mergedCandidates.length !== 1 ? "es" : ""}?`);
+      const ok = args.yes || await confirmPrompt(`Delete ${pc4.bold(String(mergedCandidates.length))} merged branch${mergedCandidates.length !== 1 ? "es" : ""}?`);
       if (ok) {
         for (const branch of mergedCandidates) {
           if (branch === currentBranch) {
@@ -1376,7 +1161,7 @@ ${pc5.bold("Merged branches to delete:")}`);
           }
           const result = await deleteBranch(branch);
           if (result.exitCode === 0) {
-            success(`  Deleted ${pc5.bold(branch)}`);
+            success(`  Deleted ${pc4.bold(branch)}`);
           } else {
             warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
           }
@@ -1387,13 +1172,13 @@ ${pc5.bold("Merged branches to delete:")}`);
     }
     if (goneCandidates.length > 0) {
       console.log(`
-${pc5.bold("Stale branches (remote deleted, likely squash-merged):")}`);
+${pc4.bold("Stale branches (remote deleted, likely squash-merged):")}`);
       for (const b of goneCandidates) {
-        const marker = b === currentBranch ? pc5.yellow(" (current)") : "";
-        console.log(`  ${pc5.dim("•")} ${b}${marker}`);
+        const marker = b === currentBranch ? pc4.yellow(" (current)") : "";
+        console.log(`  ${pc4.dim("•")} ${b}${marker}`);
       }
       console.log();
-      const ok = args.yes || await confirmPrompt(`Delete ${pc5.bold(String(goneCandidates.length))} stale branch${goneCandidates.length !== 1 ? "es" : ""}?`);
+      const ok = args.yes || await confirmPrompt(`Delete ${pc4.bold(String(goneCandidates.length))} stale branch${goneCandidates.length !== 1 ? "es" : ""}?`);
       if (ok) {
         for (const branch of goneCandidates) {
           if (branch === currentBranch) {
@@ -1410,7 +1195,7 @@ ${pc5.bold("Stale branches (remote deleted, likely squash-merged):")}`);
           }
           const result = await forceDeleteBranch(branch);
           if (result.exitCode === 0) {
-            success(`  Deleted ${pc5.bold(branch)}`);
+            success(`  Deleted ${pc4.bold(branch)}`);
           } else {
             warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
           }
@@ -1425,14 +1210,14 @@ ${pc5.bold("Stale branches (remote deleted, likely squash-merged):")}`);
     const finalBranch = await getCurrentBranch();
     if (finalBranch && protectedBranches.has(finalBranch)) {
       console.log();
-      info(`You're on ${pc5.bold(finalBranch)}. Run ${pc5.bold("contrib start")} to begin a new feature.`);
+      info(`You're on ${pc4.bold(finalBranch)}. Run ${pc4.bold("contrib start")} to begin a new feature.`);
     }
   }
 });
 
 // src/commands/commit.ts
-import { defineCommand as defineCommand3 } from "citty";
-import pc6 from "picocolors";
+import { defineCommand as defineCommand2 } from "citty";
+import pc5 from "picocolors";
 
 // src/utils/convention.ts
 var CLEAN_COMMIT_PATTERN = /^(📦|🔧|🗑\uFE0F?|🔒|⚙\uFE0F?|☕|🧪|📖|🚀) (new|update|remove|security|setup|chore|test|docs|release)(!?)( \([a-zA-Z0-9][a-zA-Z0-9-]*\))?: .{1,72}$/u;
@@ -1478,7 +1263,7 @@ function getValidationError(convention) {
 }
 
 // src/commands/commit.ts
-var commit_default = defineCommand3({
+var commit_default = defineCommand2({
   meta: {
     name: "commit",
     description: "Stage changes and create a commit message (AI-powered)"
@@ -1522,9 +1307,9 @@ var commit_default = defineCommand3({
         process.exit(1);
       }
       console.log(`
-${pc6.bold("Changed files:")}`);
+${pc5.bold("Changed files:")}`);
       for (const f of changedFiles) {
-        console.log(`  ${pc6.dim("•")} ${f}`);
+        console.log(`  ${pc5.dim("•")} ${f}`);
       }
       const stageAction = await selectPrompt("No staged changes. How would you like to stage?", [
         "Stage all changes",
@@ -1574,7 +1359,7 @@ ${pc6.bold("Changed files:")}`);
         if (commitMessage) {
           spinner.success("AI commit message generated.");
           console.log(`
-  ${pc6.dim("AI suggestion:")} ${pc6.bold(pc6.cyan(commitMessage))}`);
+  ${pc5.dim("AI suggestion:")} ${pc5.bold(pc5.cyan(commitMessage))}`);
         } else {
           spinner.fail("AI did not return a commit message.");
           warn("Falling back to manual entry.");
@@ -1600,7 +1385,7 @@ ${pc6.bold("Changed files:")}`);
         if (regen) {
           spinner.success("Commit message regenerated.");
           console.log(`
-  ${pc6.dim("AI suggestion:")} ${pc6.bold(pc6.cyan(regen))}`);
+  ${pc5.dim("AI suggestion:")} ${pc5.bold(pc5.cyan(regen))}`);
           const ok = await confirmPrompt("Use this message?");
           finalMessage = ok ? regen : await inputPrompt("Enter commit message manually");
         } else {
@@ -1615,7 +1400,7 @@ ${pc6.bold("Changed files:")}`);
       if (convention2 !== "none") {
         console.log();
         for (const hint of CONVENTION_FORMAT_HINTS[convention2]) {
-          console.log(pc6.dim(hint));
+          console.log(pc5.dim(hint));
         }
         console.log();
       }
@@ -1639,7 +1424,7 @@ ${pc6.bold("Changed files:")}`);
       error(`Failed to commit: ${result.stderr}`);
       process.exit(1);
     }
-    success(`✅ Committed: ${pc6.bold(finalMessage)}`);
+    success(`✅ Committed: ${pc5.bold(finalMessage)}`);
   }
 });
 async function runGroupCommit(model, config) {
@@ -1656,9 +1441,9 @@ async function runGroupCommit(model, config) {
     process.exit(1);
   }
   console.log(`
-${pc6.bold("Changed files:")}`);
+${pc5.bold("Changed files:")}`);
   for (const f of changedFiles) {
-    console.log(`  ${pc6.dim("•")} ${f}`);
+    console.log(`  ${pc5.dim("•")} ${f}`);
   }
   const spinner = createSpinner(`Asking AI to group ${changedFiles.length} file(s) into logical commits...`);
   const diffs = await getFullDiffForFiles(changedFiles);
@@ -1696,13 +1481,13 @@ ${pc6.bold("Changed files:")}`);
   let commitAll = false;
   while (!proceedToCommit) {
     console.log(`
-${pc6.bold(`AI suggested ${validGroups.length} commit group(s):`)}
+${pc5.bold(`AI suggested ${validGroups.length} commit group(s):`)}
 `);
     for (let i = 0;i < validGroups.length; i++) {
       const g = validGroups[i];
-      console.log(`  ${pc6.cyan(`Group ${i + 1}:`)} ${pc6.bold(g.message)}`);
+      console.log(`  ${pc5.cyan(`Group ${i + 1}:`)} ${pc5.bold(g.message)}`);
       for (const f of g.files) {
-        console.log(`    ${pc6.dim("•")} ${f}`);
+        console.log(`    ${pc5.dim("•")} ${f}`);
       }
       console.log();
     }
@@ -1746,16 +1531,16 @@ ${pc6.bold(`AI suggested ${validGroups.length} commit group(s):`)}
         continue;
       }
       committed++;
-      success(`✅ Committed group ${i + 1}: ${pc6.bold(group.message)}`);
+      success(`✅ Committed group ${i + 1}: ${pc5.bold(group.message)}`);
     }
   } else {
     for (let i = 0;i < validGroups.length; i++) {
       const group = validGroups[i];
-      console.log(pc6.bold(`
+      console.log(pc5.bold(`
 ── Group ${i + 1}/${validGroups.length} ──`));
-      console.log(`  ${pc6.cyan(group.message)}`);
+      console.log(`  ${pc5.cyan(group.message)}`);
       for (const f of group.files) {
-        console.log(`  ${pc6.dim("•")} ${f}`);
+        console.log(`  ${pc5.dim("•")} ${f}`);
       }
       let message = group.message;
       let actionDone = false;
@@ -1777,7 +1562,7 @@ ${pc6.bold(`AI suggested ${validGroups.length} commit group(s):`)}
           if (newMsg) {
             message = newMsg;
             group.message = newMsg;
-            regenSpinner.success(`New message: ${pc6.bold(message)}`);
+            regenSpinner.success(`New message: ${pc5.bold(message)}`);
           } else {
             regenSpinner.fail("AI could not generate a new message. Keeping current one.");
           }
@@ -1817,7 +1602,7 @@ ${pc6.bold(`AI suggested ${validGroups.length} commit group(s):`)}
           continue;
         }
         committed++;
-        success(`✅ Committed group ${i + 1}: ${pc6.bold(message)}`);
+        success(`✅ Committed group ${i + 1}: ${pc5.bold(message)}`);
         actionDone = true;
       }
     }
@@ -1833,12 +1618,12 @@ ${pc6.bold(`AI suggested ${validGroups.length} commit group(s):`)}
 
 // src/commands/doctor.ts
 import { execFile as execFileCb3 } from "node:child_process";
-import { defineCommand as defineCommand4 } from "citty";
-import pc7 from "picocolors";
+import { defineCommand as defineCommand3 } from "citty";
+import pc6 from "picocolors";
 // package.json
 var package_default = {
   name: "contribute-now",
-  version: "0.2.0-dev.2621ffa",
+  version: "0.2.0-dev.69b11fd",
   description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
   type: "module",
   bin: {
@@ -1927,16 +1712,16 @@ async function getRepoInfoFromRemote(remote = "origin") {
 }
 
 // src/commands/doctor.ts
-var PASS = `  ${pc7.green("✔")} `;
-var FAIL = `  ${pc7.red("✗")} `;
-var WARN = `  ${pc7.yellow("⚠")} `;
+var PASS = `  ${pc6.green("✔")} `;
+var FAIL = `  ${pc6.red("✗")} `;
+var WARN = `  ${pc6.yellow("⚠")} `;
 function printReport(report) {
   for (const section of report.sections) {
     console.log(`
-  ${pc7.bold(pc7.underline(section.title))}`);
+  ${pc6.bold(pc6.underline(section.title))}`);
     for (const check of section.checks) {
       const prefix = check.ok ? check.warning ? WARN : PASS : FAIL;
-      const text2 = check.detail ? `${check.label} ${pc7.dim(`— ${check.detail}`)}` : check.label;
+      const text2 = check.detail ? `${check.label} ${pc6.dim(`— ${check.detail}`)}` : check.label;
       console.log(`${prefix}${text2}`);
     }
   }
@@ -2144,7 +1929,7 @@ function envSection() {
   }
   return { title: "Environment", checks };
 }
-var doctor_default = defineCommand4({
+var doctor_default = defineCommand3({
   meta: {
     name: "doctor",
     description: "Diagnose the contribute-now CLI environment and configuration"
@@ -2180,14 +1965,14 @@ var doctor_default = defineCommand4({
     const failures = total.filter((c) => !c.ok);
     const warnings = total.filter((c) => c.ok && c.warning);
     if (failures.length === 0 && warnings.length === 0) {
-      console.log(`  ${pc7.green("All checks passed!")} No issues detected.
+      console.log(`  ${pc6.green("All checks passed!")} No issues detected.
 `);
     } else {
       if (failures.length > 0) {
-        console.log(`  ${pc7.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
+        console.log(`  ${pc6.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
       }
       if (warnings.length > 0) {
-        console.log(`  ${pc7.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
+        console.log(`  ${pc6.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
       }
       console.log();
     }
@@ -2197,8 +1982,8 @@ var doctor_default = defineCommand4({
 // src/commands/hook.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join3 } from "node:path";
-import { defineCommand as defineCommand5 } from "citty";
-import pc8 from "picocolors";
+import { defineCommand as defineCommand4 } from "citty";
+import pc7 from "picocolors";
 var HOOK_MARKER = "# managed by contribute-now";
 function getHooksDir(cwd = process.cwd()) {
   return join3(cwd, ".git", "hooks");
@@ -2236,7 +2021,7 @@ else
 fi
 `;
 }
-var hook_default = defineCommand5({
+var hook_default = defineCommand4({
   meta: {
     name: "hook",
     description: "Install or uninstall the commit-msg git hook"
@@ -2294,8 +2079,8 @@ async function installHook() {
   }
   writeFileSync2(hookPath, generateHookScript(), { mode: 493 });
   success(`commit-msg hook installed.`);
-  info(`Convention: ${pc8.bold(CONVENTION_LABELS[config.commitConvention])}`);
-  info(`Path: ${pc8.dim(hookPath)}`);
+  info(`Convention: ${pc7.bold(CONVENTION_LABELS[config.commitConvention])}`);
+  info(`Path: ${pc7.dim(hookPath)}`);
 }
 async function uninstallHook() {
   heading("\uD83E\uDE9D hook uninstall");
@@ -2313,165 +2098,10 @@ async function uninstallHook() {
   success("commit-msg hook removed.");
 }
 
-// src/commands/log.ts
-import { defineCommand as defineCommand6 } from "citty";
-import pc9 from "picocolors";
-var log_default = defineCommand6({
-  meta: {
-    name: "log",
-    description: "Show a colorized, workflow-aware commit log with graph"
-  },
-  args: {
-    count: {
-      type: "string",
-      alias: "n",
-      description: "Number of commits to show (default: 20)"
-    },
-    all: {
-      type: "boolean",
-      alias: "a",
-      description: "Show all branches, not just current",
-      default: false
-    },
-    graph: {
-      type: "boolean",
-      alias: "g",
-      description: "Show graph view with branch lines",
-      default: true
-    },
-    branch: {
-      type: "string",
-      alias: "b",
-      description: "Show log for a specific branch"
-    }
-  },
-  async run({ args }) {
-    if (!await isGitRepo()) {
-      error("Not inside a git repository.");
-      process.exit(1);
-    }
-    const config = readConfig();
-    const count = args.count ? Number.parseInt(args.count, 10) : 20;
-    const showAll = args.all;
-    const showGraph = args.graph;
-    const targetBranch = args.branch;
-    const protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
-    const currentBranch = await getCurrentBranch();
-    heading("\uD83D\uDCDC commit log");
-    if (showGraph) {
-      const lines = await getLogGraph({ count, all: showAll, branch: targetBranch });
-      if (lines.length === 0) {
-        console.log(pc9.dim("  No commits found."));
-        console.log();
-        return;
-      }
-      console.log();
-      for (const line of lines) {
-        console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
-      }
-    } else {
-      const entries = await getLogEntries({ count, all: showAll, branch: targetBranch });
-      if (entries.length === 0) {
-        console.log(pc9.dim("  No commits found."));
-        console.log();
-        return;
-      }
-      console.log();
-      for (const entry of entries) {
-        const hashStr = pc9.yellow(entry.hash);
-        const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
-        const subjectStr = colorizeSubject(entry.subject);
-        console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
-      }
-    }
-    console.log();
-    console.log(pc9.dim(`  Showing ${count} most recent commits${showAll ? " (all branches)" : targetBranch ? ` (${targetBranch})` : ""}`));
-    console.log(pc9.dim(`  Use ${pc9.bold("contrib log -n 50")} for more, or ${pc9.bold("contrib log --all")} for all branches`));
-    console.log();
-  }
-});
-function colorizeGraphLine(line, protectedBranches, currentBranch) {
-  const match = line.match(/^([|/\\*\s_.-]*)([a-f0-9]{7,12})(\s+\(([^)]+)\))?\s*(.*)/);
-  if (!match) {
-    return pc9.cyan(line);
-  }
-  const [, graphPart = "", hash, , refs, subject = ""] = match;
-  const parts = [];
-  if (graphPart) {
-    parts.push(colorizeGraphChars(graphPart));
-  }
-  parts.push(pc9.yellow(hash));
-  if (refs) {
-    parts.push(` (${colorizeRefs(refs, protectedBranches, currentBranch)})`);
-  }
-  parts.push(` ${colorizeSubject(subject)}`);
-  return parts.join("");
-}
-function colorizeGraphChars(graphPart) {
-  return graphPart.split("").map((ch) => {
-    switch (ch) {
-      case "*":
-        return pc9.green(ch);
-      case "|":
-        return pc9.cyan(ch);
-      case "/":
-      case "\\":
-        return pc9.cyan(ch);
-      case "-":
-      case "_":
-        return pc9.cyan(ch);
-      default:
-        return ch;
-    }
-  }).join("");
-}
-function colorizeRefs(refs, protectedBranches, currentBranch) {
-  return refs.split(",").map((ref) => {
-    const trimmed = ref.trim();
-    if (trimmed.startsWith("HEAD ->") || trimmed === "HEAD") {
-      const branchName = trimmed.replace("HEAD -> ", "");
-      if (trimmed === "HEAD") {
-        return pc9.bold(pc9.cyan("HEAD"));
-      }
-      return `${pc9.bold(pc9.cyan("HEAD"))} ${pc9.dim("->")} ${colorizeRefName(branchName, protectedBranches, currentBranch)}`;
-    }
-    if (trimmed.startsWith("tag:")) {
-      return pc9.bold(pc9.magenta(trimmed));
-    }
-    return colorizeRefName(trimmed, protectedBranches, currentBranch);
-  }).join(pc9.dim(", "));
-}
-function colorizeRefName(name, protectedBranches, currentBranch) {
-  const isRemote = name.includes("/");
-  const localName = isRemote ? name.split("/").slice(1).join("/") : name;
-  if (protectedBranches.includes(localName)) {
-    return isRemote ? pc9.bold(pc9.red(name)) : pc9.bold(pc9.red(name));
-  }
-  if (localName === currentBranch) {
-    return pc9.bold(pc9.green(name));
-  }
-  if (isRemote) {
-    return pc9.blue(name);
-  }
-  return pc9.green(name);
-}
-function colorizeSubject(subject) {
-  const emojiMatch = subject.match(/^([\p{Emoji_Presentation}\p{Emoji}\uFE0F]+\s*)/u);
-  if (emojiMatch) {
-    const emoji = emojiMatch[1];
-    const rest = subject.slice(emoji.length);
-    return `${emoji}${pc9.white(rest)}`;
-  }
-  if (subject.startsWith("Merge ")) {
-    return pc9.dim(subject);
-  }
-  return pc9.white(subject);
-}
-
 // src/commands/setup.ts
-import { defineCommand as defineCommand7 } from "citty";
-import pc10 from "picocolors";
-var setup_default = defineCommand7({
+import { defineCommand as defineCommand5 } from "citty";
+import pc8 from "picocolors";
+var setup_default = defineCommand5({
   meta: {
     name: "setup",
     description: "Initialize contribute-now config for this repo (.contributerc.json)"
@@ -2492,7 +2122,7 @@ var setup_default = defineCommand7({
       workflow = "github-flow";
     else if (workflowChoice.startsWith("Git Flow"))
       workflow = "git-flow";
-    info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
+    info(`Workflow: ${pc8.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
     const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
       `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
       CONVENTION_DESCRIPTIONS.conventional,
@@ -2545,8 +2175,8 @@ var setup_default = defineCommand7({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${pc10.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${pc10.bold(detectedRole)}. Is this correct?`);
+      info(`Detected role: ${pc8.bold(detectedRole)} (via ${detectionSource})`);
+      const confirmed = await confirmPrompt(`Role detected as ${pc8.bold(detectedRole)}. Is this correct?`);
       if (!confirmed) {
         const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
         detectedRole = roleChoice;
@@ -2591,22 +2221,22 @@ var setup_default = defineCommand7({
       warn('  echo ".contributerc.json" >> .gitignore');
     }
     console.log();
-    info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    info(`Convention: ${pc10.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-    info(`Role: ${pc10.bold(config.role)}`);
+    info(`Workflow: ${pc8.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    info(`Convention: ${pc8.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+    info(`Role: ${pc8.bold(config.role)}`);
     if (config.devBranch) {
-      info(`Main: ${pc10.bold(config.mainBranch)} | Dev: ${pc10.bold(config.devBranch)}`);
+      info(`Main: ${pc8.bold(config.mainBranch)} | Dev: ${pc8.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${pc10.bold(config.mainBranch)}`);
+      info(`Main: ${pc8.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${pc10.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc10.bold(config.upstream)}` : ""}`);
+    info(`Origin: ${pc8.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc8.bold(config.upstream)}` : ""}`);
   }
 });
 
 // src/commands/start.ts
-import { defineCommand as defineCommand8 } from "citty";
-import pc11 from "picocolors";
-var start_default = defineCommand8({
+import { defineCommand as defineCommand6 } from "citty";
+import pc9 from "picocolors";
+var start_default = defineCommand6({
   meta: {
     name: "start",
     description: "Create a new feature branch from the latest base branch"
@@ -2653,8 +2283,8 @@ var start_default = defineCommand8({
       if (suggested) {
         spinner.success("Branch name suggestion ready.");
         console.log(`
-  ${pc11.dim("AI suggestion:")} ${pc11.bold(pc11.cyan(suggested))}`);
-        const accepted = await confirmPrompt(`Use ${pc11.bold(suggested)} as your branch name?`);
+  ${pc9.dim("AI suggestion:")} ${pc9.bold(pc9.cyan(suggested))}`);
+        const accepted = await confirmPrompt(`Use ${pc9.bold(suggested)} as your branch name?`);
         if (accepted) {
           branchName = suggested;
         } else {
@@ -2665,14 +2295,14 @@ var start_default = defineCommand8({
       }
     }
     if (!hasPrefix(branchName, branchPrefixes)) {
-      const prefix = await selectPrompt(`Choose a branch type for ${pc11.bold(branchName)}:`, branchPrefixes);
+      const prefix = await selectPrompt(`Choose a branch type for ${pc9.bold(branchName)}:`, branchPrefixes);
       branchName = formatBranchName(prefix, branchName);
     }
     if (!isValidBranchName(branchName)) {
       error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
       process.exit(1);
     }
-    info(`Creating branch: ${pc11.bold(branchName)}`);
+    info(`Creating branch: ${pc9.bold(branchName)}`);
     await fetchRemote(syncSource.remote);
     const updateResult = await updateLocalBranch(baseBranch, syncSource.ref);
     if (updateResult.exitCode !== 0) {}
@@ -2681,14 +2311,14 @@ var start_default = defineCommand8({
       error(`Failed to create branch: ${result.stderr}`);
       process.exit(1);
     }
-    success(`✅ Created ${pc11.bold(branchName)} from latest ${pc11.bold(baseBranch)}`);
+    success(`✅ Created ${pc9.bold(branchName)} from latest ${pc9.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand9 } from "citty";
-import pc12 from "picocolors";
-var status_default = defineCommand9({
+import { defineCommand as defineCommand7 } from "citty";
+import pc10 from "picocolors";
+var status_default = defineCommand7({
   meta: {
     name: "status",
     description: "Show sync status of branches"
@@ -2704,8 +2334,8 @@ var status_default = defineCommand9({
       process.exit(1);
     }
     heading("\uD83D\uDCCA contribute-now status");
-    console.log(`  ${pc12.dim("Workflow:")} ${pc12.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    console.log(`  ${pc12.dim("Role:")} ${pc12.bold(config.role)}`);
+    console.log(`  ${pc10.dim("Workflow:")} ${pc10.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    console.log(`  ${pc10.dim("Role:")} ${pc10.bold(config.role)}`);
     console.log();
     await fetchAll();
     const currentBranch = await getCurrentBranch();
@@ -2714,7 +2344,7 @@ var status_default = defineCommand9({
     const isContributor = config.role === "contributor";
     const [dirty, fileStatus] = await Promise.all([hasUncommittedChanges(), getFileStatus()]);
     if (dirty) {
-      console.log(`  ${pc12.yellow("⚠")}  ${pc12.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${pc10.yellow("⚠")}  ${pc10.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -2730,82 +2360,82 @@ var status_default = defineCommand9({
     if (currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
       const branchDiv = await getDivergence(currentBranch, baseBranch);
       const branchLine = formatStatus(currentBranch, baseBranch, branchDiv.ahead, branchDiv.behind);
-      console.log(branchLine + pc12.dim(` (current ${pc12.green("*")})`));
+      console.log(branchLine + pc10.dim(` (current ${pc10.green("*")})`));
     } else if (currentBranch) {
-      console.log(pc12.dim(`  (on ${pc12.bold(currentBranch)} branch)`));
+      console.log(pc10.dim(`  (on ${pc10.bold(currentBranch)} branch)`));
     }
     const hasFiles = fileStatus.staged.length > 0 || fileStatus.modified.length > 0 || fileStatus.untracked.length > 0;
     if (hasFiles) {
       console.log();
       if (fileStatus.staged.length > 0) {
-        console.log(`  ${pc12.green("Staged for commit:")}`);
+        console.log(`  ${pc10.green("Staged for commit:")}`);
         for (const { file, status } of fileStatus.staged) {
-          console.log(`    ${pc12.green("+")} ${pc12.dim(`${status}:`)} ${file}`);
+          console.log(`    ${pc10.green("+")} ${pc10.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.modified.length > 0) {
-        console.log(`  ${pc12.yellow("Unstaged changes:")}`);
+        console.log(`  ${pc10.yellow("Unstaged changes:")}`);
         for (const { file, status } of fileStatus.modified) {
-          console.log(`    ${pc12.yellow("~")} ${pc12.dim(`${status}:`)} ${file}`);
+          console.log(`    ${pc10.yellow("~")} ${pc10.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.untracked.length > 0) {
-        console.log(`  ${pc12.red("Untracked files:")}`);
+        console.log(`  ${pc10.red("Untracked files:")}`);
         for (const file of fileStatus.untracked) {
-          console.log(`    ${pc12.red("?")} ${file}`);
+          console.log(`    ${pc10.red("?")} ${file}`);
         }
       }
     } else if (!dirty) {
-      console.log(`  ${pc12.green("✓")}  ${pc12.dim("Working tree clean")}`);
+      console.log(`  ${pc10.green("✓")}  ${pc10.dim("Working tree clean")}`);
     }
     const tips = [];
     if (fileStatus.staged.length > 0) {
-      tips.push(`Run ${pc12.bold("contrib commit")} to commit staged changes`);
+      tips.push(`Run ${pc10.bold("contrib commit")} to commit staged changes`);
     }
     if (fileStatus.modified.length > 0 || fileStatus.untracked.length > 0) {
-      tips.push(`Run ${pc12.bold("contrib commit")} to stage and commit changes`);
+      tips.push(`Run ${pc10.bold("contrib commit")} to stage and commit changes`);
     }
     if (fileStatus.staged.length === 0 && fileStatus.modified.length === 0 && fileStatus.untracked.length === 0 && currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
       const branchDiv = await getDivergence(currentBranch, `${origin}/${currentBranch}`);
       if (branchDiv.ahead > 0) {
-        tips.push(`Run ${pc12.bold("contrib submit")} to push and create/update your PR`);
+        tips.push(`Run ${pc10.bold("contrib submit")} to push and create/update your PR`);
       }
     }
     if (tips.length > 0) {
       console.log();
-      console.log(`  ${pc12.dim("\uD83D\uDCA1 Tip:")}`);
+      console.log(`  ${pc10.dim("\uD83D\uDCA1 Tip:")}`);
       for (const tip of tips) {
-        console.log(`     ${pc12.dim(tip)}`);
+        console.log(`     ${pc10.dim(tip)}`);
       }
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = pc12.bold(branch.padEnd(20));
+  const label = pc10.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${pc12.green("✓")}  ${label} ${pc12.dim(`in sync with ${base}`)}`;
+    return `  ${pc10.green("✓")}  ${label} ${pc10.dim(`in sync with ${base}`)}`;
   }
   if (ahead > 0 && behind === 0) {
-    return `  ${pc12.yellow("↑")}  ${label} ${pc12.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+    return `  ${pc10.yellow("↑")}  ${label} ${pc10.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
   }
   if (behind > 0 && ahead === 0) {
-    return `  ${pc12.red("↓")}  ${label} ${pc12.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+    return `  ${pc10.red("↓")}  ${label} ${pc10.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
   }
-  return `  ${pc12.red("⚡")}  ${label} ${pc12.yellow(`${ahead} ahead`)}${pc12.dim(", ")}${pc12.red(`${behind} behind`)} ${pc12.dim(base)}`;
+  return `  ${pc10.red("⚡")}  ${label} ${pc10.yellow(`${ahead} ahead`)}${pc10.dim(", ")}${pc10.red(`${behind} behind`)} ${pc10.dim(base)}`;
 }
 
 // src/commands/submit.ts
-import { defineCommand as defineCommand10 } from "citty";
-import pc13 from "picocolors";
+import { defineCommand as defineCommand8 } from "citty";
+import pc11 from "picocolors";
 async function performSquashMerge(origin, baseBranch, featureBranch, options) {
-  info(`Checking out ${pc13.bold(baseBranch)}...`);
+  info(`Checking out ${pc11.bold(baseBranch)}...`);
   const coResult = await checkoutBranch2(baseBranch);
   if (coResult.exitCode !== 0) {
     error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
     process.exit(1);
   }
-  info(`Squash merging ${pc13.bold(featureBranch)} into ${pc13.bold(baseBranch)}...`);
+  info(`Squash merging ${pc11.bold(featureBranch)} into ${pc11.bold(baseBranch)}...`);
   const mergeResult = await mergeSquash(featureBranch);
   if (mergeResult.exitCode !== 0) {
     error(`Squash merge failed: ${mergeResult.stderr}`);
@@ -2835,26 +2465,26 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
     error(`Commit failed: ${commitResult.stderr}`);
     process.exit(1);
   }
-  info(`Pushing ${pc13.bold(baseBranch)} to ${origin}...`);
+  info(`Pushing ${pc11.bold(baseBranch)} to ${origin}...`);
   const pushResult = await pushBranch(origin, baseBranch);
   if (pushResult.exitCode !== 0) {
     error(`Failed to push ${baseBranch}: ${pushResult.stderr}`);
     process.exit(1);
   }
-  info(`Deleting local branch ${pc13.bold(featureBranch)}...`);
+  info(`Deleting local branch ${pc11.bold(featureBranch)}...`);
   const delLocal = await forceDeleteBranch(featureBranch);
   if (delLocal.exitCode !== 0) {
     warn(`Could not delete local branch: ${delLocal.stderr.trim()}`);
   }
-  info(`Deleting remote branch ${pc13.bold(featureBranch)}...`);
+  info(`Deleting remote branch ${pc11.bold(featureBranch)}...`);
   const delRemote = await deleteRemoteBranch(origin, featureBranch);
   if (delRemote.exitCode !== 0) {
     warn(`Could not delete remote branch: ${delRemote.stderr.trim()}`);
   }
-  success(`✅ Squash merged ${pc13.bold(featureBranch)} into ${pc13.bold(baseBranch)} and pushed.`);
-  info(`Run ${pc13.bold("contrib start")} to begin a new feature.`);
+  success(`✅ Squash merged ${pc11.bold(featureBranch)} into ${pc11.bold(baseBranch)} and pushed.`);
+  info(`Run ${pc11.bold("contrib start")} to begin a new feature.`);
 }
-var submit_default = defineCommand10({
+var submit_default = defineCommand8({
   meta: {
     name: "submit",
     description: "Push current branch and create a pull request"
@@ -2894,73 +2524,8 @@ var submit_default = defineCommand10({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      heading("\uD83D\uDE80 contrib submit");
-      warn(`You're on ${pc13.bold(currentBranch)}, which is a protected branch. PRs should come from feature branches.`);
-      await fetchAll();
-      const remoteRef = `${origin}/${currentBranch}`;
-      const localWork = await hasLocalWork(origin, currentBranch);
-      const dirty = await hasUncommittedChanges();
-      const hasCommits = localWork.unpushedCommits > 0;
-      const hasAnything = hasCommits || dirty;
-      if (!hasAnything) {
-        error("No local changes or commits to move. Switch to a feature branch first.");
-        info(`  Run ${pc13.bold("contrib start")} to create a new feature branch.`);
-        process.exit(1);
-      }
-      if (hasCommits) {
-        info(`Found ${pc13.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${pc13.bold(currentBranch)}.`);
-      }
-      if (dirty) {
-        info("You also have uncommitted changes in the working tree.");
-      }
-      console.log();
-      const MOVE_BRANCH = "Move my changes to a new feature branch";
-      const CANCEL2 = "Cancel (stay on this branch)";
-      const action = await selectPrompt("Let's get you back on track. What would you like to do?", [MOVE_BRANCH, CANCEL2]);
-      if (action === CANCEL2) {
-        info("No changes made. You are still on your current branch.");
-        return;
-      }
-      info(pc13.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
-      const description = await inputPrompt("What are you working on?");
-      let newBranchName = description;
-      if (looksLikeNaturalLanguage(description)) {
-        const copilotError = await checkCopilotAvailable();
-        if (!copilotError) {
-          const spinner = createSpinner("Generating branch name suggestion...");
-          const suggested = await suggestBranchName(description, args.model);
-          if (suggested) {
-            spinner.success("Branch name suggestion ready.");
-            console.log(`
-  ${pc13.dim("AI suggestion:")} ${pc13.bold(pc13.cyan(suggested))}`);
-            const accepted = await confirmPrompt(`Use ${pc13.bold(suggested)} as your branch name?`);
-            newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
-          } else {
-            spinner.fail("AI did not return a suggestion.");
-            newBranchName = await inputPrompt("Enter branch name", description);
-          }
-        }
-      }
-      if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-        const prefix = await selectPrompt(`Choose a branch type for ${pc13.bold(newBranchName)}:`, config.branchPrefixes);
-        newBranchName = formatBranchName(prefix, newBranchName);
-      }
-      if (!isValidBranchName(newBranchName)) {
-        error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
-        process.exit(1);
-      }
-      const branchResult = await createBranch(newBranchName);
-      if (branchResult.exitCode !== 0) {
-        error(`Failed to create branch: ${branchResult.stderr}`);
-        process.exit(1);
-      }
-      success(`Created ${pc13.bold(newBranchName)} with your changes.`);
-      await updateLocalBranch(currentBranch, remoteRef);
-      info(`Reset ${pc13.bold(currentBranch)} back to ${pc13.bold(remoteRef)} — no damage done.`);
-      console.log();
-      success(`You're now on ${pc13.bold(newBranchName)} with all your work intact.`);
-      info(`Run ${pc13.bold("contrib submit")} again to push and create your PR.`);
-      return;
+      error(`Cannot submit ${protectedBranches.map((b) => pc11.bold(b)).join(" or ")} as a PR. Switch to your feature branch.`);
+      process.exit(1);
     }
     heading("\uD83D\uDE80 contrib submit");
     const ghInstalled = await checkGhInstalled();
@@ -2968,7 +2533,7 @@ var submit_default = defineCommand10({
     if (ghInstalled && ghAuthed) {
       const mergedPR = await getMergedPRForBranch(currentBranch);
       if (mergedPR) {
-        warn(`PR #${mergedPR.number} (${pc13.bold(mergedPR.title)}) was already merged.`);
+        warn(`PR #${mergedPR.number} (${pc11.bold(mergedPR.title)}) was already merged.`);
         const localWork = await hasLocalWork(origin, currentBranch);
         const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
         if (hasWork) {
@@ -2976,7 +2541,7 @@ var submit_default = defineCommand10({
             warn("You have uncommitted changes in your working tree.");
           }
           if (localWork.unpushedCommits > 0) {
-            warn(`You have ${pc13.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not in the merged PR.`);
+            warn(`You have ${pc11.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not in the merged PR.`);
           }
           const SAVE_NEW_BRANCH = "Save changes to a new branch";
           const DISCARD = "Discard all changes and clean up";
@@ -2987,7 +2552,7 @@ var submit_default = defineCommand10({
             return;
           }
           if (action === SAVE_NEW_BRANCH) {
-            info(pc13.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
+            info(pc11.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
             const description = await inputPrompt("What are you working on?");
             let newBranchName = description;
             if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
@@ -2996,8 +2561,8 @@ var submit_default = defineCommand10({
               if (suggested) {
                 spinner.success("Branch name suggestion ready.");
                 console.log(`
-  ${pc13.dim("AI suggestion:")} ${pc13.bold(pc13.cyan(suggested))}`);
-                const accepted = await confirmPrompt(`Use ${pc13.bold(suggested)} as your branch name?`);
+  ${pc11.dim("AI suggestion:")} ${pc11.bold(pc11.cyan(suggested))}`);
+                const accepted = await confirmPrompt(`Use ${pc11.bold(suggested)} as your branch name?`);
                 newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
               } else {
                 spinner.fail("AI did not return a suggestion.");
@@ -3005,7 +2570,7 @@ var submit_default = defineCommand10({
               }
             }
             if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-              const prefix = await selectPrompt(`Choose a branch type for ${pc13.bold(newBranchName)}:`, config.branchPrefixes);
+              const prefix = await selectPrompt(`Choose a branch type for ${pc11.bold(newBranchName)}:`, config.branchPrefixes);
               newBranchName = formatBranchName(prefix, newBranchName);
             }
             if (!isValidBranchName(newBranchName)) {
@@ -3019,10 +2584,10 @@ var submit_default = defineCommand10({
               error(`Failed to rename branch: ${renameResult.stderr}`);
               process.exit(1);
             }
-            success(`Renamed ${pc13.bold(currentBranch)} → ${pc13.bold(newBranchName)}`);
+            success(`Renamed ${pc11.bold(currentBranch)} → ${pc11.bold(newBranchName)}`);
             await unsetUpstream();
             const syncSource2 = getSyncSource(config);
-            info(`Syncing ${pc13.bold(newBranchName)} with latest ${pc13.bold(baseBranch)}...`);
+            info(`Syncing ${pc11.bold(newBranchName)} with latest ${pc11.bold(baseBranch)}...`);
             await fetchRemote(syncSource2.remote);
             let rebaseResult;
             if (staleUpstreamHash) {
@@ -3033,17 +2598,17 @@ var submit_default = defineCommand10({
             }
             if (rebaseResult.exitCode !== 0) {
               warn("Rebase encountered conflicts. Resolve them manually, then run:");
-              info(`  ${pc13.bold("git rebase --continue")}`);
+              info(`  ${pc11.bold("git rebase --continue")}`);
             } else {
-              success(`Rebased ${pc13.bold(newBranchName)} onto ${pc13.bold(syncSource2.ref)}.`);
+              success(`Rebased ${pc11.bold(newBranchName)} onto ${pc11.bold(syncSource2.ref)}.`);
             }
-            info(`All your changes are preserved. Run ${pc13.bold("contrib submit")} when ready to create a new PR.`);
+            info(`All your changes are preserved. Run ${pc11.bold("contrib submit")} when ready to create a new PR.`);
             return;
           }
           warn("Discarding local changes...");
         }
         const syncSource = getSyncSource(config);
-        info(`Switching to ${pc13.bold(baseBranch)} and syncing...`);
+        info(`Switching to ${pc11.bold(baseBranch)} and syncing...`);
         await fetchRemote(syncSource.remote);
         const coResult = await checkoutBranch2(baseBranch);
         if (coResult.exitCode !== 0) {
@@ -3051,16 +2616,16 @@ var submit_default = defineCommand10({
           process.exit(1);
         }
         await updateLocalBranch(baseBranch, syncSource.ref);
-        success(`Synced ${pc13.bold(baseBranch)} with ${pc13.bold(syncSource.ref)}.`);
-        info(`Deleting stale branch ${pc13.bold(currentBranch)}...`);
+        success(`Synced ${pc11.bold(baseBranch)} with ${pc11.bold(syncSource.ref)}.`);
+        info(`Deleting stale branch ${pc11.bold(currentBranch)}...`);
         const delResult = await forceDeleteBranch(currentBranch);
         if (delResult.exitCode === 0) {
-          success(`Deleted ${pc13.bold(currentBranch)}.`);
+          success(`Deleted ${pc11.bold(currentBranch)}.`);
         } else {
           warn(`Could not delete branch: ${delResult.stderr.trim()}`);
         }
         console.log();
-        info(`You're now on ${pc13.bold(baseBranch)}. Run ${pc13.bold("contrib start")} to begin a new feature.`);
+        info(`You're now on ${pc11.bold(baseBranch)}. Run ${pc11.bold("contrib start")} to begin a new feature.`);
         return;
       }
     }
@@ -3080,10 +2645,10 @@ var submit_default = defineCommand10({
           prBody = result.body;
           spinner.success("PR description generated.");
           console.log(`
-  ${pc13.dim("AI title:")} ${pc13.bold(pc13.cyan(prTitle))}`);
+  ${pc11.dim("AI title:")} ${pc11.bold(pc11.cyan(prTitle))}`);
           console.log(`
-${pc13.dim("AI body preview:")}`);
-          console.log(pc13.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+${pc11.dim("AI body preview:")}`);
+          console.log(pc11.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
         } else {
           spinner.fail("AI did not return a PR description.");
         }
@@ -3172,7 +2737,7 @@ ${pc13.dim("AI body preview:")}`);
       });
       return;
     }
-    info(`Pushing ${pc13.bold(currentBranch)} to ${origin}...`);
+    info(`Pushing ${pc11.bold(currentBranch)} to ${origin}...`);
     const pushResult = await pushSetUpstream(origin, currentBranch);
     if (pushResult.exitCode !== 0) {
       error(`Failed to push: ${pushResult.stderr}`);
@@ -3184,7 +2749,7 @@ ${pc13.dim("AI body preview:")}`);
         const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/compare/${baseBranch}...${currentBranch}?expand=1`;
         console.log();
         info("Create your PR manually:");
-        console.log(`  ${pc13.cyan(prUrl)}`);
+        console.log(`  ${pc11.cyan(prUrl)}`);
       } else {
         info("gh CLI not available. Create your PR manually on GitHub.");
       }
@@ -3192,8 +2757,8 @@ ${pc13.dim("AI body preview:")}`);
     }
     const existingPR = await getPRForBranch(currentBranch);
     if (existingPR) {
-      success(`Pushed changes to existing PR #${existingPR.number}: ${pc13.bold(existingPR.title)}`);
-      console.log(`  ${pc13.cyan(existingPR.url)}`);
+      success(`Pushed changes to existing PR #${existingPR.number}: ${pc11.bold(existingPR.title)}`);
+      console.log(`  ${pc11.cyan(existingPR.url)}`);
       return;
     }
     if (submitAction === "fill") {
@@ -3224,9 +2789,9 @@ ${pc13.dim("AI body preview:")}`);
 });
 
 // src/commands/sync.ts
-import { defineCommand as defineCommand11 } from "citty";
-import pc14 from "picocolors";
-var sync_default = defineCommand11({
+import { defineCommand as defineCommand9 } from "citty";
+import pc12 from "picocolors";
+var sync_default = defineCommand9({
   meta: {
     name: "sync",
     description: "Sync your local branches with the remote"
@@ -3268,12 +2833,12 @@ var sync_default = defineCommand11({
     }
     const div = await getDivergence(baseBranch, syncSource.ref);
     if (div.ahead > 0 || div.behind > 0) {
-      info(`${pc14.bold(baseBranch)} is ${pc14.yellow(`${div.ahead} ahead`)} and ${pc14.red(`${div.behind} behind`)} ${syncSource.ref}`);
+      info(`${pc12.bold(baseBranch)} is ${pc12.yellow(`${div.ahead} ahead`)} and ${pc12.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`${pc14.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+      info(`${pc12.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
     }
     if (!args.yes) {
-      const ok = await confirmPrompt(`This will pull ${pc14.bold(syncSource.ref)} into local ${pc14.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${pc12.bold(syncSource.ref)} into local ${pc12.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
@@ -3291,7 +2856,7 @@ var sync_default = defineCommand11({
     if (hasDevBranch(workflow) && role === "maintainer") {
       const mainDiv = await getDivergence(config.mainBranch, `${origin}/${config.mainBranch}`);
       if (mainDiv.behind > 0) {
-        info(`Also syncing ${pc14.bold(config.mainBranch)}...`);
+        info(`Also syncing ${pc12.bold(config.mainBranch)}...`);
         const mainCoResult = await checkoutBranch2(config.mainBranch);
         if (mainCoResult.exitCode === 0) {
           const mainPullResult = await pullBranch(origin, config.mainBranch);
@@ -3307,9 +2872,9 @@ var sync_default = defineCommand11({
 
 // src/commands/update.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { defineCommand as defineCommand12 } from "citty";
-import pc15 from "picocolors";
-var update_default = defineCommand12({
+import { defineCommand as defineCommand10 } from "citty";
+import pc13 from "picocolors";
+var update_default = defineCommand10({
   meta: {
     name: "update",
     description: "Rebase current branch onto the latest base branch"
@@ -3344,7 +2909,7 @@ var update_default = defineCommand12({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      error(`Use \`contrib sync\` to update ${protectedBranches.map((b) => pc15.bold(b)).join(" or ")} branches.`);
+      error(`Use \`contrib sync\` to update ${protectedBranches.map((b) => pc13.bold(b)).join(" or ")} branches.`);
       process.exit(1);
     }
     if (await hasUncommittedChanges()) {
@@ -3354,8 +2919,8 @@ var update_default = defineCommand12({
     heading("\uD83D\uDD03 contrib update");
     const mergedPR = await getMergedPRForBranch(currentBranch);
     if (mergedPR) {
-      warn(`PR #${mergedPR.number} (${pc15.bold(mergedPR.title)}) has already been merged.`);
-      info(`Link: ${pc15.underline(mergedPR.url)}`);
+      warn(`PR #${mergedPR.number} (${pc13.bold(mergedPR.title)}) has already been merged.`);
+      info(`Link: ${pc13.underline(mergedPR.url)}`);
       const localWork = await hasLocalWork(syncSource.remote, currentBranch);
       const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
       if (hasWork) {
@@ -3368,13 +2933,13 @@ var update_default = defineCommand12({
         const SAVE_NEW_BRANCH = "Save changes to a new branch";
         const DISCARD = "Discard all changes and clean up";
         const CANCEL = "Cancel";
-        const action = await selectPrompt(`${pc15.bold(currentBranch)} is stale but has local work. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
+        const action = await selectPrompt(`${pc13.bold(currentBranch)} is stale but has local work. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
         if (action === CANCEL) {
           info("No changes made. You are still on your current branch.");
           return;
         }
         if (action === SAVE_NEW_BRANCH) {
-          info(pc15.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
+          info(pc13.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
           const description = await inputPrompt("What are you working on?");
           let newBranchName = description;
           if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
@@ -3383,8 +2948,8 @@ var update_default = defineCommand12({
             if (suggested) {
               spinner.success("Branch name suggestion ready.");
               console.log(`
-  ${pc15.dim("AI suggestion:")} ${pc15.bold(pc15.cyan(suggested))}`);
-              const accepted = await confirmPrompt(`Use ${pc15.bold(suggested)} as your branch name?`);
+  ${pc13.dim("AI suggestion:")} ${pc13.bold(pc13.cyan(suggested))}`);
+              const accepted = await confirmPrompt(`Use ${pc13.bold(suggested)} as your branch name?`);
               newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
             } else {
               spinner.fail("AI did not return a suggestion.");
@@ -3392,7 +2957,7 @@ var update_default = defineCommand12({
             }
           }
           if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-            const prefix = await selectPrompt(`Choose a branch type for ${pc15.bold(newBranchName)}:`, config.branchPrefixes);
+            const prefix = await selectPrompt(`Choose a branch type for ${pc13.bold(newBranchName)}:`, config.branchPrefixes);
             newBranchName = formatBranchName(prefix, newBranchName);
           }
           if (!isValidBranchName(newBranchName)) {
@@ -3406,7 +2971,7 @@ var update_default = defineCommand12({
             error(`Failed to rename branch: ${renameResult.stderr}`);
             process.exit(1);
           }
-          success(`Renamed ${pc15.bold(currentBranch)} → ${pc15.bold(newBranchName)}`);
+          success(`Renamed ${pc13.bold(currentBranch)} → ${pc13.bold(newBranchName)}`);
           await unsetUpstream();
           await fetchRemote(syncSource.remote);
           let rebaseResult2;
@@ -3418,11 +2983,11 @@ var update_default = defineCommand12({
           }
           if (rebaseResult2.exitCode !== 0) {
             warn("Rebase encountered conflicts. Resolve them manually, then run:");
-            info(`  ${pc15.bold("git rebase --continue")}`);
+            info(`  ${pc13.bold("git rebase --continue")}`);
           } else {
-            success(`Rebased ${pc15.bold(newBranchName)} onto ${pc15.bold(syncSource.ref)}.`);
+            success(`Rebased ${pc13.bold(newBranchName)} onto ${pc13.bold(syncSource.ref)}.`);
           }
-          info(`All your changes are preserved. Run ${pc15.bold("contrib submit")} when ready to create a new PR.`);
+          info(`All your changes are preserved. Run ${pc13.bold("contrib submit")} when ready to create a new PR.`);
           return;
         }
         warn("Discarding local changes...");
@@ -3434,19 +2999,19 @@ var update_default = defineCommand12({
         process.exit(1);
       }
       await updateLocalBranch(baseBranch, syncSource.ref);
-      success(`Synced ${pc15.bold(baseBranch)} with ${pc15.bold(syncSource.ref)}.`);
-      info(`Deleting stale branch ${pc15.bold(currentBranch)}...`);
+      success(`Synced ${pc13.bold(baseBranch)} with ${pc13.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${pc13.bold(currentBranch)}...`);
       await forceDeleteBranch(currentBranch);
-      success(`Deleted ${pc15.bold(currentBranch)}.`);
-      info(`Run ${pc15.bold("contrib start")} to begin a new feature branch.`);
+      success(`Deleted ${pc13.bold(currentBranch)}.`);
+      info(`Run ${pc13.bold("contrib start")} to begin a new feature branch.`);
       return;
     }
-    info(`Updating ${pc15.bold(currentBranch)} with latest ${pc15.bold(baseBranch)}...`);
+    info(`Updating ${pc13.bold(currentBranch)} with latest ${pc13.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
     await updateLocalBranch(baseBranch, syncSource.ref);
     const rebaseStrategy = await determineRebaseStrategy(currentBranch, syncSource.ref);
     if (rebaseStrategy.strategy === "onto" && rebaseStrategy.ontoOldBase) {
-      info(pc15.dim(`Using --onto rebase (branch was based on a different ref)`));
+      info(pc13.dim(`Using --onto rebase (branch was based on a different ref)`));
     }
     const rebaseResult = rebaseStrategy.strategy === "onto" && rebaseStrategy.ontoOldBase ? await rebaseOnto(syncSource.ref, rebaseStrategy.ontoOldBase) : await rebase(syncSource.ref);
     if (rebaseResult.exitCode !== 0) {
@@ -3475,10 +3040,10 @@ ${content.slice(0, 2000)}
             if (suggestion) {
               spinner.success("AI conflict guidance ready.");
               console.log(`
-${pc15.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(pc15.dim("─".repeat(60)));
+${pc13.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(pc13.dim("─".repeat(60)));
               console.log(suggestion);
-              console.log(pc15.dim("─".repeat(60)));
+              console.log(pc13.dim("─".repeat(60)));
               console.log();
             } else {
               spinner.fail("AI could not analyze the conflicts.");
@@ -3486,22 +3051,22 @@ ${pc15.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
           }
         }
       }
-      console.log(pc15.bold("To resolve:"));
+      console.log(pc13.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${pc15.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${pc15.cyan("git rebase --continue")}`);
+      console.log(`  2. ${pc13.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${pc13.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${pc15.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${pc13.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`✅ ${pc15.bold(currentBranch)} has been rebased onto latest ${pc15.bold(baseBranch)}`);
+    success(`✅ ${pc13.bold(currentBranch)} has been rebased onto latest ${pc13.bold(baseBranch)}`);
   }
 });
 
 // src/commands/validate.ts
-import { defineCommand as defineCommand13 } from "citty";
-import pc16 from "picocolors";
-var validate_default = defineCommand13({
+import { defineCommand as defineCommand11 } from "citty";
+import pc14 from "picocolors";
+var validate_default = defineCommand11({
   meta: {
     name: "validate",
     description: "Validate a commit message against the configured convention"
@@ -3531,7 +3096,7 @@ var validate_default = defineCommand13({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(pc16.red(`  ✗ ${line}`));
+      console.error(pc14.red(`  ✗ ${line}`));
     }
     process.exit(1);
   }
@@ -3539,7 +3104,7 @@ var validate_default = defineCommand13({
 
 // src/ui/banner.ts
 import figlet from "figlet";
-import pc17 from "picocolors";
+import pc15 from "picocolors";
 var LOGO_BIG;
 try {
   LOGO_BIG = figlet.textSync(`Contribute
@@ -3561,14 +3126,14 @@ function getAuthor() {
 }
 function showBanner(variant = "small") {
   const logo = variant === "big" ? LOGO_BIG : LOGO_SMALL;
-  console.log(pc17.cyan(`
+  console.log(pc15.cyan(`
 ${logo}`));
-  console.log(`  ${pc17.dim(`v${getVersion()}`)} ${pc17.dim("—")} ${pc17.dim(`Built by ${getAuthor()}`)}`);
+  console.log(`  ${pc15.dim(`v${getVersion()}`)} ${pc15.dim("—")} ${pc15.dim(`Built by ${getAuthor()}`)}`);
   if (variant === "big") {
     console.log();
-    console.log(`  ${pc17.yellow("Star")}        ${pc17.cyan("https://github.com/warengonzaga/contribute-now")}`);
-    console.log(`  ${pc17.green("Contribute")}  ${pc17.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
-    console.log(`  ${pc17.magenta("Sponsor")}     ${pc17.cyan("https://warengonzaga.com/sponsor")}`);
+    console.log(`  ${pc15.yellow("Star")}        ${pc15.cyan("https://github.com/warengonzaga/contribute-now")}`);
+    console.log(`  ${pc15.green("Contribute")}  ${pc15.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
+    console.log(`  ${pc15.magenta("Sponsor")}     ${pc15.cyan("https://warengonzaga.com/sponsor")}`);
   }
   console.log();
 }
@@ -3576,13 +3141,13 @@ ${logo}`));
 // src/index.ts
 var isVersion = process.argv.includes("--version") || process.argv.includes("-v");
 if (!isVersion) {
-  const subCommands = ["setup", "sync", "start", "commit", "update", "submit", "clean", "status", "log", "branch", "hook", "validate", "doctor"];
+  const subCommands = ["setup", "sync", "start", "commit", "update", "submit", "clean", "status", "hook", "validate", "doctor"];
   const isHelp = process.argv.includes("--help") || process.argv.includes("-h");
   const hasSubCommand = subCommands.some((cmd) => process.argv.includes(cmd));
   const useBigBanner = isHelp || !hasSubCommand;
   showBanner(useBigBanner ? "big" : "small");
 }
-var main = defineCommand14({
+var main = defineCommand12({
   meta: {
     name: "contrib",
     version: getVersion(),
@@ -3602,10 +3167,8 @@ var main = defineCommand14({
     commit: commit_default,
     update: update_default,
     submit: submit_default,
-    branch: branch_default,
     clean: clean_default,
     status: status_default,
-    log: log_default,
     hook: hook_default,
     validate: validate_default,
     doctor: doctor_default