contribute-now 0.2.0 → 0.2.1-dev.22ad5a1

package/dist/index.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-import { defineCommand as defineCommand11, runMain } from "citty";
+import { defineCommand as defineCommand14, runMain } from "citty";
 
-// src/commands/clean.ts
+// src/commands/branch.ts
 import { defineCommand } from "citty";
-import pc3 from "picocolors";
+import pc2 from "picocolors";
 
 // src/utils/config.ts
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -14,13 +16,55 @@ var CONFIG_FILENAME = ".contributerc.json";
 function getConfigPath(cwd = process.cwd()) {
   return join(cwd, CONFIG_FILENAME);
 }
+function configExists(cwd = process.cwd()) {
+  return existsSync(getConfigPath(cwd));
+}
+var VALID_WORKFLOWS = ["clean-flow", "github-flow", "git-flow"];
+var VALID_ROLES = ["maintainer", "contributor"];
+var VALID_CONVENTIONS = ["conventional", "clean-commit", "none"];
 function readConfig(cwd = process.cwd()) {
   const path = getConfigPath(cwd);
   if (!existsSync(path))
     return null;
   try {
     const raw = readFileSync(path, "utf-8");
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.workflow !== "string" || typeof parsed.role !== "string" || typeof parsed.mainBranch !== "string" || typeof parsed.upstream !== "string" || typeof parsed.origin !== "string" || !Array.isArray(parsed.branchPrefixes) || typeof parsed.commitConvention !== "string") {
+      return null;
+    }
+    if (!VALID_WORKFLOWS.includes(parsed.workflow)) {
+      console.error(`Invalid workflow "${parsed.workflow}" in .contributerc.json. Valid: ${VALID_WORKFLOWS.join(", ")}`);
+      return null;
+    }
+    if (!VALID_ROLES.includes(parsed.role)) {
+      console.error(`Invalid role "${parsed.role}" in .contributerc.json. Valid: ${VALID_ROLES.join(", ")}`);
+      return null;
+    }
+    if (!VALID_CONVENTIONS.includes(parsed.commitConvention)) {
+      console.error(`Invalid commitConvention "${parsed.commitConvention}" in .contributerc.json. Valid: ${VALID_CONVENTIONS.join(", ")}`);
+      return null;
+    }
+    if (!parsed.mainBranch.trim()) {
+      console.error("Invalid .contributerc.json: mainBranch must not be empty.");
+      return null;
+    }
+    if (!parsed.origin.trim()) {
+      console.error("Invalid .contributerc.json: origin must not be empty.");
+      return null;
+    }
+    if (parsed.role === "contributor" && !parsed.upstream.trim()) {
+      console.error("Invalid .contributerc.json: upstream must not be empty for contributors.");
+      return null;
+    }
+    if (parsed.branchPrefixes.length === 0) {
+      console.error("Invalid .contributerc.json: branchPrefixes must not be empty.");
+      return null;
+    }
+    if (!parsed.branchPrefixes.every((p) => typeof p === "string" && p.trim().length > 0)) {
+      console.error("Invalid .contributerc.json: all branchPrefixes must be non-empty strings.");
+      return null;
+    }
+    return parsed;
   } catch {
     return null;
   }
@@ -55,69 +99,15 @@ function getDefaultConfig() {
   };
 }
 
-// src/utils/confirm.ts
-import pc from "picocolors";
-async function confirmPrompt(message) {
-  console.log(`
-${message}`);
-  process.stdout.write(`${pc.dim("Continue? [y/N] ")}`);
-  const response = await new Promise((resolve) => {
-    process.stdin.setEncoding("utf-8");
-    process.stdin.once("data", (data) => {
-      process.stdin.pause();
-      resolve(data.toString().trim());
-    });
-    process.stdin.resume();
-  });
-  if (response.toLowerCase() !== "y") {
-    console.log(pc.yellow("Aborted."));
-    return false;
-  }
-  return true;
-}
-async function selectPrompt(message, choices) {
-  console.log(`
-${message}`);
-  choices.forEach((choice, i) => {
-    console.log(`  ${pc.dim(`${i + 1}.`)} ${choice}`);
-  });
-  process.stdout.write(pc.dim(`Enter number [1-${choices.length}]: `));
-  const response = await new Promise((resolve) => {
-    process.stdin.setEncoding("utf-8");
-    process.stdin.once("data", (data) => {
-      process.stdin.pause();
-      resolve(data.toString().trim());
-    });
-    process.stdin.resume();
-  });
-  const index = Number.parseInt(response, 10) - 1;
-  if (index >= 0 && index < choices.length) {
-    return choices[index];
-  }
-  return choices[0];
-}
-async function inputPrompt(message, defaultValue) {
-  const hint = defaultValue ? ` ${pc.dim(`[${defaultValue}]`)}` : "";
-  process.stdout.write(`
-${message}${hint}: `);
-  const response = await new Promise((resolve) => {
-    process.stdin.setEncoding("utf-8");
-    process.stdin.once("data", (data) => {
-      process.stdin.pause();
-      resolve(data.toString().trim());
-    });
-    process.stdin.resume();
-  });
-  return response || defaultValue || "";
-}
-
 // src/utils/git.ts
 import { execFile as execFileCb } from "node:child_process";
+import { existsSync as existsSync2, 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.code != null ? Number(error.code) : 1 : 0,
+        exitCode: error ? error.code === "ENOENT" ? 127 : error.status ?? 1 : 0,
         stdout: stdout ?? "",
         stderr: stderr ?? ""
       });
@@ -128,11 +118,69 @@ async function isGitRepo() {
   const { exitCode } = await run(["rev-parse", "--is-inside-work-tree"]);
   return exitCode === 0;
 }
+async function getGitDir() {
+  const { exitCode, stdout } = await run(["rev-parse", "--git-dir"]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function checkGitState() {
+  const gitDir = await getGitDir();
+  if (!gitDir)
+    return { lockFile: false, inProgressOp: null, gitDir: null };
+  const lockFile = existsSync2(join2(gitDir, "index.lock"));
+  let inProgressOp = null;
+  if (existsSync2(join2(gitDir, "rebase-merge")) || existsSync2(join2(gitDir, "rebase-apply"))) {
+    inProgressOp = "rebase";
+  } else if (existsSync2(join2(gitDir, "MERGE_HEAD"))) {
+    inProgressOp = "merge";
+  } else if (existsSync2(join2(gitDir, "CHERRY_PICK_HEAD"))) {
+    inProgressOp = "cherry-pick";
+  } else if (existsSync2(join2(gitDir, "BISECT_LOG"))) {
+    inProgressOp = "bisect";
+  }
+  return { lockFile, inProgressOp, gitDir };
+}
+async function isGitOperationInProgress() {
+  const { inProgressOp } = await checkGitState();
+  return inProgressOp;
+}
+async function hasGitLockFile() {
+  const { lockFile } = await checkGitState();
+  return lockFile;
+}
+async function assertCleanGitState(action) {
+  const { lockFile, inProgressOp, gitDir } = await checkGitState();
+  if (lockFile) {
+    const lockPath = gitDir ? `${gitDir}/index.lock` : ".git/index.lock";
+    console.error("\x1B[31m✖\x1B[0m A git lock file exists (index.lock). Another git process may be running.");
+    console.error(`\x1B[36mℹ\x1B[0m If no other git process is running, remove it: rm ${lockPath}`);
+    process.exit(1);
+  }
+  if (inProgressOp) {
+    console.error(`\x1B[31m✖\x1B[0m A git ${inProgressOp} is in progress. Complete or abort it before ${action}.`);
+    console.error(`\x1B[36mℹ\x1B[0m   To abort: git ${inProgressOp} --abort`);
+    process.exit(1);
+  }
+  if (await isShallowRepo()) {
+    console.error("\x1B[33m⚠\x1B[0m This is a shallow clone — some operations may behave unexpectedly.");
+    console.error("\x1B[36mℹ\x1B[0m Consider running `git fetch --unshallow` for full history.");
+  }
+}
+async function isShallowRepo() {
+  const { exitCode, stdout } = await run(["rev-parse", "--is-shallow-repository"]);
+  if (exitCode !== 0)
+    return false;
+  return stdout.trim() === "true";
+}
 async function getCurrentBranch() {
   const { exitCode, stdout } = await run(["rev-parse", "--abbrev-ref", "HEAD"]);
   if (exitCode !== 0)
     return null;
-  return stdout.trim() || null;
+  const branch = stdout.trim();
+  if (!branch || branch === "HEAD")
+    return null;
+  return branch;
 }
 async function getRemotes() {
   const { exitCode, stdout } = await run(["remote"]);
@@ -150,12 +198,19 @@ async function getRemoteUrl(remote) {
 async function hasUncommittedChanges() {
   const { exitCode, stdout } = await run(["status", "--porcelain"]);
   if (exitCode !== 0)
-    return false;
+    return true;
   return stdout.trim().length > 0;
 }
+async function branchExists(branch) {
+  const { exitCode } = await run(["rev-parse", "--verify", branch]);
+  return exitCode === 0;
+}
 async function fetchRemote(remote) {
   return run(["fetch", remote]);
 }
+async function addRemote(name, url) {
+  return run(["remote", "add", name, url]);
+}
 async function fetchAll() {
   return run(["fetch", "--all", "--quiet"]);
 }
@@ -169,12 +224,77 @@ async function createBranch(branch, from) {
 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 rebaseAbort() {
+  return run(["rebase", "--abort"]);
+}
+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;
@@ -190,8 +310,16 @@ async function getChangedFiles() {
   const { exitCode, stdout } = await run(["status", "--porcelain"]);
   if (exitCode !== 0)
     return [];
-  return stdout.trim().split(`
-`).filter(Boolean).map((l) => l.slice(3));
+  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.lastIndexOf(" -> ");
+    return renameIdx !== -1 ? file.slice(renameIdx + 4) : file;
+  }).filter(Boolean);
 }
 async function getDivergence(branch, base) {
   const { exitCode, stdout } = await run([
@@ -215,9 +343,40 @@ async function getMergedBranches(base) {
   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) => {
+    return /\[\S+: gone\]/.test(line);
+  }).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]);
 }
@@ -238,10 +397,164 @@ async function getLog(base, head) {
 async function pullBranch(remote, branch) {
   return run(["pull", remote, branch]);
 }
+async function pullFastForwardOnly(remote, branch) {
+  return run(["pull", "--ff-only", remote, branch]);
+}
+async function refExists(ref) {
+  const { exitCode } = await run(["rev-parse", "--verify", "--quiet", ref]);
+  return exitCode === 0;
+}
+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.lastIndexOf(" -> ");
+    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 pc2 from "picocolors";
+import pc from "picocolors";
 LogEngine.configure({
   mode: LogMode.INFO,
   format: {
@@ -264,7 +577,7 @@ function info(msg) {
 }
 function heading(msg) {
   console.log(`
-${pc2.bold(msg)}`);
+${pc.bold(msg)}`);
 }
 
 // src/utils/workflow.ts
@@ -313,18 +626,37 @@ function getProtectedBranches(config) {
   }
   return branches;
 }
+function getProtectedPrefixes(config) {
+  if (config.workflow === "git-flow") {
+    return ["release/", "hotfix/"];
+  }
+  return [];
+}
+function isBranchProtected(branch, config) {
+  const protectedBranches = getProtectedBranches(config);
+  if (protectedBranches.includes(branch))
+    return true;
+  const protectedPrefixes = getProtectedPrefixes(config);
+  return protectedPrefixes.some((prefix) => branch.startsWith(prefix));
+}
 
-// src/commands/clean.ts
-var clean_default = defineCommand({
+// src/commands/branch.ts
+var branch_default = defineCommand({
   meta: {
-    name: "clean",
-    description: "Delete merged branches and prune remote refs"
+    name: "branch",
+    description: "List branches with workflow-aware labels and status"
   },
   args: {
-    yes: {
+    all: {
       type: "boolean",
-      alias: "y",
-      description: "Skip confirmation prompt",
+      alias: "a",
+      description: "Show both local and remote branches",
+      default: false
+    },
+    remote: {
+      type: "boolean",
+      alias: "r",
+      description: "Show only remote branches",
       default: false
     }
   },
@@ -334,189 +666,302 @@ var clean_default = defineCommand({
       process.exit(1);
     }
     const config = readConfig();
-    if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
-      process.exit(1);
-    }
-    const { origin } = config;
-    const baseBranch = getBaseBranch(config);
+    const protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
     const currentBranch = await getCurrentBranch();
-    heading("\uD83E\uDDF9 contrib clean");
-    const mergedBranches = await getMergedBranches(baseBranch);
-    const protectedBranches = new Set([...getProtectedBranches(config), currentBranch ?? ""]);
-    const candidates = mergedBranches.filter((b) => !protectedBranches.has(b));
-    if (candidates.length === 0) {
-      info("No merged branches to clean up.");
-    } else {
-      console.log(`
-${pc3.bold("Branches to delete:")}`);
-      for (const b of candidates) {
-        console.log(`  ${pc3.dim("•")} ${b}`);
-      }
-      console.log();
-      const ok = args.yes || await confirmPrompt(`Delete ${pc3.bold(String(candidates.length))} merged branch${candidates.length !== 1 ? "es" : ""}?`);
-      if (!ok) {
-        info("Skipped branch deletion.");
+    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 {
-        for (const branch of candidates) {
-          const result = await deleteBranch(branch);
-          if (result.exitCode === 0) {
-            success(`  Deleted ${pc3.bold(branch)}`);
+        console.log(`  ${pc2.bold("Local")}`);
+        console.log();
+        for (const branch of localBranches) {
+          const parts = [];
+          if (branch.isCurrent) {
+            parts.push(pc2.green("* "));
           } else {
-            warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
+            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("")}`);
         }
       }
     }
-    info(`Pruning ${origin} remote refs...`);
-    const pruneResult = await pruneRemote(origin);
-    if (pruneResult.exitCode === 0) {
-      success(`✅ Pruned ${origin} remote refs.`);
-    } else {
-      warn(`Could not prune remote: ${pruneResult.stderr.trim()}`);
+    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/commit.ts
+// src/commands/clean.ts
 import { defineCommand as defineCommand2 } from "citty";
-import pc4 from "picocolors";
+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;
-var CONVENTIONAL_COMMIT_PATTERN = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(!?)(\([a-zA-Z0-9][a-zA-Z0-9._-]*\))?: .{1,72}$/;
-var CONVENTION_LABELS = {
-  conventional: "Conventional Commits",
-  "clean-commit": "Clean Commit (by WGTech Labs)",
-  none: "No convention"
-};
-var CONVENTION_DESCRIPTIONS = {
-  conventional: "Conventional Commits — feat: | fix: | docs: | chore: etc. (conventionalcommits.org)",
-  "clean-commit": "Clean Commit — \uD83D\uDCE6 new: | \uD83D\uDD27 update: | \uD83D\uDDD1️ remove: etc. (by WGTech Labs)",
-  none: "No commit convention enforcement"
-};
-var CONVENTION_FORMAT_HINTS = {
-  conventional: [
-    "Format: <type>[!][(<scope>)]: <description>",
-    "Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert",
-    "Examples: feat: add login page | fix(auth): resolve token expiry | docs: update README"
-  ],
-  "clean-commit": [
-    "Format: <emoji> <type>[!][(<scope>)]: <description>",
-    "Types: \uD83D\uDCE6 new | \uD83D\uDD27 update | \uD83D\uDDD1️ remove | \uD83D\uDD12 security | ⚙️ setup | ☕ chore | \uD83E\uDDEA test | \uD83D\uDCD6 docs | \uD83D\uDE80 release",
-    "Examples: \uD83D\uDCE6 new: user auth | \uD83D\uDD27 update (api): improve errors | ⚙️ setup (ci): add workflow"
-  ]
-};
-function validateCommitMessage(message, convention) {
-  if (convention === "none")
-    return true;
-  if (convention === "clean-commit")
-    return CLEAN_COMMIT_PATTERN.test(message);
-  if (convention === "conventional")
-    return CONVENTIONAL_COMMIT_PATTERN.test(message);
-  return true;
+// 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 getValidationError(convention) {
-  if (convention === "none")
-    return [];
-  return [
-    `Commit message does not follow ${CONVENTION_LABELS[convention]} format.`,
-    ...CONVENTION_FORMAT_HINTS[convention]
-  ];
+function formatBranchName(prefix, name) {
+  const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${prefix}/${sanitized}`;
+}
+var RESERVED_GIT_NAMES = new Set([
+  "HEAD",
+  "FETCH_HEAD",
+  "ORIG_HEAD",
+  "MERGE_HEAD",
+  "CHERRY_PICK_HEAD",
+  "REBASE_HEAD",
+  "BISECT_HEAD"
+]);
+function isValidBranchName(name) {
+  if (!name || name.length === 0)
+    return false;
+  if (RESERVED_GIT_NAMES.has(name))
+    return false;
+  if (name.startsWith("-"))
+    return false;
+  if (name.includes("..") || name.includes("@{"))
+    return false;
+  if (/[\x00-\x1f\x7f ~^:?*[\]\\]/.test(name))
+    return false;
+  if (name.includes("/.") || name.endsWith(".lock") || name.endsWith("."))
+    return false;
+  if (!/^[a-zA-Z0-9._/-]+$/.test(name))
+    return false;
+  if (name.startsWith("/") || name.endsWith("/") || name.includes("//"))
+    return false;
+  return true;
+}
+function looksLikeNaturalLanguage(input) {
+  return input.includes(" ") && !input.includes("/");
 }
 
-// src/utils/copilot.ts
-import { CopilotClient } from "@github/copilot-sdk";
-var CONVENTIONAL_COMMIT_SYSTEM_PROMPT = `You are a git commit message generator. Generate a Conventional Commit message following this exact format:
-<type>[!][(<scope>)]: <description>
-
-Types:
-feat     – a new feature
-fix      – a bug fix
-docs     – documentation only changes
-style    – changes that do not affect code meaning (whitespace, formatting)
-refactor – code change that neither fixes a bug nor adds a feature
-perf     – performance improvement
-test     – adding or correcting tests
-build    – changes to the build system or external dependencies
-ci       – changes to CI configuration files and scripts
-chore    – other changes that don't modify src or test files
-revert   – reverts a previous commit
-
-Rules:
-- Breaking change (!) only for: feat, fix, refactor, perf
-- Description: concise, imperative mood, max 72 chars, lowercase start
-- Scope: optional, camelCase or kebab-case component name
-- Return ONLY the commit message line, nothing else
-
-Examples:
-feat: add user authentication system
-fix(auth): resolve token expiry issue
-docs: update contributing guidelines
-feat!: redesign authentication API`;
-var CLEAN_COMMIT_SYSTEM_PROMPT = `You are a git commit message generator. Generate a Clean Commit message following this exact format:
-<emoji> <type>[!][(<scope>)]: <description>
-
-Emoji and type table:
-\uD83D\uDCE6 new      – new features, files, or capabilities
-\uD83D\uDD27 update   – changes, refactoring, improvements
-\uD83D\uDDD1️ remove   – removing code, files, or dependencies
-\uD83D\uDD12 security – security fixes or patches
-⚙️ setup    – configs, CI/CD, tooling, build systems
-☕ chore    – maintenance, dependency updates
-\uD83E\uDDEA test     – adding or updating tests
-\uD83D\uDCD6 docs     – documentation changes
-\uD83D\uDE80 release  – version releases
+// src/utils/confirm.ts
+import * as clack from "@clack/prompts";
+import pc3 from "picocolors";
+function handleCancel(value) {
+  if (clack.isCancel(value)) {
+    clack.cancel("Cancelled.");
+    process.exit(0);
+  }
+}
+async function confirmPrompt(message) {
+  const result = await clack.confirm({ message });
+  handleCancel(result);
+  return result;
+}
+async function selectPrompt(message, choices) {
+  const result = await clack.select({
+    message,
+    options: choices.map((choice) => ({ value: choice, label: choice }))
+  });
+  handleCancel(result);
+  return result;
+}
+async function inputPrompt(message, defaultValue) {
+  const result = await clack.text({
+    message,
+    placeholder: defaultValue,
+    defaultValue
+  });
+  handleCancel(result);
+  return result || defaultValue || "";
+}
+async function multiSelectPrompt(message, choices) {
+  const result = await clack.multiselect({
+    message: `${message} ${pc3.dim("(space to toggle, enter to confirm)")}`,
+    options: choices.map((choice) => ({ value: choice, label: choice })),
+    required: false
+  });
+  handleCancel(result);
+  return result;
+}
 
-Rules:
-- Breaking change (!) only for: new, update, remove, security
-- Description: concise, imperative mood, max 72 chars
-- Scope: optional, camelCase or kebab-case component name
-- Return ONLY the commit message line, nothing else
+// src/utils/copilot.ts
+import { CopilotClient } from "@github/copilot-sdk";
+var CONVENTIONAL_COMMIT_SYSTEM_PROMPT = `Git commit message generator. Format: <type>[!][(<scope>)]: <description>
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+Rules: breaking (!) only for feat/fix/refactor/perf; imperative mood; max 72 chars; lowercase start; scope optional camelCase/kebab-case. Return ONLY the message line.
+Examples: feat: add user auth | fix(auth): resolve token expiry | feat!: redesign auth API`;
+var CLEAN_COMMIT_SYSTEM_PROMPT = `Git commit message generator. EXACT format: <emoji> <type>[!][ (<scope>)]: <description>
+Spacing: EMOJI SPACE TYPE [SPACE OPENPAREN SCOPE CLOSEPAREN] COLON SPACE DESCRIPTION
+Types: \uD83D\uDCE6 new, \uD83D\uDD27 update, \uD83D\uDDD1️ remove, \uD83D\uDD12 security, ⚙️ setup, ☕ chore, \uD83E\uDDEA test, \uD83D\uDCD6 docs, \uD83D\uDE80 release
+Rules: breaking (!) only for new/update/remove/security; imperative mood; max 72 chars; lowercase start; scope optional. Return ONLY the message line.
+Correct: \uD83D\uDCE6 new: add user auth | \uD83D\uDD27 update (api): improve error handling | ⚙️ setup (ci): configure github actions
+WRONG: ⚙️setup(ci): ... | \uD83D\uDD27 update(api): ... ← always space before scope parenthesis`;
+function getGroupingSystemPrompt(convention) {
+  const conventionBlock = convention === "conventional" ? `Use Conventional Commit format: <type>[(<scope>)]: <description>
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert` : `Use Clean Commit format: <emoji> <type>[!][ (<scope>)]: <description>
+Emoji/type table:
+\uD83D\uDCE6 new, \uD83D\uDD27 update, \uD83D\uDDD1️ remove, \uD83D\uDD12 security, ⚙️ setup, ☕ chore, \uD83E\uDDEA test, \uD83D\uDCD6 docs, \uD83D\uDE80 release`;
+  return `You are a smart commit grouping assistant. Given a list of changed files and their diffs, group related changes into logical atomic commits.
 
-Examples:
-\uD83D\uDCE6 new: user authentication system
-\uD83D\uDD27 update (api): improve error handling
-⚙️ setup (ci): configure github actions workflow
-\uD83D\uDCE6 new!: completely redesign authentication system`;
-var BRANCH_NAME_SYSTEM_PROMPT = `You are a git branch name generator. Convert natural language descriptions into proper git branch names.
+${conventionBlock}
 
-Format: <prefix>/<kebab-case-name>
-Prefixes: feature, fix, docs, chore, test, refactor
+Return a JSON array of commit groups with this EXACT structure (no markdown fences, no explanation):
+[
+  {
+    "files": ["path/to/file1.ts", "path/to/file2.ts"],
+    "message": "<commit message following the convention above>"
+  }
+]
 
 Rules:
-- Use lowercase kebab-case for the name part
-- Keep it short and descriptive (2-5 words max)
-- Return ONLY the branch name, nothing else
-
-Examples:
-Input: "fix the login timeout bug" → fix/login-timeout
-Input: "add user profile page" → feature/user-profile-page
-Input: "update readme documentation" → docs/update-readme`;
-var PR_DESCRIPTION_SYSTEM_PROMPT = `You are a GitHub pull request description generator. Create a clear, structured PR description.
-
-Return a JSON object with this exact structure:
-{
-  "title": "Brief PR title (50 chars max)",
-  "body": "## Summary\\n...\\n\\n## Changes\\n...\\n\\n## Test Plan\\n..."
+- Group files that are logically related (e.g. a utility and its tests, a feature and its types)
+- Each group should represent ONE logical change
+- Every file must appear in exactly one group
+- Commit messages must follow the convention, be concise, imperative, max 72 chars
+- Order groups so foundational changes come first (types, utils) and consumers come after
+- Return ONLY the JSON array, nothing else`;
+}
+var BRANCH_NAME_SYSTEM_PROMPT = `You are a git branch name generator. Your ONLY job is to output a single git branch name. NOTHING ELSE.
+Output format: <prefix>/<kebab-case-name>
+Valid prefixes: feature, fix, docs, chore, test, refactor
+Rules: lowercase, kebab-case, 2-5 words after the prefix, no punctuation.
+CRITICAL: Output ONLY the branch name on a single line. No explanation. No markdown. No questions. No other text.
+Examples: fix/login-timeout | feature/user-profile-page | docs/update-readme | chore/update-pr-title`;
+var PR_DESCRIPTION_SYSTEM_PROMPT_BASE = `GitHub PR description generator. Return JSON: {"title":"<72 chars>","body":"## Summary\\n...\\n\\n## Changes\\n- ...\\n\\n## Test Plan\\n..."}
+IMPORTANT: The title must capture the overall theme or goal of the PR — NOT enumerate individual changes. Think: what problem does this PR solve or what capability does it add? Keep it focused and specific but high-level.`;
+function getPRDescriptionSystemPrompt(convention) {
+  if (convention === "clean-commit") {
+    return `${PR_DESCRIPTION_SYSTEM_PROMPT_BASE}
+CRITICAL: The PR title MUST follow the Clean Commit format exactly: <emoji> <type>: <description>
+Emoji/type table: \uD83D\uDCE6 new, \uD83D\uDD27 update, \uD83D\uDDD1️ remove, \uD83D\uDD12 security, ⚙️ setup, ☕ chore, \uD83E\uDDEA test, \uD83D\uDCD6 docs, \uD83D\uDE80 release
+Title examples: \uD83D\uDCE6 new: add user authentication | \uD83D\uDD27 update: improve error handling | \uD83D\uDDD1️ remove: drop legacy API
+Rules: title follows convention, present tense, max 72 chars, describes the PR theme not individual commits; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+  }
+  if (convention === "conventional") {
+    return `${PR_DESCRIPTION_SYSTEM_PROMPT_BASE}
+CRITICAL: The PR title MUST follow Conventional Commits format: <type>[(<scope>)]: <description>
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+Title examples: feat: add user authentication | fix(auth): resolve token expiry | docs: update contributing guide
+Rules: title follows convention, present tense, max 72 chars, describes the PR theme not individual commits; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+  }
+  return `${PR_DESCRIPTION_SYSTEM_PROMPT_BASE}
+Rules: title concise present tense, describes the PR theme not individual commits; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+}
+var CONFLICT_RESOLUTION_SYSTEM_PROMPT = `Git merge conflict advisor. Explain each side, suggest resolution strategy. Never auto-resolve — guidance only. Be concise and actionable.`;
+function suppressSubprocessWarnings() {
+  process.env.NODE_NO_WARNINGS = "1";
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Copilot request timed out after ${ms / 1000}s`)), ms);
+    promise.then((val) => {
+      clearTimeout(timer);
+      resolve(val);
+    }, (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
 }
-
-Rules:
-- title: concise, present tense, describes what the PR does
-- body: markdown with Summary, Changes (bullet list), and Test Plan sections
-- Return ONLY the JSON object, no markdown fences, no extra text`;
-var CONFLICT_RESOLUTION_SYSTEM_PROMPT = `You are a git merge conflict resolution advisor. Analyze the conflict markers and provide guidance.
-
-Rules:
-- Explain what each side of the conflict contains
-- Suggest the most likely correct resolution strategy
-- Never auto-resolve — provide guidance only
-- Be concise and actionable`;
+var COPILOT_TIMEOUT_MS = 30000;
+var COPILOT_LONG_TIMEOUT_MS = 90000;
 async function checkCopilotAvailable() {
-  let client = null;
   try {
-    client = new CopilotClient;
-    await client.start();
+    const client = await getManagedClient();
+    try {
+      await client.ping();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("auth") || msg.includes("token") || msg.includes("401") || msg.includes("403")) {
+        return "Copilot authentication failed. Run `gh auth login` to refresh your token.";
+      }
+      if (msg.includes("ECONNREFUSED") || msg.includes("timeout") || msg.includes("network")) {
+        return "Could not reach GitHub Copilot service. Check your internet connection.";
+      }
+      return `Copilot health check failed: ${msg}`;
+    }
+    return null;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     if (msg.includes("ENOENT") || msg.includes("not found")) {
@@ -524,44 +969,45 @@ async function checkCopilotAvailable() {
     }
     return `Failed to start Copilot service: ${msg}`;
   }
-  try {
-    await client.ping();
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("auth") || msg.includes("token") || msg.includes("401") || msg.includes("403")) {
-      return "Copilot authentication failed. Run `gh auth login` to refresh your token.";
-    }
-    if (msg.includes("ECONNREFUSED") || msg.includes("timeout") || msg.includes("network")) {
-      return "Could not reach GitHub Copilot service. Check your internet connection.";
-    }
-    return `Copilot health check failed: ${msg}`;
-  } finally {
-    try {
-      await client.stop();
-    } catch {}
+}
+var _managedClient = null;
+var _clientStarted = false;
+async function getManagedClient() {
+  if (!_managedClient || !_clientStarted) {
+    suppressSubprocessWarnings();
+    _managedClient = new CopilotClient;
+    await _managedClient.start();
+    _clientStarted = true;
+    const cleanup = () => {
+      if (_managedClient && _clientStarted) {
+        try {
+          _managedClient.stop();
+        } catch {}
+        _clientStarted = false;
+        _managedClient = null;
+      }
+    };
+    process.once("exit", cleanup);
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
   }
-  return null;
+  return _managedClient;
 }
-async function callCopilot(systemMessage, userMessage, model) {
-  const client = new CopilotClient;
-  await client.start();
+async function callCopilot(systemMessage, userMessage, model, timeoutMs = COPILOT_TIMEOUT_MS) {
+  const client = await getManagedClient();
+  const sessionConfig = {
+    systemMessage: { mode: "replace", content: systemMessage }
+  };
+  if (model)
+    sessionConfig.model = model;
+  const session = await client.createSession(sessionConfig);
   try {
-    const sessionConfig = {
-      systemMessage: { content: systemMessage }
-    };
-    if (model)
-      sessionConfig.model = model;
-    const session = await client.createSession(sessionConfig);
-    try {
-      const response = await session.sendAndWait({ content: userMessage });
-      if (!response?.data?.content)
-        return null;
-      return response.data.content;
-    } finally {
-      await session.destroy();
-    }
+    const response = await withTimeout(session.sendAndWait({ prompt: userMessage }), timeoutMs);
+    if (!response?.data?.content)
+      return null;
+    return response.data.content;
   } finally {
-    await client.stop();
+    await session.destroy();
   }
 }
 function getCommitSystemPrompt(convention) {
@@ -569,21 +1015,53 @@ function getCommitSystemPrompt(convention) {
     return CONVENTIONAL_COMMIT_SYSTEM_PROMPT;
   return CLEAN_COMMIT_SYSTEM_PROMPT;
 }
+function extractJson(raw) {
+  let text2 = raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+  if (text2.startsWith("[") || text2.startsWith("{"))
+    return text2;
+  const arrayStart = text2.indexOf("[");
+  const objStart = text2.indexOf("{");
+  let start;
+  let closeChar;
+  if (arrayStart === -1 && objStart === -1)
+    return text2;
+  if (arrayStart === -1) {
+    start = objStart;
+    closeChar = "}";
+  } else if (objStart === -1) {
+    start = arrayStart;
+    closeChar = "]";
+  } else if (arrayStart < objStart) {
+    start = arrayStart;
+    closeChar = "]";
+  } else {
+    start = objStart;
+    closeChar = "}";
+  }
+  const end = text2.lastIndexOf(closeChar);
+  if (end > start) {
+    text2 = text2.slice(start, end + 1);
+  }
+  return text2;
+}
 async function generateCommitMessage(diff, stagedFiles, model, convention = "clean-commit") {
   try {
+    const multiFileHint = stagedFiles.length > 1 ? `
+
+IMPORTANT: Multiple files are staged. Generate ONE commit message that captures the high-level purpose of ALL changes together. Focus on the overall intent, not individual file changes. Be specific but concise — do not list every file.` : "";
     const userMessage = `Generate a commit message for these staged changes:
 
 Files: ${stagedFiles.join(", ")}
 
 Diff:
-${diff.slice(0, 4000)}`;
+${diff.slice(0, 4000)}${multiFileHint}`;
     const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model);
     return result?.trim() ?? null;
   } catch {
     return null;
   }
 }
-async function generatePRDescription(commits, diff, model) {
+async function generatePRDescription(commits, diff, model, convention = "clean-commit") {
   try {
     const userMessage = `Generate a PR description for these changes:
 
@@ -593,10 +1071,10 @@ ${commits.join(`
 
 Diff (truncated):
 ${diff.slice(0, 4000)}`;
-    const result = await callCopilot(PR_DESCRIPTION_SYSTEM_PROMPT, userMessage, model);
+    const result = await callCopilot(getPRDescriptionSystemPrompt(convention), userMessage, model);
     if (!result)
       return null;
-    const cleaned = result.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+    const cleaned = extractJson(result);
     return JSON.parse(cleaned);
   } catch {
     return null;
@@ -605,25 +1083,557 @@ ${diff.slice(0, 4000)}`;
 async function suggestBranchName(description, model) {
   try {
     const result = await callCopilot(BRANCH_NAME_SYSTEM_PROMPT, description, model);
+    const trimmed = result?.trim() ?? null;
+    if (trimmed && /^[a-z]+\/[a-z0-9-]+$/.test(trimmed)) {
+      return trimmed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function suggestConflictResolution(conflictDiff, model) {
+  try {
+    const userMessage = `Help me resolve this merge conflict:
+
+${conflictDiff.slice(0, 4000)}`;
+    const result = await callCopilot(CONFLICT_RESOLUTION_SYSTEM_PROMPT, userMessage, model);
     return result?.trim() ?? null;
   } catch {
     return null;
   }
 }
-async function suggestConflictResolution(conflictDiff, model) {
-  try {
-    const userMessage = `Help me resolve this merge conflict:
-
-${conflictDiff.slice(0, 4000)}`;
-    const result = await callCopilot(CONFLICT_RESOLUTION_SYSTEM_PROMPT, userMessage, model);
-    return result?.trim() ?? null;
-  } catch {
-    return null;
-  }
+async function generateCommitGroups(files, diffs, model, convention = "clean-commit") {
+  const userMessage = `Group these changed files into logical atomic commits:
+
+Files:
+${files.join(`
+`)}
+
+Diffs (truncated):
+${diffs.slice(0, 6000)}`;
+  const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+  if (!result) {
+    throw new Error("AI returned an empty response");
+  }
+  const cleaned = extractJson(result);
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    throw new Error(`AI response is not valid JSON. Raw start: "${result.slice(0, 120)}..."`);
+  }
+  const groups = parsed;
+  if (!Array.isArray(groups) || groups.length === 0) {
+    throw new Error("AI response was not a valid JSON array of commit groups");
+  }
+  for (const group of groups) {
+    if (!Array.isArray(group.files) || typeof group.message !== "string") {
+      throw new Error("AI returned groups with invalid structure (missing files or message)");
+    }
+  }
+  return groups;
+}
+async function regenerateAllGroupMessages(groups, diffs, model, convention = "clean-commit") {
+  const groupSummary = groups.map((g, i) => `Group ${i + 1}: [${g.files.join(", ")}]`).join(`
+`);
+  const userMessage = `Regenerate ONLY the commit messages for these pre-defined file groups. Do NOT change the file groupings.
+
+Groups:
+${groupSummary}
+
+Diffs (truncated):
+${diffs.slice(0, 6000)}`;
+  const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+  if (!result)
+    return groups;
+  try {
+    const cleaned = extractJson(result);
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed) || parsed.length !== groups.length)
+      return groups;
+    return groups.map((g, i) => ({
+      files: g.files,
+      message: typeof parsed[i]?.message === "string" ? parsed[i].message : g.message
+    }));
+  } catch {
+    return groups;
+  }
+}
+async function regenerateGroupMessage(files, diffs, model, convention = "clean-commit") {
+  try {
+    const userMessage = `Generate a single commit message for these files:
+
+Files: ${files.join(", ")}
+
+Diff:
+${diffs.slice(0, 4000)}`;
+    const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model);
+    return result?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/gh.ts
+import { execFile as execFileCb2 } from "node:child_process";
+function run2(args) {
+  return new Promise((resolve) => {
+    execFileCb2("gh", args, (error2, stdout, stderr) => {
+      resolve({
+        exitCode: error2 ? error2.code === "ENOENT" ? 127 : error2.status ?? 1 : 0,
+        stdout: stdout ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
+}
+async function checkGhInstalled() {
+  try {
+    const { exitCode } = await run2(["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function checkGhAuth() {
+  try {
+    const { exitCode } = await run2(["auth", "status"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+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"]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    return JSON.parse(stdout.trim());
+  } catch {
+    return null;
+  }
+}
+async function isRepoFork() {
+  const { exitCode, stdout } = await run2(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
+  if (exitCode !== 0)
+    return null;
+  const val = stdout.trim();
+  if (val === "true")
+    return true;
+  if (val === "false")
+    return false;
+  return null;
+}
+async function getCurrentRepoInfo() {
+  const { exitCode, stdout } = await run2([
+    "repo",
+    "view",
+    "--json",
+    "nameWithOwner",
+    "-q",
+    ".nameWithOwner"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  const nameWithOwner = stdout.trim();
+  if (!nameWithOwner)
+    return null;
+  const [owner, repo] = nameWithOwner.split("/");
+  if (!owner || !repo)
+    return null;
+  return { owner, repo };
+}
+async function createPR(options) {
+  const args = [
+    "pr",
+    "create",
+    "--base",
+    options.base,
+    "--title",
+    options.title,
+    "--body",
+    options.body
+  ];
+  if (options.draft)
+    args.push("--draft");
+  return run2(args);
+}
+async function createPRFill(base, draft) {
+  const args = ["pr", "create", "--base", base, "--fill"];
+  if (draft)
+    args.push("--draft");
+  return run2(args);
+}
+async function getPRForBranch(headBranch) {
+  const { exitCode, stdout } = await run2([
+    "pr",
+    "list",
+    "--head",
+    headBranch,
+    "--state",
+    "open",
+    "--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;
+  }
+}
+async function getMergedPRForBranch(headBranch) {
+  const { exitCode, stdout } = await run2([
+    "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/spinner.ts
+import pc4 from "picocolors";
+var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function createSpinner(text2) {
+  let frameIdx = 0;
+  let currentText = text2;
+  let stopped = false;
+  const clearLine = () => {
+    process.stderr.write("\r\x1B[K");
+  };
+  const render = () => {
+    if (stopped)
+      return;
+    const frame = pc4.cyan(FRAMES[frameIdx % FRAMES.length]);
+    clearLine();
+    process.stderr.write(`${frame} ${currentText}`);
+    frameIdx++;
+  };
+  const timer = setInterval(render, 80);
+  render();
+  const stop = () => {
+    if (stopped)
+      return;
+    stopped = true;
+    clearInterval(timer);
+    clearLine();
+  };
+  return {
+    update(newText) {
+      currentText = newText;
+    },
+    success(msg) {
+      stop();
+      process.stderr.write(`${pc4.green("✔")} ${msg}
+`);
+    },
+    fail(msg) {
+      stop();
+      process.stderr.write(`${pc4.red("✖")} ${msg}
+`);
+    },
+    stop() {
+      stop();
+    }
+  };
+}
+
+// src/commands/clean.ts
+async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
+  if (!config)
+    return "skipped";
+  const { origin } = config;
+  const localWork = await hasLocalWork(origin, currentBranch);
+  const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
+  if (hasWork) {
+    if (localWork.uncommitted) {
+      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.`);
+    }
+    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]);
+    if (action === CANCEL)
+      return "skipped";
+    if (action === SAVE_NEW_BRANCH) {
+      if (!config)
+        return "skipped";
+      info(pc5.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
+      const description = await inputPrompt("What are you going to work on?");
+      let newBranchName = description;
+      if (looksLikeNaturalLanguage(description)) {
+        const spinner = createSpinner("Generating branch name suggestion...");
+        const suggested = await suggestBranchName(description);
+        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?`);
+          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 ${pc5.bold(newBranchName)}:`, config.branchPrefixes);
+        newBranchName = formatBranchName(prefix, newBranchName);
+      }
+      if (!isValidBranchName(newBranchName)) {
+        error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
+        return "skipped";
+      }
+      if (await branchExists(newBranchName)) {
+        error(`Branch ${pc5.bold(newBranchName)} already exists. Choose a different name.`);
+        return "skipped";
+      }
+      const renameResult = await renameBranch(currentBranch, newBranchName);
+      if (renameResult.exitCode !== 0) {
+        error(`Failed to rename branch: ${renameResult.stderr}`);
+        return "skipped";
+      }
+      success(`Renamed ${pc5.bold(currentBranch)} → ${pc5.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) {
+        await rebaseAbort();
+        warn("Rebase had conflicts — aborted to keep the repo in a clean state.");
+        info(`Your work is saved on ${pc5.bold(newBranchName)}. After cleanup, rebase manually:`);
+        info(`  ${pc5.bold(`git checkout ${newBranchName} && git rebase ${syncSource2.ref}`)}`);
+      } else {
+        success(`Rebased ${pc5.bold(newBranchName)} onto ${pc5.bold(syncSource2.ref)}.`);
+      }
+      const coResult2 = await checkoutBranch(baseBranch);
+      if (coResult2.exitCode !== 0) {
+        error(`Failed to checkout ${baseBranch}: ${coResult2.stderr}`);
+        return "saved";
+      }
+      await updateLocalBranch(baseBranch, syncSource2.ref);
+      success(`Synced ${pc5.bold(baseBranch)} with ${pc5.bold(syncSource2.ref)}.`);
+      return "saved";
+    }
+  }
+  const syncSource = getSyncSource(config);
+  info(`Switching to ${pc5.bold(baseBranch)} and syncing...`);
+  await fetchRemote(syncSource.remote);
+  await resetHard("HEAD");
+  const coResult = await checkoutBranch(baseBranch);
+  if (coResult.exitCode !== 0) {
+    error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
+    return "skipped";
+  }
+  await updateLocalBranch(baseBranch, syncSource.ref);
+  success(`Synced ${pc5.bold(baseBranch)} with ${pc5.bold(syncSource.ref)}.`);
+  return "switched";
+}
+var clean_default = defineCommand2({
+  meta: {
+    name: "clean",
+    description: "Delete merged branches and prune remote refs"
+  },
+  args: {
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip confirmation prompt",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    await assertCleanGitState("cleaning");
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    const { origin } = config;
+    const baseBranch = getBaseBranch(config);
+    let currentBranch = await getCurrentBranch();
+    heading("\uD83E\uDDF9 contrib clean");
+    info(`Pruning ${origin} remote refs...`);
+    const pruneResult = await pruneRemote(origin);
+    if (pruneResult.exitCode === 0) {
+      success(`Pruned ${origin} remote refs.`);
+    } else {
+      warn(`Could not prune remote: ${pruneResult.stderr.trim()}`);
+    }
+    const protectedBranches = new Set(getProtectedBranches(config));
+    const isProtected = (b) => protectedBranches.has(b) || isBranchProtected(b, config);
+    const mergedBranches = await getMergedBranches(baseBranch);
+    const mergedCandidates = mergedBranches.filter((b) => !isProtected(b));
+    const goneBranches = await getGoneBranches();
+    const goneCandidates = goneBranches.filter((b) => !isProtected(b) && !mergedCandidates.includes(b));
+    if (currentBranch && !isProtected(currentBranch) && !mergedCandidates.includes(currentBranch) && !goneCandidates.includes(currentBranch)) {
+      const ghInstalled = await checkGhInstalled();
+      const ghAuthed = ghInstalled && await checkGhAuth();
+      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)}`);
+          goneCandidates.push(currentBranch);
+        }
+      }
+    }
+    if (mergedCandidates.length > 0) {
+      console.log(`
+${pc5.bold("Merged branches to delete:")}`);
+      for (const b of mergedCandidates) {
+        const marker = b === currentBranch ? pc5.yellow(" (current)") : "";
+        console.log(`  ${pc5.dim("•")} ${b}${marker}`);
+      }
+      console.log();
+      const ok = args.yes || await confirmPrompt(`Delete ${pc5.bold(String(mergedCandidates.length))} merged branch${mergedCandidates.length !== 1 ? "es" : ""}?`);
+      if (ok) {
+        for (const branch of mergedCandidates) {
+          if (branch === currentBranch) {
+            const result2 = await handleCurrentBranchDeletion(currentBranch, baseBranch, config);
+            if (result2 === "skipped") {
+              warn(`  Skipped ${branch}.`);
+              continue;
+            }
+            if (result2 === "saved") {
+              currentBranch = baseBranch;
+              continue;
+            }
+            currentBranch = baseBranch;
+          }
+          const result = await deleteBranch(branch);
+          if (result.exitCode === 0) {
+            success(`  Deleted ${pc5.bold(branch)}`);
+          } else {
+            warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
+          }
+        }
+      } else {
+        info("Skipped merged branch deletion.");
+      }
+    }
+    if (goneCandidates.length > 0) {
+      console.log(`
+${pc5.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}`);
+      }
+      console.log();
+      const ok = args.yes || await confirmPrompt(`Delete ${pc5.bold(String(goneCandidates.length))} stale branch${goneCandidates.length !== 1 ? "es" : ""}?`);
+      if (ok) {
+        for (const branch of goneCandidates) {
+          if (branch === currentBranch) {
+            const result2 = await handleCurrentBranchDeletion(currentBranch, baseBranch, config);
+            if (result2 === "skipped") {
+              warn(`  Skipped ${branch}.`);
+              continue;
+            }
+            if (result2 === "saved") {
+              currentBranch = baseBranch;
+              continue;
+            }
+            currentBranch = baseBranch;
+          }
+          const result = await forceDeleteBranch(branch);
+          if (result.exitCode === 0) {
+            success(`  Deleted ${pc5.bold(branch)}`);
+          } else {
+            warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
+          }
+        }
+      } else {
+        info("Skipped stale branch deletion.");
+      }
+    }
+    if (mergedCandidates.length === 0 && goneCandidates.length === 0) {
+      info("No branches to clean up. Everything is tidy! \uD83E\uDDF9");
+    }
+    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.`);
+    }
+  }
+});
+
+// src/commands/commit.ts
+import { defineCommand as defineCommand3 } from "citty";
+import pc6 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;
+var CONVENTIONAL_COMMIT_PATTERN = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(!?)(\([a-zA-Z0-9][a-zA-Z0-9._-]*\))?: .{1,72}$/;
+var CONVENTION_LABELS = {
+  conventional: "Conventional Commits",
+  "clean-commit": "Clean Commit (by WGTech Labs)",
+  none: "No convention"
+};
+var CONVENTION_DESCRIPTIONS = {
+  conventional: "Conventional Commits — feat: | fix: | docs: | chore: etc. (conventionalcommits.org)",
+  "clean-commit": "Clean Commit — \uD83D\uDCE6 new: | \uD83D\uDD27 update: | \uD83D\uDDD1️ remove: etc. (by WGTech Labs)",
+  none: "No commit convention enforcement"
+};
+var CONVENTION_FORMAT_HINTS = {
+  conventional: [
+    "Format: <type>[!][(<scope>)]: <description>",
+    "Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert",
+    "Examples: feat: add login page | fix(auth): resolve token expiry | docs: update README"
+  ],
+  "clean-commit": [
+    "Format: <emoji> <type>[!][(<scope>)]: <description>",
+    "Types: \uD83D\uDCE6 new | \uD83D\uDD27 update | \uD83D\uDDD1️ remove | \uD83D\uDD12 security | ⚙️ setup | ☕ chore | \uD83E\uDDEA test | \uD83D\uDCD6 docs | \uD83D\uDE80 release",
+    "Examples: \uD83D\uDCE6 new: user auth | \uD83D\uDD27 update (api): improve errors | ⚙️ setup (ci): add workflow"
+  ]
+};
+function validateCommitMessage(message, convention) {
+  if (convention === "none")
+    return true;
+  if (convention === "clean-commit")
+    return CLEAN_COMMIT_PATTERN.test(message);
+  if (convention === "conventional")
+    return CONVENTIONAL_COMMIT_PATTERN.test(message);
+  return true;
+}
+function getValidationError(convention) {
+  if (convention === "none")
+    return [];
+  return [
+    `Commit message does not follow ${CONVENTION_LABELS[convention]} format.`,
+    ...CONVENTION_FORMAT_HINTS[convention]
+  ];
 }
 
 // src/commands/commit.ts
-var commit_default = defineCommand2({
+var commit_default = defineCommand3({
   meta: {
     name: "commit",
     description: "Stage changes and create a commit message (AI-powered)"
@@ -637,6 +1647,11 @@ var commit_default = defineCommand2({
       type: "boolean",
       description: "Skip AI and write commit message manually",
       default: false
+    },
+    group: {
+      type: "boolean",
+      description: "AI groups related changes into separate atomic commits",
+      default: false
     }
   },
   async run({ args }) {
@@ -644,13 +1659,18 @@ var commit_default = defineCommand2({
       error("Not inside a git repository.");
       process.exit(1);
     }
+    await assertCleanGitState("committing");
     const config = readConfig();
     if (!config) {
       error("No .contributerc.json found. Run `contrib setup` first.");
       process.exit(1);
     }
     heading("\uD83D\uDCBE contrib commit");
-    const stagedFiles = await getStagedFiles();
+    if (args.group) {
+      await runGroupCommit(args.model, config);
+      return;
+    }
+    let stagedFiles = await getStagedFiles();
     if (stagedFiles.length === 0) {
       const changedFiles = await getChangedFiles();
       if (changedFiles.length === 0) {
@@ -658,31 +1678,62 @@ var commit_default = defineCommand2({
         process.exit(1);
       }
       console.log(`
-${pc4.bold("Changed files:")}`);
+${pc6.bold("Changed files:")}`);
       for (const f of changedFiles) {
-        console.log(`  ${pc4.dim("•")} ${f}`);
+        console.log(`  ${pc6.dim("•")} ${f}`);
+      }
+      const stageAction = await selectPrompt("No staged changes. How would you like to stage?", [
+        "Stage all changes",
+        "Select files to stage",
+        "Cancel"
+      ]);
+      if (stageAction === "Cancel") {
+        process.exit(0);
+      }
+      if (stageAction === "Stage all changes") {
+        const result2 = await stageAll();
+        if (result2.exitCode !== 0) {
+          error(`Failed to stage files: ${result2.stderr}`);
+          process.exit(1);
+        }
+        success("Staged all changes.");
+      } else {
+        const selected = await multiSelectPrompt("Select files to stage:", changedFiles);
+        if (selected.length === 0) {
+          error("No files selected.");
+          process.exit(1);
+        }
+        const result2 = await stageFiles(selected);
+        if (result2.exitCode !== 0) {
+          error(`Failed to stage files: ${result2.stderr}`);
+          process.exit(1);
+        }
+        success(`Staged ${selected.length} file(s).`);
+      }
+      stagedFiles = await getStagedFiles();
+      if (stagedFiles.length === 0) {
+        error("No staged changes after staging attempt.");
+        process.exit(1);
       }
-      console.log();
-      warn("No staged changes. Stage your files with `git add` and re-run.");
-      process.exit(1);
     }
     info(`Staged files: ${stagedFiles.join(", ")}`);
     let commitMessage = null;
     const useAI = !args["no-ai"];
     if (useAI) {
-      const copilotError = await checkCopilotAvailable();
+      const [copilotError, diff] = await Promise.all([checkCopilotAvailable(), getStagedDiff()]);
       if (copilotError) {
         warn(`AI unavailable: ${copilotError}`);
         warn("Falling back to manual commit message entry.");
       } else {
-        info("Generating commit message with AI...");
-        const diff = await getStagedDiff();
+        const spinner = createSpinner("Generating commit message with AI...");
         commitMessage = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
         if (commitMessage) {
+          spinner.success("AI commit message generated.");
           console.log(`
-  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(commitMessage))}`);
+  ${pc6.dim("AI suggestion:")} ${pc6.bold(pc6.cyan(commitMessage))}`);
         } else {
-          warn("AI did not return a commit message. Falling back to manual entry.");
+          spinner.fail("AI did not return a commit message.");
+          warn("Falling back to manual entry.");
         }
       }
     }
@@ -699,16 +1750,17 @@ ${pc4.bold("Changed files:")}`);
       } else if (action === "Edit this message") {
         finalMessage = await inputPrompt("Edit commit message", commitMessage);
       } else if (action === "Regenerate") {
-        info("Regenerating...");
+        const spinner = createSpinner("Regenerating commit message...");
         const diff = await getStagedDiff();
         const regen = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
         if (regen) {
+          spinner.success("Commit message regenerated.");
           console.log(`
-  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(regen))}`);
+  ${pc6.dim("AI suggestion:")} ${pc6.bold(pc6.cyan(regen))}`);
           const ok = await confirmPrompt("Use this message?");
           finalMessage = ok ? regen : await inputPrompt("Enter commit message manually");
         } else {
-          warn("Regeneration failed. Falling back to manual entry.");
+          spinner.fail("Regeneration failed.");
           finalMessage = await inputPrompt("Enter commit message");
         }
       } else {
@@ -719,7 +1771,7 @@ ${pc4.bold("Changed files:")}`);
       if (convention2 !== "none") {
         console.log();
         for (const hint of CONVENTION_FORMAT_HINTS[convention2]) {
-          console.log(pc4.dim(hint));
+          console.log(pc6.dim(hint));
         }
         console.log();
       }
@@ -729,35 +1781,611 @@ ${pc4.bold("Changed files:")}`);
       error("No commit message provided.");
       process.exit(1);
     }
-    const convention = config.commitConvention;
-    if (!validateCommitMessage(finalMessage, convention)) {
-      for (const line of getValidationError(convention)) {
-        warn(line);
+    const convention = config.commitConvention;
+    if (!validateCommitMessage(finalMessage, convention)) {
+      for (const line of getValidationError(convention)) {
+        warn(line);
+      }
+      const proceed = await confirmPrompt("Commit anyway?");
+      if (!proceed)
+        process.exit(1);
+    }
+    const result = await commitWithMessage(finalMessage);
+    if (result.exitCode !== 0) {
+      error(`Failed to commit: ${result.stderr}`);
+      process.exit(1);
+    }
+    success(`✅ Committed: ${pc6.bold(finalMessage)}`);
+  }
+});
+async function runGroupCommit(model, config) {
+  const [copilotError, changedFiles] = await Promise.all([
+    checkCopilotAvailable(),
+    getChangedFiles()
+  ]);
+  if (copilotError) {
+    error(`AI is required for --group mode but unavailable: ${copilotError}`);
+    process.exit(1);
+  }
+  if (changedFiles.length === 0) {
+    error("No changes to group-commit.");
+    process.exit(1);
+  }
+  console.log(`
+${pc6.bold("Changed files:")}`);
+  for (const f of changedFiles) {
+    console.log(`  ${pc6.dim("•")} ${f}`);
+  }
+  const spinner = createSpinner(`Asking AI to group ${changedFiles.length} file(s) into logical commits...`);
+  const diffs = await getFullDiffForFiles(changedFiles);
+  if (!diffs.trim()) {
+    spinner.stop();
+    warn("Could not retrieve diff context for any files. AI needs diffs to produce groups.");
+  }
+  let groups;
+  try {
+    groups = await generateCommitGroups(changedFiles, diffs, model, config.commitConvention);
+    spinner.success(`AI generated ${groups.length} commit group(s).`);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    spinner.fail(`AI grouping failed: ${reason}`);
+    process.exit(1);
+  }
+  if (groups.length === 0) {
+    error("AI could not produce commit groups. Try committing files manually.");
+    process.exit(1);
+  }
+  const changedSet = new Set(changedFiles);
+  for (const group of groups) {
+    const invalid = group.files.filter((f) => !changedSet.has(f));
+    if (invalid.length > 0) {
+      warn(`AI suggested unknown file(s): ${invalid.join(", ")} — removed from group.`);
+    }
+    group.files = group.files.filter((f) => changedSet.has(f));
+  }
+  let validGroups = groups.filter((g) => g.files.length > 0);
+  if (validGroups.length === 0) {
+    error("No valid groups remain after validation. Try committing files manually.");
+    process.exit(1);
+  }
+  let proceedToCommit = false;
+  let commitAll = false;
+  while (!proceedToCommit) {
+    console.log(`
+${pc6.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)}`);
+      for (const f of g.files) {
+        console.log(`    ${pc6.dim("•")} ${f}`);
+      }
+      console.log();
+    }
+    const summaryAction = await selectPrompt("What would you like to do?", [
+      "Commit all",
+      "Review each group",
+      "Regenerate all messages",
+      "Cancel"
+    ]);
+    if (summaryAction === "Cancel") {
+      warn("Group commit cancelled.");
+      process.exit(0);
+    }
+    if (summaryAction === "Regenerate all messages") {
+      const regenSpinner = createSpinner("Regenerating all commit messages...");
+      try {
+        validGroups = await regenerateAllGroupMessages(validGroups, diffs, model, config.commitConvention);
+        regenSpinner.success("All commit messages regenerated.");
+      } catch {
+        regenSpinner.fail("Failed to regenerate messages. Keeping current ones.");
+      }
+      continue;
+    }
+    proceedToCommit = true;
+    commitAll = summaryAction === "Commit all";
+  }
+  let committed = 0;
+  if (commitAll) {
+    for (let i = 0;i < validGroups.length; i++) {
+      const group = validGroups[i];
+      const stageResult = await stageFiles(group.files);
+      if (stageResult.exitCode !== 0) {
+        error(`Failed to stage group ${i + 1}: ${stageResult.stderr}`);
+        continue;
+      }
+      const commitResult = await commitWithMessage(group.message);
+      if (commitResult.exitCode !== 0) {
+        const detail = (commitResult.stderr || commitResult.stdout).trim();
+        error(`Failed to commit group ${i + 1}: ${detail}`);
+        await unstageFiles(group.files);
+        continue;
+      }
+      committed++;
+      success(`✅ Committed group ${i + 1}: ${pc6.bold(group.message)}`);
+    }
+  } else {
+    for (let i = 0;i < validGroups.length; i++) {
+      const group = validGroups[i];
+      console.log(pc6.bold(`
+── Group ${i + 1}/${validGroups.length} ──`));
+      console.log(`  ${pc6.cyan(group.message)}`);
+      for (const f of group.files) {
+        console.log(`  ${pc6.dim("•")} ${f}`);
+      }
+      let message = group.message;
+      let actionDone = false;
+      while (!actionDone) {
+        const action = await selectPrompt("Action for this group:", [
+          "Commit as-is",
+          "Edit message and commit",
+          "Regenerate message",
+          "Skip this group"
+        ]);
+        if (action === "Skip this group") {
+          warn(`Skipped group ${i + 1}.`);
+          actionDone = true;
+          continue;
+        }
+        if (action === "Regenerate message") {
+          const regenSpinner = createSpinner("Regenerating commit message for this group...");
+          const newMsg = await regenerateGroupMessage(group.files, diffs, model, config.commitConvention);
+          if (newMsg) {
+            message = newMsg;
+            group.message = newMsg;
+            regenSpinner.success(`New message: ${pc6.bold(message)}`);
+          } else {
+            regenSpinner.fail("AI could not generate a new message. Keeping current one.");
+          }
+          continue;
+        }
+        if (action === "Edit message and commit") {
+          message = await inputPrompt("Edit commit message", message);
+          if (!message) {
+            warn(`Skipped group ${i + 1} (empty message).`);
+            actionDone = true;
+            continue;
+          }
+        }
+        if (!validateCommitMessage(message, config.commitConvention)) {
+          for (const line of getValidationError(config.commitConvention)) {
+            warn(line);
+          }
+          const proceed = await confirmPrompt("Commit anyway?");
+          if (!proceed) {
+            warn(`Skipped group ${i + 1}.`);
+            actionDone = true;
+            continue;
+          }
+        }
+        const stageResult = await stageFiles(group.files);
+        if (stageResult.exitCode !== 0) {
+          error(`Failed to stage group ${i + 1}: ${stageResult.stderr}`);
+          actionDone = true;
+          continue;
+        }
+        const commitResult = await commitWithMessage(message);
+        if (commitResult.exitCode !== 0) {
+          const detail = (commitResult.stderr || commitResult.stdout).trim();
+          error(`Failed to commit group ${i + 1}: ${detail}`);
+          await unstageFiles(group.files);
+          actionDone = true;
+          continue;
+        }
+        committed++;
+        success(`✅ Committed group ${i + 1}: ${pc6.bold(message)}`);
+        actionDone = true;
+      }
+    }
+  }
+  if (committed === 0) {
+    warn("No groups were committed.");
+  } else {
+    success(`
+\uD83C\uDF89 ${committed} of ${validGroups.length} group(s) committed successfully.`);
+  }
+  process.exit(0);
+}
+
+// src/commands/doctor.ts
+import { execFile as execFileCb3 } from "node:child_process";
+import { defineCommand as defineCommand4 } from "citty";
+import pc7 from "picocolors";
+// package.json
+var package_default = {
+  name: "contribute-now",
+  version: "0.2.1-dev.22ad5a1",
+  description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
+  type: "module",
+  bin: {
+    contrib: "dist/index.js",
+    contribute: "dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun build src/index.ts --outfile dist/index.js --target node --packages external",
+    cli: "bun run src/index.ts --",
+    dev: "bun src/index.ts",
+    test: "bun test",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    format: "biome format --write .",
+    "www:dev": "bun run --cwd www dev",
+    "www:build": "bun run --cwd www build",
+    "www:preview": "bun run --cwd www preview"
+  },
+  engines: {
+    node: ">=18",
+    bun: ">=1.0"
+  },
+  keywords: [
+    "git",
+    "workflow",
+    "squash-merge",
+    "sync",
+    "cli",
+    "contribute",
+    "fork",
+    "dev-branch",
+    "clean-commit"
+  ],
+  author: "Waren Gonzaga",
+  license: "GPL-3.0",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/warengonzaga/contribute-now.git"
+  },
+  dependencies: {
+    "@clack/prompts": "^1.0.1",
+    "@github/copilot-sdk": "^0.1.25",
+    "@wgtechlabs/log-engine": "^2.3.1",
+    citty: "^0.1.6",
+    figlet: "^1.10.0",
+    picocolors: "^1.1.1"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.4.4",
+    "@types/bun": "latest",
+    "@types/figlet": "^1.7.0",
+    typescript: "^5.7.0"
+  }
+};
+
+// src/utils/remote.ts
+function parseRepoFromUrl(url) {
+  const httpsMatch = url.match(/https?:\/\/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/([^/.]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+  return null;
+}
+async function detectForkSetup() {
+  const remotes = await getRemotes();
+  const hasOrigin = remotes.includes("origin");
+  const hasUpstream = remotes.includes("upstream");
+  return {
+    isFork: hasUpstream,
+    originRemote: hasOrigin ? "origin" : null,
+    upstreamRemote: hasUpstream ? "upstream" : null
+  };
+}
+async function getRepoInfoFromRemote(remote = "origin") {
+  const url = await getRemoteUrl(remote);
+  if (!url)
+    return null;
+  return parseRepoFromUrl(url);
+}
+
+// src/commands/doctor.ts
+var PASS = `  ${pc7.green("✔")} `;
+var FAIL = `  ${pc7.red("✗")} `;
+var WARN = `  ${pc7.yellow("⚠")} `;
+function printReport(report) {
+  for (const section of report.sections) {
+    console.log(`
+  ${pc7.bold(pc7.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;
+      console.log(`${prefix}${text2}`);
+    }
+  }
+  console.log();
+}
+function toJson(report) {
+  return JSON.stringify(report.sections.map((s) => ({
+    section: s.title,
+    checks: s.checks.map((c) => ({
+      label: c.label,
+      ok: c.ok,
+      warning: c.warning ?? false,
+      detail: c.detail ?? null
+    }))
+  })), null, 2);
+}
+function runCmd(cmd, args) {
+  return new Promise((resolve) => {
+    execFileCb3(cmd, args, (error2, stdout) => {
+      resolve({
+        ok: !error2,
+        stdout: (stdout ?? "").trim()
+      });
+    });
+  });
+}
+async function toolSection() {
+  const checks = [];
+  checks.push({
+    label: `contrib v${package_default.version ?? "unknown"}`,
+    ok: true
+  });
+  const runtime = typeof globalThis.Bun !== "undefined" ? `Bun ${globalThis.Bun.version ?? "?"}` : `Node ${process.version}`;
+  checks.push({ label: runtime, ok: true, detail: `${process.platform}-${process.arch}` });
+  return { title: "Tool", checks };
+}
+async function depsSection() {
+  const checks = [];
+  const git = await runCmd("git", ["--version"]);
+  checks.push({
+    label: git.ok ? git.stdout.replace("git version ", "git ") : "git not found",
+    ok: git.ok
+  });
+  const ghInstalled = await checkGhInstalled();
+  if (ghInstalled) {
+    const ghVer = await runCmd("gh", ["--version"]);
+    const ver = ghVer.stdout.split(`
+`)[0] ?? "gh";
+    checks.push({ label: ver, ok: true });
+    const ghAuth = await checkGhAuth();
+    checks.push({
+      label: ghAuth ? "gh authenticated" : "gh not authenticated",
+      ok: ghAuth,
+      warning: !ghAuth,
+      detail: ghAuth ? undefined : "run `gh auth login`"
+    });
+  } else {
+    checks.push({
+      label: "gh CLI not installed",
+      ok: false,
+      detail: "install from https://cli.github.com"
+    });
+  }
+  try {
+    await import("@github/copilot-sdk");
+    checks.push({ label: "Copilot SDK importable", ok: true });
+  } catch {
+    checks.push({
+      label: "Copilot SDK not loadable",
+      ok: false,
+      warning: true,
+      detail: "AI features will be unavailable"
+    });
+  }
+  return { title: "Dependencies", checks };
+}
+async function configSection() {
+  const checks = [];
+  const exists = configExists();
+  if (!exists) {
+    checks.push({
+      label: ".contributerc.json not found",
+      ok: false,
+      detail: "run `contrib setup` to create it"
+    });
+    return { title: "Config", checks };
+  }
+  const config = readConfig();
+  if (!config) {
+    checks.push({ label: ".contributerc.json found but invalid", ok: false });
+    return { title: "Config", checks };
+  }
+  checks.push({ label: ".contributerc.json found and valid", ok: true });
+  const desc = WORKFLOW_DESCRIPTIONS[config.workflow] ?? config.workflow;
+  checks.push({
+    label: `Workflow: ${config.workflow}`,
+    ok: true,
+    detail: desc
+  });
+  checks.push({ label: `Role: ${config.role}`, ok: true });
+  checks.push({ label: `Commit convention: ${config.commitConvention}`, ok: true });
+  if (hasDevBranch(config.workflow)) {
+    checks.push({
+      label: `Dev branch: ${config.devBranch ?? "(not set)"}`,
+      ok: !!config.devBranch
+    });
+  }
+  const ignored = isGitignored();
+  checks.push({
+    label: ignored ? ".contributerc.json in .gitignore" : ".contributerc.json NOT in .gitignore",
+    ok: true,
+    warning: !ignored,
+    detail: ignored ? undefined : "consider adding it to .gitignore"
+  });
+  return { title: "Config", checks };
+}
+async function gitSection() {
+  const checks = [];
+  const inRepo = await isGitRepo();
+  checks.push({
+    label: inRepo ? "Inside a git repository" : "Not inside a git repository",
+    ok: inRepo
+  });
+  if (!inRepo)
+    return { title: "Git Environment", checks };
+  const branch = await getCurrentBranch();
+  const head = await runCmd("git", ["rev-parse", "--short", "HEAD"]);
+  checks.push({
+    label: `Branch: ${branch ?? "(detached)"}`,
+    ok: !!branch,
+    detail: head.ok ? `HEAD ${head.stdout}` : undefined
+  });
+  const remotes = await getRemotes();
+  if (remotes.length === 0) {
+    checks.push({ label: "No remotes configured", ok: false, warning: true });
+  } else {
+    for (const remote of remotes) {
+      const url = await getRemoteUrl(remote);
+      const repoInfo = url ? parseRepoFromUrl(url) : null;
+      const detail = repoInfo ? `${repoInfo.owner}/${repoInfo.repo}` : url ?? "unknown URL";
+      checks.push({ label: `Remote: ${remote}`, ok: true, detail });
+    }
+  }
+  const dirty = await hasUncommittedChanges();
+  checks.push({
+    label: dirty ? "Uncommitted changes detected" : "Working tree clean",
+    ok: true,
+    warning: dirty
+  });
+  const shallow = await isShallowRepo();
+  if (shallow) {
+    checks.push({
+      label: "Shallow clone detected",
+      ok: true,
+      warning: true,
+      detail: "run `git fetch --unshallow` for full history"
+    });
+  }
+  const inProgressOp = await isGitOperationInProgress();
+  if (inProgressOp) {
+    checks.push({
+      label: `Git ${inProgressOp} in progress`,
+      ok: false,
+      detail: `complete or abort: git ${inProgressOp} --abort`
+    });
+  }
+  if (await hasGitLockFile()) {
+    checks.push({
+      label: "Git lock file detected (index.lock)",
+      ok: true,
+      warning: true,
+      detail: "another git process may be running, or the lock is stale"
+    });
+  }
+  return { title: "Git Environment", checks };
+}
+async function forkSection() {
+  const checks = [];
+  const fork = await detectForkSetup();
+  checks.push({
+    label: fork.isFork ? "Fork detected (upstream remote exists)" : "Not a fork (no upstream remote)",
+    ok: true
+  });
+  if (fork.originRemote) {
+    checks.push({ label: `Origin remote: ${fork.originRemote}`, ok: true });
+  }
+  if (fork.upstreamRemote) {
+    checks.push({ label: `Upstream remote: ${fork.upstreamRemote}`, ok: true });
+  }
+  return { title: "Fork Detection", checks };
+}
+async function workflowSection() {
+  const checks = [];
+  const config = readConfig();
+  if (!config) {
+    checks.push({
+      label: "Cannot resolve workflow (no config)",
+      ok: false,
+      detail: "run `contrib setup` first"
+    });
+    return { title: "Workflow Resolution", checks };
+  }
+  const baseBranch = getBaseBranch(config);
+  checks.push({ label: `Base branch: ${baseBranch}`, ok: true });
+  const sync = getSyncSource(config);
+  checks.push({
+    label: `Sync source: ${sync.ref}`,
+    ok: true,
+    detail: `strategy: ${sync.strategy}`
+  });
+  checks.push({
+    label: `Branch prefixes: ${config.branchPrefixes.join(", ")}`,
+    ok: config.branchPrefixes.length > 0
+  });
+  return { title: "Workflow Resolution", checks };
+}
+function envSection() {
+  const checks = [];
+  const vars = ["GITHUB_TOKEN", "GH_TOKEN", "COPILOT_AGENT_TOKEN", "NO_COLOR", "FORCE_COLOR", "CI"];
+  for (const name of vars) {
+    const val = process.env[name];
+    if (val !== undefined) {
+      const isSecret = name.toLowerCase().includes("token");
+      const display = isSecret ? `${val.slice(0, 4)}${"*".repeat(Math.min(val.length - 4, 12))}` : val;
+      checks.push({ label: `${name} = ${display}`, ok: true });
+    }
+  }
+  if (checks.length === 0) {
+    checks.push({ label: "No relevant environment variables set", ok: true });
+  }
+  return { title: "Environment", checks };
+}
+var doctor_default = defineCommand4({
+  meta: {
+    name: "doctor",
+    description: "Diagnose the contribute-now CLI environment and configuration"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output report as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const isJson = args.json;
+    const [tool, deps, config, git, fork, workflow] = await Promise.all([
+      toolSection(),
+      depsSection(),
+      configSection(),
+      gitSection(),
+      forkSection(),
+      workflowSection()
+    ]);
+    const env = envSection();
+    const report = {
+      sections: [tool, deps, config, git, fork, workflow, env]
+    };
+    if (isJson) {
+      console.log(toJson(report));
+      return;
+    }
+    heading("\uD83E\uDE7A contribute-now doctor");
+    printReport(report);
+    const total = report.sections.flatMap((s) => s.checks);
+    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.
+`);
+    } else {
+      if (failures.length > 0) {
+        console.log(`  ${pc7.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
       }
-      const proceed = await confirmPrompt("Commit anyway?");
-      if (!proceed)
-        process.exit(1);
-    }
-    const result = await commitWithMessage(finalMessage);
-    if (result.exitCode !== 0) {
-      error(`Failed to commit: ${result.stderr}`);
-      process.exit(1);
+      if (warnings.length > 0) {
+        console.log(`  ${pc7.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
+      }
+      console.log();
     }
-    success(`✅ Committed: ${pc4.bold(finalMessage)}`);
   }
 });
 
 // src/commands/hook.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-import { defineCommand as defineCommand3 } from "citty";
-import pc5 from "picocolors";
+import { existsSync as existsSync3, 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";
 var HOOK_MARKER = "# managed by contribute-now";
 function getHooksDir(cwd = process.cwd()) {
-  return join2(cwd, ".git", "hooks");
+  return join3(cwd, ".git", "hooks");
 }
 function getHookPath(cwd = process.cwd()) {
-  return join2(getHooksDir(cwd), "commit-msg");
+  return join3(getHooksDir(cwd), "commit-msg");
 }
 function generateHookScript() {
   return `#!/bin/sh
@@ -774,11 +2402,22 @@ case "$commit_msg" in
   Merge\\ *|fixup!*|squash!*|amend!*) exit 0 ;;
 esac
 
-# Validate using contrib CLI
-npx contrib validate "$commit_msg"
+# Detect available package runner
+if command -v contrib >/dev/null 2>&1; then
+  contrib validate "$commit_msg"
+elif command -v bunx >/dev/null 2>&1; then
+  bunx contrib validate "$commit_msg"
+elif command -v pnpx >/dev/null 2>&1; then
+  pnpx contrib validate "$commit_msg"
+elif command -v npx >/dev/null 2>&1; then
+  npx contrib validate "$commit_msg"
+else
+  echo "Warning: No package runner found. Skipping commit message validation."
+  exit 0
+fi
 `;
 }
-var hook_default = defineCommand3({
+var hook_default = defineCommand5({
   meta: {
     name: "hook",
     description: "Install or uninstall the commit-msg git hook"
@@ -821,8 +2460,8 @@ async function installHook() {
   }
   const hookPath = getHookPath();
   const hooksDir = getHooksDir();
-  if (existsSync2(hookPath)) {
-    const existing = readFileSync2(hookPath, "utf-8");
+  if (existsSync3(hookPath)) {
+    const existing = readFileSync3(hookPath, "utf-8");
     if (!existing.includes(HOOK_MARKER)) {
       error("A commit-msg hook already exists and was not installed by contribute-now.");
       warn(`Path: ${hookPath}`);
@@ -831,22 +2470,23 @@ async function installHook() {
     }
     info("Updating existing contribute-now hook...");
   }
-  if (!existsSync2(hooksDir)) {
+  if (!existsSync3(hooksDir)) {
     mkdirSync(hooksDir, { recursive: true });
   }
   writeFileSync2(hookPath, generateHookScript(), { mode: 493 });
   success(`commit-msg hook installed.`);
-  info(`Convention: ${pc5.bold(CONVENTION_LABELS[config.commitConvention])}`);
-  info(`Path: ${pc5.dim(hookPath)}`);
+  info(`Convention: ${pc8.bold(CONVENTION_LABELS[config.commitConvention])}`);
+  info(`Path: ${pc8.dim(hookPath)}`);
+  warn("Note: hooks can be bypassed with `git commit --no-verify`.");
 }
 async function uninstallHook() {
   heading("\uD83E\uDE9D hook uninstall");
   const hookPath = getHookPath();
-  if (!existsSync2(hookPath)) {
+  if (!existsSync3(hookPath)) {
     info("No commit-msg hook found. Nothing to uninstall.");
     return;
   }
-  const content = readFileSync2(hookPath, "utf-8");
+  const content = readFileSync3(hookPath, "utf-8");
   if (!content.includes(HOOK_MARKER)) {
     error("The commit-msg hook was not installed by contribute-now. Leaving it untouched.");
     process.exit(1);
@@ -855,122 +2495,165 @@ async function uninstallHook() {
   success("commit-msg hook removed.");
 }
 
-// src/commands/setup.ts
-import { defineCommand as defineCommand4 } from "citty";
-import pc6 from "picocolors";
-
-// src/utils/gh.ts
-import { execFile as execFileCb2 } from "node:child_process";
-function run2(args) {
-  return new Promise((resolve) => {
-    execFileCb2("gh", args, (error2, stdout, stderr) => {
-      resolve({
-        exitCode: error2 ? error2.code != null ? Number(error2.code) : 1 : 0,
-        stdout: stdout ?? "",
-        stderr: stderr ?? ""
-      });
-    });
-  });
-}
-async function checkGhInstalled() {
-  try {
-    const { exitCode } = await run2(["--version"]);
-    return exitCode === 0;
-  } catch {
-    return false;
+// 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();
   }
-}
-async function checkGhAuth() {
-  try {
-    const { exitCode } = await run2(["auth", "status"]);
-    return exitCode === 0;
-  } catch {
-    return false;
+});
+function colorizeGraphLine(line, protectedBranches, currentBranch) {
+  const match = line.match(/^([|/\\*\s_.-]*)([a-f0-9]{7,12})(\s+\(([^)]+)\))?\s*(.*)/);
+  if (!match) {
+    return pc9.cyan(line);
   }
-}
-async function checkRepoPermissions(owner, repo) {
-  const { exitCode, stdout } = await run2(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
-  if (exitCode !== 0)
-    return null;
-  try {
-    return JSON.parse(stdout.trim());
-  } catch {
-    return null;
+  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(", "));
 }
-async function isRepoFork() {
-  const { exitCode, stdout } = await run2(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
-  if (exitCode !== 0)
-    return null;
-  const val = stdout.trim();
-  if (val === "true")
-    return true;
-  if (val === "false")
-    return false;
-  return null;
-}
-async function getCurrentRepoInfo() {
-  const { exitCode, stdout } = await run2([
-    "repo",
-    "view",
-    "--json",
-    "nameWithOwner",
-    "-q",
-    ".nameWithOwner"
-  ]);
-  if (exitCode !== 0)
-    return null;
-  const nameWithOwner = stdout.trim();
-  if (!nameWithOwner)
-    return null;
-  const [owner, repo] = nameWithOwner.split("/");
-  if (!owner || !repo)
-    return null;
-  return { owner, repo };
-}
-async function createPR(options) {
-  const args = [
-    "pr",
-    "create",
-    "--base",
-    options.base,
-    "--title",
-    options.title,
-    "--body",
-    options.body
-  ];
-  if (options.draft)
-    args.push("--draft");
-  return run2(args);
-}
-async function createPRFill(base, draft) {
-  const args = ["pr", "create", "--base", base, "--fill"];
-  if (draft)
-    args.push("--draft");
-  return run2(args);
-}
-
-// src/utils/remote.ts
-function parseRepoFromUrl(url) {
-  const httpsMatch = url.match(/https?:\/\/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?$/);
-  if (httpsMatch) {
-    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+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));
   }
-  const sshMatch = url.match(/git@github\.com:([^/]+)\/([^/.]+?)(?:\.git)?$/);
-  if (sshMatch) {
-    return { owner: sshMatch[1], repo: sshMatch[2] };
+  if (localName === currentBranch) {
+    return pc9.bold(pc9.green(name));
   }
-  return null;
-}
-async function getRepoInfoFromRemote(remote = "origin") {
-  const url = await getRemoteUrl(remote);
-  if (!url)
-    return null;
-  return parseRepoFromUrl(url);
+  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
-var setup_default = defineCommand4({
+import { defineCommand as defineCommand7 } from "citty";
+import pc10 from "picocolors";
+var setup_default = defineCommand7({
   meta: {
     name: "setup",
     description: "Initialize contribute-now config for this repo (.contributerc.json)"
@@ -991,7 +2674,7 @@ var setup_default = defineCommand4({
       workflow = "github-flow";
     else if (workflowChoice.startsWith("Git Flow"))
       workflow = "git-flow";
-    info(`Workflow: ${pc6.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
+    info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
     const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
       `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
       CONVENTION_DESCRIPTIONS.conventional,
@@ -1044,8 +2727,8 @@ var setup_default = defineCommand4({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${pc6.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${pc6.bold(detectedRole)}. Is this correct?`);
+      info(`Detected role: ${pc10.bold(detectedRole)} (via ${detectionSource})`);
+      const confirmed = await confirmPrompt(`Role detected as ${pc10.bold(detectedRole)}. Is this correct?`);
       if (!confirmed) {
         const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
         detectedRole = roleChoice;
@@ -1068,8 +2751,17 @@ var setup_default = defineCommand4({
         const repoInfo = originUrl ? parseRepoFromUrl(originUrl) : null;
         const upstreamUrl = await inputPrompt("Enter upstream repository URL to add", repoInfo ? `https://github.com/${repoInfo.owner}/${repoInfo.repo}` : undefined);
         if (upstreamUrl) {
-          info(`Run: git remote add ${upstreamRemote} ${upstreamUrl}`);
-          warn("Please add the upstream remote and re-run setup, or add it manually.");
+          const addResult = await addRemote(upstreamRemote, upstreamUrl);
+          if (addResult.exitCode !== 0) {
+            error(`Failed to add remote "${upstreamRemote}": ${addResult.stderr.trim()}`);
+            error("Setup cannot continue without the upstream remote for contributors.");
+            process.exit(1);
+          }
+          success(`Added remote ${pc10.bold(upstreamRemote)} → ${upstreamUrl}`);
+        } else {
+          error("An upstream remote URL is required for contributors.");
+          info("Add it manually: git remote add upstream <url>");
+          process.exit(1);
         }
       }
     }
@@ -1085,42 +2777,42 @@ var setup_default = defineCommand4({
     };
     writeConfig(config);
     success(`✅ Config written to .contributerc.json`);
+    const syncRemote = config.role === "contributor" ? config.upstream : config.origin;
+    info(`Fetching ${pc10.bold(syncRemote)} to verify branch configuration...`);
+    await fetchRemote(syncRemote);
+    const mainRef = `${syncRemote}/${config.mainBranch}`;
+    if (!await refExists(mainRef)) {
+      warn(`Main branch ref ${pc10.bold(mainRef)} not found on remote.`);
+      warn("Config was saved — verify the branch name and re-run setup if needed.");
+    }
+    if (config.devBranch) {
+      const devRef = `${syncRemote}/${config.devBranch}`;
+      if (!await refExists(devRef)) {
+        warn(`Dev branch ref ${pc10.bold(devRef)} not found on remote.`);
+        warn("Config was saved — verify the branch name and re-run setup if needed.");
+      }
+    }
     if (!isGitignored()) {
       warn(".contributerc.json is not in .gitignore. Add it to avoid committing personal config.");
       warn('  echo ".contributerc.json" >> .gitignore');
     }
     console.log();
-    info(`Workflow: ${pc6.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    info(`Convention: ${pc6.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-    info(`Role: ${pc6.bold(config.role)}`);
+    info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    info(`Convention: ${pc10.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+    info(`Role: ${pc10.bold(config.role)}`);
     if (config.devBranch) {
-      info(`Main: ${pc6.bold(config.mainBranch)} | Dev: ${pc6.bold(config.devBranch)}`);
+      info(`Main: ${pc10.bold(config.mainBranch)} | Dev: ${pc10.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${pc6.bold(config.mainBranch)}`);
+      info(`Main: ${pc10.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${pc6.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc6.bold(config.upstream)}` : ""}`);
+    info(`Origin: ${pc10.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc10.bold(config.upstream)}` : ""}`);
   }
 });
 
 // src/commands/start.ts
-import { defineCommand as defineCommand5 } from "citty";
-import pc7 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 looksLikeNaturalLanguage(input) {
-  return input.includes(" ") && !input.includes("/");
-}
-
-// src/commands/start.ts
-var start_default = defineCommand5({
+import { defineCommand as defineCommand8 } from "citty";
+import pc11 from "picocolors";
+var start_default = defineCommand8({
   meta: {
     name: "start",
     description: "Create a new feature branch from the latest base branch"
@@ -1128,8 +2820,8 @@ var start_default = defineCommand5({
   args: {
     name: {
       type: "positional",
-      description: "Branch name or description",
-      required: true
+      description: "Branch name or description (prompted if omitted)",
+      required: false
     },
     model: {
       type: "string",
@@ -1146,6 +2838,7 @@ var start_default = defineCommand5({
       error("Not inside a git repository.");
       process.exit(1);
     }
+    await assertCleanGitState("starting a new branch");
     const config = readConfig();
     if (!config) {
       error("No .contributerc.json found. Run `contrib setup` first.");
@@ -1160,42 +2853,78 @@ var start_default = defineCommand5({
     const syncSource = getSyncSource(config);
     let branchName = args.name;
     heading("\uD83C\uDF3F contrib start");
+    if (!branchName) {
+      branchName = await inputPrompt("What are you going to work on?");
+      if (!branchName || branchName.trim().length === 0) {
+        error("A branch name or description is required.");
+        process.exit(1);
+      }
+      branchName = branchName.trim();
+    }
     const useAI = !args["no-ai"] && looksLikeNaturalLanguage(branchName);
     if (useAI) {
-      info("Generating branch name suggestion from description...");
+      const spinner = createSpinner("Generating branch name suggestion...");
       const suggested = await suggestBranchName(branchName, args.model);
       if (suggested) {
+        spinner.success("Branch name suggestion ready.");
         console.log(`
-  ${pc7.dim("AI suggestion:")} ${pc7.bold(pc7.cyan(suggested))}`);
-        const accepted = await confirmPrompt(`Use ${pc7.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?`);
         if (accepted) {
           branchName = suggested;
         } else {
           branchName = await inputPrompt("Enter branch name", branchName);
         }
+      } else {
+        spinner.fail("AI did not return a branch name suggestion.");
       }
     }
     if (!hasPrefix(branchName, branchPrefixes)) {
-      const prefix = await selectPrompt(`Choose a branch type for ${pc7.bold(branchName)}:`, branchPrefixes);
+      const prefix = await selectPrompt(`Choose a branch type for ${pc11.bold(branchName)}:`, branchPrefixes);
       branchName = formatBranchName(prefix, branchName);
     }
-    info(`Creating branch: ${pc7.bold(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)}`);
+    if (await branchExists(branchName)) {
+      error(`Branch ${pc11.bold(branchName)} already exists.`);
+      info(`  Use ${pc11.bold(`git checkout ${branchName}`)} to switch to it, or choose a different name.`);
+      process.exit(1);
+    }
     await fetchRemote(syncSource.remote);
-    const resetResult = await resetHard(syncSource.ref);
-    if (resetResult.exitCode !== 0) {}
+    if (!await refExists(syncSource.ref)) {
+      warn(`Remote ref ${pc11.bold(syncSource.ref)} not found. Creating branch from local ${pc11.bold(baseBranch)}.`);
+    }
+    const updateResult = await updateLocalBranch(baseBranch, syncSource.ref);
+    if (updateResult.exitCode !== 0) {
+      if (await refExists(syncSource.ref)) {
+        const result2 = await createBranch(branchName, syncSource.ref);
+        if (result2.exitCode !== 0) {
+          error(`Failed to create branch: ${result2.stderr}`);
+          process.exit(1);
+        }
+        success(`✅ Created ${pc11.bold(branchName)} from ${pc11.bold(syncSource.ref)}`);
+        return;
+      }
+      error(`Failed to update ${pc11.bold(baseBranch)}: ${updateResult.stderr}`);
+      info("Make sure your base branch exists locally or the remote ref is available.");
+      process.exit(1);
+    }
     const result = await createBranch(branchName, baseBranch);
     if (result.exitCode !== 0) {
       error(`Failed to create branch: ${result.stderr}`);
       process.exit(1);
     }
-    success(`✅ Created ${pc7.bold(branchName)} from latest ${pc7.bold(baseBranch)}`);
+    success(`✅ Created ${pc11.bold(branchName)} from latest ${pc11.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand6 } from "citty";
-import pc8 from "picocolors";
-var status_default = defineCommand6({
+import { defineCommand as defineCommand9 } from "citty";
+import pc12 from "picocolors";
+var status_default = defineCommand9({
   meta: {
     name: "status",
     description: "Show sync status of branches"
@@ -1211,17 +2940,17 @@ var status_default = defineCommand6({
       process.exit(1);
     }
     heading("\uD83D\uDCCA contribute-now status");
-    console.log(`  ${pc8.dim("Workflow:")} ${pc8.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    console.log(`  ${pc8.dim("Role:")} ${pc8.bold(config.role)}`);
+    console.log(`  ${pc12.dim("Workflow:")} ${pc12.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    console.log(`  ${pc12.dim("Role:")} ${pc12.bold(config.role)}`);
     console.log();
     await fetchAll();
     const currentBranch = await getCurrentBranch();
     const { mainBranch, origin, upstream, workflow } = config;
     const baseBranch = getBaseBranch(config);
     const isContributor = config.role === "contributor";
-    const dirty = await hasUncommittedChanges();
+    const [dirty, fileStatus] = await Promise.all([hasUncommittedChanges(), getFileStatus()]);
     if (dirty) {
-      console.log(`  ${pc8.yellow("⚠")}  ${pc8.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${pc12.yellow("⚠")}  ${pc12.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -1237,31 +2966,141 @@ var status_default = defineCommand6({
     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 + pc8.dim(` (current ${pc8.green("*")})`));
+      console.log(branchLine + pc12.dim(` (current ${pc12.green("*")})`));
     } else if (currentBranch) {
-      console.log(pc8.dim(`  (on ${pc8.bold(currentBranch)} branch)`));
+      console.log(pc12.dim(`  (on ${pc12.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:")}`);
+        for (const { file, status } of fileStatus.staged) {
+          console.log(`    ${pc12.green("+")} ${pc12.dim(`${status}:`)} ${file}`);
+        }
+      }
+      if (fileStatus.modified.length > 0) {
+        console.log(`  ${pc12.yellow("Unstaged changes:")}`);
+        for (const { file, status } of fileStatus.modified) {
+          console.log(`    ${pc12.yellow("~")} ${pc12.dim(`${status}:`)} ${file}`);
+        }
+      }
+      if (fileStatus.untracked.length > 0) {
+        console.log(`  ${pc12.red("Untracked files:")}`);
+        for (const file of fileStatus.untracked) {
+          console.log(`    ${pc12.red("?")} ${file}`);
+        }
+      }
+    } else if (!dirty) {
+      console.log(`  ${pc12.green("✓")}  ${pc12.dim("Working tree clean")}`);
+    }
+    const tips = [];
+    if (fileStatus.staged.length > 0) {
+      tips.push(`Run ${pc12.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`);
+    }
+    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`);
+      }
+    }
+    if (tips.length > 0) {
+      console.log();
+      console.log(`  ${pc12.dim("\uD83D\uDCA1 Tip:")}`);
+      for (const tip of tips) {
+        console.log(`     ${pc12.dim(tip)}`);
+      }
+    }
+    console.log();
+  }
+});
+function formatStatus(branch, base, ahead, behind) {
+  const label = pc12.bold(branch.padEnd(20));
+  if (ahead === 0 && behind === 0) {
+    return `  ${pc12.green("✓")}  ${label} ${pc12.dim(`in sync with ${base}`)}`;
+  }
+  if (ahead > 0 && behind === 0) {
+    return `  ${pc12.yellow("↑")}  ${label} ${pc12.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 `  ${pc12.red("⚡")}  ${label} ${pc12.yellow(`${ahead} ahead`)}${pc12.dim(", ")}${pc12.red(`${behind} behind`)} ${pc12.dim(base)}`;
+}
+
+// src/commands/submit.ts
+import { defineCommand as defineCommand10 } from "citty";
+import pc13 from "picocolors";
+async function performSquashMerge(origin, baseBranch, featureBranch, options) {
+  info(`Checking out ${pc13.bold(baseBranch)}...`);
+  const coResult = await checkoutBranch(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)}...`);
+  const mergeResult = await mergeSquash(featureBranch);
+  if (mergeResult.exitCode !== 0) {
+    error(`Squash merge failed: ${mergeResult.stderr}`);
+    process.exit(1);
+  }
+  let message = options?.defaultMsg;
+  if (!message) {
+    const copilotError = await checkCopilotAvailable();
+    if (!copilotError) {
+      const spinner = createSpinner("Generating AI commit message for squash merge...");
+      const [stagedDiff, stagedFiles] = await Promise.all([getStagedDiff(), getStagedFiles()]);
+      const aiMsg = await generateCommitMessage(stagedDiff, stagedFiles, options?.model, options?.convention ?? "clean-commit");
+      if (aiMsg) {
+        message = aiMsg;
+        spinner.success("AI commit message generated.");
+      } else {
+        spinner.fail("AI did not return a commit message.");
+      }
+    } else {
+      warn(`AI unavailable: ${copilotError}`);
     }
-    console.log();
   }
-});
-function formatStatus(branch, base, ahead, behind) {
-  const label = pc8.bold(branch.padEnd(20));
-  if (ahead === 0 && behind === 0) {
-    return `  ${pc8.green("✓")}  ${label} ${pc8.dim(`in sync with ${base}`)}`;
+  const fallback = message || `squash merge ${featureBranch}`;
+  let finalMsg;
+  if (message) {
+    console.log(`  ${pc13.dim("Commit message:")} ${pc13.bold(message)}`);
+    finalMsg = message;
+  } else {
+    finalMsg = await inputPrompt("Commit message", fallback);
   }
-  if (ahead > 0 && behind === 0) {
-    return `  ${pc8.yellow("↑")}  ${label} ${pc8.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+  const commitResult = await commitWithMessage(finalMsg);
+  if (commitResult.exitCode !== 0) {
+    error(`Commit failed: ${commitResult.stderr}`);
+    process.exit(1);
   }
-  if (behind > 0 && ahead === 0) {
-    return `  ${pc8.red("↓")}  ${label} ${pc8.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+  info(`Pushing ${pc13.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)}...`);
+  const delLocal = await forceDeleteBranch(featureBranch);
+  if (delLocal.exitCode !== 0) {
+    warn(`Could not delete local branch: ${delLocal.stderr.trim()}`);
   }
-  return `  ${pc8.red("⚡")}  ${label} ${pc8.yellow(`${ahead} ahead`)}${pc8.dim(", ")}${pc8.red(`${behind} behind`)} ${pc8.dim(base)}`;
+  const remoteBranchRef = `${origin}/${featureBranch}`;
+  const remoteExists = await branchExists(remoteBranchRef);
+  if (remoteExists) {
+    info(`Deleting remote branch ${pc13.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.`);
 }
-
-// src/commands/submit.ts
-import { defineCommand as defineCommand7 } from "citty";
-import pc9 from "picocolors";
-var submit_default = defineCommand7({
+var submit_default = defineCommand10({
   meta: {
     name: "submit",
     description: "Push current branch and create a pull request"
@@ -1287,6 +3126,7 @@ var submit_default = defineCommand7({
       error("Not inside a git repository.");
       process.exit(1);
     }
+    await assertCleanGitState("submitting");
     const config = readConfig();
     if (!config) {
       error("No .contributerc.json found. Run `contrib setup` first.");
@@ -1301,89 +3141,335 @@ var submit_default = defineCommand7({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      error(`Cannot submit ${protectedBranches.map((b) => pc9.bold(b)).join(" or ")} as a PR. Switch to your feature branch.`);
-      process.exit(1);
+      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 going to work on in plain English and we'll generate a branch name."));
+      const description = await inputPrompt("What are you going to work 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);
+      }
+      if (await branchExists(newBranchName)) {
+        error(`Branch ${pc13.bold(newBranchName)} already exists. Choose a different name.`);
+        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;
     }
     heading("\uD83D\uDE80 contrib submit");
-    info(`Pushing ${pc9.bold(currentBranch)} to ${origin}...`);
-    const pushResult = await pushSetUpstream(origin, currentBranch);
-    if (pushResult.exitCode !== 0) {
-      error(`Failed to push: ${pushResult.stderr}`);
-      process.exit(1);
-    }
     const ghInstalled = await checkGhInstalled();
     const ghAuthed = ghInstalled && await checkGhAuth();
-    if (!ghInstalled || !ghAuthed) {
-      const repoInfo = await getRepoInfoFromRemote(origin);
-      if (repoInfo) {
-        const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/compare/${baseBranch}...${currentBranch}?expand=1`;
+    if (ghInstalled && ghAuthed) {
+      const mergedPR = await getMergedPRForBranch(currentBranch);
+      if (mergedPR) {
+        warn(`PR #${mergedPR.number} (${pc13.bold(mergedPR.title)}) was already merged.`);
+        const localWork = await hasLocalWork(origin, currentBranch);
+        const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
+        if (hasWork) {
+          if (localWork.uncommitted) {
+            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.`);
+          }
+          const SAVE_NEW_BRANCH = "Save changes to a new branch";
+          const DISCARD = "Discard all changes and clean up";
+          const CANCEL2 = "Cancel";
+          const action = await selectPrompt("This branch was merged but you have local changes. What would you like to do?", [SAVE_NEW_BRANCH, DISCARD, CANCEL2]);
+          if (action === CANCEL2) {
+            info("No changes made. You are still on your current branch.");
+            return;
+          }
+          if (action === SAVE_NEW_BRANCH) {
+            info(pc13.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
+            const description = await inputPrompt("What are you going to work on?");
+            let newBranchName = description;
+            if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
+              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 staleUpstream = await getUpstreamRef();
+            const staleUpstreamHash = staleUpstream ? await getCommitHash(staleUpstream) : null;
+            if (await branchExists(newBranchName)) {
+              error(`Branch ${pc13.bold(newBranchName)} already exists. Choose a different name.`);
+              process.exit(1);
+            }
+            const renameResult = await renameBranch(currentBranch, newBranchName);
+            if (renameResult.exitCode !== 0) {
+              error(`Failed to rename branch: ${renameResult.stderr}`);
+              process.exit(1);
+            }
+            success(`Renamed ${pc13.bold(currentBranch)} → ${pc13.bold(newBranchName)}`);
+            await unsetUpstream();
+            const syncSource2 = getSyncSource(config);
+            info(`Syncing ${pc13.bold(newBranchName)} with latest ${pc13.bold(baseBranch)}...`);
+            await fetchRemote(syncSource2.remote);
+            let rebaseResult;
+            if (staleUpstreamHash) {
+              rebaseResult = await rebaseOnto(syncSource2.ref, staleUpstreamHash);
+            } else {
+              const savedStrategy = await determineRebaseStrategy(newBranchName, syncSource2.ref);
+              rebaseResult = savedStrategy.strategy === "onto" && savedStrategy.ontoOldBase ? await rebaseOnto(syncSource2.ref, savedStrategy.ontoOldBase) : await rebase(syncSource2.ref);
+            }
+            if (rebaseResult.exitCode !== 0) {
+              warn("Rebase encountered conflicts. Resolve them manually, then run:");
+              info(`  ${pc13.bold("git rebase --continue")}`);
+            } else {
+              success(`Rebased ${pc13.bold(newBranchName)} onto ${pc13.bold(syncSource2.ref)}.`);
+            }
+            info(`All your changes are preserved. Run ${pc13.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...`);
+        await fetchRemote(syncSource.remote);
+        await resetHard("HEAD");
+        const coResult = await checkoutBranch(baseBranch);
+        if (coResult.exitCode !== 0) {
+          error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
+          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)}...`);
+        const delResult = await forceDeleteBranch(currentBranch);
+        if (delResult.exitCode === 0) {
+          success(`Deleted ${pc13.bold(currentBranch)}.`);
+        } else {
+          warn(`Could not delete branch: ${delResult.stderr.trim()}`);
+        }
         console.log();
-        info("Create your PR manually:");
-        console.log(`  ${pc9.cyan(prUrl)}`);
-      } else {
-        info("gh CLI not available. Create your PR manually on GitHub.");
+        info(`You're now on ${pc13.bold(baseBranch)}. Run ${pc13.bold("contrib start")} to begin a new feature.`);
+        return;
       }
-      return;
     }
     let prTitle = null;
     let prBody = null;
-    if (!args["no-ai"]) {
-      const copilotError = await checkCopilotAvailable();
+    async function tryGenerateAI() {
+      const [copilotError, commits, diff] = await Promise.all([
+        checkCopilotAvailable(),
+        getLog(baseBranch, "HEAD"),
+        getLogDiff(baseBranch, "HEAD")
+      ]);
       if (!copilotError) {
-        info("Generating AI PR description...");
-        const commits = await getLog(baseBranch, "HEAD");
-        const diff = await getLogDiff(baseBranch, "HEAD");
-        const result = await generatePRDescription(commits, diff, args.model);
+        const spinner = createSpinner("Generating AI PR description...");
+        const result = await generatePRDescription(commits, diff, args.model, config.commitConvention);
         if (result) {
           prTitle = result.title;
           prBody = result.body;
+          spinner.success("PR description generated.");
           console.log(`
-  ${pc9.dim("AI title:")} ${pc9.bold(pc9.cyan(prTitle))}`);
+  ${pc13.dim("AI title:")} ${pc13.bold(pc13.cyan(prTitle))}`);
           console.log(`
-${pc9.dim("AI body preview:")}`);
-          console.log(pc9.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+${pc13.dim("AI body preview:")}`);
+          console.log(pc13.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
         } else {
-          warn("AI did not return a PR description.");
+          spinner.fail("AI did not return a PR description.");
         }
       } else {
         warn(`AI unavailable: ${copilotError}`);
       }
     }
-    if (prTitle && prBody) {
-      const action = await selectPrompt("What would you like to do with the PR description?", [
-        "Use AI description",
-        "Edit title",
-        "Write manually",
-        "Use gh --fill (auto-fill from commits)"
-      ]);
-      if (action === "Use AI description") {} else if (action === "Edit title") {
-        prTitle = await inputPrompt("PR title", prTitle);
-      } else if (action === "Write manually") {
-        prTitle = await inputPrompt("PR title");
-        prBody = await inputPrompt("PR body (markdown)");
+    if (!args["no-ai"]) {
+      await tryGenerateAI();
+    }
+    const CANCEL = "Cancel";
+    const SQUASH_LOCAL = `Squash merge to ${baseBranch} locally (no PR)`;
+    const REGENERATE = "Regenerate AI description";
+    let submitAction = "cancel";
+    const isMaintainer = config.role === "maintainer";
+    let actionResolved = false;
+    while (!actionResolved) {
+      if (prTitle && prBody) {
+        const choices = ["Use AI description"];
+        if (isMaintainer)
+          choices.push(SQUASH_LOCAL);
+        choices.push("Edit title", "Write manually", "Use gh --fill (auto-fill from commits)", REGENERATE, CANCEL);
+        const action = await selectPrompt("What would you like to do with the PR description?", choices);
+        if (action === CANCEL) {
+          submitAction = "cancel";
+          actionResolved = true;
+        } else if (action === REGENERATE) {
+          prTitle = null;
+          prBody = null;
+          await tryGenerateAI();
+        } else if (action === SQUASH_LOCAL) {
+          submitAction = "squash";
+          actionResolved = true;
+        } else if (action === "Use AI description") {
+          submitAction = "create-pr";
+          actionResolved = true;
+        } else if (action === "Edit title") {
+          prTitle = await inputPrompt("PR title", prTitle);
+          submitAction = "create-pr";
+          actionResolved = true;
+        } else if (action === "Write manually") {
+          prTitle = await inputPrompt("PR title");
+          prBody = await inputPrompt("PR body (markdown)");
+          submitAction = "create-pr";
+          actionResolved = true;
+        } else {
+          submitAction = "fill";
+          actionResolved = true;
+        }
       } else {
-        const fillResult = await createPRFill(baseBranch, args.draft);
-        if (fillResult.exitCode !== 0) {
-          error(`Failed to create PR: ${fillResult.stderr}`);
-          process.exit(1);
+        const choices = [];
+        if (isMaintainer)
+          choices.push(SQUASH_LOCAL);
+        if (!args["no-ai"])
+          choices.push(REGENERATE);
+        choices.push("Write title & body manually", "Use gh --fill (auto-fill from commits)", CANCEL);
+        const action = await selectPrompt("How would you like to create the PR?", choices);
+        if (action === CANCEL) {
+          submitAction = "cancel";
+          actionResolved = true;
+        } else if (action === REGENERATE) {
+          await tryGenerateAI();
+        } else if (action === SQUASH_LOCAL) {
+          submitAction = "squash";
+          actionResolved = true;
+        } else if (action === "Write title & body manually") {
+          prTitle = await inputPrompt("PR title");
+          prBody = await inputPrompt("PR body (markdown)");
+          submitAction = "create-pr";
+          actionResolved = true;
+        } else {
+          submitAction = "fill";
+          actionResolved = true;
         }
-        success(`✅ PR created: ${fillResult.stdout.trim()}`);
-        return;
       }
-    } else {
-      const useManual = await confirmPrompt("Create PR with manual title/body?");
-      if (useManual) {
-        prTitle = await inputPrompt("PR title");
-        prBody = await inputPrompt("PR body (markdown)");
+    }
+    if (submitAction === "cancel") {
+      warn("Submit cancelled.");
+      return;
+    }
+    if (submitAction === "squash") {
+      await performSquashMerge(origin, baseBranch, currentBranch, {
+        defaultMsg: prTitle ?? undefined,
+        model: args.model,
+        convention: config.commitConvention
+      });
+      return;
+    }
+    info(`Pushing ${pc13.bold(currentBranch)} to ${origin}...`);
+    const pushResult = await pushSetUpstream(origin, currentBranch);
+    if (pushResult.exitCode !== 0) {
+      error(`Failed to push: ${pushResult.stderr}`);
+      if (pushResult.stderr.includes("rejected") || pushResult.stderr.includes("non-fast-forward")) {
+        warn("The remote branch has diverged. Try:");
+        info(`  git pull --rebase ${origin} ${currentBranch}`);
+        info("  Then run `contrib submit` again.");
+        info("If you need to force push (use with caution):");
+        info(`  git push --force-with-lease ${origin} ${currentBranch}`);
+      }
+      process.exit(1);
+    }
+    if (!ghInstalled || !ghAuthed) {
+      const repoInfo = await getRepoInfoFromRemote(origin);
+      if (repoInfo) {
+        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)}`);
       } else {
-        const fillResult = await createPRFill(baseBranch, args.draft);
-        if (fillResult.exitCode !== 0) {
-          error(`Failed to create PR: ${fillResult.stderr}`);
-          process.exit(1);
-        }
-        success(`✅ PR created: ${fillResult.stdout.trim()}`);
-        return;
+        info("gh CLI not available. Create your PR manually on GitHub.");
+      }
+      return;
+    }
+    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)}`);
+      return;
+    }
+    if (submitAction === "fill") {
+      const fillResult = await createPRFill(baseBranch, args.draft);
+      if (fillResult.exitCode !== 0) {
+        error(`Failed to create PR: ${fillResult.stderr}`);
+        process.exit(1);
       }
+      success(`✅ PR created: ${fillResult.stdout.trim()}`);
+      return;
     }
     if (!prTitle) {
       error("No PR title provided.");
@@ -1404,9 +3490,9 @@ ${pc9.dim("AI body preview:")}`);
 });
 
 // src/commands/sync.ts
-import { defineCommand as defineCommand8 } from "citty";
-import pc10 from "picocolors";
-var sync_default = defineCommand8({
+import { defineCommand as defineCommand11 } from "citty";
+import pc14 from "picocolors";
+var sync_default = defineCommand11({
   meta: {
     name: "sync",
     description: "Sync your local branches with the remote"
@@ -1417,6 +3503,15 @@ var sync_default = defineCommand8({
       alias: "y",
       description: "Skip confirmation prompt",
       default: false
+    },
+    model: {
+      type: "string",
+      description: "AI model to use for branch name suggestion"
+    },
+    "no-ai": {
+      type: "boolean",
+      description: "Skip AI branch name suggestion",
+      default: false
     }
   },
   async run({ args }) {
@@ -1424,6 +3519,7 @@ var sync_default = defineCommand8({
       error("Not inside a git repository.");
       process.exit(1);
     }
+    await assertCleanGitState("syncing");
     const config = readConfig();
     if (!config) {
       error("No .contributerc.json found. Run `contrib setup` first.");
@@ -1446,14 +3542,98 @@ var sync_default = defineCommand8({
     if (role === "contributor" && syncSource.remote !== origin) {
       await fetchRemote(origin);
     }
+    if (!await refExists(syncSource.ref)) {
+      error(`Remote ref ${pc14.bold(syncSource.ref)} does not exist.`);
+      info("This can happen if the branch was renamed or deleted on the remote.");
+      info(`Check your config: the base branch may need updating via ${pc14.bold("contrib setup")}.`);
+      process.exit(1);
+    }
+    let allowMergeCommit = false;
     const div = await getDivergence(baseBranch, syncSource.ref);
     if (div.ahead > 0 || div.behind > 0) {
-      info(`${pc10.bold(baseBranch)} is ${pc10.yellow(`${div.ahead} ahead`)} and ${pc10.red(`${div.behind} behind`)} ${syncSource.ref}`);
+      info(`${pc14.bold(baseBranch)} is ${pc14.yellow(`${div.ahead} ahead`)} and ${pc14.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`${pc10.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+      info(`${pc14.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+    }
+    if (div.ahead > 0) {
+      const currentBranch = await getCurrentBranch();
+      const protectedBranches = getProtectedBranches(config);
+      const isOnProtected = currentBranch && protectedBranches.includes(currentBranch);
+      if (isOnProtected) {
+        warn(`You have ${pc14.bold(String(div.ahead))} local commit${div.ahead !== 1 ? "s" : ""} on ${pc14.bold(baseBranch)} that aren't on the remote.`);
+        info("Pulling now could create a merge commit, which breaks clean history.");
+        console.log();
+        const MOVE_BRANCH = "Move my commits to a new feature branch, then sync";
+        const PULL_ANYWAY = "Pull anyway (may create a merge commit)";
+        const CANCEL = "Cancel";
+        const action = await selectPrompt("How would you like to handle this?", [
+          MOVE_BRANCH,
+          PULL_ANYWAY,
+          CANCEL
+        ]);
+        if (action === CANCEL) {
+          info("No changes made.");
+          return;
+        }
+        if (action === MOVE_BRANCH) {
+          info(pc14.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
+          const description = await inputPrompt("What are you going to work on?");
+          let newBranchName = description;
+          if (!args["no-ai"] && 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(`
+  ${pc14.dim("AI suggestion:")} ${pc14.bold(pc14.cyan(suggested))}`);
+                const accepted = await confirmPrompt(`Use ${pc14.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 ${pc14.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);
+          }
+          if (await branchExists(newBranchName)) {
+            error(`Branch ${pc14.bold(newBranchName)} already exists. Choose a different name.`);
+            process.exit(1);
+          }
+          const branchResult = await createBranch(newBranchName);
+          if (branchResult.exitCode !== 0) {
+            error(`Failed to create branch: ${branchResult.stderr}`);
+            process.exit(1);
+          }
+          success(`Created ${pc14.bold(newBranchName)} with your commits.`);
+          const coResult2 = await checkoutBranch(baseBranch);
+          if (coResult2.exitCode !== 0) {
+            error(`Failed to checkout ${baseBranch}: ${coResult2.stderr}`);
+            process.exit(1);
+          }
+          const remoteRef = syncSource.ref;
+          await updateLocalBranch(baseBranch, remoteRef);
+          success(`Reset ${pc14.bold(baseBranch)} to ${pc14.bold(remoteRef)}.`);
+          success(`✅ ${pc14.bold(baseBranch)} is now in sync with ${syncSource.ref}`);
+          console.log();
+          info(`Your commits are safe on ${pc14.bold(newBranchName)}.`);
+          info(`Run ${pc14.bold(`git checkout ${newBranchName}`)} then ${pc14.bold("contrib update")} to rebase onto the synced ${pc14.bold(baseBranch)}.`);
+          return;
+        }
+        allowMergeCommit = true;
+        warn("Proceeding with pull — a merge commit may be created.");
+      }
     }
     if (!args.yes) {
-      const ok = await confirmPrompt(`This will pull ${pc10.bold(syncSource.ref)} into local ${pc10.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${pc14.bold(syncSource.ref)} into local ${pc14.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
@@ -1462,19 +3642,24 @@ var sync_default = defineCommand8({
       error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
       process.exit(1);
     }
-    const pullResult = await pullBranch(syncSource.remote, baseBranch);
+    const pullResult = allowMergeCommit ? await pullBranch(syncSource.remote, baseBranch) : await pullFastForwardOnly(syncSource.remote, baseBranch);
     if (pullResult.exitCode !== 0) {
-      error(`Failed to pull: ${pullResult.stderr}`);
+      if (allowMergeCommit) {
+        error(`Pull failed: ${pullResult.stderr.trim()}`);
+      } else {
+        error(`Fast-forward pull failed. Your local ${pc14.bold(baseBranch)} may have diverged.`);
+        info(`Use ${pc14.bold("contrib sync")} again and choose "Move my commits to a new feature branch" to fix this.`);
+      }
       process.exit(1);
     }
     success(`✅ ${baseBranch} is now in sync with ${syncSource.ref}`);
     if (hasDevBranch(workflow) && role === "maintainer") {
       const mainDiv = await getDivergence(config.mainBranch, `${origin}/${config.mainBranch}`);
       if (mainDiv.behind > 0) {
-        info(`Also syncing ${pc10.bold(config.mainBranch)}...`);
+        info(`Also syncing ${pc14.bold(config.mainBranch)}...`);
         const mainCoResult = await checkoutBranch(config.mainBranch);
         if (mainCoResult.exitCode === 0) {
-          const mainPullResult = await pullBranch(origin, config.mainBranch);
+          const mainPullResult = await pullFastForwardOnly(origin, config.mainBranch);
           if (mainPullResult.exitCode === 0) {
             success(`✅ ${config.mainBranch} is now in sync with ${origin}/${config.mainBranch}`);
           }
@@ -1486,10 +3671,10 @@ var sync_default = defineCommand8({
 });
 
 // src/commands/update.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { defineCommand as defineCommand9 } from "citty";
-import pc11 from "picocolors";
-var update_default = defineCommand9({
+import { readFileSync as readFileSync4 } from "node:fs";
+import { defineCommand as defineCommand12 } from "citty";
+import pc15 from "picocolors";
+var update_default = defineCommand12({
   meta: {
     name: "update",
     description: "Rebase current branch onto the latest base branch"
@@ -1510,6 +3695,7 @@ var update_default = defineCommand9({
       error("Not inside a git repository.");
       process.exit(1);
     }
+    await assertCleanGitState("updating");
     const config = readConfig();
     if (!config) {
       error("No .contributerc.json found. Run `contrib setup` first.");
@@ -1524,18 +3710,190 @@ var update_default = defineCommand9({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      error(`Use \`contrib sync\` to update ${protectedBranches.map((b) => pc11.bold(b)).join(" or ")} branches.`);
-      process.exit(1);
+      heading("\uD83D\uDD03 contrib update");
+      warn(`You're on ${pc15.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
+      await fetchAll();
+      const { origin } = config;
+      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) {
+        info(`No local changes found on ${pc15.bold(currentBranch)}.`);
+        info(`Use ${pc15.bold("contrib sync")} to sync protected branches, or ${pc15.bold("contrib start")} to create a feature branch.`);
+        process.exit(1);
+      }
+      if (hasCommits) {
+        info(`Found ${pc15.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${pc15.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 CANCEL = "Cancel (stay on this branch)";
+      const action = await selectPrompt("Let's get you back on track. What would you like to do?", [
+        MOVE_BRANCH,
+        CANCEL
+      ]);
+      if (action === CANCEL) {
+        info("No changes made. You are still on your current branch.");
+        return;
+      }
+      info(pc15.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
+      const description = await inputPrompt("What are you going to work on?");
+      let newBranchName = description;
+      if (!args["no-ai"] && 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(`
+  ${pc15.dim("AI suggestion:")} ${pc15.bold(pc15.cyan(suggested))}`);
+            const accepted = await confirmPrompt(`Use ${pc15.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 ${pc15.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 ${pc15.bold(newBranchName)} with your changes.`);
+      await updateLocalBranch(currentBranch, remoteRef);
+      info(`Reset ${pc15.bold(currentBranch)} back to ${pc15.bold(remoteRef)} — no damage done.`);
+      console.log();
+      success(`You're now on ${pc15.bold(newBranchName)} with all your work intact.`);
+      info(`Run ${pc15.bold("contrib update")} again to rebase onto latest ${pc15.bold(baseBranch)}.`);
+      return;
     }
     if (await hasUncommittedChanges()) {
       error("You have uncommitted changes. Please commit or stash them first.");
       process.exit(1);
     }
     heading("\uD83D\uDD03 contrib update");
-    info(`Updating ${pc11.bold(currentBranch)} with latest ${pc11.bold(baseBranch)}...`);
+    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)}`);
+      const localWork = await hasLocalWork(syncSource.remote, currentBranch);
+      const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
+      if (hasWork) {
+        if (localWork.uncommitted) {
+          info("You have uncommitted local changes.");
+        }
+        if (localWork.unpushedCommits > 0) {
+          info(`You have ${localWork.unpushedCommits} unpushed commit(s).`);
+        }
+        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]);
+        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 going to work on in plain English and we'll generate a branch name."));
+          const description = await inputPrompt("What are you going to work on?");
+          let newBranchName = description;
+          if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
+            const spinner = createSpinner("Generating branch name suggestion...");
+            const suggested = await suggestBranchName(description, args.model);
+            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?`);
+              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 ${pc15.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 staleUpstream = await getUpstreamRef();
+          const staleUpstreamHash = staleUpstream ? await getCommitHash(staleUpstream) : null;
+          if (await branchExists(newBranchName)) {
+            error(`Branch ${pc15.bold(newBranchName)} already exists. Choose a different name.`);
+            process.exit(1);
+          }
+          const renameResult = await renameBranch(currentBranch, newBranchName);
+          if (renameResult.exitCode !== 0) {
+            error(`Failed to rename branch: ${renameResult.stderr}`);
+            process.exit(1);
+          }
+          success(`Renamed ${pc15.bold(currentBranch)} → ${pc15.bold(newBranchName)}`);
+          await unsetUpstream();
+          await fetchRemote(syncSource.remote);
+          let rebaseResult2;
+          if (staleUpstreamHash) {
+            rebaseResult2 = await rebaseOnto(syncSource.ref, staleUpstreamHash);
+          } else {
+            const savedStrategy = await determineRebaseStrategy(newBranchName, syncSource.ref);
+            rebaseResult2 = savedStrategy.strategy === "onto" && savedStrategy.ontoOldBase ? await rebaseOnto(syncSource.ref, savedStrategy.ontoOldBase) : await rebase(syncSource.ref);
+          }
+          if (rebaseResult2.exitCode !== 0) {
+            warn("Rebase encountered conflicts. Resolve them manually, then run:");
+            info(`  ${pc15.bold("git rebase --continue")}`);
+          } else {
+            success(`Rebased ${pc15.bold(newBranchName)} onto ${pc15.bold(syncSource.ref)}.`);
+          }
+          info(`All your changes are preserved. Run ${pc15.bold("contrib submit")} when ready to create a new PR.`);
+          return;
+        }
+        warn("Discarding local changes...");
+      }
+      await fetchRemote(syncSource.remote);
+      await resetHard("HEAD");
+      const coResult = await checkoutBranch(baseBranch);
+      if (coResult.exitCode !== 0) {
+        error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
+        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)}...`);
+      await forceDeleteBranch(currentBranch);
+      success(`Deleted ${pc15.bold(currentBranch)}.`);
+      info(`Run ${pc15.bold("contrib start")} to begin a new feature branch.`);
+      return;
+    }
+    info(`Updating ${pc15.bold(currentBranch)} with latest ${pc15.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
-    await resetHard(syncSource.ref);
-    const rebaseResult = await rebase(baseBranch);
+    if (!await refExists(syncSource.ref)) {
+      error(`Remote ref ${pc15.bold(syncSource.ref)} does not exist.`);
+      error("Run `git fetch --all` and verify your remote configuration.");
+      process.exit(1);
+    }
+    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)`));
+    }
+    const rebaseResult = rebaseStrategy.strategy === "onto" && rebaseStrategy.ontoOldBase ? await rebaseOnto(syncSource.ref, rebaseStrategy.ontoOldBase) : await rebase(syncSource.ref);
     if (rebaseResult.exitCode !== 0) {
       warn("Rebase hit conflicts. Resolve them manually.");
       console.log();
@@ -1547,7 +3905,7 @@ var update_default = defineCommand9({
           let conflictDiff = "";
           for (const file of conflictFiles.slice(0, 3)) {
             try {
-              const content = readFileSync3(file, "utf-8");
+              const content = readFileSync4(file, "utf-8");
               if (content.includes("<<<<<<<")) {
                 conflictDiff += `
 --- ${file} ---
@@ -1557,34 +3915,38 @@ ${content.slice(0, 2000)}
             } catch {}
           }
           if (conflictDiff) {
+            const spinner = createSpinner("Analyzing conflicts with AI...");
             const suggestion = await suggestConflictResolution(conflictDiff, args.model);
             if (suggestion) {
+              spinner.success("AI conflict guidance ready.");
               console.log(`
-${pc11.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(pc11.dim("─".repeat(60)));
+${pc15.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(pc15.dim("─".repeat(60)));
               console.log(suggestion);
-              console.log(pc11.dim("─".repeat(60)));
+              console.log(pc15.dim("─".repeat(60)));
               console.log();
+            } else {
+              spinner.fail("AI could not analyze the conflicts.");
             }
           }
         }
       }
-      console.log(pc11.bold("To resolve:"));
+      console.log(pc15.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${pc11.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${pc11.cyan("git rebase --continue")}`);
+      console.log(`  2. ${pc15.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${pc15.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${pc11.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${pc15.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`✅ ${pc11.bold(currentBranch)} has been rebased onto latest ${pc11.bold(baseBranch)}`);
+    success(`✅ ${pc15.bold(currentBranch)} has been rebased onto latest ${pc15.bold(baseBranch)}`);
   }
 });
 
 // src/commands/validate.ts
-import { defineCommand as defineCommand10 } from "citty";
-import pc12 from "picocolors";
-var validate_default = defineCommand10({
+import { defineCommand as defineCommand13 } from "citty";
+import pc16 from "picocolors";
+var validate_default = defineCommand13({
   meta: {
     name: "validate",
     description: "Validate a commit message against the configured convention"
@@ -1614,7 +3976,7 @@ var validate_default = defineCommand10({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(pc12.red(`  ✗ ${line}`));
+      console.error(pc16.red(`  ✗ ${line}`));
     }
     process.exit(1);
   }
@@ -1622,75 +3984,19 @@ var validate_default = defineCommand10({
 
 // src/ui/banner.ts
 import figlet from "figlet";
-import pc13 from "picocolors";
-// package.json
-var package_default = {
-  name: "contribute-now",
-  version: "0.2.0",
-  description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
-  type: "module",
-  bin: {
-    contrib: "dist/index.js",
-    contribute: "dist/index.js"
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    build: "bun build src/index.ts --outfile dist/index.js --target node --packages external",
-    dev: "bun src/index.ts",
-    test: "bun test",
-    lint: "biome check .",
-    "lint:fix": "biome check --write .",
-    format: "biome format --write .",
-    prepare: "husky || true",
-    "www:dev": "bun run --cwd www dev",
-    "www:build": "bun run --cwd www build",
-    "www:preview": "bun run --cwd www preview"
-  },
-  engines: {
-    node: ">=18",
-    bun: ">=1.0"
-  },
-  keywords: [
-    "git",
-    "workflow",
-    "squash-merge",
-    "sync",
-    "cli",
-    "contribute",
-    "fork",
-    "dev-branch",
-    "clean-commit"
-  ],
-  author: "Waren Gonzaga",
-  license: "GPL-3.0",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/warengonzaga/contribute-now.git"
-  },
-  dependencies: {
-    "@github/copilot-sdk": "^0.1.25",
-    "@wgtechlabs/log-engine": "^2.3.1",
-    citty: "^0.1.6",
-    figlet: "^1.10.0",
-    picocolors: "^1.1.1"
-  },
-  devDependencies: {
-    "@biomejs/biome": "^2.4.4",
-    "@types/bun": "latest",
-    "@types/figlet": "^1.7.0",
-    husky: "^9.1.7",
-    typescript: "^5.7.0"
-  }
-};
-
-// src/ui/banner.ts
-var LOGO;
+import pc17 from "picocolors";
+var LOGO_BIG;
+try {
+  LOGO_BIG = figlet.textSync(`Contribute
+Now`, { font: "ANSI Shadow" });
+} catch {
+  LOGO_BIG = "Contribute Now";
+}
+var LOGO_SMALL;
 try {
-  LOGO = figlet.textSync("contrib", { font: "ANSI Shadow" });
+  LOGO_SMALL = figlet.textSync("Contribute Now", { font: "Slant" });
 } catch {
-  LOGO = "contribute-now";
+  LOGO_SMALL = "Contribute Now";
 }
 function getVersion() {
   return package_default.version ?? "unknown";
@@ -1698,24 +4004,44 @@ function getVersion() {
 function getAuthor() {
   return typeof package_default.author === "string" ? package_default.author : "unknown";
 }
-function showBanner(minimal = false) {
-  console.log(pc13.cyan(`
-${LOGO}`));
-  console.log(`  ${pc13.dim(`v${getVersion()}`)} ${pc13.dim("—")} ${pc13.dim(`Built by ${getAuthor()}`)}`);
-  if (!minimal) {
-    console.log(`  ${pc13.dim(package_default.description)}`);
+function showBanner(variant = "small") {
+  const logo = variant === "big" ? LOGO_BIG : LOGO_SMALL;
+  console.log(pc17.cyan(`
+${logo}`));
+  console.log(`  ${pc17.dim(`v${getVersion()}`)} ${pc17.dim("—")} ${pc17.dim(`Built by ${getAuthor()}`)}`);
+  if (variant === "big") {
     console.log();
-    console.log(`  ${pc13.yellow("Star")}        ${pc13.cyan("https://github.com/warengonzaga/contribute-now")}`);
-    console.log(`  ${pc13.green("Contribute")}  ${pc13.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
-    console.log(`  ${pc13.magenta("Sponsor")}     ${pc13.cyan("https://warengonzaga.com/sponsor")}`);
+    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();
 }
 
 // src/index.ts
-var isHelp = process.argv.includes("--help") || process.argv.includes("-h");
-showBanner(isHelp);
-var main = defineCommand11({
+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 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({
   meta: {
     name: "contrib",
     version: getVersion(),
@@ -1735,10 +4061,13 @@ var main = defineCommand11({
     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
+    validate: validate_default,
+    doctor: doctor_default
   },
   run({ args }) {
     if (args.version) {
@@ -1746,4 +4075,6 @@ var main = defineCommand11({
     }
   }
 });
-runMain(main);
+runMain(main).then(() => {
+  process.exit(0);
+});