contribute-now 0.2.0-dev.7c81c96 → 0.2.0-dev.88d5119

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,6 +16,12 @@ 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))
@@ -24,6 +32,38 @@ function readConfig(cwd = process.cwd()) {
     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;
@@ -59,50 +99,9 @@ function getDefaultConfig() {
   };
 }
 
-// src/utils/confirm.ts
-import * as clack from "@clack/prompts";
-import pc 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} ${pc.dim("(space to toggle, enter to confirm)")}`,
-    options: choices.map((choice) => ({ value: choice, label: choice })),
-    required: false
-  });
-  handleCancel(result);
-  return result;
-}
-
 // src/utils/git.ts
 import { execFile as execFileCb } from "node:child_process";
-import { readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
 function run(args) {
   return new Promise((resolve) => {
@@ -119,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"]);
@@ -141,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"]);
 }
@@ -173,15 +237,64 @@ async function pushSetUpstream(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}"]);
+  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;
@@ -204,7 +317,7 @@ async function getChangedFiles() {
     if (!match)
       return "";
     const file = match[1];
-    const renameIdx = file.indexOf(" -> ");
+    const renameIdx = file.lastIndexOf(" -> ");
     return renameIdx !== -1 ? file.slice(renameIdx + 4) : file;
   }).filter(Boolean);
 }
@@ -235,7 +348,9 @@ async function getGoneBranches() {
   if (exitCode !== 0)
     return [];
   return stdout.trimEnd().split(`
-`).filter((line) => line.includes(": gone]")).map((line) => line.replace(/^\*?\s+/, "").split(/\s+/)[0]).filter(Boolean);
+`).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]);
@@ -282,6 +397,13 @@ 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]);
 }
@@ -346,7 +468,7 @@ async function getFileStatus() {
     const indexStatus = line[0];
     const workTreeStatus = line[1];
     const pathPart = line.slice(3);
-    const renameIdx = pathPart.indexOf(" -> ");
+    const renameIdx = pathPart.lastIndexOf(" -> ");
     const file = renameIdx !== -1 ? pathPart.slice(renameIdx + 4) : pathPart;
     if (indexStatus === "?" && workTreeStatus === "?") {
       result.untracked.push(file);
@@ -361,10 +483,78 @@ async function getFileStatus() {
   }
   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: {
@@ -387,7 +577,7 @@ function info(msg) {
 }
 function heading(msg) {
   console.log(`
-${pc2.bold(msg)}`);
+${pc.bold(msg)}`);
 }
 
 // src/utils/workflow.ts
@@ -436,78 +626,37 @@ function getProtectedBranches(config) {
   }
   return branches;
 }
-
-// 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 ${pc3.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(`${pc3.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) {
-      const suggestedName = currentBranch.replace(/^(feature|fix|docs|chore|test|refactor)\//, "$1/new-");
-      const newBranchName = await inputPrompt("New branch name", suggestedName !== currentBranch ? suggestedName : `${currentBranch}-v2`);
-      const renameResult = await renameBranch(currentBranch, newBranchName);
-      if (renameResult.exitCode !== 0) {
-        error(`Failed to rename branch: ${renameResult.stderr}`);
-        return "skipped";
-      }
-      success(`Renamed ${pc3.bold(currentBranch)} → ${pc3.bold(newBranchName)}`);
-      const syncSource2 = getSyncSource(config);
-      await fetchRemote(syncSource2.remote);
-      const savedUpstreamRef = await getUpstreamRef();
-      const rebaseResult = savedUpstreamRef && savedUpstreamRef !== syncSource2.ref ? await rebaseOnto(syncSource2.ref, savedUpstreamRef) : await rebase(syncSource2.ref);
-      if (rebaseResult.exitCode !== 0) {
-        warn("Rebase encountered conflicts. Resolve them after cleanup:");
-        info(`  ${pc3.bold(`git checkout ${newBranchName} && git rebase --continue`)}`);
-      } else {
-        success(`Rebased ${pc3.bold(newBranchName)} onto ${pc3.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 ${pc3.bold(baseBranch)} with ${pc3.bold(syncSource2.ref)}.`);
-      return "saved";
-    }
-  }
-  const syncSource = getSyncSource(config);
-  info(`Switching to ${pc3.bold(baseBranch)} and syncing...`);
-  await fetchRemote(syncSource.remote);
-  const coResult = await checkoutBranch(baseBranch);
-  if (coResult.exitCode !== 0) {
-    error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
-    return "skipped";
+function getProtectedPrefixes(config) {
+  if (config.workflow === "git-flow") {
+    return ["release/", "hotfix/"];
   }
-  await updateLocalBranch(baseBranch, syncSource.ref);
-  success(`Synced ${pc3.bold(baseBranch)} with ${pc3.bold(syncSource.ref)}.`);
-  return "switched";
+  return [];
 }
-var clean_default = defineCommand({
+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/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
     }
   },
@@ -517,150 +666,203 @@ 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);
-    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 mergedBranches = await getMergedBranches(baseBranch);
-    const mergedCandidates = mergedBranches.filter((b) => !protectedBranches.has(b));
-    const goneBranches = await getGoneBranches();
-    const goneCandidates = goneBranches.filter((b) => !protectedBranches.has(b) && !mergedCandidates.includes(b));
-    if (mergedCandidates.length > 0) {
-      console.log(`
-${pc3.bold("Merged branches to delete:")}`);
-      for (const b of mergedCandidates) {
-        const marker = b === currentBranch ? pc3.yellow(" (current)") : "";
-        console.log(`  ${pc3.dim("•")} ${b}${marker}`);
-      }
-      console.log();
-      const ok = args.yes || await confirmPrompt(`Delete ${pc3.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 protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
+    const currentBranch = await getCurrentBranch();
+    const showRemoteOnly = args.remote;
+    const showAll = args.all;
+    heading("\uD83C\uDF3F branches");
+    console.log();
+    if (!showRemoteOnly) {
+      const localBranches = await getLocalBranches();
+      if (localBranches.length === 0) {
+        console.log(pc2.dim("  No local branches found."));
+      } else {
+        console.log(`  ${pc2.bold("Local")}`);
+        console.log();
+        for (const branch of localBranches) {
+          const parts = [];
+          if (branch.isCurrent) {
+            parts.push(pc2.green("* "));
+          } else {
+            parts.push("  ");
           }
-          const result = await deleteBranch(branch);
-          if (result.exitCode === 0) {
-            success(`  Deleted ${pc3.bold(branch)}`);
+          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 {
-            warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
+            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("")}`);
         }
-      } else {
-        info("Skipped merged branch deletion.");
       }
     }
-    if (goneCandidates.length > 0) {
-      console.log(`
-${pc3.bold("Stale branches (remote deleted, likely squash-merged):")}`);
-      for (const b of goneCandidates) {
-        const marker = b === currentBranch ? pc3.yellow(" (current)") : "";
-        console.log(`  ${pc3.dim("•")} ${b}${marker}`);
+    if (showRemoteOnly || showAll) {
+      const remoteBranches = await getRemoteBranches();
+      if (!showRemoteOnly) {
+        console.log();
       }
-      console.log();
-      const ok = args.yes || await confirmPrompt(`Delete ${pc3.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 ${pc3.bold(branch)}`);
-          } else {
-            warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
+      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();
         }
-      } 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 tips = [];
+    if (!showAll && !showRemoteOnly) {
+      tips.push(`Use ${pc2.bold("contrib branch -a")} to include remote branches`);
     }
-    const finalBranch = await getCurrentBranch();
-    if (finalBranch && protectedBranches.has(finalBranch)) {
-      console.log();
-      info(`You're on ${pc3.bold(finalBranch)}. Run ${pc3.bold("contrib start")} to begin a new feature.`);
+    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 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);
+// 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}`;
+}
+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 getValidationError(convention) {
-  if (convention === "none")
-    return [];
-  return [
-    `Commit message does not follow ${CONVENTION_LABELS[convention]} format.`,
-    ...CONVENTION_FORMAT_HINTS[convention]
-  ];
+function looksLikeNaturalLanguage(input) {
+  return input.includes(" ") && !input.includes("/");
+}
+
+// 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;
 }
 
 // src/utils/copilot.ts
@@ -700,28 +902,31 @@ Rules:
 - 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 = `Git branch name generator. Format: <prefix>/<kebab-case-name>
-Prefixes: feature, fix, docs, chore, test, refactor
-Rules: lowercase kebab-case, 2-5 words max. Return ONLY the branch name.
-Examples: fix/login-timeout | feature/user-profile-page | docs/update-readme`;
-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..."}`;
+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; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+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; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+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; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+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() {
@@ -878,7 +1083,11 @@ ${diff.slice(0, 4000)}`;
 async function suggestBranchName(description, model) {
   try {
     const result = await callCopilot(BRANCH_NAME_SYSTEM_PROMPT, description, model);
-    return result?.trim() ?? null;
+    const trimmed = result?.trim() ?? null;
+    if (trimmed && /^[a-z]+\/[a-z0-9-]+$/.test(trimmed)) {
+      return trimmed;
+    }
+    return null;
   } catch {
     return null;
   }
@@ -966,6 +1175,144 @@ ${diffs.slice(0, 4000)}`;
   }
 }
 
+// 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 = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -1010,11 +1357,283 @@ function createSpinner(text2) {
     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)"
@@ -1040,6 +1659,7 @@ 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.");
@@ -1058,9 +1678,9 @@ var commit_default = defineCommand2({
         process.exit(1);
       }
       console.log(`
-${pc5.bold("Changed files:")}`);
+${pc6.bold("Changed files:")}`);
       for (const f of changedFiles) {
-        console.log(`  ${pc5.dim("•")} ${f}`);
+        console.log(`  ${pc6.dim("•")} ${f}`);
       }
       const stageAction = await selectPrompt("No staged changes. How would you like to stage?", [
         "Stage all changes",
@@ -1110,7 +1730,7 @@ ${pc5.bold("Changed files:")}`);
         if (commitMessage) {
           spinner.success("AI commit message generated.");
           console.log(`
-  ${pc5.dim("AI suggestion:")} ${pc5.bold(pc5.cyan(commitMessage))}`);
+  ${pc6.dim("AI suggestion:")} ${pc6.bold(pc6.cyan(commitMessage))}`);
         } else {
           spinner.fail("AI did not return a commit message.");
           warn("Falling back to manual entry.");
@@ -1136,7 +1756,7 @@ ${pc5.bold("Changed files:")}`);
         if (regen) {
           spinner.success("Commit message regenerated.");
           console.log(`
-  ${pc5.dim("AI suggestion:")} ${pc5.bold(pc5.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 {
@@ -1151,7 +1771,7 @@ ${pc5.bold("Changed files:")}`);
       if (convention2 !== "none") {
         console.log();
         for (const hint of CONVENTION_FORMAT_HINTS[convention2]) {
-          console.log(pc5.dim(hint));
+          console.log(pc6.dim(hint));
         }
         console.log();
       }
@@ -1175,7 +1795,7 @@ ${pc5.bold("Changed files:")}`);
       error(`Failed to commit: ${result.stderr}`);
       process.exit(1);
     }
-    success(`✅ Committed: ${pc5.bold(finalMessage)}`);
+    success(`✅ Committed: ${pc6.bold(finalMessage)}`);
   }
 });
 async function runGroupCommit(model, config) {
@@ -1192,9 +1812,9 @@ async function runGroupCommit(model, config) {
     process.exit(1);
   }
   console.log(`
-${pc5.bold("Changed files:")}`);
+${pc6.bold("Changed files:")}`);
   for (const f of changedFiles) {
-    console.log(`  ${pc5.dim("•")} ${f}`);
+    console.log(`  ${pc6.dim("•")} ${f}`);
   }
   const spinner = createSpinner(`Asking AI to group ${changedFiles.length} file(s) into logical commits...`);
   const diffs = await getFullDiffForFiles(changedFiles);
@@ -1232,13 +1852,13 @@ ${pc5.bold("Changed files:")}`);
   let commitAll = false;
   while (!proceedToCommit) {
     console.log(`
-${pc5.bold(`AI suggested ${validGroups.length} commit group(s):`)}
+${pc6.bold(`AI suggested ${validGroups.length} commit group(s):`)}
 `);
     for (let i = 0;i < validGroups.length; i++) {
       const g = validGroups[i];
-      console.log(`  ${pc5.cyan(`Group ${i + 1}:`)} ${pc5.bold(g.message)}`);
+      console.log(`  ${pc6.cyan(`Group ${i + 1}:`)} ${pc6.bold(g.message)}`);
       for (const f of g.files) {
-        console.log(`    ${pc5.dim("•")} ${f}`);
+        console.log(`    ${pc6.dim("•")} ${f}`);
       }
       console.log();
     }
@@ -1282,16 +1902,16 @@ ${pc5.bold(`AI suggested ${validGroups.length} commit group(s):`)}
         continue;
       }
       committed++;
-      success(`✅ Committed group ${i + 1}: ${pc5.bold(group.message)}`);
+      success(`✅ Committed group ${i + 1}: ${pc6.bold(group.message)}`);
     }
   } else {
     for (let i = 0;i < validGroups.length; i++) {
       const group = validGroups[i];
-      console.log(pc5.bold(`
+      console.log(pc6.bold(`
 ── Group ${i + 1}/${validGroups.length} ──`));
-      console.log(`  ${pc5.cyan(group.message)}`);
+      console.log(`  ${pc6.cyan(group.message)}`);
       for (const f of group.files) {
-        console.log(`  ${pc5.dim("•")} ${f}`);
+        console.log(`  ${pc6.dim("•")} ${f}`);
       }
       let message = group.message;
       let actionDone = false;
@@ -1313,7 +1933,7 @@ ${pc5.bold(`AI suggested ${validGroups.length} commit group(s):`)}
           if (newMsg) {
             message = newMsg;
             group.message = newMsg;
-            regenSpinner.success(`New message: ${pc5.bold(message)}`);
+            regenSpinner.success(`New message: ${pc6.bold(message)}`);
           } else {
             regenSpinner.fail("AI could not generate a new message. Keeping current one.");
           }
@@ -1353,25 +1973,413 @@ ${pc5.bold(`AI suggested ${validGroups.length} commit group(s):`)}
           continue;
         }
         committed++;
-        success(`✅ Committed group ${i + 1}: ${pc5.bold(message)}`);
+        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);
-}
+  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.0-dev.88d5119",
+  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.`)}`);
+      }
+      if (warnings.length > 0) {
+        console.log(`  ${pc7.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
+      }
+      console.log();
+    }
+  }
+});
 
 // src/commands/hook.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+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 defineCommand3 } from "citty";
-import pc6 from "picocolors";
+import { defineCommand as defineCommand5 } from "citty";
+import pc8 from "picocolors";
 var HOOK_MARKER = "# managed by contribute-now";
 function getHooksDir(cwd = process.cwd()) {
   return join3(cwd, ".git", "hooks");
@@ -1409,7 +2417,7 @@ else
 fi
 `;
 }
-var hook_default = defineCommand3({
+var hook_default = defineCommand5({
   meta: {
     name: "hook",
     description: "Install or uninstall the commit-msg git hook"
@@ -1452,7 +2460,7 @@ async function installHook() {
   }
   const hookPath = getHookPath();
   const hooksDir = getHooksDir();
-  if (existsSync2(hookPath)) {
+  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.");
@@ -1462,18 +2470,19 @@ 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: ${pc6.bold(CONVENTION_LABELS[config.commitConvention])}`);
-  info(`Path: ${pc6.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;
   }
@@ -1486,169 +2495,165 @@ async function uninstallHook() {
   success("commit-msg hook removed.");
 }
 
-// src/commands/setup.ts
-import { defineCommand as defineCommand4 } from "citty";
-import pc7 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 === "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;
+// src/commands/log.ts
+import { defineCommand as defineCommand6 } from "citty";
+import pc9 from "picocolors";
+var log_default = defineCommand6({
+  meta: {
+    name: "log",
+    description: "Show a colorized, workflow-aware commit log with graph"
+  },
+  args: {
+    count: {
+      type: "string",
+      alias: "n",
+      description: "Number of commits to show (default: 20)"
+    },
+    all: {
+      type: "boolean",
+      alias: "a",
+      description: "Show all branches, not just current",
+      default: false
+    },
+    graph: {
+      type: "boolean",
+      alias: "g",
+      description: "Show graph view with branch lines",
+      default: true
+    },
+    branch: {
+      type: "string",
+      alias: "b",
+      description: "Show log for a specific branch"
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    const count = args.count ? Number.parseInt(args.count, 10) : 20;
+    const showAll = args.all;
+    const showGraph = args.graph;
+    const targetBranch = args.branch;
+    const protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
+    const currentBranch = await getCurrentBranch();
+    heading("\uD83D\uDCDC commit log");
+    if (showGraph) {
+      const lines = await getLogGraph({ count, all: showAll, branch: targetBranch });
+      if (lines.length === 0) {
+        console.log(pc9.dim("  No commits found."));
+        console.log();
+        return;
+      }
+      console.log();
+      for (const line of lines) {
+        console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
+      }
+    } else {
+      const entries = await getLogEntries({ count, all: showAll, branch: targetBranch });
+      if (entries.length === 0) {
+        console.log(pc9.dim("  No commits found."));
+        console.log();
+        return;
+      }
+      console.log();
+      for (const entry of entries) {
+        const hashStr = pc9.yellow(entry.hash);
+        const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
+        const subjectStr = colorizeSubject(entry.subject);
+        console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
+      }
+    }
+    console.log();
+    console.log(pc9.dim(`  Showing ${count} most recent commits${showAll ? " (all branches)" : targetBranch ? ` (${targetBranch})` : ""}`));
+    console.log(pc9.dim(`  Use ${pc9.bold("contrib log -n 50")} for more, or ${pc9.bold("contrib log --all")} for all branches`));
+    console.log();
   }
+});
+function colorizeGraphLine(line, protectedBranches, currentBranch) {
+  const match = line.match(/^([|/\\*\s_.-]*)([a-f0-9]{7,12})(\s+\(([^)]+)\))?\s*(.*)/);
+  if (!match) {
+    return pc9.cyan(line);
+  }
+  const [, graphPart = "", hash, , refs, subject = ""] = match;
+  const parts = [];
+  if (graphPart) {
+    parts.push(colorizeGraphChars(graphPart));
+  }
+  parts.push(pc9.yellow(hash));
+  if (refs) {
+    parts.push(` (${colorizeRefs(refs, protectedBranches, currentBranch)})`);
+  }
+  parts.push(` ${colorizeSubject(subject)}`);
+  return parts.join("");
+}
+function colorizeGraphChars(graphPart) {
+  return graphPart.split("").map((ch) => {
+    switch (ch) {
+      case "*":
+        return pc9.green(ch);
+      case "|":
+        return pc9.cyan(ch);
+      case "/":
+      case "\\":
+        return pc9.cyan(ch);
+      case "-":
+      case "_":
+        return pc9.cyan(ch);
+      default:
+        return ch;
+    }
+  }).join("");
+}
+function colorizeRefs(refs, protectedBranches, currentBranch) {
+  return refs.split(",").map((ref) => {
+    const trimmed = ref.trim();
+    if (trimmed.startsWith("HEAD ->") || trimmed === "HEAD") {
+      const branchName = trimmed.replace("HEAD -> ", "");
+      if (trimmed === "HEAD") {
+        return pc9.bold(pc9.cyan("HEAD"));
+      }
+      return `${pc9.bold(pc9.cyan("HEAD"))} ${pc9.dim("->")} ${colorizeRefName(branchName, protectedBranches, currentBranch)}`;
+    }
+    if (trimmed.startsWith("tag:")) {
+      return pc9.bold(pc9.magenta(trimmed));
+    }
+    return colorizeRefName(trimmed, protectedBranches, currentBranch);
+  }).join(pc9.dim(", "));
 }
-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;
+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));
   }
-}
-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;
+  if (localName === currentBranch) {
+    return pc9.bold(pc9.green(name));
   }
-}
-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;
+  if (isRemote) {
+    return pc9.blue(name);
   }
+  return pc9.green(name);
 }
-
-// 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 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)}`;
   }
-  const sshMatch = url.match(/git@github\.com:([^/]+)\/([^/.]+?)(?:\.git)?$/);
-  if (sshMatch) {
-    return { owner: sshMatch[1], repo: sshMatch[2] };
+  if (subject.startsWith("Merge ")) {
+    return pc9.dim(subject);
   }
-  return null;
-}
-async function getRepoInfoFromRemote(remote = "origin") {
-  const url = await getRemoteUrl(remote);
-  if (!url)
-    return null;
-  return parseRepoFromUrl(url);
+  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)"
@@ -1669,7 +2674,7 @@ var setup_default = defineCommand4({
       workflow = "github-flow";
     else if (workflowChoice.startsWith("Git Flow"))
       workflow = "git-flow";
-    info(`Workflow: ${pc7.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,
@@ -1722,8 +2727,8 @@ var setup_default = defineCommand4({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${pc7.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${pc7.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;
@@ -1746,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);
         }
       }
     }
@@ -1763,45 +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: ${pc7.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    info(`Convention: ${pc7.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-    info(`Role: ${pc7.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: ${pc7.bold(config.mainBranch)} | Dev: ${pc7.bold(config.devBranch)}`);
+      info(`Main: ${pc10.bold(config.mainBranch)} | Dev: ${pc10.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${pc7.bold(config.mainBranch)}`);
+      info(`Main: ${pc10.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${pc7.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc7.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 pc8 from "picocolors";
-
-// src/utils/branch.ts
-var DEFAULT_PREFIXES = ["feature", "fix", "docs", "chore", "test", "refactor"];
-function hasPrefix(branchName, prefixes = DEFAULT_PREFIXES) {
-  return prefixes.some((p) => branchName.startsWith(`${p}/`));
-}
-function formatBranchName(prefix, name) {
-  const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return `${prefix}/${sanitized}`;
-}
-function isValidBranchName(name) {
-  return /^[a-zA-Z0-9._/-]+$/.test(name) && !name.startsWith("/") && !name.endsWith("/");
-}
-function looksLikeNaturalLanguage(input) {
-  return input.includes(" ") && !input.includes("/");
-}
-
-// src/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"
@@ -1809,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",
@@ -1827,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.");
@@ -1841,6 +2853,14 @@ 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) {
       const spinner = createSpinner("Generating branch name suggestion...");
@@ -1848,8 +2868,8 @@ var start_default = defineCommand5({
       if (suggested) {
         spinner.success("Branch name suggestion ready.");
         console.log(`
-  ${pc8.dim("AI suggestion:")} ${pc8.bold(pc8.cyan(suggested))}`);
-        const accepted = await confirmPrompt(`Use ${pc8.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 {
@@ -1860,30 +2880,51 @@ var start_default = defineCommand5({
       }
     }
     if (!hasPrefix(branchName, branchPrefixes)) {
-      const prefix = await selectPrompt(`Choose a branch type for ${pc8.bold(branchName)}:`, branchPrefixes);
+      const prefix = await selectPrompt(`Choose a branch type for ${pc11.bold(branchName)}:`, branchPrefixes);
       branchName = formatBranchName(prefix, branchName);
     }
     if (!isValidBranchName(branchName)) {
       error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
       process.exit(1);
     }
-    info(`Creating branch: ${pc8.bold(branchName)}`);
+    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);
+    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 (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 ${pc8.bold(branchName)} from latest ${pc8.bold(baseBranch)}`);
+    success(`✅ Created ${pc11.bold(branchName)} from latest ${pc11.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand6 } from "citty";
-import pc9 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"
@@ -1899,20 +2940,17 @@ var status_default = defineCommand6({
       process.exit(1);
     }
     heading("\uD83D\uDCCA contribute-now status");
-    console.log(`  ${pc9.dim("Workflow:")} ${pc9.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    console.log(`  ${pc9.dim("Role:")} ${pc9.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, fileStatus] = await Promise.all([
-      hasUncommittedChanges(),
-      getFileStatus()
-    ]);
+    const [dirty, fileStatus] = await Promise.all([hasUncommittedChanges(), getFileStatus()]);
     if (dirty) {
-      console.log(`  ${pc9.yellow("⚠")}  ${pc9.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${pc12.yellow("⚠")}  ${pc12.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -1928,82 +2966,82 @@ 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 + pc9.dim(` (current ${pc9.green("*")})`));
+      console.log(branchLine + pc12.dim(` (current ${pc12.green("*")})`));
     } else if (currentBranch) {
-      console.log(pc9.dim(`  (on ${pc9.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(`  ${pc9.green("Staged for commit:")}`);
+        console.log(`  ${pc12.green("Staged for commit:")}`);
         for (const { file, status } of fileStatus.staged) {
-          console.log(`    ${pc9.green("+")} ${pc9.dim(`${status}:`)} ${file}`);
+          console.log(`    ${pc12.green("+")} ${pc12.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.modified.length > 0) {
-        console.log(`  ${pc9.yellow("Unstaged changes:")}`);
+        console.log(`  ${pc12.yellow("Unstaged changes:")}`);
         for (const { file, status } of fileStatus.modified) {
-          console.log(`    ${pc9.yellow("~")} ${pc9.dim(`${status}:`)} ${file}`);
+          console.log(`    ${pc12.yellow("~")} ${pc12.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.untracked.length > 0) {
-        console.log(`  ${pc9.red("Untracked files:")}`);
+        console.log(`  ${pc12.red("Untracked files:")}`);
         for (const file of fileStatus.untracked) {
-          console.log(`    ${pc9.red("?")} ${file}`);
+          console.log(`    ${pc12.red("?")} ${file}`);
         }
       }
     } else if (!dirty) {
-      console.log(`  ${pc9.green("✓")}  ${pc9.dim("Working tree clean")}`);
+      console.log(`  ${pc12.green("✓")}  ${pc12.dim("Working tree clean")}`);
     }
     const tips = [];
     if (fileStatus.staged.length > 0) {
-      tips.push(`Run ${pc9.bold("contrib commit")} to commit staged changes`);
+      tips.push(`Run ${pc12.bold("contrib commit")} to commit staged changes`);
     }
     if (fileStatus.modified.length > 0 || fileStatus.untracked.length > 0) {
-      tips.push(`Run ${pc9.bold("contrib commit")} to stage and commit changes`);
+      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 ${pc9.bold("contrib submit")} to push and create/update your PR`);
+        tips.push(`Run ${pc12.bold("contrib submit")} to push and create/update your PR`);
       }
     }
     if (tips.length > 0) {
       console.log();
-      console.log(`  ${pc9.dim("\uD83D\uDCA1 Tip:")}`);
+      console.log(`  ${pc12.dim("\uD83D\uDCA1 Tip:")}`);
       for (const tip of tips) {
-        console.log(`     ${pc9.dim(tip)}`);
+        console.log(`     ${pc12.dim(tip)}`);
       }
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = pc9.bold(branch.padEnd(20));
+  const label = pc12.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${pc9.green("✓")}  ${label} ${pc9.dim(`in sync with ${base}`)}`;
+    return `  ${pc12.green("✓")}  ${label} ${pc12.dim(`in sync with ${base}`)}`;
   }
   if (ahead > 0 && behind === 0) {
-    return `  ${pc9.yellow("↑")}  ${label} ${pc9.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+    return `  ${pc12.yellow("↑")}  ${label} ${pc12.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
   }
   if (behind > 0 && ahead === 0) {
-    return `  ${pc9.red("↓")}  ${label} ${pc9.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+    return `  ${pc12.red("↓")}  ${label} ${pc12.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
   }
-  return `  ${pc9.red("⚡")}  ${label} ${pc9.yellow(`${ahead} ahead`)}${pc9.dim(", ")}${pc9.red(`${behind} behind`)} ${pc9.dim(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 defineCommand7 } from "citty";
-import pc10 from "picocolors";
+import { defineCommand as defineCommand10 } from "citty";
+import pc13 from "picocolors";
 async function performSquashMerge(origin, baseBranch, featureBranch, options) {
-  info(`Checking out ${pc10.bold(baseBranch)}...`);
+  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 ${pc10.bold(featureBranch)} into ${pc10.bold(baseBranch)}...`);
+  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}`);
@@ -2027,32 +3065,42 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
     }
   }
   const fallback = message || `squash merge ${featureBranch}`;
-  const finalMsg = await inputPrompt("Commit message", fallback);
+  let finalMsg;
+  if (message) {
+    console.log(`  ${pc13.dim("Commit message:")} ${pc13.bold(message)}`);
+    finalMsg = message;
+  } else {
+    finalMsg = await inputPrompt("Commit message", fallback);
+  }
   const commitResult = await commitWithMessage(finalMsg);
   if (commitResult.exitCode !== 0) {
     error(`Commit failed: ${commitResult.stderr}`);
     process.exit(1);
   }
-  info(`Pushing ${pc10.bold(baseBranch)} to ${origin}...`);
+  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 ${pc10.bold(featureBranch)}...`);
+  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()}`);
   }
-  info(`Deleting remote branch ${pc10.bold(featureBranch)}...`);
-  const delRemote = await deleteRemoteBranch(origin, featureBranch);
-  if (delRemote.exitCode !== 0) {
-    warn(`Could not delete remote branch: ${delRemote.stderr.trim()}`);
+  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 ${pc10.bold(featureBranch)} into ${pc10.bold(baseBranch)} and pushed.`);
-  info(`Run ${pc10.bold("contrib start")} to begin a new feature.`);
+  success(`✅ Squash merged ${pc13.bold(featureBranch)} into ${pc13.bold(baseBranch)} and pushed.`);
+  info(`Run ${pc13.bold("contrib start")} to begin a new feature.`);
 }
-var submit_default = defineCommand7({
+var submit_default = defineCommand10({
   meta: {
     name: "submit",
     description: "Push current branch and create a pull request"
@@ -2078,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.");
@@ -2092,8 +3141,80 @@ var submit_default = defineCommand7({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      error(`Cannot submit ${protectedBranches.map((b) => pc10.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");
     const ghInstalled = await checkGhInstalled();
@@ -2101,7 +3222,7 @@ var submit_default = defineCommand7({
     if (ghInstalled && ghAuthed) {
       const mergedPR = await getMergedPRForBranch(currentBranch);
       if (mergedPR) {
-        warn(`PR #${mergedPR.number} (${pc10.bold(mergedPR.title)}) was already merged.`);
+        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) {
@@ -2109,7 +3230,7 @@ var submit_default = defineCommand7({
             warn("You have uncommitted changes in your working tree.");
           }
           if (localWork.unpushedCommits > 0) {
-            warn(`You have ${pc10.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not in the merged PR.`);
+            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";
@@ -2120,79 +3241,91 @@ var submit_default = defineCommand7({
             return;
           }
           if (action === SAVE_NEW_BRANCH) {
-            const suggestedName = currentBranch.replace(/^(feature|fix|docs|chore|test|refactor)\//, "$1/new-");
-            const newBranchName = await inputPrompt("New branch name", suggestedName !== currentBranch ? suggestedName : `${currentBranch}-v2`);
+            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 ${pc10.bold(currentBranch)} → ${pc10.bold(newBranchName)}`);
+            success(`Renamed ${pc13.bold(currentBranch)} → ${pc13.bold(newBranchName)}`);
+            await unsetUpstream();
             const syncSource2 = getSyncSource(config);
-            info(`Syncing ${pc10.bold(newBranchName)} with latest ${pc10.bold(baseBranch)}...`);
+            info(`Syncing ${pc13.bold(newBranchName)} with latest ${pc13.bold(baseBranch)}...`);
             await fetchRemote(syncSource2.remote);
-            const savedUpstreamRef = await getUpstreamRef();
-            const rebaseResult = savedUpstreamRef && savedUpstreamRef !== syncSource2.ref ? await rebaseOnto(syncSource2.ref, savedUpstreamRef) : await rebase(syncSource2.ref);
+            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(`  ${pc10.bold("git rebase --continue")}`);
+              info(`  ${pc13.bold("git rebase --continue")}`);
             } else {
-              success(`Rebased ${pc10.bold(newBranchName)} onto ${pc10.bold(syncSource2.ref)}.`);
+              success(`Rebased ${pc13.bold(newBranchName)} onto ${pc13.bold(syncSource2.ref)}.`);
             }
-            info(`All your changes are preserved. Run ${pc10.bold("contrib submit")} when ready to create a new PR.`);
+            info(`All your changes are preserved. Run ${pc13.bold("contrib submit")} when ready to create a new PR.`);
             return;
           }
           warn("Discarding local changes...");
         }
         const syncSource = getSyncSource(config);
-        info(`Switching to ${pc10.bold(baseBranch)} and syncing...`);
+        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 ${pc10.bold(baseBranch)} with ${pc10.bold(syncSource.ref)}.`);
-        info(`Deleting stale branch ${pc10.bold(currentBranch)}...`);
+        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 ${pc10.bold(currentBranch)}.`);
+          success(`Deleted ${pc13.bold(currentBranch)}.`);
         } else {
           warn(`Could not delete branch: ${delResult.stderr.trim()}`);
         }
         console.log();
-        info(`You're now on ${pc10.bold(baseBranch)}. Run ${pc10.bold("contrib start")} to begin a new feature.`);
+        info(`You're now on ${pc13.bold(baseBranch)}. Run ${pc13.bold("contrib start")} to begin a new feature.`);
         return;
       }
     }
-    info(`Pushing ${pc10.bold(currentBranch)} to ${origin}...`);
-    const pushResult = await pushSetUpstream(origin, currentBranch);
-    if (pushResult.exitCode !== 0) {
-      error(`Failed to push: ${pushResult.stderr}`);
-      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(`  ${pc10.cyan(prUrl)}`);
-      } else {
-        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}: ${pc10.bold(existingPR.title)}`);
-      console.log(`  ${pc10.cyan(existingPR.url)}`);
-      return;
-    }
     let prTitle = null;
     let prBody = null;
-    if (!args["no-ai"]) {
+    async function tryGenerateAI() {
       const [copilotError, commits, diff] = await Promise.all([
         checkCopilotAvailable(),
         getLog(baseBranch, "HEAD"),
@@ -2206,10 +3339,10 @@ var submit_default = defineCommand7({
           prBody = result.body;
           spinner.success("PR description generated.");
           console.log(`
-  ${pc10.dim("AI title:")} ${pc10.bold(pc10.cyan(prTitle))}`);
+  ${pc13.dim("AI title:")} ${pc13.bold(pc13.cyan(prTitle))}`);
           console.log(`
-${pc10.dim("AI body preview:")}`);
-          console.log(pc10.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 {
           spinner.fail("AI did not return a PR description.");
         }
@@ -2217,77 +3350,126 @@ ${pc10.dim("AI body preview:")}`);
         warn(`AI unavailable: ${copilotError}`);
       }
     }
+    if (!args["no-ai"]) {
+      await tryGenerateAI();
+    }
     const CANCEL = "Cancel";
     const SQUASH_LOCAL = `Squash merge to ${baseBranch} locally (no PR)`;
-    if (prTitle && prBody) {
-      const choices = [
-        "Use AI description",
-        "Edit title",
-        "Write manually",
-        "Use gh --fill (auto-fill from commits)"
-      ];
-      if (config.role === "maintainer")
-        choices.push(SQUASH_LOCAL);
-      choices.push(CANCEL);
-      const action = await selectPrompt("What would you like to do with the PR description?", choices);
-      if (action === CANCEL) {
-        warn("Submit cancelled.");
-        return;
-      }
-      if (action === SQUASH_LOCAL) {
-        await performSquashMerge(origin, baseBranch, currentBranch, {
-          defaultMsg: prTitle ?? undefined,
-          model: args.model,
-          convention: config.commitConvention
-        });
-        return;
-      }
-      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)");
+    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 choices = [
-        "Write title & body manually",
-        "Use gh --fill (auto-fill from commits)"
-      ];
-      if (config.role === "maintainer")
-        choices.push(SQUASH_LOCAL);
-      choices.push(CANCEL);
-      const action = await selectPrompt("How would you like to create the PR?", choices);
-      if (action === CANCEL) {
-        warn("Submit cancelled.");
-        return;
       }
-      if (action === SQUASH_LOCAL) {
-        await performSquashMerge(origin, baseBranch, currentBranch, {
-          model: args.model,
-          convention: config.commitConvention
-        });
-        return;
+    }
+    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}`);
       }
-      if (action === "Write title & body manually") {
-        prTitle = await inputPrompt("PR title");
-        prBody = await inputPrompt("PR body (markdown)");
+      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.");
@@ -2308,9 +3490,9 @@ ${pc10.dim("AI body preview:")}`);
 });
 
 // src/commands/sync.ts
-import { defineCommand as defineCommand8 } from "citty";
-import pc11 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"
@@ -2321,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 }) {
@@ -2328,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.");
@@ -2350,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(`${pc11.bold(baseBranch)} is ${pc11.yellow(`${div.ahead} ahead`)} and ${pc11.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(`${pc11.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 ${pc11.bold(syncSource.ref)} into local ${pc11.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${pc14.bold(syncSource.ref)} into local ${pc14.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
@@ -2366,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 ${pc11.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}`);
           }
@@ -2391,9 +3672,9 @@ var sync_default = defineCommand8({
 
 // src/commands/update.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { defineCommand as defineCommand9 } from "citty";
-import pc12 from "picocolors";
-var update_default = defineCommand9({
+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"
@@ -2414,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.");
@@ -2428,8 +3710,77 @@ var update_default = defineCommand9({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      error(`Use \`contrib sync\` to update ${protectedBranches.map((b) => pc12.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.");
@@ -2438,8 +3789,8 @@ var update_default = defineCommand9({
     heading("\uD83D\uDD03 contrib update");
     const mergedPR = await getMergedPRForBranch(currentBranch);
     if (mergedPR) {
-      warn(`PR #${mergedPR.number} (${pc12.bold(mergedPR.title)}) has already been merged.`);
-      info(`Link: ${pc12.underline(mergedPR.url)}`);
+      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) {
@@ -2452,14 +3803,14 @@ var update_default = defineCommand9({
         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(`${pc12.bold(currentBranch)} is stale but has local work. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, 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(pc12.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
-          const description = await inputPrompt("What are you working on?");
+          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...");
@@ -2467,8 +3818,8 @@ var update_default = defineCommand9({
             if (suggested) {
               spinner.success("Branch name suggestion ready.");
               console.log(`
-  ${pc12.dim("AI suggestion:")} ${pc12.bold(pc12.cyan(suggested))}`);
-              const accepted = await confirmPrompt(`Use ${pc12.bold(suggested)} as your branch name?`);
+  ${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.");
@@ -2476,52 +3827,73 @@ var update_default = defineCommand9({
             }
           }
           if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-            const prefix = await selectPrompt(`Choose a branch type for ${pc12.bold(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 ${pc12.bold(currentBranch)} → ${pc12.bold(newBranchName)}`);
+          success(`Renamed ${pc15.bold(currentBranch)} → ${pc15.bold(newBranchName)}`);
+          await unsetUpstream();
           await fetchRemote(syncSource.remote);
-          const savedUpstreamRef = await getUpstreamRef();
-          const rebaseResult2 = savedUpstreamRef && savedUpstreamRef !== syncSource.ref ? await rebaseOnto(syncSource.ref, savedUpstreamRef) : await rebase(syncSource.ref);
+          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(`  ${pc12.bold("git rebase --continue")}`);
+            info(`  ${pc15.bold("git rebase --continue")}`);
           } else {
-            success(`Rebased ${pc12.bold(newBranchName)} onto ${pc12.bold(syncSource.ref)}.`);
+            success(`Rebased ${pc15.bold(newBranchName)} onto ${pc15.bold(syncSource.ref)}.`);
           }
-          info(`All your changes are preserved. Run ${pc12.bold("contrib submit")} when ready to create a new PR.`);
+          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 ${pc12.bold(baseBranch)} with ${pc12.bold(syncSource.ref)}.`);
-      info(`Deleting stale branch ${pc12.bold(currentBranch)}...`);
+      success(`Synced ${pc15.bold(baseBranch)} with ${pc15.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${pc15.bold(currentBranch)}...`);
       await forceDeleteBranch(currentBranch);
-      success(`Deleted ${pc12.bold(currentBranch)}.`);
-      info(`Run ${pc12.bold("contrib start")} to begin a new feature branch.`);
+      success(`Deleted ${pc15.bold(currentBranch)}.`);
+      info(`Run ${pc15.bold("contrib start")} to begin a new feature branch.`);
       return;
     }
-    info(`Updating ${pc12.bold(currentBranch)} with latest ${pc12.bold(baseBranch)}...`);
+    info(`Updating ${pc15.bold(currentBranch)} with latest ${pc15.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
+    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 upstreamRef = await getUpstreamRef();
-    const rebaseResult = upstreamRef && upstreamRef !== syncSource.ref ? await rebaseOnto(syncSource.ref, upstreamRef) : await rebase(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();
@@ -2548,10 +3920,10 @@ ${content.slice(0, 2000)}
             if (suggestion) {
               spinner.success("AI conflict guidance ready.");
               console.log(`
-${pc12.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(pc12.dim("─".repeat(60)));
+${pc15.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(pc15.dim("─".repeat(60)));
               console.log(suggestion);
-              console.log(pc12.dim("─".repeat(60)));
+              console.log(pc15.dim("─".repeat(60)));
               console.log();
             } else {
               spinner.fail("AI could not analyze the conflicts.");
@@ -2559,22 +3931,22 @@ ${pc12.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
           }
         }
       }
-      console.log(pc12.bold("To resolve:"));
+      console.log(pc15.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${pc12.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${pc12.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: ${pc12.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${pc15.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`✅ ${pc12.bold(currentBranch)} has been rebased onto latest ${pc12.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 pc13 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"
@@ -2604,7 +3976,7 @@ var validate_default = defineCommand10({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(pc13.red(`  ✗ ${line}`));
+      console.error(pc16.red(`  ✗ ${line}`));
     }
     process.exit(1);
   }
@@ -2612,76 +3984,19 @@ var validate_default = defineCommand10({
 
 // src/ui/banner.ts
 import figlet from "figlet";
-import pc14 from "picocolors";
-// package.json
-var package_default = {
-  name: "contribute-now",
-  version: "0.2.0-dev.7c81c96",
-  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/ui/banner.ts
-var LOGO;
+import pc17 from "picocolors";
+var LOGO_BIG;
 try {
-  LOGO = figlet.textSync(`Contribute
+  LOGO_BIG = figlet.textSync(`Contribute
 Now`, { font: "ANSI Shadow" });
 } catch {
-  LOGO = "Contribute Now";
+  LOGO_BIG = "Contribute Now";
+}
+var LOGO_SMALL;
+try {
+  LOGO_SMALL = figlet.textSync("Contribute Now", { font: "Slant" });
+} catch {
+  LOGO_SMALL = "Contribute Now";
 }
 function getVersion() {
   return package_default.version ?? "unknown";
@@ -2689,23 +4004,44 @@ function getVersion() {
 function getAuthor() {
   return typeof package_default.author === "string" ? package_default.author : "unknown";
 }
-function showBanner(showLinks = false) {
-  console.log(pc14.cyan(`
-${LOGO}`));
-  console.log(`  ${pc14.dim(`v${getVersion()}`)} ${pc14.dim("—")} ${pc14.dim(`Built by ${getAuthor()}`)}`);
-  if (showLinks) {
+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(`  ${pc14.yellow("Star")}        ${pc14.cyan("https://github.com/warengonzaga/contribute-now")}`);
-    console.log(`  ${pc14.green("Contribute")}  ${pc14.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
-    console.log(`  ${pc14.magenta("Sponsor")}     ${pc14.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(),
@@ -2725,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) {