contribute-now 0.4.1 → 0.5.0-dev.914e35d

package/dist/index.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-import { defineCommand as defineCommand14, runMain } from "citty";
+import { defineCommand as defineCommand16, runMain } from "citty";
 
 // src/commands/branch.ts
 import { defineCommand } from "citty";
@@ -547,6 +547,76 @@ async function getLogEntries(options) {
     return { hash: hash.trim(), subject: subject.trim(), refs: refs.trim() };
   });
 }
+async function getLocalCommitsGraph(options) {
+  const count = options?.count ?? 20;
+  const upstream = options?.upstream;
+  if (!upstream)
+    return [];
+  const args = [
+    "log",
+    "--oneline",
+    "--graph",
+    "--decorate",
+    `--max-count=${count}`,
+    "--color=never",
+    `${upstream}..HEAD`
+  ];
+  const { exitCode, stdout } = await run(args);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter(Boolean);
+}
+async function getLocalCommitsEntries(options) {
+  const count = options?.count ?? 20;
+  const upstream = options?.upstream;
+  if (!upstream)
+    return [];
+  const args = ["log", `--format=%h||%s||%D`, `--max-count=${count}`, `${upstream}..HEAD`];
+  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 getRemoteOnlyCommitsGraph(options) {
+  const count = options?.count ?? 20;
+  const upstream = options?.upstream;
+  if (!upstream)
+    return [];
+  const args = [
+    "log",
+    "--oneline",
+    "--graph",
+    "--decorate",
+    `--max-count=${count}`,
+    "--color=never",
+    `HEAD..${upstream}`
+  ];
+  const { exitCode, stdout } = await run(args);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter(Boolean);
+}
+async function getRemoteOnlyCommitsEntries(options) {
+  const count = options?.count ?? 20;
+  const upstream = options?.upstream;
+  if (!upstream)
+    return [];
+  const args = ["log", `--format=%h||%s||%D`, `--max-count=${count}`, `HEAD..${upstream}`];
+  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)
@@ -575,6 +645,17 @@ async function getRemoteBranches() {
   return stdout.trimEnd().split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.includes(" -> "));
 }
+async function isBranchMergedInto(branch, base) {
+  const { exitCode } = await run(["merge-base", "--is-ancestor", branch, base]);
+  return exitCode === 0;
+}
+async function getLastCommitDate(branch) {
+  const { exitCode, stdout } = await run(["log", "-1", "--format=%aI", branch]);
+  if (exitCode !== 0)
+    return null;
+  const date = stdout.trim();
+  return date || null;
+}
 
 // src/utils/logger.ts
 import { LogEngine, LogMode } from "@wgtechlabs/log-engine";
@@ -1141,19 +1222,22 @@ function extractJson(raw) {
   }
   return text2;
 }
-async function generateCommitMessage(diff, stagedFiles, model, convention = "clean-commit") {
+async function generateCommitMessage(diff, stagedFiles, model, convention = "clean-commit", context) {
   try {
     const isLarge = stagedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD;
     const multiFileHint = stagedFiles.length > 1 ? `
 
 IMPORTANT: Multiple files are staged. Generate ONE commit message that captures the high-level purpose of ALL changes together. Focus on the overall intent, not individual file changes. Be specific but concise — do not list every file.` : "";
+    const squashHint = context === "squash-merge" ? `
+
+CONTEXT: This is a squash merge of an entire feature branch into the base branch. All commits are being combined into ONE single commit. Generate a single high-level summary that describes the overall feature or change — NOT a list of individual commits. Think: what capability was added or what problem was solved? Be specific but concise.` : "";
     const diffContent = isLarge ? createCompactDiff(stagedFiles, diff) : diff.slice(0, 4000);
     const userMessage = `Generate a commit message for these staged changes:
 
 Files (${stagedFiles.length}): ${stagedFiles.join(", ")}
 
 Diff:
-${diffContent}${multiFileHint}`;
+${diffContent}${multiFileHint}${squashHint}`;
     const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model, isLarge ? COPILOT_LONG_TIMEOUT_MS : COPILOT_TIMEOUT_MS);
     return result?.trim() ?? null;
   } catch {
@@ -1885,6 +1969,27 @@ ${pc6.bold("Changed files:")}`);
       }
     }
     info(`Staged files: ${stagedFiles.join(", ")}`);
+    const LARGE_COMMIT_THRESHOLD = 10;
+    if (stagedFiles.length >= LARGE_COMMIT_THRESHOLD && !args.group) {
+      const dirs = new Set(stagedFiles.map((f) => f.split("/")[0]));
+      if (dirs.size > 1) {
+        console.log();
+        warn(`You're staging ${pc6.bold(String(stagedFiles.length))} files across ${pc6.bold(String(dirs.size))} directories in a single commit.`);
+        info(pc6.dim("Large commits mixing different topics make history harder to read and bisect. " + "For cleaner history, consider splitting into atomic commits."));
+        const choice = await selectPrompt("How would you like to proceed?", [
+          "Continue as single commit",
+          "Switch to group mode (AI splits into atomic commits)",
+          "Cancel"
+        ]);
+        if (choice === "Cancel") {
+          process.exit(0);
+        }
+        if (choice === "Switch to group mode (AI splits into atomic commits)") {
+          await runGroupCommit(args.model, config);
+          return;
+        }
+      }
+    }
     let commitMessage = null;
     const useAI = !args["no-ai"];
     if (useAI) {
@@ -2163,7 +2268,7 @@ import pc7 from "picocolors";
 // package.json
 var package_default = {
   name: "contribute-now",
-  version: "0.4.1",
+  version: "0.5.0-dev.914e35d",
   description: "Developer CLI that automates git workflows — branching, syncing, committing, and PRs — with multi-workflow and commit convention support.",
   type: "module",
   bin: {
@@ -2181,9 +2286,10 @@ var package_default = {
     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"
+    "landing:install": "bun install --cwd landing",
+    "landing:dev": "bun run --cwd landing dev",
+    "landing:build": "bun run --cwd landing build",
+    "landing:preview": "bun run --cwd landing preview"
   },
   engines: {
     node: ">=18",
@@ -2681,7 +2787,19 @@ var log_default = defineCommand6({
     all: {
       type: "boolean",
       alias: "a",
-      description: "Show all branches, not just current",
+      description: "Show commits from all branches",
+      default: false
+    },
+    remote: {
+      type: "boolean",
+      alias: "r",
+      description: "Show only remote commits not yet pulled locally",
+      default: false
+    },
+    full: {
+      type: "boolean",
+      alias: "f",
+      description: "Show full commit history for the current branch",
       default: false
     },
     graph: {
@@ -2703,44 +2821,197 @@ var log_default = defineCommand6({
     }
     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;
+    let mode = "local";
+    if (args.all)
+      mode = "all";
+    else if (args.remote)
+      mode = "remote";
+    else if (args.full || targetBranch)
+      mode = "full";
     const protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
     const currentBranch = await getCurrentBranch();
+    const upstream = await getUpstreamRef();
+    let compareRef = upstream;
+    let usingFallback = false;
+    if (!compareRef) {
+      const fallback = await resolveBaseBranchRef(config);
+      if (fallback) {
+        compareRef = fallback;
+        usingFallback = true;
+      }
+    }
     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."));
+    printModeHeader(mode, currentBranch, compareRef, usingFallback);
+    if (mode === "local" || mode === "remote") {
+      if (!compareRef) {
+        console.log();
+        console.log(pc9.yellow("  ⚠ Could not determine a comparison branch."));
+        console.log(pc9.dim("    No upstream tracking set and no remote base branch found."));
+        console.log(pc9.dim(`    Use ${pc9.bold("contrib log --full")} to see the full commit history instead.`));
         console.log();
+        printGuidance();
         return;
       }
-      console.log();
-      for (const line of lines) {
-        console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
+      const hasCommits = await renderScopedLog({ mode, count, upstream: compareRef, showGraph, protectedBranches, currentBranch });
+      if (!hasCommits) {
+        printGuidance();
+        return;
       }
     } else {
-      const entries = await getLogEntries({ count, all: showAll, branch: targetBranch });
-      if (entries.length === 0) {
-        console.log(pc9.dim("  No commits found."));
-        console.log();
+      const hasCommits = await renderFullLog({ count, all: mode === "all", showGraph, targetBranch, protectedBranches, currentBranch });
+      if (!hasCommits) {
+        printGuidance();
         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}`);
+    }
+    printFooter(mode, count, targetBranch);
+    printGuidance();
+  }
+});
+async function resolveBaseBranchRef(config) {
+  if (!config) {
+    for (const candidate2 of ["origin/main", "origin/master"]) {
+      if (await branchExists(candidate2))
+        return candidate2;
+    }
+    return null;
+  }
+  const baseBranch = getBaseBranch(config);
+  const remote = config.origin ?? "origin";
+  const candidate = `${remote}/${baseBranch}`;
+  if (await branchExists(candidate))
+    return candidate;
+  for (const fallback of ["origin/main", "origin/master"]) {
+    if (fallback !== candidate && await branchExists(fallback))
+      return fallback;
+  }
+  return null;
+}
+function printModeHeader(mode, currentBranch, compareRef, usingFallback = false) {
+  const branch = currentBranch ?? "HEAD";
+  const fallbackNote = usingFallback ? pc9.yellow(" (no upstream — comparing against base branch)") : "";
+  console.log();
+  switch (mode) {
+    case "local":
+      console.log(pc9.dim(`  mode: ${pc9.bold("local")} — unpushed commits on ${pc9.bold(branch)}`) + fallbackNote);
+      if (compareRef) {
+        console.log(pc9.dim(`  comparing: ${pc9.bold(compareRef)} ➜ ${pc9.bold("HEAD")}`));
+      }
+      break;
+    case "remote":
+      console.log(pc9.dim(`  mode: ${pc9.bold("remote")} — commits on remote not yet pulled into ${pc9.bold(branch)}`) + fallbackNote);
+      if (compareRef) {
+        console.log(pc9.dim(`  comparing: ${pc9.bold("HEAD")} ➜ ${pc9.bold(compareRef)}`));
       }
+      break;
+    case "full":
+      console.log(pc9.dim(`  mode: ${pc9.bold("full")} — complete commit history for ${pc9.bold(branch)}`));
+      break;
+    case "all":
+      console.log(pc9.dim(`  mode: ${pc9.bold("all")} — commits across all branches`));
+      break;
+  }
+}
+async function renderScopedLog(options) {
+  const { mode, count, upstream, showGraph, protectedBranches, currentBranch } = options;
+  if (showGraph) {
+    const graphFn = mode === "local" ? getLocalCommitsGraph : getRemoteOnlyCommitsGraph;
+    const lines = await graphFn({ count, upstream });
+    if (lines.length === 0) {
+      printEmptyState(mode);
+      return false;
     }
     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`));
+    for (const line of lines) {
+      console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
+    }
+  } else {
+    const entryFn = mode === "local" ? getLocalCommitsEntries : getRemoteOnlyCommitsEntries;
+    const entries = await entryFn({ count, upstream });
+    if (entries.length === 0) {
+      printEmptyState(mode);
+      return false;
+    }
     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}`);
+    }
   }
-});
+  return true;
+}
+function printEmptyState(mode) {
+  console.log();
+  if (mode === "local") {
+    console.log(pc9.dim("  No local unpushed commits — you're up to date with remote!"));
+  } else {
+    console.log(pc9.dim("  No remote-only commits — your local branch is up to date!"));
+  }
+  console.log();
+}
+async function renderFullLog(options) {
+  const { count, all, showGraph, targetBranch, protectedBranches, currentBranch } = options;
+  if (showGraph) {
+    const lines = await getLogGraph({ count, all, branch: targetBranch });
+    if (lines.length === 0) {
+      console.log(pc9.dim("  No commits found."));
+      console.log();
+      return false;
+    }
+    console.log();
+    for (const line of lines) {
+      console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
+    }
+  } else {
+    const entries = await getLogEntries({ count, all, branch: targetBranch });
+    if (entries.length === 0) {
+      console.log(pc9.dim("  No commits found."));
+      console.log();
+      return false;
+    }
+    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}`);
+    }
+  }
+  return true;
+}
+function printFooter(mode, count, targetBranch) {
+  console.log();
+  switch (mode) {
+    case "local":
+      console.log(pc9.dim(`  Showing up to ${count} unpushed commits`));
+      break;
+    case "remote":
+      console.log(pc9.dim(`  Showing up to ${count} remote-only commits`));
+      break;
+    case "full":
+      console.log(pc9.dim(`  Showing ${count} most recent commits${targetBranch ? ` (${targetBranch})` : ""}`));
+      break;
+    case "all":
+      console.log(pc9.dim(`  Showing ${count} most recent commits (all branches)`));
+      break;
+  }
+}
+function printGuidance() {
+  console.log();
+  console.log(pc9.dim("  ─── quick guide ───"));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log")}            local unpushed commits (default)`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log --remote")}   commits on remote not yet pulled`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log --full")}     full history for the current branch`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log --all")}      commits across all branches`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log -n 50")}      change the commit limit (default: 20)`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log -b dev")}     view log for a specific branch`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log --no-graph")} flat list without graph lines`));
+  console.log();
+}
 function colorizeGraphLine(line, protectedBranches, currentBranch) {
   const match = line.match(/^([|/\\*\s_.-]*)([a-f0-9]{7,12})(\s+\(([^)]+)\))?\s*(.*)/);
   if (!match) {
@@ -2819,9 +3090,161 @@ function colorizeSubject(subject) {
   return pc9.white(subject);
 }
 
-// src/commands/setup.ts
+// src/commands/save.ts
 import { defineCommand as defineCommand7 } from "citty";
 import pc10 from "picocolors";
+import { execFile as execFileCb4 } from "node:child_process";
+function gitRun(args) {
+  return new Promise((resolve) => {
+    execFileCb4("git", args, (err, stdout, stderr) => {
+      resolve({
+        exitCode: err ? err.code === "ENOENT" ? 127 : err.status ?? 1 : 0,
+        stdout: stdout ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
+}
+var save_default = defineCommand7({
+  meta: {
+    name: "save",
+    description: "Save, restore, or manage uncommitted changes"
+  },
+  args: {
+    action: {
+      type: "positional",
+      description: "Action: save (default), restore, list, drop",
+      required: false
+    },
+    message: {
+      type: "string",
+      alias: "m",
+      description: "Description for saved changes"
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const action = args.action ?? "save";
+    switch (action) {
+      case "save":
+        await handleSave(args.message);
+        break;
+      case "restore":
+        await handleRestore();
+        break;
+      case "list":
+        await handleList();
+        break;
+      case "drop":
+        await handleDrop();
+        break;
+      default:
+        error(`Unknown action: ${action}. Use save, restore, list, or drop.`);
+        process.exit(1);
+    }
+  }
+});
+async function handleSave(message) {
+  heading("\uD83D\uDCBE contrib save");
+  const currentBranch = await getCurrentBranch();
+  const label = message ?? `work-in-progress on ${currentBranch ?? "unknown"}`;
+  const stashMsg = `contrib-save: ${label}`;
+  const result = await gitRun(["stash", "push", "-m", stashMsg]);
+  if (result.exitCode !== 0) {
+    error(`Failed to save: ${result.stderr}`);
+    process.exit(1);
+  }
+  if (result.stdout.includes("No local changes to save")) {
+    info("No uncommitted changes to save.");
+    return;
+  }
+  success(`Saved: ${pc10.dim(label)}`);
+  info(`Use ${pc10.bold("contrib save restore")} to bring them back.`);
+}
+async function handleRestore() {
+  heading("\uD83D\uDCBE contrib save restore");
+  const stashes = await getStashList();
+  if (stashes.length === 0) {
+    info("No saved changes found.");
+    return;
+  }
+  if (stashes.length === 1) {
+    const result2 = await gitRun(["stash", "pop", "stash@{0}"]);
+    if (result2.exitCode !== 0) {
+      error(`Failed to restore: ${result2.stderr}`);
+      warn("You may have conflicts. Resolve them and run `git stash drop` when done.");
+      process.exit(1);
+    }
+    success(`Restored: ${pc10.dim(stashes[0].message)}`);
+    return;
+  }
+  const choices = stashes.map((s) => `${s.index}  ${s.message}`);
+  const selected = await selectPrompt("Which save to restore?", choices);
+  const idx = selected.split(/\s{2,}/)[0].trim();
+  const result = await gitRun(["stash", "pop", `stash@{${idx}}`]);
+  if (result.exitCode !== 0) {
+    error(`Failed to restore: ${result.stderr}`);
+    warn("You may have conflicts. Resolve them and run `git stash drop` when done.");
+    process.exit(1);
+  }
+  const match = stashes.find((s) => String(s.index) === idx);
+  success(`Restored: ${pc10.dim(match?.message ?? "saved changes")}`);
+}
+async function handleList() {
+  heading("\uD83D\uDCBE contrib save list");
+  const stashes = await getStashList();
+  if (stashes.length === 0) {
+    info("No saved changes.");
+    return;
+  }
+  console.log();
+  for (const s of stashes) {
+    const idx = pc10.dim(`[${s.index}]`);
+    const msg = s.message;
+    console.log(`  ${idx}  ${msg}`);
+  }
+  console.log();
+  info(`Use ${pc10.bold("contrib save restore")} to bring changes back.`);
+  info(`Use ${pc10.bold("contrib save drop")} to discard saved changes.`);
+}
+async function handleDrop() {
+  heading("\uD83D\uDCBE contrib save drop");
+  const stashes = await getStashList();
+  if (stashes.length === 0) {
+    info("No saved changes to drop.");
+    return;
+  }
+  const choices = stashes.map((s) => `${s.index}  ${s.message}`);
+  const selected = await selectPrompt("Which save to drop?", choices);
+  const idx = selected.split(/\s{2,}/)[0].trim();
+  const result = await gitRun(["stash", "drop", `stash@{${idx}}`]);
+  if (result.exitCode !== 0) {
+    error(`Failed to drop: ${result.stderr}`);
+    process.exit(1);
+  }
+  const match = stashes.find((s) => String(s.index) === idx);
+  success(`Dropped: ${pc10.dim(match?.message ?? "saved changes")}`);
+}
+async function getStashList() {
+  const result = await gitRun(["stash", "list"]);
+  if (result.exitCode !== 0 || !result.stdout.trim())
+    return [];
+  return result.stdout.trimEnd().split(`
+`).filter(Boolean).map((line) => {
+    const idxMatch = line.match(/^stash@\{(\d+)\}/);
+    const index = idxMatch ? Number.parseInt(idxMatch[1], 10) : 0;
+    const parts = line.split(": ");
+    const message = parts.length > 2 ? parts.slice(2).join(": ") : parts[parts.length - 1];
+    return { index, message };
+  });
+}
+
+// src/commands/setup.ts
+import { defineCommand as defineCommand8 } from "citty";
+import pc11 from "picocolors";
 async function shouldContinueSetupWithExistingConfig(options) {
   const {
     existingConfig,
@@ -2859,7 +3282,7 @@ async function shouldContinueSetupWithExistingConfig(options) {
   }
   return true;
 }
-var setup_default = defineCommand7({
+var setup_default = defineCommand8({
   meta: {
     name: "setup",
     description: "Initialize contribute-now config for this repo (.contributerc.json)"
@@ -2894,7 +3317,7 @@ var setup_default = defineCommand7({
       workflow = "github-flow";
     else if (workflowChoice.startsWith("Git Flow"))
       workflow = "git-flow";
-    info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
+    info(`Workflow: ${pc11.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
     const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
       `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
       CONVENTION_DESCRIPTIONS.conventional,
@@ -2958,15 +3381,15 @@ var setup_default = defineCommand7({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${pc10.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${pc10.bold(detectedRole)}. Is this correct?`);
+      info(`Detected role: ${pc11.bold(detectedRole)} (via ${detectionSource})`);
+      const confirmed = await confirmPrompt(`Role detected as ${pc11.bold(detectedRole)}. Is this correct?`);
       if (!confirmed) {
         const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
         detectedRole = roleChoice;
       }
     }
     const defaultConfig = getDefaultConfig();
-    info(pc10.dim("Tip: press Enter to keep the default branch name shown in each prompt."));
+    info(pc11.dim("Tip: press Enter to keep the default branch name shown in each prompt."));
     const mainBranchDefault = defaultConfig.mainBranch;
     const mainBranch = await inputPrompt(`Main branch name (default: ${mainBranchDefault} — press Enter to keep)`, mainBranchDefault);
     let devBranch;
@@ -2992,7 +3415,7 @@ var setup_default = defineCommand7({
             error("Setup cannot continue without the upstream remote for contributors.");
             process.exit(1);
           }
-          success(`Added remote ${pc10.bold(upstreamRemote)} → ${upstreamUrl}`);
+          success(`Added remote ${pc11.bold(upstreamRemote)} → ${upstreamUrl}`);
         } else {
           error("An upstream remote URL is required for contributors.");
           info("Add it manually: git remote add upstream <url>");
@@ -3013,17 +3436,17 @@ var setup_default = defineCommand7({
     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...`);
+    info(`Fetching ${pc11.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(`Main branch ref ${pc11.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(`Dev branch ref ${pc11.bold(devRef)} not found on remote.`);
         warn("Config was saved — verify the branch name and re-run setup if needed.");
       }
     }
@@ -3031,33 +3454,33 @@ var setup_default = defineCommand7({
       info("Added .contributerc.json to .gitignore to avoid committing personal config.");
     }
     console.log();
-    info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    info(`Convention: ${pc10.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-    info(`Role: ${pc10.bold(config.role)}`);
+    info(`Workflow: ${pc11.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    info(`Convention: ${pc11.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+    info(`Role: ${pc11.bold(config.role)}`);
     if (config.devBranch) {
-      info(`Main: ${pc10.bold(config.mainBranch)} | Dev: ${pc10.bold(config.devBranch)}`);
+      info(`Main: ${pc11.bold(config.mainBranch)} | Dev: ${pc11.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${pc10.bold(config.mainBranch)}`);
+      info(`Main: ${pc11.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${pc10.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc10.bold(config.upstream)}` : ""}`);
+    info(`Origin: ${pc11.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc11.bold(config.upstream)}` : ""}`);
   }
 });
 function logConfigSummary(config) {
-  info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-  info(`Convention: ${pc10.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-  info(`Role: ${pc10.bold(config.role)}`);
+  info(`Workflow: ${pc11.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+  info(`Convention: ${pc11.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+  info(`Role: ${pc11.bold(config.role)}`);
   if (config.devBranch) {
-    info(`Main: ${pc10.bold(config.mainBranch)} | Dev: ${pc10.bold(config.devBranch)}`);
+    info(`Main: ${pc11.bold(config.mainBranch)} | Dev: ${pc11.bold(config.devBranch)}`);
   } else {
-    info(`Main: ${pc10.bold(config.mainBranch)}`);
+    info(`Main: ${pc11.bold(config.mainBranch)}`);
   }
-  info(`Origin: ${pc10.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc10.bold(config.upstream)}` : ""}`);
+  info(`Origin: ${pc11.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc11.bold(config.upstream)}` : ""}`);
 }
 
 // src/commands/start.ts
-import { defineCommand as defineCommand8 } from "citty";
-import pc11 from "picocolors";
-var start_default = defineCommand8({
+import { defineCommand as defineCommand9 } from "citty";
+import pc12 from "picocolors";
+var start_default = defineCommand9({
   meta: {
     name: "start",
     description: "Create a new feature branch from the latest base branch"
@@ -3113,8 +3536,8 @@ var start_default = defineCommand8({
       if (suggested) {
         spinner.success("Branch name suggestion ready.");
         console.log(`
-  ${pc11.dim("AI suggestion:")} ${pc11.bold(pc11.cyan(suggested))}`);
-        const accepted = await confirmPrompt(`Use ${pc11.bold(suggested)} as your branch name?`);
+  ${pc12.dim("AI suggestion:")} ${pc12.bold(pc12.cyan(suggested))}`);
+        const accepted = await confirmPrompt(`Use ${pc12.bold(suggested)} as your branch name?`);
         if (accepted) {
           branchName = suggested;
         } else {
@@ -3125,28 +3548,28 @@ var start_default = defineCommand8({
       }
     }
     if (!hasPrefix(branchName, branchPrefixes)) {
-      const prefix = await selectPrompt(`Choose a branch type for ${pc11.bold(branchName)}:`, branchPrefixes);
+      const prefix = await selectPrompt(`Choose a branch type for ${pc12.bold(branchName)}:`, branchPrefixes);
       branchName = formatBranchName(prefix, branchName);
     }
     if (!isValidBranchName(branchName)) {
       error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
       process.exit(1);
     }
-    info(`Creating branch: ${pc11.bold(branchName)}`);
+    info(`Creating branch: ${pc12.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.`);
+      error(`Branch ${pc12.bold(branchName)} already exists.`);
+      info(`  Use ${pc12.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)}.`);
+      warn(`Remote ref ${pc12.bold(syncSource.ref)} not found. Creating branch from local ${pc12.bold(baseBranch)}.`);
     }
     const currentBranch = await getCurrentBranch();
     if (currentBranch === baseBranch && await refExists(syncSource.ref)) {
       const ahead = await countCommitsAhead(baseBranch, syncSource.ref);
       if (ahead > 0) {
-        warn(`You are on ${pc11.bold(baseBranch)} with ${pc11.bold(String(ahead))} local commit${ahead > 1 ? "s" : ""} not in ${pc11.bold(syncSource.ref)}.`);
+        warn(`You are on ${pc12.bold(baseBranch)} with ${pc12.bold(String(ahead))} local commit${ahead > 1 ? "s" : ""} not in ${pc12.bold(syncSource.ref)}.`);
         info("  Syncing will discard those commits. Consider backing them up first (e.g. create a branch).");
         const proceed = await confirmPrompt("Discard local commits and sync to remote?");
         if (!proceed) {
@@ -3163,10 +3586,10 @@ var start_default = defineCommand8({
           error(`Failed to create branch: ${result2.stderr}`);
           process.exit(1);
         }
-        success(`✅ Created ${pc11.bold(branchName)} from ${pc11.bold(syncSource.ref)}`);
+        success(`✅ Created ${pc12.bold(branchName)} from ${pc12.bold(syncSource.ref)}`);
         return;
       }
-      error(`Failed to update ${pc11.bold(baseBranch)}: ${updateResult.stderr}`);
+      error(`Failed to update ${pc12.bold(baseBranch)}: ${updateResult.stderr}`);
       info("Make sure your base branch exists locally or the remote ref is available.");
       process.exit(1);
     }
@@ -3175,14 +3598,14 @@ var start_default = defineCommand8({
       error(`Failed to create branch: ${result.stderr}`);
       process.exit(1);
     }
-    success(`✅ Created ${pc11.bold(branchName)} from latest ${pc11.bold(baseBranch)}`);
+    success(`✅ Created ${pc12.bold(branchName)} from latest ${pc12.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand9 } from "citty";
-import pc12 from "picocolors";
-var status_default = defineCommand9({
+import { defineCommand as defineCommand10 } from "citty";
+import pc13 from "picocolors";
+var status_default = defineCommand10({
   meta: {
     name: "status",
     description: "Show sync status of branches"
@@ -3198,8 +3621,8 @@ var status_default = defineCommand9({
       process.exit(1);
     }
     heading("\uD83D\uDCCA contribute-now status");
-    console.log(`  ${pc12.dim("Workflow:")} ${pc12.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    console.log(`  ${pc12.dim("Role:")} ${pc12.bold(config.role)}`);
+    console.log(`  ${pc13.dim("Workflow:")} ${pc13.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    console.log(`  ${pc13.dim("Role:")} ${pc13.bold(config.role)}`);
     console.log();
     await fetchAll();
     const currentBranch = await getCurrentBranch();
@@ -3208,7 +3631,7 @@ var status_default = defineCommand9({
     const isContributor = config.role === "contributor";
     const [dirty, fileStatus] = await Promise.all([hasUncommittedChanges(), getFileStatus()]);
     if (dirty) {
-      console.log(`  ${pc12.yellow("⚠")}  ${pc12.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${pc13.yellow("⚠")}  ${pc13.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -3221,85 +3644,143 @@ var status_default = defineCommand9({
       const devLine = formatStatus(config.devBranch, devRemoteRef, devDiv.ahead, devDiv.behind);
       console.log(devLine);
     }
-    if (currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
+    const protectedBranches = getProtectedBranches(config);
+    const isFeatureBranch = currentBranch && !protectedBranches.includes(currentBranch);
+    let branchStatus = null;
+    if (isFeatureBranch) {
       const branchDiv = await getDivergence(currentBranch, baseBranch);
       const branchLine = formatStatus(currentBranch, baseBranch, branchDiv.ahead, branchDiv.behind);
-      console.log(branchLine + pc12.dim(` (current ${pc12.green("*")})`));
+      console.log(branchLine + pc13.dim(` (current ${pc13.green("*")})`));
+      branchStatus = await detectBranchStatus(currentBranch, baseBranch);
+      if (branchStatus.merged) {
+        console.log(`  ${pc13.green("✓")}  ${pc13.green("Branch merged")} — ${pc13.dim(branchStatus.mergedReason ?? "all commits reachable from base")}`);
+      }
+      if (branchStatus.stale) {
+        console.log(`  ${pc13.yellow("⏳")}  ${pc13.yellow("Branch is stale")} — ${pc13.dim(`last commit ${branchStatus.staleDaysAgo} days ago`)}`);
+      }
     } else if (currentBranch) {
-      console.log(pc12.dim(`  (on ${pc12.bold(currentBranch)} branch)`));
+      console.log(pc13.dim(`  (on ${pc13.bold(currentBranch)} branch)`));
     }
     const hasFiles = fileStatus.staged.length > 0 || fileStatus.modified.length > 0 || fileStatus.untracked.length > 0;
     if (hasFiles) {
       console.log();
       if (fileStatus.staged.length > 0) {
-        console.log(`  ${pc12.green("Staged for commit:")}`);
+        console.log(`  ${pc13.green("Staged for commit:")}`);
         for (const { file, status } of fileStatus.staged) {
-          console.log(`    ${pc12.green("+")} ${pc12.dim(`${status}:`)} ${file}`);
+          console.log(`    ${pc13.green("+")} ${pc13.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.modified.length > 0) {
-        console.log(`  ${pc12.yellow("Unstaged changes:")}`);
+        console.log(`  ${pc13.yellow("Unstaged changes:")}`);
         for (const { file, status } of fileStatus.modified) {
-          console.log(`    ${pc12.yellow("~")} ${pc12.dim(`${status}:`)} ${file}`);
+          console.log(`    ${pc13.yellow("~")} ${pc13.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.untracked.length > 0) {
-        console.log(`  ${pc12.red("Untracked files:")}`);
+        console.log(`  ${pc13.red("Untracked files:")}`);
         for (const file of fileStatus.untracked) {
-          console.log(`    ${pc12.red("?")} ${file}`);
+          console.log(`    ${pc13.red("?")} ${file}`);
         }
       }
     } else if (!dirty) {
-      console.log(`  ${pc12.green("✓")}  ${pc12.dim("Working tree clean")}`);
+      console.log(`  ${pc13.green("✓")}  ${pc13.dim("Working tree clean")}`);
     }
     const tips = [];
     if (fileStatus.staged.length > 0) {
-      tips.push(`Run ${pc12.bold("contrib commit")} to commit staged changes`);
+      tips.push(`Run ${pc13.bold("contrib commit")} to commit staged changes`);
     }
     if (fileStatus.modified.length > 0 || fileStatus.untracked.length > 0) {
-      tips.push(`Run ${pc12.bold("contrib commit")} to stage and commit changes`);
-    }
-    if (fileStatus.staged.length === 0 && fileStatus.modified.length === 0 && fileStatus.untracked.length === 0 && currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
-      const branchDiv = await getDivergence(currentBranch, `${origin}/${currentBranch}`);
-      if (branchDiv.ahead > 0) {
-        tips.push(`Run ${pc12.bold("contrib submit")} to push and create/update your PR`);
+      tips.push(`Run ${pc13.bold("contrib commit")} to stage and commit changes`);
+    }
+    if (isFeatureBranch && branchStatus) {
+      if (branchStatus.merged) {
+        tips.push(`Run ${pc13.bold("contrib clean")} to delete this merged branch`);
+      } else if (branchStatus.stale) {
+        tips.push(`Run ${pc13.bold("contrib sync")} to rebase on latest changes, or ${pc13.bold("contrib clean")} if no longer needed`);
+      } else if (fileStatus.staged.length === 0 && fileStatus.modified.length === 0 && fileStatus.untracked.length === 0) {
+        const branchDiv = await getDivergence(currentBranch, `${origin}/${currentBranch}`);
+        if (branchDiv.ahead > 0) {
+          tips.push(`Run ${pc13.bold("contrib submit")} to push and create/update your PR`);
+        }
       }
     }
     if (tips.length > 0) {
       console.log();
-      console.log(`  ${pc12.dim("\uD83D\uDCA1 Tip:")}`);
+      console.log(`  ${pc13.dim("\uD83D\uDCA1 Tip:")}`);
       for (const tip of tips) {
-        console.log(`     ${pc12.dim(tip)}`);
+        console.log(`     ${pc13.dim(tip)}`);
       }
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = pc12.bold(branch.padEnd(20));
+  const label = pc13.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${pc12.green("✓")}  ${label} ${pc12.dim(`in sync with ${base}`)}`;
+    return `  ${pc13.green("✓")}  ${label} ${pc13.dim(`in sync with ${base}`)}`;
   }
   if (ahead > 0 && behind === 0) {
-    return `  ${pc12.yellow("↑")}  ${label} ${pc12.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+    return `  ${pc13.yellow("↑")}  ${label} ${pc13.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
   }
   if (behind > 0 && ahead === 0) {
-    return `  ${pc12.red("↓")}  ${label} ${pc12.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+    return `  ${pc13.red("↓")}  ${label} ${pc13.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+  }
+  return `  ${pc13.red("⚡")}  ${label} ${pc13.yellow(`${ahead} ahead`)}${pc13.dim(", ")}${pc13.red(`${behind} behind`)} ${pc13.dim(base)}`;
+}
+var STALE_THRESHOLD_DAYS = 14;
+async function detectBranchStatus(branch, baseBranch) {
+  const result = { merged: false, mergedReason: null, stale: false, staleDaysAgo: null };
+  const div = await getDivergence(branch, baseBranch);
+  const hasWork = div.ahead > 0;
+  if (hasWork) {
+    if (await isBranchMergedInto(branch, baseBranch)) {
+      result.merged = true;
+      result.mergedReason = `all commits reachable from ${baseBranch}`;
+      return result;
+    }
+    const mergedBranches = await getMergedBranches(baseBranch);
+    if (mergedBranches.includes(branch)) {
+      result.merged = true;
+      result.mergedReason = `listed in merged branches of ${baseBranch}`;
+      return result;
+    }
+  }
+  const goneBranches = await getGoneBranches();
+  if (goneBranches.includes(branch)) {
+    result.merged = true;
+    result.mergedReason = "remote branch deleted (likely squash-merged)";
+    return result;
+  }
+  if (await checkGhInstalled()) {
+    const mergedPR = await getMergedPRForBranch(branch);
+    if (mergedPR) {
+      result.merged = true;
+      result.mergedReason = `PR #${mergedPR.number} was merged`;
+      return result;
+    }
   }
-  return `  ${pc12.red("⚡")}  ${label} ${pc12.yellow(`${ahead} ahead`)}${pc12.dim(", ")}${pc12.red(`${behind} behind`)} ${pc12.dim(base)}`;
+  const lastDate = await getLastCommitDate(branch);
+  if (lastDate) {
+    const daysAgo = Math.floor((Date.now() - new Date(lastDate).getTime()) / (1000 * 60 * 60 * 24));
+    if (daysAgo >= STALE_THRESHOLD_DAYS) {
+      result.stale = true;
+      result.staleDaysAgo = daysAgo;
+    }
+  }
+  return result;
 }
 
 // src/commands/submit.ts
-import { defineCommand as defineCommand10 } from "citty";
-import pc13 from "picocolors";
+import { defineCommand as defineCommand11 } from "citty";
+import pc14 from "picocolors";
 async function performSquashMerge(origin, baseBranch, featureBranch, options) {
-  info(`Checking out ${pc13.bold(baseBranch)}...`);
+  info(`Checking out ${pc14.bold(baseBranch)}...`);
   const coResult = await checkoutBranch(baseBranch);
   if (coResult.exitCode !== 0) {
     error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
     process.exit(1);
   }
-  info(`Squash merging ${pc13.bold(featureBranch)} into ${pc13.bold(baseBranch)}...`);
+  info(`Squash merging ${pc14.bold(featureBranch)} into ${pc14.bold(baseBranch)}...`);
   const mergeResult = await mergeSquash(featureBranch);
   if (mergeResult.exitCode !== 0) {
     error(`Squash merge failed: ${mergeResult.stderr}`);
@@ -3311,10 +3792,12 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
     if (!copilotError) {
       const spinner = createSpinner("Generating AI commit message for squash merge...");
       const [stagedDiff, stagedFiles] = await Promise.all([getStagedDiff(), getStagedFiles()]);
-      const aiMsg = await generateCommitMessage(stagedDiff, stagedFiles, options?.model, options?.convention ?? "clean-commit");
+      const aiMsg = await generateCommitMessage(stagedDiff, stagedFiles, options?.model, options?.convention ?? "clean-commit", "squash-merge");
       if (aiMsg) {
         message = aiMsg;
         spinner.success("AI commit message generated.");
+        console.log(`
+  ${pc14.dim("AI suggestion:")} ${pc14.bold(pc14.cyan(message))}`);
       } else {
         spinner.fail("AI did not return a commit message.");
       }
@@ -3322,26 +3805,51 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
       warn(`AI unavailable: ${copilotError}`);
     }
   }
-  const fallback = message || `squash merge ${featureBranch}`;
-  let finalMsg;
+  let finalMsg = null;
   if (message) {
-    console.log(`  ${pc13.dim("Commit message:")} ${pc13.bold(message)}`);
-    finalMsg = message;
+    while (!finalMsg) {
+      const action = await selectPrompt("What would you like to do?", [
+        "Accept this message",
+        "Edit this message",
+        "Regenerate",
+        "Write manually"
+      ]);
+      if (action === "Accept this message") {
+        finalMsg = message;
+      } else if (action === "Edit this message") {
+        finalMsg = await inputPrompt("Edit commit message", message);
+      } else if (action === "Regenerate") {
+        const spinner = createSpinner("Regenerating commit message...");
+        const [stagedDiff, stagedFiles] = await Promise.all([getStagedDiff(), getStagedFiles()]);
+        const regen = await generateCommitMessage(stagedDiff, stagedFiles, options?.model, options?.convention ?? "clean-commit", "squash-merge");
+        if (regen) {
+          message = regen;
+          spinner.success("Commit message regenerated.");
+          console.log(`
+  ${pc14.dim("AI suggestion:")} ${pc14.bold(pc14.cyan(regen))}`);
+        } else {
+          spinner.fail("Regeneration failed.");
+          finalMsg = await inputPrompt("Enter commit message");
+        }
+      } else {
+        finalMsg = await inputPrompt("Enter commit message");
+      }
+    }
   } else {
-    finalMsg = await inputPrompt("Commit message", fallback);
+    finalMsg = await inputPrompt("Commit message", `squash merge ${featureBranch}`);
   }
   const commitResult = await commitWithMessage(finalMsg);
   if (commitResult.exitCode !== 0) {
     error(`Commit failed: ${commitResult.stderr}`);
     process.exit(1);
   }
-  info(`Pushing ${pc13.bold(baseBranch)} to ${origin}...`);
+  info(`Pushing ${pc14.bold(baseBranch)} to ${origin}...`);
   const pushResult = await pushBranch(origin, baseBranch);
   if (pushResult.exitCode !== 0) {
     error(`Failed to push ${baseBranch}: ${pushResult.stderr}`);
     process.exit(1);
   }
-  info(`Deleting local branch ${pc13.bold(featureBranch)}...`);
+  info(`Deleting local branch ${pc14.bold(featureBranch)}...`);
   const delLocal = await forceDeleteBranch(featureBranch);
   if (delLocal.exitCode !== 0) {
     warn(`Could not delete local branch: ${delLocal.stderr.trim()}`);
@@ -3349,16 +3857,16 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
   const remoteBranchRef = `${origin}/${featureBranch}`;
   const remoteExists = await branchExists(remoteBranchRef);
   if (remoteExists) {
-    info(`Deleting remote branch ${pc13.bold(featureBranch)}...`);
+    info(`Deleting remote branch ${pc14.bold(featureBranch)}...`);
     const delRemote = await deleteRemoteBranch(origin, featureBranch);
     if (delRemote.exitCode !== 0) {
       warn(`Could not delete remote branch: ${delRemote.stderr.trim()}`);
     }
   }
-  success(`✅ Squash merged ${pc13.bold(featureBranch)} into ${pc13.bold(baseBranch)} and pushed.`);
-  info(`Run ${pc13.bold("contrib start")} to begin a new feature.`);
+  success(`✅ Squash merged ${pc14.bold(featureBranch)} into ${pc14.bold(baseBranch)} and pushed.`);
+  info(`Run ${pc14.bold("contrib start")} to begin a new feature.`);
 }
-var submit_default = defineCommand10({
+var submit_default = defineCommand11({
   meta: {
     name: "submit",
     description: "Push current branch and create a pull request"
@@ -3400,7 +3908,7 @@ var submit_default = defineCommand10({
     }
     if (protectedBranches.includes(currentBranch)) {
       heading("\uD83D\uDE80 contrib submit");
-      warn(`You're on ${pc13.bold(currentBranch)}, which is a protected branch. PRs should come from feature branches.`);
+      warn(`You're on ${pc14.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);
@@ -3409,11 +3917,11 @@ var submit_default = defineCommand10({
       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.`);
+        info(`  Run ${pc14.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)}.`);
+        info(`Found ${pc14.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${pc14.bold(currentBranch)}.`);
       }
       if (dirty) {
         info("You also have uncommitted changes in the working tree.");
@@ -3429,7 +3937,7 @@ var submit_default = defineCommand10({
         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."));
+      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 (looksLikeNaturalLanguage(description)) {
@@ -3440,8 +3948,8 @@ var submit_default = defineCommand10({
           if (suggested) {
             spinner.success("Branch name suggestion ready.");
             console.log(`
-  ${pc13.dim("AI suggestion:")} ${pc13.bold(pc13.cyan(suggested))}`);
-            const accepted = await confirmPrompt(`Use ${pc13.bold(suggested)} as your branch name?`);
+  ${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.");
@@ -3450,7 +3958,7 @@ var submit_default = defineCommand10({
         }
       }
       if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-        const prefix = await selectPrompt(`Choose a branch type for ${pc13.bold(newBranchName)}:`, config.branchPrefixes);
+        const prefix = await selectPrompt(`Choose a branch type for ${pc14.bold(newBranchName)}:`, config.branchPrefixes);
         newBranchName = formatBranchName(prefix, newBranchName);
       }
       if (!isValidBranchName(newBranchName)) {
@@ -3458,7 +3966,7 @@ var submit_default = defineCommand10({
         process.exit(1);
       }
       if (await branchExists(newBranchName)) {
-        error(`Branch ${pc13.bold(newBranchName)} already exists. Choose a different name.`);
+        error(`Branch ${pc14.bold(newBranchName)} already exists. Choose a different name.`);
         process.exit(1);
       }
       const branchResult = await createBranch(newBranchName);
@@ -3466,12 +3974,12 @@ var submit_default = defineCommand10({
         error(`Failed to create branch: ${branchResult.stderr}`);
         process.exit(1);
       }
-      success(`Created ${pc13.bold(newBranchName)} with your changes.`);
+      success(`Created ${pc14.bold(newBranchName)} with your changes.`);
       await updateLocalBranch(currentBranch, remoteRef);
-      info(`Reset ${pc13.bold(currentBranch)} back to ${pc13.bold(remoteRef)} — no damage done.`);
+      info(`Reset ${pc14.bold(currentBranch)} back to ${pc14.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.`);
+      success(`You're now on ${pc14.bold(newBranchName)} with all your work intact.`);
+      info(`Run ${pc14.bold("contrib submit")} again to push and create your PR.`);
       return;
     }
     heading("\uD83D\uDE80 contrib submit");
@@ -3480,7 +3988,7 @@ var submit_default = defineCommand10({
     if (ghInstalled && ghAuthed) {
       const mergedPR = await getMergedPRForBranch(currentBranch);
       if (mergedPR) {
-        warn(`PR #${mergedPR.number} (${pc13.bold(mergedPR.title)}) was already merged.`);
+        warn(`PR #${mergedPR.number} (${pc14.bold(mergedPR.title)}) was already merged.`);
         const localWork = await hasLocalWork(origin, currentBranch);
         const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
         if (hasWork) {
@@ -3488,7 +3996,7 @@ var submit_default = defineCommand10({
             warn("You have uncommitted changes in your working tree.");
           }
           if (localWork.unpushedCommits > 0) {
-            warn(`You have ${pc13.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not in the merged PR.`);
+            warn(`You have ${pc14.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";
@@ -3499,7 +4007,7 @@ var submit_default = defineCommand10({
             return;
           }
           if (action === SAVE_NEW_BRANCH) {
-            info(pc13.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
+            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)) {
@@ -3508,8 +4016,8 @@ var submit_default = defineCommand10({
               if (suggested) {
                 spinner.success("Branch name suggestion ready.");
                 console.log(`
-  ${pc13.dim("AI suggestion:")} ${pc13.bold(pc13.cyan(suggested))}`);
-                const accepted = await confirmPrompt(`Use ${pc13.bold(suggested)} as your branch name?`);
+  ${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.");
@@ -3517,7 +4025,7 @@ var submit_default = defineCommand10({
               }
             }
             if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-              const prefix = await selectPrompt(`Choose a branch type for ${pc13.bold(newBranchName)}:`, config.branchPrefixes);
+              const prefix = await selectPrompt(`Choose a branch type for ${pc14.bold(newBranchName)}:`, config.branchPrefixes);
               newBranchName = formatBranchName(prefix, newBranchName);
             }
             if (!isValidBranchName(newBranchName)) {
@@ -3527,7 +4035,7 @@ var submit_default = defineCommand10({
             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.`);
+              error(`Branch ${pc14.bold(newBranchName)} already exists. Choose a different name.`);
               process.exit(1);
             }
             const renameResult = await renameBranch(currentBranch, newBranchName);
@@ -3535,10 +4043,10 @@ var submit_default = defineCommand10({
               error(`Failed to rename branch: ${renameResult.stderr}`);
               process.exit(1);
             }
-            success(`Renamed ${pc13.bold(currentBranch)} → ${pc13.bold(newBranchName)}`);
+            success(`Renamed ${pc14.bold(currentBranch)} → ${pc14.bold(newBranchName)}`);
             await unsetUpstream();
             const syncSource2 = getSyncSource(config);
-            info(`Syncing ${pc13.bold(newBranchName)} with latest ${pc13.bold(baseBranch)}...`);
+            info(`Syncing ${pc14.bold(newBranchName)} with latest ${pc14.bold(baseBranch)}...`);
             await fetchRemote(syncSource2.remote);
             let rebaseResult;
             if (staleUpstreamHash) {
@@ -3549,17 +4057,17 @@ var submit_default = defineCommand10({
             }
             if (rebaseResult.exitCode !== 0) {
               warn("Rebase encountered conflicts. Resolve them manually, then run:");
-              info(`  ${pc13.bold("git rebase --continue")}`);
+              info(`  ${pc14.bold("git rebase --continue")}`);
             } else {
-              success(`Rebased ${pc13.bold(newBranchName)} onto ${pc13.bold(syncSource2.ref)}.`);
+              success(`Rebased ${pc14.bold(newBranchName)} onto ${pc14.bold(syncSource2.ref)}.`);
             }
-            info(`All your changes are preserved. Run ${pc13.bold("contrib submit")} when ready to create a new PR.`);
+            info(`All your changes are preserved. Run ${pc14.bold("contrib submit")} when ready to create a new PR.`);
             return;
           }
           warn("Discarding local changes...");
         }
         const syncSource = getSyncSource(config);
-        info(`Switching to ${pc13.bold(baseBranch)} and syncing...`);
+        info(`Switching to ${pc14.bold(baseBranch)} and syncing...`);
         await fetchRemote(syncSource.remote);
         await resetHard("HEAD");
         const coResult = await checkoutBranch(baseBranch);
@@ -3568,16 +4076,35 @@ var submit_default = defineCommand10({
           process.exit(1);
         }
         await updateLocalBranch(baseBranch, syncSource.ref);
-        success(`Synced ${pc13.bold(baseBranch)} with ${pc13.bold(syncSource.ref)}.`);
-        info(`Deleting stale branch ${pc13.bold(currentBranch)}...`);
+        success(`Synced ${pc14.bold(baseBranch)} with ${pc14.bold(syncSource.ref)}.`);
+        info(`Deleting stale branch ${pc14.bold(currentBranch)}...`);
         const delResult = await forceDeleteBranch(currentBranch);
         if (delResult.exitCode === 0) {
-          success(`Deleted ${pc13.bold(currentBranch)}.`);
+          success(`Deleted ${pc14.bold(currentBranch)}.`);
         } else {
           warn(`Could not delete branch: ${delResult.stderr.trim()}`);
         }
         console.log();
-        info(`You're now on ${pc13.bold(baseBranch)}. Run ${pc13.bold("contrib start")} to begin a new feature.`);
+        info(`You're now on ${pc14.bold(baseBranch)}. Run ${pc14.bold("contrib start")} to begin a new feature.`);
+        return;
+      }
+    }
+    if (ghInstalled && ghAuthed) {
+      const existingPR = await getPRForBranch(currentBranch);
+      if (existingPR) {
+        info(`Pushing ${pc14.bold(currentBranch)} to ${origin}...`);
+        const pushResult2 = await pushSetUpstream(origin, currentBranch);
+        if (pushResult2.exitCode !== 0) {
+          error(`Failed to push: ${pushResult2.stderr}`);
+          if (pushResult2.stderr.includes("rejected") || pushResult2.stderr.includes("non-fast-forward")) {
+            warn("The remote branch has diverged. Try:");
+            info(`  git pull --rebase ${origin} ${currentBranch}`);
+            info("  Then run `contrib submit` again.");
+          }
+          process.exit(1);
+        }
+        success(`Pushed changes to existing PR #${existingPR.number}: ${pc14.bold(existingPR.title)}`);
+        console.log(`  ${pc14.cyan(existingPR.url)}`);
         return;
       }
     }
@@ -3597,10 +4124,10 @@ var submit_default = defineCommand10({
           prBody = result.body;
           spinner.success("PR description generated.");
           console.log(`
-  ${pc13.dim("AI title:")} ${pc13.bold(pc13.cyan(prTitle))}`);
+  ${pc14.dim("AI title:")} ${pc14.bold(pc14.cyan(prTitle))}`);
           console.log(`
-${pc13.dim("AI body preview:")}`);
-          console.log(pc13.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+${pc14.dim("AI body preview:")}`);
+          console.log(pc14.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
         } else {
           spinner.fail("AI did not return a PR description.");
         }
@@ -3683,13 +4210,12 @@ ${pc13.dim("AI body preview:")}`);
     }
     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}...`);
+    info(`Pushing ${pc14.bold(currentBranch)} to ${origin}...`);
     const pushResult = await pushSetUpstream(origin, currentBranch);
     if (pushResult.exitCode !== 0) {
       error(`Failed to push: ${pushResult.stderr}`);
@@ -3708,18 +4234,12 @@ ${pc13.dim("AI body preview:")}`);
         const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/compare/${baseBranch}...${currentBranch}?expand=1`;
         console.log();
         info("Create your PR manually:");
-        console.log(`  ${pc13.cyan(prUrl)}`);
+        console.log(`  ${pc14.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}: ${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) {
@@ -3747,10 +4267,109 @@ ${pc13.dim("AI body preview:")}`);
   }
 });
 
+// src/commands/switch.ts
+import { defineCommand as defineCommand12 } from "citty";
+import pc15 from "picocolors";
+var switch_default = defineCommand12({
+  meta: {
+    name: "switch",
+    description: "Switch to another branch with stash protection for uncommitted changes"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Branch name to switch to (interactive picker if omitted)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    const protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
+    const currentBranch = await getCurrentBranch();
+    heading("\uD83D\uDD00 contrib switch");
+    let targetBranch = args.name;
+    if (!targetBranch) {
+      const localBranches = await getLocalBranches();
+      if (localBranches.length === 0) {
+        error("No local branches found.");
+        process.exit(1);
+      }
+      const choices = localBranches.filter((b) => b.name !== currentBranch).map((b) => {
+        const labels = [];
+        if (protectedBranches.includes(b.name))
+          labels.push(pc15.red("protected"));
+        if (b.upstream)
+          labels.push(pc15.dim(`→ ${b.upstream}`));
+        if (b.gone)
+          labels.push(pc15.red("remote gone"));
+        const suffix = labels.length > 0 ? `  ${labels.join(" · ")}` : "";
+        return `${b.name}${suffix}`;
+      });
+      if (choices.length === 0) {
+        info("You are already on the only local branch.");
+        process.exit(0);
+      }
+      const selected = await selectPrompt("Switch to which branch?", choices);
+      targetBranch = selected.split(/\s{2,}/)[0].trim();
+    }
+    if (targetBranch === currentBranch) {
+      info(`Already on ${pc15.bold(targetBranch)}.`);
+      return;
+    }
+    if (await hasUncommittedChanges()) {
+      warn("You have uncommitted changes.");
+      const action = await selectPrompt("How would you like to handle them?", [
+        "Save changes and switch",
+        "Cancel"
+      ]);
+      if (action === "Cancel") {
+        info("Switch cancelled.");
+        return;
+      }
+      const { execFile } = await import("node:child_process");
+      const { promisify } = await import("node:util");
+      const exec = promisify(execFile);
+      const stashMsg = `contrib-save: auto-save from ${currentBranch}`;
+      try {
+        await exec("git", ["stash", "push", "-m", stashMsg]);
+        info(`Saved changes: ${pc15.dim(stashMsg)}`);
+      } catch {
+        error("Failed to save changes. Please commit or save manually.");
+        process.exit(1);
+      }
+      const result2 = await checkoutBranch(targetBranch);
+      if (result2.exitCode !== 0) {
+        error(`Failed to switch to ${targetBranch}: ${result2.stderr}`);
+        try {
+          await exec("git", ["stash", "pop"]);
+          info("Restored saved changes.");
+        } catch {
+          warn("Could not restore save automatically. Use `contrib save restore` to recover.");
+        }
+        process.exit(1);
+      }
+      success(`Switched to ${pc15.bold(targetBranch)}`);
+      info(`Your changes from ${pc15.bold(currentBranch ?? "previous branch")} are saved.`);
+      info(`Use ${pc15.bold("contrib save restore")} to bring them back.`);
+      return;
+    }
+    const result = await checkoutBranch(targetBranch);
+    if (result.exitCode !== 0) {
+      error(`Failed to switch to ${targetBranch}: ${result.stderr}`);
+      process.exit(1);
+    }
+    success(`Switched to ${pc15.bold(targetBranch)}`);
+  }
+});
+
 // src/commands/sync.ts
-import { defineCommand as defineCommand11 } from "citty";
-import pc14 from "picocolors";
-var sync_default = defineCommand11({
+import { defineCommand as defineCommand13 } from "citty";
+import pc16 from "picocolors";
+var sync_default = defineCommand13({
   meta: {
     name: "sync",
     description: "Sync your local branches with the remote"
@@ -3801,24 +4420,24 @@ var sync_default = defineCommand11({
       await fetchRemote(origin);
     }
     if (!await refExists(syncSource.ref)) {
-      error(`Remote ref ${pc14.bold(syncSource.ref)} does not exist.`);
+      error(`Remote ref ${pc16.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")}.`);
+      info(`Check your config: the base branch may need updating via ${pc16.bold("contrib setup")}.`);
       process.exit(1);
     }
     let allowMergeCommit = false;
     const div = await getDivergence(baseBranch, syncSource.ref);
     if (div.ahead > 0 || div.behind > 0) {
-      info(`${pc14.bold(baseBranch)} is ${pc14.yellow(`${div.ahead} ahead`)} and ${pc14.red(`${div.behind} behind`)} ${syncSource.ref}`);
+      info(`${pc16.bold(baseBranch)} is ${pc16.yellow(`${div.ahead} ahead`)} and ${pc16.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`${pc14.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+      info(`${pc16.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.`);
+        warn(`You have ${pc16.bold(String(div.ahead))} local commit${div.ahead !== 1 ? "s" : ""} on ${pc16.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";
@@ -3834,7 +4453,7 @@ var sync_default = defineCommand11({
           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."));
+          info(pc16.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)) {
@@ -3845,8 +4464,8 @@ var sync_default = defineCommand11({
               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?`);
+  ${pc16.dim("AI suggestion:")} ${pc16.bold(pc16.cyan(suggested))}`);
+                const accepted = await confirmPrompt(`Use ${pc16.bold(suggested)} as your branch name?`);
                 newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
               } else {
                 spinner.fail("AI did not return a suggestion.");
@@ -3855,7 +4474,7 @@ var sync_default = defineCommand11({
             }
           }
           if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-            const prefix = await selectPrompt(`Choose a branch type for ${pc14.bold(newBranchName)}:`, config.branchPrefixes);
+            const prefix = await selectPrompt(`Choose a branch type for ${pc16.bold(newBranchName)}:`, config.branchPrefixes);
             newBranchName = formatBranchName(prefix, newBranchName);
           }
           if (!isValidBranchName(newBranchName)) {
@@ -3863,7 +4482,7 @@ var sync_default = defineCommand11({
             process.exit(1);
           }
           if (await branchExists(newBranchName)) {
-            error(`Branch ${pc14.bold(newBranchName)} already exists. Choose a different name.`);
+            error(`Branch ${pc16.bold(newBranchName)} already exists. Choose a different name.`);
             process.exit(1);
           }
           const branchResult = await createBranch(newBranchName);
@@ -3871,7 +4490,7 @@ var sync_default = defineCommand11({
             error(`Failed to create branch: ${branchResult.stderr}`);
             process.exit(1);
           }
-          success(`Created ${pc14.bold(newBranchName)} with your commits.`);
+          success(`Created ${pc16.bold(newBranchName)} with your commits.`);
           const coResult2 = await checkoutBranch(baseBranch);
           if (coResult2.exitCode !== 0) {
             error(`Failed to checkout ${baseBranch}: ${coResult2.stderr}`);
@@ -3879,11 +4498,11 @@ var sync_default = defineCommand11({
           }
           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}`);
+          success(`Reset ${pc16.bold(baseBranch)} to ${pc16.bold(remoteRef)}.`);
+          success(`✅ ${pc16.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)}.`);
+          info(`Your commits are safe on ${pc16.bold(newBranchName)}.`);
+          info(`Run ${pc16.bold(`git checkout ${newBranchName}`)} then ${pc16.bold("contrib update")} to rebase onto the synced ${pc16.bold(baseBranch)}.`);
           return;
         }
         allowMergeCommit = true;
@@ -3891,7 +4510,7 @@ var sync_default = defineCommand11({
       }
     }
     if (!args.yes) {
-      const ok = await confirmPrompt(`This will pull ${pc14.bold(syncSource.ref)} into local ${pc14.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${pc16.bold(syncSource.ref)} into local ${pc16.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
@@ -3905,8 +4524,8 @@ var sync_default = defineCommand11({
       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.`);
+        error(`Fast-forward pull failed. Your local ${pc16.bold(baseBranch)} may have diverged.`);
+        info(`Use ${pc16.bold("contrib sync")} again and choose "Move my commits to a new feature branch" to fix this.`);
       }
       process.exit(1);
     }
@@ -3914,7 +4533,7 @@ var sync_default = defineCommand11({
     if (hasDevBranch(workflow) && role === "maintainer") {
       const mainDiv = await getDivergence(config.mainBranch, `${origin}/${config.mainBranch}`);
       if (mainDiv.behind > 0) {
-        info(`Also syncing ${pc14.bold(config.mainBranch)}...`);
+        info(`Also syncing ${pc16.bold(config.mainBranch)}...`);
         const mainCoResult = await checkoutBranch(config.mainBranch);
         if (mainCoResult.exitCode === 0) {
           const mainPullResult = await pullFastForwardOnly(origin, config.mainBranch);
@@ -3930,9 +4549,9 @@ var sync_default = defineCommand11({
 
 // src/commands/update.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { defineCommand as defineCommand12 } from "citty";
-import pc15 from "picocolors";
-var update_default = defineCommand12({
+import { defineCommand as defineCommand14 } from "citty";
+import pc17 from "picocolors";
+var update_default = defineCommand14({
   meta: {
     name: "update",
     description: "Rebase current branch onto the latest base branch"
@@ -3969,7 +4588,7 @@ var update_default = defineCommand12({
     }
     if (protectedBranches.includes(currentBranch)) {
       heading("\uD83D\uDD03 contrib update");
-      warn(`You're on ${pc15.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
+      warn(`You're on ${pc17.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
       await fetchAll();
       const { origin } = config;
       const remoteRef = `${origin}/${currentBranch}`;
@@ -3978,12 +4597,12 @@ var update_default = defineCommand12({
       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.`);
+        info(`No local changes found on ${pc17.bold(currentBranch)}.`);
+        info(`Use ${pc17.bold("contrib sync")} to sync protected branches, or ${pc17.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)}.`);
+        info(`Found ${pc17.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${pc17.bold(currentBranch)}.`);
       }
       if (dirty) {
         info("You also have uncommitted changes in the working tree.");
@@ -3999,7 +4618,7 @@ var update_default = defineCommand12({
         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."));
+      info(pc17.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)) {
@@ -4010,8 +4629,8 @@ var update_default = defineCommand12({
           if (suggested) {
             spinner.success("Branch name suggestion ready.");
             console.log(`
-  ${pc15.dim("AI suggestion:")} ${pc15.bold(pc15.cyan(suggested))}`);
-            const accepted = await confirmPrompt(`Use ${pc15.bold(suggested)} as your branch name?`);
+  ${pc17.dim("AI suggestion:")} ${pc17.bold(pc17.cyan(suggested))}`);
+            const accepted = await confirmPrompt(`Use ${pc17.bold(suggested)} as your branch name?`);
             newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
           } else {
             spinner.fail("AI did not return a suggestion.");
@@ -4020,7 +4639,7 @@ var update_default = defineCommand12({
         }
       }
       if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-        const prefix = await selectPrompt(`Choose a branch type for ${pc15.bold(newBranchName)}:`, config.branchPrefixes);
+        const prefix = await selectPrompt(`Choose a branch type for ${pc17.bold(newBranchName)}:`, config.branchPrefixes);
         newBranchName = formatBranchName(prefix, newBranchName);
       }
       if (!isValidBranchName(newBranchName)) {
@@ -4032,12 +4651,12 @@ var update_default = defineCommand12({
         error(`Failed to create branch: ${branchResult.stderr}`);
         process.exit(1);
       }
-      success(`Created ${pc15.bold(newBranchName)} with your changes.`);
+      success(`Created ${pc17.bold(newBranchName)} with your changes.`);
       await updateLocalBranch(currentBranch, remoteRef);
-      info(`Reset ${pc15.bold(currentBranch)} back to ${pc15.bold(remoteRef)} — no damage done.`);
+      info(`Reset ${pc17.bold(currentBranch)} back to ${pc17.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)}.`);
+      success(`You're now on ${pc17.bold(newBranchName)} with all your work intact.`);
+      info(`Run ${pc17.bold("contrib update")} again to rebase onto latest ${pc17.bold(baseBranch)}.`);
       return;
     }
     if (await hasUncommittedChanges()) {
@@ -4047,8 +4666,8 @@ var update_default = defineCommand12({
     heading("\uD83D\uDD03 contrib update");
     const mergedPR = await getMergedPRForBranch(currentBranch);
     if (mergedPR) {
-      warn(`PR #${mergedPR.number} (${pc15.bold(mergedPR.title)}) has already been merged.`);
-      info(`Link: ${pc15.underline(mergedPR.url)}`);
+      warn(`PR #${mergedPR.number} (${pc17.bold(mergedPR.title)}) has already been merged.`);
+      info(`Link: ${pc17.underline(mergedPR.url)}`);
       const localWork = await hasLocalWork(syncSource.remote, currentBranch);
       const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
       if (hasWork) {
@@ -4061,13 +4680,13 @@ var update_default = defineCommand12({
         const SAVE_NEW_BRANCH = "Save changes to a new branch";
         const DISCARD = "Discard all changes and clean up";
         const CANCEL = "Cancel";
-        const action = await selectPrompt(`${pc15.bold(currentBranch)} is stale but has local work. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
+        const action = await selectPrompt(`${pc17.bold(currentBranch)} is stale but has local work. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
         if (action === CANCEL) {
           info("No changes made. You are still on your current branch.");
           return;
         }
         if (action === SAVE_NEW_BRANCH) {
-          info(pc15.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
+          info(pc17.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)) {
@@ -4076,8 +4695,8 @@ var update_default = defineCommand12({
             if (suggested) {
               spinner.success("Branch name suggestion ready.");
               console.log(`
-  ${pc15.dim("AI suggestion:")} ${pc15.bold(pc15.cyan(suggested))}`);
-              const accepted = await confirmPrompt(`Use ${pc15.bold(suggested)} as your branch name?`);
+  ${pc17.dim("AI suggestion:")} ${pc17.bold(pc17.cyan(suggested))}`);
+              const accepted = await confirmPrompt(`Use ${pc17.bold(suggested)} as your branch name?`);
               newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
             } else {
               spinner.fail("AI did not return a suggestion.");
@@ -4085,7 +4704,7 @@ var update_default = defineCommand12({
             }
           }
           if (!hasPrefix(newBranchName, config.branchPrefixes)) {
-            const prefix = await selectPrompt(`Choose a branch type for ${pc15.bold(newBranchName)}:`, config.branchPrefixes);
+            const prefix = await selectPrompt(`Choose a branch type for ${pc17.bold(newBranchName)}:`, config.branchPrefixes);
             newBranchName = formatBranchName(prefix, newBranchName);
           }
           if (!isValidBranchName(newBranchName)) {
@@ -4095,7 +4714,7 @@ var update_default = defineCommand12({
           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.`);
+            error(`Branch ${pc17.bold(newBranchName)} already exists. Choose a different name.`);
             process.exit(1);
           }
           const renameResult = await renameBranch(currentBranch, newBranchName);
@@ -4103,7 +4722,7 @@ var update_default = defineCommand12({
             error(`Failed to rename branch: ${renameResult.stderr}`);
             process.exit(1);
           }
-          success(`Renamed ${pc15.bold(currentBranch)} → ${pc15.bold(newBranchName)}`);
+          success(`Renamed ${pc17.bold(currentBranch)} → ${pc17.bold(newBranchName)}`);
           await unsetUpstream();
           await fetchRemote(syncSource.remote);
           let rebaseResult2;
@@ -4115,11 +4734,11 @@ var update_default = defineCommand12({
           }
           if (rebaseResult2.exitCode !== 0) {
             warn("Rebase encountered conflicts. Resolve them manually, then run:");
-            info(`  ${pc15.bold("git rebase --continue")}`);
+            info(`  ${pc17.bold("git rebase --continue")}`);
           } else {
-            success(`Rebased ${pc15.bold(newBranchName)} onto ${pc15.bold(syncSource.ref)}.`);
+            success(`Rebased ${pc17.bold(newBranchName)} onto ${pc17.bold(syncSource.ref)}.`);
           }
-          info(`All your changes are preserved. Run ${pc15.bold("contrib submit")} when ready to create a new PR.`);
+          info(`All your changes are preserved. Run ${pc17.bold("contrib submit")} when ready to create a new PR.`);
           return;
         }
         warn("Discarding local changes...");
@@ -4132,24 +4751,24 @@ var update_default = defineCommand12({
         process.exit(1);
       }
       await updateLocalBranch(baseBranch, syncSource.ref);
-      success(`Synced ${pc15.bold(baseBranch)} with ${pc15.bold(syncSource.ref)}.`);
-      info(`Deleting stale branch ${pc15.bold(currentBranch)}...`);
+      success(`Synced ${pc17.bold(baseBranch)} with ${pc17.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${pc17.bold(currentBranch)}...`);
       await forceDeleteBranch(currentBranch);
-      success(`Deleted ${pc15.bold(currentBranch)}.`);
-      info(`Run ${pc15.bold("contrib start")} to begin a new feature branch.`);
+      success(`Deleted ${pc17.bold(currentBranch)}.`);
+      info(`Run ${pc17.bold("contrib start")} to begin a new feature branch.`);
       return;
     }
-    info(`Updating ${pc15.bold(currentBranch)} with latest ${pc15.bold(baseBranch)}...`);
+    info(`Updating ${pc17.bold(currentBranch)} with latest ${pc17.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
     if (!await refExists(syncSource.ref)) {
-      error(`Remote ref ${pc15.bold(syncSource.ref)} does not exist.`);
+      error(`Remote ref ${pc17.bold(syncSource.ref)} does not exist.`);
       error("Run `git fetch --all` and verify your remote configuration.");
       process.exit(1);
     }
     await updateLocalBranch(baseBranch, syncSource.ref);
     const rebaseStrategy = await determineRebaseStrategy(currentBranch, syncSource.ref);
     if (rebaseStrategy.strategy === "onto" && rebaseStrategy.ontoOldBase) {
-      info(pc15.dim(`Using --onto rebase (branch was based on a different ref)`));
+      info(pc17.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) {
@@ -4178,10 +4797,10 @@ ${content.slice(0, 2000)}
             if (suggestion) {
               spinner.success("AI conflict guidance ready.");
               console.log(`
-${pc15.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(pc15.dim("─".repeat(60)));
+${pc17.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(pc17.dim("─".repeat(60)));
               console.log(suggestion);
-              console.log(pc15.dim("─".repeat(60)));
+              console.log(pc17.dim("─".repeat(60)));
               console.log();
             } else {
               spinner.fail("AI could not analyze the conflicts.");
@@ -4189,22 +4808,22 @@ ${pc15.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
           }
         }
       }
-      console.log(pc15.bold("To resolve:"));
+      console.log(pc17.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${pc15.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${pc15.cyan("git rebase --continue")}`);
+      console.log(`  2. ${pc17.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${pc17.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${pc15.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${pc17.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`✅ ${pc15.bold(currentBranch)} has been rebased onto latest ${pc15.bold(baseBranch)}`);
+    success(`✅ ${pc17.bold(currentBranch)} has been rebased onto latest ${pc17.bold(baseBranch)}`);
   }
 });
 
 // src/commands/validate.ts
-import { defineCommand as defineCommand13 } from "citty";
-import pc16 from "picocolors";
-var validate_default = defineCommand13({
+import { defineCommand as defineCommand15 } from "citty";
+import pc18 from "picocolors";
+var validate_default = defineCommand15({
   meta: {
     name: "validate",
     description: "Validate a commit message against the configured convention"
@@ -4234,7 +4853,7 @@ var validate_default = defineCommand13({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(pc16.red(`  ✗ ${line}`));
+      console.error(pc18.red(`  ✗ ${line}`));
     }
     process.exit(1);
   }
@@ -4242,7 +4861,7 @@ var validate_default = defineCommand13({
 
 // src/ui/banner.ts
 import figlet from "figlet";
-import pc17 from "picocolors";
+import pc19 from "picocolors";
 var LOGO_BIG;
 try {
   LOGO_BIG = figlet.textSync(`Contribute
@@ -4264,14 +4883,14 @@ function getAuthor() {
 }
 function showBanner(variant = "small") {
   const logo = variant === "big" ? LOGO_BIG : LOGO_SMALL;
-  console.log(pc17.cyan(`
+  console.log(pc19.cyan(`
 ${logo}`));
-  console.log(`  ${pc17.dim(`v${getVersion()}`)} ${pc17.dim("—")} ${pc17.dim(`Built by ${getAuthor()}`)}`);
+  console.log(`  ${pc19.dim(`v${getVersion()}`)} ${pc19.dim("—")} ${pc19.dim(`Built by ${getAuthor()}`)}`);
   if (variant === "big") {
     console.log();
-    console.log(`  ${pc17.yellow("Star")}        ${pc17.cyan("https://github.com/warengonzaga/contribute-now")}`);
-    console.log(`  ${pc17.green("Contribute")}  ${pc17.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
-    console.log(`  ${pc17.magenta("Sponsor")}     ${pc17.cyan("https://warengonzaga.com/sponsor")}`);
+    console.log(`  ${pc19.yellow("Star")}        ${pc19.cyan("https://github.com/warengonzaga/contribute-now")}`);
+    console.log(`  ${pc19.green("Contribute")}  ${pc19.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
+    console.log(`  ${pc19.magenta("Sponsor")}     ${pc19.cyan("https://warengonzaga.com/sponsor")}`);
   }
   console.log();
 }
@@ -4286,6 +4905,8 @@ if (!isVersion) {
     "commit",
     "update",
     "submit",
+    "switch",
+    "save",
     "clean",
     "status",
     "log",
@@ -4299,7 +4920,7 @@ if (!isVersion) {
   const useBigBanner = isHelp || !hasSubCommand;
   showBanner(useBigBanner ? "big" : "small");
 }
-var main = defineCommand14({
+var main = defineCommand16({
   meta: {
     name: "contrib",
     version: getVersion(),
@@ -4319,6 +4940,8 @@ var main = defineCommand14({
     commit: commit_default,
     update: update_default,
     submit: submit_default,
+    switch: switch_default,
+    save: save_default,
     branch: branch_default,
     clean: clean_default,
     status: status_default,