contribute-now 0.2.0-dev.33be40f → 0.2.0-dev.69b11fd

package/dist/index.js

@@ -1,7 +1,9 @@
 #!/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 defineCommand12, runMain } from "citty";
 
 // src/commands/clean.ts
 import { defineCommand } from "citty";
@@ -30,6 +32,9 @@ var CONFIG_FILENAME = ".contributerc.json";
 function getConfigPath(cwd = process.cwd()) {
   return join(cwd, CONFIG_FILENAME);
 }
+function configExists(cwd = process.cwd()) {
+  return existsSync(getConfigPath(cwd));
+}
 function readConfig(cwd = process.cwd()) {
   const path = getConfigPath(cwd);
   if (!existsSync(path))
@@ -638,14 +643,60 @@ async function rebase(branch) {
   return run2(["rebase", branch]);
 }
 async function getUpstreamRef() {
-  const { exitCode, stdout } = await run2(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
+  const { exitCode, stdout } = await run2([
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{u}"
+  ]);
   if (exitCode !== 0)
     return null;
   return stdout.trim() || null;
 }
+async function unsetUpstream() {
+  return run2(["branch", "--unset-upstream"]);
+}
 async function rebaseOnto(newBase, oldBase) {
   return run2(["rebase", "--onto", newBase, oldBase]);
 }
+async function getMergeBase(ref1, ref2) {
+  const { exitCode, stdout } = await run2(["merge-base", ref1, ref2]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function getCommitHash(ref) {
+  const { exitCode, stdout } = await run2(["rev-parse", ref]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function determineRebaseStrategy(currentBranch, syncRef) {
+  const upstreamRef = await getUpstreamRef();
+  if (!upstreamRef) {
+    return { strategy: "plain" };
+  }
+  const upstreamHash = await getCommitHash(upstreamRef);
+  if (!upstreamHash) {
+    return { strategy: "plain" };
+  }
+  const slashIdx = upstreamRef.indexOf("/");
+  const upstreamBranchName = slashIdx !== -1 ? upstreamRef.slice(slashIdx + 1) : upstreamRef;
+  if (upstreamBranchName === currentBranch) {
+    return { strategy: "plain" };
+  }
+  const [forkFromUpstream, forkFromSync] = await Promise.all([
+    getMergeBase("HEAD", upstreamRef),
+    getMergeBase("HEAD", syncRef)
+  ]);
+  if (forkFromUpstream && forkFromSync && forkFromUpstream === forkFromSync) {
+    return { strategy: "plain" };
+  }
+  if (forkFromUpstream) {
+    return { strategy: "onto", ontoOldBase: forkFromUpstream };
+  }
+  return { strategy: "plain" };
+}
 async function getStagedDiff() {
   const { stdout } = await run2(["diff", "--cached"]);
   return stdout;
@@ -1565,11 +1616,374 @@ ${pc5.bold(`AI suggested ${validGroups.length} commit group(s):`)}
   process.exit(0);
 }
 
+// src/commands/doctor.ts
+import { execFile as execFileCb3 } from "node:child_process";
+import { defineCommand as defineCommand3 } from "citty";
+import pc6 from "picocolors";
+// package.json
+var package_default = {
+  name: "contribute-now",
+  version: "0.2.0-dev.69b11fd",
+  description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
+  type: "module",
+  bin: {
+    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 = `  ${pc6.green("✔")} `;
+var FAIL = `  ${pc6.red("✗")} `;
+var WARN = `  ${pc6.yellow("⚠")} `;
+function printReport(report) {
+  for (const section of report.sections) {
+    console.log(`
+  ${pc6.bold(pc6.underline(section.title))}`);
+    for (const check of section.checks) {
+      const prefix = check.ok ? check.warning ? WARN : PASS : FAIL;
+      const text2 = check.detail ? `${check.label} ${pc6.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
+  });
+  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 = defineCommand3({
+  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(`  ${pc6.green("All checks passed!")} No issues detected.
+`);
+    } else {
+      if (failures.length > 0) {
+        console.log(`  ${pc6.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
+      }
+      if (warnings.length > 0) {
+        console.log(`  ${pc6.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 { join as join3 } from "node:path";
-import { defineCommand as defineCommand3 } from "citty";
-import pc6 from "picocolors";
+import { defineCommand as defineCommand4 } from "citty";
+import pc7 from "picocolors";
 var HOOK_MARKER = "# managed by contribute-now";
 function getHooksDir(cwd = process.cwd()) {
   return join3(cwd, ".git", "hooks");
@@ -1607,7 +2021,7 @@ else
 fi
 `;
 }
-var hook_default = defineCommand3({
+var hook_default = defineCommand4({
   meta: {
     name: "hook",
     description: "Install or uninstall the commit-msg git hook"
@@ -1665,8 +2079,8 @@ async function installHook() {
   }
   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: ${pc7.bold(CONVENTION_LABELS[config.commitConvention])}`);
+  info(`Path: ${pc7.dim(hookPath)}`);
 }
 async function uninstallHook() {
   heading("\uD83E\uDE9D hook uninstall");
@@ -1685,30 +2099,9 @@ async function uninstallHook() {
 }
 
 // src/commands/setup.ts
-import { defineCommand as defineCommand4 } from "citty";
-import pc7 from "picocolors";
-
-// 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 getRepoInfoFromRemote(remote = "origin") {
-  const url = await getRemoteUrl(remote);
-  if (!url)
-    return null;
-  return parseRepoFromUrl(url);
-}
-
-// src/commands/setup.ts
-var setup_default = defineCommand4({
+import { defineCommand as defineCommand5 } from "citty";
+import pc8 from "picocolors";
+var setup_default = defineCommand5({
   meta: {
     name: "setup",
     description: "Initialize contribute-now config for this repo (.contributerc.json)"
@@ -1729,7 +2122,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: ${pc8.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
     const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
       `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
       CONVENTION_DESCRIPTIONS.conventional,
@@ -1782,8 +2175,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: ${pc8.bold(detectedRole)} (via ${detectionSource})`);
+      const confirmed = await confirmPrompt(`Role detected as ${pc8.bold(detectedRole)}. Is this correct?`);
       if (!confirmed) {
         const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
         detectedRole = roleChoice;
@@ -1828,22 +2221,22 @@ var setup_default = defineCommand4({
       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: ${pc8.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    info(`Convention: ${pc8.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+    info(`Role: ${pc8.bold(config.role)}`);
     if (config.devBranch) {
-      info(`Main: ${pc7.bold(config.mainBranch)} | Dev: ${pc7.bold(config.devBranch)}`);
+      info(`Main: ${pc8.bold(config.mainBranch)} | Dev: ${pc8.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${pc7.bold(config.mainBranch)}`);
+      info(`Main: ${pc8.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${pc7.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc7.bold(config.upstream)}` : ""}`);
+    info(`Origin: ${pc8.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc8.bold(config.upstream)}` : ""}`);
   }
 });
 
 // src/commands/start.ts
-import { defineCommand as defineCommand5 } from "citty";
-import pc8 from "picocolors";
-var start_default = defineCommand5({
+import { defineCommand as defineCommand6 } from "citty";
+import pc9 from "picocolors";
+var start_default = defineCommand6({
   meta: {
     name: "start",
     description: "Create a new feature branch from the latest base branch"
@@ -1890,8 +2283,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?`);
+  ${pc9.dim("AI suggestion:")} ${pc9.bold(pc9.cyan(suggested))}`);
+        const accepted = await confirmPrompt(`Use ${pc9.bold(suggested)} as your branch name?`);
         if (accepted) {
           branchName = suggested;
         } else {
@@ -1902,14 +2295,14 @@ 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 ${pc9.bold(branchName)}:`, branchPrefixes);
       branchName = formatBranchName(prefix, branchName);
     }
     if (!isValidBranchName(branchName)) {
       error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
       process.exit(1);
     }
-    info(`Creating branch: ${pc8.bold(branchName)}`);
+    info(`Creating branch: ${pc9.bold(branchName)}`);
     await fetchRemote(syncSource.remote);
     const updateResult = await updateLocalBranch(baseBranch, syncSource.ref);
     if (updateResult.exitCode !== 0) {}
@@ -1918,14 +2311,14 @@ var start_default = defineCommand5({
       error(`Failed to create branch: ${result.stderr}`);
       process.exit(1);
     }
-    success(`✅ Created ${pc8.bold(branchName)} from latest ${pc8.bold(baseBranch)}`);
+    success(`✅ Created ${pc9.bold(branchName)} from latest ${pc9.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand6 } from "citty";
-import pc9 from "picocolors";
-var status_default = defineCommand6({
+import { defineCommand as defineCommand7 } from "citty";
+import pc10 from "picocolors";
+var status_default = defineCommand7({
   meta: {
     name: "status",
     description: "Show sync status of branches"
@@ -1941,20 +2334,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(`  ${pc10.dim("Workflow:")} ${pc10.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    console.log(`  ${pc10.dim("Role:")} ${pc10.bold(config.role)}`);
     console.log();
     await fetchAll();
     const currentBranch = await getCurrentBranch();
     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(`  ${pc10.yellow("⚠")}  ${pc10.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -1970,82 +2360,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 + pc10.dim(` (current ${pc10.green("*")})`));
     } else if (currentBranch) {
-      console.log(pc9.dim(`  (on ${pc9.bold(currentBranch)} branch)`));
+      console.log(pc10.dim(`  (on ${pc10.bold(currentBranch)} branch)`));
     }
     const hasFiles = fileStatus.staged.length > 0 || fileStatus.modified.length > 0 || fileStatus.untracked.length > 0;
     if (hasFiles) {
       console.log();
       if (fileStatus.staged.length > 0) {
-        console.log(`  ${pc9.green("Staged for commit:")}`);
+        console.log(`  ${pc10.green("Staged for commit:")}`);
         for (const { file, status } of fileStatus.staged) {
-          console.log(`    ${pc9.green("+")} ${pc9.dim(`${status}:`)} ${file}`);
+          console.log(`    ${pc10.green("+")} ${pc10.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.modified.length > 0) {
-        console.log(`  ${pc9.yellow("Unstaged changes:")}`);
+        console.log(`  ${pc10.yellow("Unstaged changes:")}`);
         for (const { file, status } of fileStatus.modified) {
-          console.log(`    ${pc9.yellow("~")} ${pc9.dim(`${status}:`)} ${file}`);
+          console.log(`    ${pc10.yellow("~")} ${pc10.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.untracked.length > 0) {
-        console.log(`  ${pc9.red("Untracked files:")}`);
+        console.log(`  ${pc10.red("Untracked files:")}`);
         for (const file of fileStatus.untracked) {
-          console.log(`    ${pc9.red("?")} ${file}`);
+          console.log(`    ${pc10.red("?")} ${file}`);
         }
       }
     } else if (!dirty) {
-      console.log(`  ${pc9.green("✓")}  ${pc9.dim("Working tree clean")}`);
+      console.log(`  ${pc10.green("✓")}  ${pc10.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 ${pc10.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 ${pc10.bold("contrib commit")} to stage and commit changes`);
     }
     if (fileStatus.staged.length === 0 && fileStatus.modified.length === 0 && fileStatus.untracked.length === 0 && currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
       const branchDiv = await getDivergence(currentBranch, `${origin}/${currentBranch}`);
       if (branchDiv.ahead > 0) {
-        tips.push(`Run ${pc9.bold("contrib submit")} to push and create/update your PR`);
+        tips.push(`Run ${pc10.bold("contrib submit")} to push and create/update your PR`);
       }
     }
     if (tips.length > 0) {
       console.log();
-      console.log(`  ${pc9.dim("\uD83D\uDCA1 Tip:")}`);
+      console.log(`  ${pc10.dim("\uD83D\uDCA1 Tip:")}`);
       for (const tip of tips) {
-        console.log(`     ${pc9.dim(tip)}`);
+        console.log(`     ${pc10.dim(tip)}`);
       }
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = pc9.bold(branch.padEnd(20));
+  const label = pc10.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${pc9.green("✓")}  ${label} ${pc9.dim(`in sync with ${base}`)}`;
+    return `  ${pc10.green("✓")}  ${label} ${pc10.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 `  ${pc10.yellow("↑")}  ${label} ${pc10.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 `  ${pc10.red("↓")}  ${label} ${pc10.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 `  ${pc10.red("⚡")}  ${label} ${pc10.yellow(`${ahead} ahead`)}${pc10.dim(", ")}${pc10.red(`${behind} behind`)} ${pc10.dim(base)}`;
 }
 
 // src/commands/submit.ts
-import { defineCommand as defineCommand7 } from "citty";
-import pc10 from "picocolors";
+import { defineCommand as defineCommand8 } from "citty";
+import pc11 from "picocolors";
 async function performSquashMerge(origin, baseBranch, featureBranch, options) {
-  info(`Checking out ${pc10.bold(baseBranch)}...`);
+  info(`Checking out ${pc11.bold(baseBranch)}...`);
   const coResult = await checkoutBranch2(baseBranch);
   if (coResult.exitCode !== 0) {
     error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
     process.exit(1);
   }
-  info(`Squash merging ${pc10.bold(featureBranch)} into ${pc10.bold(baseBranch)}...`);
+  info(`Squash merging ${pc11.bold(featureBranch)} into ${pc11.bold(baseBranch)}...`);
   const mergeResult = await mergeSquash(featureBranch);
   if (mergeResult.exitCode !== 0) {
     error(`Squash merge failed: ${mergeResult.stderr}`);
@@ -2075,26 +2465,26 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
     error(`Commit failed: ${commitResult.stderr}`);
     process.exit(1);
   }
-  info(`Pushing ${pc10.bold(baseBranch)} to ${origin}...`);
+  info(`Pushing ${pc11.bold(baseBranch)} to ${origin}...`);
   const pushResult = await pushBranch(origin, baseBranch);
   if (pushResult.exitCode !== 0) {
     error(`Failed to push ${baseBranch}: ${pushResult.stderr}`);
     process.exit(1);
   }
-  info(`Deleting local branch ${pc10.bold(featureBranch)}...`);
+  info(`Deleting local branch ${pc11.bold(featureBranch)}...`);
   const delLocal = await forceDeleteBranch(featureBranch);
   if (delLocal.exitCode !== 0) {
     warn(`Could not delete local branch: ${delLocal.stderr.trim()}`);
   }
-  info(`Deleting remote branch ${pc10.bold(featureBranch)}...`);
+  info(`Deleting remote branch ${pc11.bold(featureBranch)}...`);
   const delRemote = await deleteRemoteBranch(origin, featureBranch);
   if (delRemote.exitCode !== 0) {
     warn(`Could not delete remote branch: ${delRemote.stderr.trim()}`);
   }
-  success(`✅ Squash merged ${pc10.bold(featureBranch)} into ${pc10.bold(baseBranch)} and pushed.`);
-  info(`Run ${pc10.bold("contrib start")} to begin a new feature.`);
+  success(`✅ Squash merged ${pc11.bold(featureBranch)} into ${pc11.bold(baseBranch)} and pushed.`);
+  info(`Run ${pc11.bold("contrib start")} to begin a new feature.`);
 }
-var submit_default = defineCommand7({
+var submit_default = defineCommand8({
   meta: {
     name: "submit",
     description: "Push current branch and create a pull request"
@@ -2134,7 +2524,7 @@ 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.`);
+      error(`Cannot submit ${protectedBranches.map((b) => pc11.bold(b)).join(" or ")} as a PR. Switch to your feature branch.`);
       process.exit(1);
     }
     heading("\uD83D\uDE80 contrib submit");
@@ -2143,7 +2533,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} (${pc11.bold(mergedPR.title)}) was already merged.`);
         const localWork = await hasLocalWork(origin, currentBranch);
         const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
         if (hasWork) {
@@ -2151,7 +2541,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 ${pc11.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not in the merged PR.`);
           }
           const SAVE_NEW_BRANCH = "Save changes to a new branch";
           const DISCARD = "Discard all changes and clean up";
@@ -2162,7 +2552,7 @@ var submit_default = defineCommand7({
             return;
           }
           if (action === SAVE_NEW_BRANCH) {
-            info(pc10.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
+            info(pc11.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
             const description = await inputPrompt("What are you working on?");
             let newBranchName = description;
             if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
@@ -2171,8 +2561,8 @@ var submit_default = defineCommand7({
               if (suggested) {
                 spinner.success("Branch name suggestion ready.");
                 console.log(`
-  ${pc10.dim("AI suggestion:")} ${pc10.bold(pc10.cyan(suggested))}`);
-                const accepted = await confirmPrompt(`Use ${pc10.bold(suggested)} as your branch name?`);
+  ${pc11.dim("AI suggestion:")} ${pc11.bold(pc11.cyan(suggested))}`);
+                const accepted = await confirmPrompt(`Use ${pc11.bold(suggested)} as your branch name?`);
                 newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
               } else {
                 spinner.fail("AI did not return a suggestion.");
@@ -2180,37 +2570,45 @@ var submit_default = defineCommand7({
               }
             }
             if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-              const prefix = await selectPrompt(`Choose a branch type for ${pc10.bold(newBranchName)}:`, config.branchPrefixes);
+              const prefix = await selectPrompt(`Choose a branch type for ${pc11.bold(newBranchName)}:`, config.branchPrefixes);
               newBranchName = formatBranchName(prefix, newBranchName);
             }
             if (!isValidBranchName(newBranchName)) {
               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;
             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 ${pc11.bold(currentBranch)} → ${pc11.bold(newBranchName)}`);
+            await unsetUpstream();
             const syncSource2 = getSyncSource(config);
-            info(`Syncing ${pc10.bold(newBranchName)} with latest ${pc10.bold(baseBranch)}...`);
+            info(`Syncing ${pc11.bold(newBranchName)} with latest ${pc11.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(`  ${pc11.bold("git rebase --continue")}`);
             } else {
-              success(`Rebased ${pc10.bold(newBranchName)} onto ${pc10.bold(syncSource2.ref)}.`);
+              success(`Rebased ${pc11.bold(newBranchName)} onto ${pc11.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 ${pc11.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 ${pc11.bold(baseBranch)} and syncing...`);
         await fetchRemote(syncSource.remote);
         const coResult = await checkoutBranch2(baseBranch);
         if (coResult.exitCode !== 0) {
@@ -2218,46 +2616,22 @@ var submit_default = defineCommand7({
           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 ${pc11.bold(baseBranch)} with ${pc11.bold(syncSource.ref)}.`);
+        info(`Deleting stale branch ${pc11.bold(currentBranch)}...`);
         const delResult = await forceDeleteBranch(currentBranch);
         if (delResult.exitCode === 0) {
-          success(`Deleted ${pc10.bold(currentBranch)}.`);
+          success(`Deleted ${pc11.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 ${pc11.bold(baseBranch)}. Run ${pc11.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"),
@@ -2271,10 +2645,10 @@ var submit_default = defineCommand7({
           prBody = result.body;
           spinner.success("PR description generated.");
           console.log(`
-  ${pc10.dim("AI title:")} ${pc10.bold(pc10.cyan(prTitle))}`);
+  ${pc11.dim("AI title:")} ${pc11.bold(pc11.cyan(prTitle))}`);
           console.log(`
-${pc10.dim("AI body preview:")}`);
-          console.log(pc10.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+${pc11.dim("AI body preview:")}`);
+          console.log(pc11.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
         } else {
           spinner.fail("AI did not return a PR description.");
         }
@@ -2282,77 +2656,119 @@ ${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 (action === "Write title & body manually") {
-        prTitle = await inputPrompt("PR title");
-        prBody = await inputPrompt("PR body (markdown)");
+    }
+    if (submitAction === "cancel") {
+      warn("Submit cancelled.");
+      return;
+    }
+    if (submitAction === "squash") {
+      await performSquashMerge(origin, baseBranch, currentBranch, {
+        defaultMsg: prTitle ?? undefined,
+        model: args.model,
+        convention: config.commitConvention
+      });
+      return;
+    }
+    info(`Pushing ${pc11.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(`  ${pc11.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}: ${pc11.bold(existingPR.title)}`);
+      console.log(`  ${pc11.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.");
@@ -2373,9 +2789,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 defineCommand9 } from "citty";
+import pc12 from "picocolors";
+var sync_default = defineCommand9({
   meta: {
     name: "sync",
     description: "Sync your local branches with the remote"
@@ -2417,12 +2833,12 @@ var sync_default = defineCommand8({
     }
     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(`${pc12.bold(baseBranch)} is ${pc12.yellow(`${div.ahead} ahead`)} and ${pc12.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`${pc11.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+      info(`${pc12.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
     }
     if (!args.yes) {
-      const ok = await confirmPrompt(`This will pull ${pc11.bold(syncSource.ref)} into local ${pc11.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${pc12.bold(syncSource.ref)} into local ${pc12.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
@@ -2440,7 +2856,7 @@ var sync_default = defineCommand8({
     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 ${pc12.bold(config.mainBranch)}...`);
         const mainCoResult = await checkoutBranch2(config.mainBranch);
         if (mainCoResult.exitCode === 0) {
           const mainPullResult = await pullBranch(origin, config.mainBranch);
@@ -2456,9 +2872,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 defineCommand10 } from "citty";
+import pc13 from "picocolors";
+var update_default = defineCommand10({
   meta: {
     name: "update",
     description: "Rebase current branch onto the latest base branch"
@@ -2493,7 +2909,7 @@ 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.`);
+      error(`Use \`contrib sync\` to update ${protectedBranches.map((b) => pc13.bold(b)).join(" or ")} branches.`);
       process.exit(1);
     }
     if (await hasUncommittedChanges()) {
@@ -2503,8 +2919,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} (${pc13.bold(mergedPR.title)}) has already been merged.`);
+      info(`Link: ${pc13.underline(mergedPR.url)}`);
       const localWork = await hasLocalWork(syncSource.remote, currentBranch);
       const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
       if (hasWork) {
@@ -2517,13 +2933,13 @@ 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(`${pc13.bold(currentBranch)} is stale but has local work. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
         if (action === CANCEL) {
           info("No changes made. You are still on your current branch.");
           return;
         }
         if (action === SAVE_NEW_BRANCH) {
-          info(pc12.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
+          info(pc13.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
           const description = await inputPrompt("What are you working on?");
           let newBranchName = description;
           if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
@@ -2532,8 +2948,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?`);
+  ${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.");
@@ -2541,29 +2957,37 @@ 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 ${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;
           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 ${pc13.bold(currentBranch)} → ${pc13.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(`  ${pc13.bold("git rebase --continue")}`);
           } else {
-            success(`Rebased ${pc12.bold(newBranchName)} onto ${pc12.bold(syncSource.ref)}.`);
+            success(`Rebased ${pc13.bold(newBranchName)} onto ${pc13.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 ${pc13.bold("contrib submit")} when ready to create a new PR.`);
           return;
         }
         warn("Discarding local changes...");
@@ -2575,18 +2999,21 @@ var update_default = defineCommand9({
         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 ${pc13.bold(baseBranch)} with ${pc13.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${pc13.bold(currentBranch)}...`);
       await forceDeleteBranch(currentBranch);
-      success(`Deleted ${pc12.bold(currentBranch)}.`);
-      info(`Run ${pc12.bold("contrib start")} to begin a new feature branch.`);
+      success(`Deleted ${pc13.bold(currentBranch)}.`);
+      info(`Run ${pc13.bold("contrib start")} to begin a new feature branch.`);
       return;
     }
-    info(`Updating ${pc12.bold(currentBranch)} with latest ${pc12.bold(baseBranch)}...`);
+    info(`Updating ${pc13.bold(currentBranch)} with latest ${pc13.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
     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(pc13.dim(`Using --onto rebase (branch was based on a different ref)`));
+    }
+    const rebaseResult = rebaseStrategy.strategy === "onto" && rebaseStrategy.ontoOldBase ? await rebaseOnto(syncSource.ref, rebaseStrategy.ontoOldBase) : await rebase(syncSource.ref);
     if (rebaseResult.exitCode !== 0) {
       warn("Rebase hit conflicts. Resolve them manually.");
       console.log();
@@ -2613,10 +3040,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)));
+${pc13.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(pc13.dim("─".repeat(60)));
               console.log(suggestion);
-              console.log(pc12.dim("─".repeat(60)));
+              console.log(pc13.dim("─".repeat(60)));
               console.log();
             } else {
               spinner.fail("AI could not analyze the conflicts.");
@@ -2624,22 +3051,22 @@ ${pc12.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
           }
         }
       }
-      console.log(pc12.bold("To resolve:"));
+      console.log(pc13.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. ${pc13.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${pc13.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${pc12.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${pc13.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`✅ ${pc12.bold(currentBranch)} has been rebased onto latest ${pc12.bold(baseBranch)}`);
+    success(`✅ ${pc13.bold(currentBranch)} has been rebased onto latest ${pc13.bold(baseBranch)}`);
   }
 });
 
 // src/commands/validate.ts
-import { defineCommand as defineCommand10 } from "citty";
-import pc13 from "picocolors";
-var validate_default = defineCommand10({
+import { defineCommand as defineCommand11 } from "citty";
+import pc14 from "picocolors";
+var validate_default = defineCommand11({
   meta: {
     name: "validate",
     description: "Validate a commit message against the configured convention"
@@ -2669,7 +3096,7 @@ var validate_default = defineCommand10({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(pc13.red(`  ✗ ${line}`));
+      console.error(pc14.red(`  ✗ ${line}`));
     }
     process.exit(1);
   }
@@ -2677,76 +3104,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.33be40f",
-  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 pc15 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";
@@ -2754,23 +3124,30 @@ 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(pc15.cyan(`
+${logo}`));
+  console.log(`  ${pc15.dim(`v${getVersion()}`)} ${pc15.dim("—")} ${pc15.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(`  ${pc15.yellow("Star")}        ${pc15.cyan("https://github.com/warengonzaga/contribute-now")}`);
+    console.log(`  ${pc15.green("Contribute")}  ${pc15.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
+    console.log(`  ${pc15.magenta("Sponsor")}     ${pc15.cyan("https://warengonzaga.com/sponsor")}`);
   }
   console.log();
 }
 
 // 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", "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 = defineCommand12({
   meta: {
     name: "contrib",
     version: getVersion(),
@@ -2793,7 +3170,8 @@ var main = defineCommand11({
     clean: clean_default,
     status: status_default,
     hook: hook_default,
-    validate: validate_default
+    validate: validate_default,
+    doctor: doctor_default
   },
   run({ args }) {
     if (args.version) {