contribute-now 0.1.2-staging.c209cc7 → 0.2.0-dev.0de9dbd

package/dist/index.js

@@ -1,11 +1,29 @@
 #!/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";
-import pc3 from "picocolors";
+import pc4 from "picocolors";
+
+// src/utils/branch.ts
+var DEFAULT_PREFIXES = ["feature", "fix", "docs", "chore", "test", "refactor"];
+function hasPrefix(branchName, prefixes = DEFAULT_PREFIXES) {
+  return prefixes.some((p) => branchName.startsWith(`${p}/`));
+}
+function formatBranchName(prefix, name) {
+  const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${prefix}/${sanitized}`;
+}
+function isValidBranchName(name) {
+  return /^[a-zA-Z0-9._/-]+$/.test(name) && !name.startsWith("/") && !name.endsWith("/");
+}
+function looksLikeNaturalLanguage(input) {
+  return input.includes(" ") && !input.includes("/");
+}
 
 // src/utils/config.ts
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -14,13 +32,20 @@ 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))
     return null;
   try {
     const raw = readFileSync(path, "utf-8");
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.workflow !== "string" || typeof parsed.role !== "string" || typeof parsed.mainBranch !== "string" || typeof parsed.upstream !== "string" || typeof parsed.origin !== "string" || !Array.isArray(parsed.branchPrefixes) || typeof parsed.commitConvention !== "string") {
+      return null;
+    }
+    return parsed;
   } catch {
     return null;
   }
@@ -56,187 +81,800 @@ function getDefaultConfig() {
 }
 
 // src/utils/confirm.ts
+import * as clack from "@clack/prompts";
 import pc from "picocolors";
-async function confirmPrompt(message) {
-  console.log(`
-${message}`);
-  process.stdout.write(`${pc.dim("Continue? [y/N] ")}`);
-  const response = await new Promise((resolve) => {
-    process.stdin.setEncoding("utf-8");
-    process.stdin.once("data", (data) => {
-      process.stdin.pause();
-      resolve(data.toString().trim());
-    });
-    process.stdin.resume();
-  });
-  if (response.toLowerCase() !== "y") {
-    console.log(pc.yellow("Aborted."));
-    return false;
+function handleCancel(value) {
+  if (clack.isCancel(value)) {
+    clack.cancel("Cancelled.");
+    process.exit(0);
   }
-  return true;
+}
+async function confirmPrompt(message) {
+  const result = await clack.confirm({ message });
+  handleCancel(result);
+  return result;
 }
 async function selectPrompt(message, choices) {
-  console.log(`
-${message}`);
-  choices.forEach((choice, i) => {
-    console.log(`  ${pc.dim(`${i + 1}.`)} ${choice}`);
-  });
-  process.stdout.write(pc.dim(`Enter number [1-${choices.length}]: `));
-  const response = await new Promise((resolve) => {
-    process.stdin.setEncoding("utf-8");
-    process.stdin.once("data", (data) => {
-      process.stdin.pause();
-      resolve(data.toString().trim());
-    });
-    process.stdin.resume();
+  const result = await clack.select({
+    message,
+    options: choices.map((choice) => ({ value: choice, label: choice }))
   });
-  const index = Number.parseInt(response, 10) - 1;
-  if (index >= 0 && index < choices.length) {
-    return choices[index];
-  }
-  return choices[0];
+  handleCancel(result);
+  return result;
 }
 async function inputPrompt(message, defaultValue) {
-  const hint = defaultValue ? ` ${pc.dim(`[${defaultValue}]`)}` : "";
-  process.stdout.write(`
-${message}${hint}: `);
-  const response = await new Promise((resolve) => {
-    process.stdin.setEncoding("utf-8");
-    process.stdin.once("data", (data) => {
-      process.stdin.pause();
-      resolve(data.toString().trim());
-    });
-    process.stdin.resume();
+  const result = await clack.text({
+    message,
+    placeholder: defaultValue,
+    defaultValue
+  });
+  handleCancel(result);
+  return result || defaultValue || "";
+}
+async function multiSelectPrompt(message, choices) {
+  const result = await clack.multiselect({
+    message: `${message} ${pc.dim("(space to toggle, enter to confirm)")}`,
+    options: choices.map((choice) => ({ value: choice, label: choice })),
+    required: false
   });
-  return response || defaultValue || "";
+  handleCancel(result);
+  return result;
 }
 
-// src/utils/git.ts
-import { execFile as execFileCb } from "node:child_process";
-function run(args) {
-  return new Promise((resolve) => {
-    execFileCb("git", args, (error, stdout, stderr) => {
-      resolve({
-        exitCode: error ? error.code === "ENOENT" ? 127 : error.code != null ? Number(error.code) : 1 : 0,
-        stdout: stdout ?? "",
-        stderr: stderr ?? ""
-      });
+// src/utils/copilot.ts
+import { CopilotClient } from "@github/copilot-sdk";
+var CONVENTIONAL_COMMIT_SYSTEM_PROMPT = `Git commit message generator. Format: <type>[!][(<scope>)]: <description>
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+Rules: breaking (!) only for feat/fix/refactor/perf; imperative mood; max 72 chars; lowercase start; scope optional camelCase/kebab-case. Return ONLY the message line.
+Examples: feat: add user auth | fix(auth): resolve token expiry | feat!: redesign auth API`;
+var CLEAN_COMMIT_SYSTEM_PROMPT = `Git commit message generator. EXACT format: <emoji> <type>[!][ (<scope>)]: <description>
+Spacing: EMOJI SPACE TYPE [SPACE OPENPAREN SCOPE CLOSEPAREN] COLON SPACE DESCRIPTION
+Types: \uD83D\uDCE6 new, \uD83D\uDD27 update, \uD83D\uDDD1️ remove, \uD83D\uDD12 security, ⚙️ setup, ☕ chore, \uD83E\uDDEA test, \uD83D\uDCD6 docs, \uD83D\uDE80 release
+Rules: breaking (!) only for new/update/remove/security; imperative mood; max 72 chars; lowercase start; scope optional. Return ONLY the message line.
+Correct: \uD83D\uDCE6 new: add user auth | \uD83D\uDD27 update (api): improve error handling | ⚙️ setup (ci): configure github actions
+WRONG: ⚙️setup(ci): ... | \uD83D\uDD27 update(api): ... ← always space before scope parenthesis`;
+function getGroupingSystemPrompt(convention) {
+  const conventionBlock = convention === "conventional" ? `Use Conventional Commit format: <type>[(<scope>)]: <description>
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert` : `Use Clean Commit format: <emoji> <type>[!][ (<scope>)]: <description>
+Emoji/type table:
+\uD83D\uDCE6 new, \uD83D\uDD27 update, \uD83D\uDDD1️ remove, \uD83D\uDD12 security, ⚙️ setup, ☕ chore, \uD83E\uDDEA test, \uD83D\uDCD6 docs, \uD83D\uDE80 release`;
+  return `You are a smart commit grouping assistant. Given a list of changed files and their diffs, group related changes into logical atomic commits.
+
+${conventionBlock}
+
+Return a JSON array of commit groups with this EXACT structure (no markdown fences, no explanation):
+[
+  {
+    "files": ["path/to/file1.ts", "path/to/file2.ts"],
+    "message": "<commit message following the convention above>"
+  }
+]
+
+Rules:
+- Group files that are logically related (e.g. a utility and its tests, a feature and its types)
+- Each group should represent ONE logical change
+- Every file must appear in exactly one group
+- Commit messages must follow the convention, be concise, imperative, max 72 chars
+- Order groups so foundational changes come first (types, utils) and consumers come after
+- Return ONLY the JSON array, nothing else`;
+}
+var BRANCH_NAME_SYSTEM_PROMPT = `You are a git branch name generator. Your ONLY job is to output a single git branch name. NOTHING ELSE.
+Output format: <prefix>/<kebab-case-name>
+Valid prefixes: feature, fix, docs, chore, test, refactor
+Rules: lowercase, kebab-case, 2-5 words after the prefix, no punctuation.
+CRITICAL: Output ONLY the branch name on a single line. No explanation. No markdown. No questions. No other text.
+Examples: fix/login-timeout | feature/user-profile-page | docs/update-readme | chore/update-pr-title`;
+var PR_DESCRIPTION_SYSTEM_PROMPT_BASE = `GitHub PR description generator. Return JSON: {"title":"<72 chars>","body":"## Summary\\n...\\n\\n## Changes\\n- ...\\n\\n## Test Plan\\n..."}
+IMPORTANT: The title must capture the overall theme or goal of the PR — NOT enumerate individual changes. Think: what problem does this PR solve or what capability does it add? Keep it focused and specific but high-level.`;
+function getPRDescriptionSystemPrompt(convention) {
+  if (convention === "clean-commit") {
+    return `${PR_DESCRIPTION_SYSTEM_PROMPT_BASE}
+CRITICAL: The PR title MUST follow the Clean Commit format exactly: <emoji> <type>: <description>
+Emoji/type table: \uD83D\uDCE6 new, \uD83D\uDD27 update, \uD83D\uDDD1️ remove, \uD83D\uDD12 security, ⚙️ setup, ☕ chore, \uD83E\uDDEA test, \uD83D\uDCD6 docs, \uD83D\uDE80 release
+Title examples: \uD83D\uDCE6 new: add user authentication | \uD83D\uDD27 update: improve error handling | \uD83D\uDDD1️ remove: drop legacy API
+Rules: title follows convention, present tense, max 72 chars, describes the PR theme not individual commits; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+  }
+  if (convention === "conventional") {
+    return `${PR_DESCRIPTION_SYSTEM_PROMPT_BASE}
+CRITICAL: The PR title MUST follow Conventional Commits format: <type>[(<scope>)]: <description>
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+Title examples: feat: add user authentication | fix(auth): resolve token expiry | docs: update contributing guide
+Rules: title follows convention, present tense, max 72 chars, describes the PR theme not individual commits; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+  }
+  return `${PR_DESCRIPTION_SYSTEM_PROMPT_BASE}
+Rules: title concise present tense, describes the PR theme not individual commits; body has Summary, Changes (bullets), Test Plan sections. Return ONLY the JSON object, no fences.`;
+}
+var CONFLICT_RESOLUTION_SYSTEM_PROMPT = `Git merge conflict advisor. Explain each side, suggest resolution strategy. Never auto-resolve — guidance only. Be concise and actionable.`;
+function suppressSubprocessWarnings() {
+  process.env.NODE_NO_WARNINGS = "1";
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Copilot request timed out after ${ms / 1000}s`)), ms);
+    promise.then((val) => {
+      clearTimeout(timer);
+      resolve(val);
+    }, (err) => {
+      clearTimeout(timer);
+      reject(err);
     });
   });
 }
-async function isGitRepo() {
-  const { exitCode } = await run(["rev-parse", "--is-inside-work-tree"]);
-  return exitCode === 0;
-}
-async function getCurrentBranch() {
-  const { exitCode, stdout } = await run(["rev-parse", "--abbrev-ref", "HEAD"]);
-  if (exitCode !== 0)
+var COPILOT_TIMEOUT_MS = 30000;
+var COPILOT_LONG_TIMEOUT_MS = 90000;
+async function checkCopilotAvailable() {
+  try {
+    const client = await getManagedClient();
+    try {
+      await client.ping();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("auth") || msg.includes("token") || msg.includes("401") || msg.includes("403")) {
+        return "Copilot authentication failed. Run `gh auth login` to refresh your token.";
+      }
+      if (msg.includes("ECONNREFUSED") || msg.includes("timeout") || msg.includes("network")) {
+        return "Could not reach GitHub Copilot service. Check your internet connection.";
+      }
+      return `Copilot health check failed: ${msg}`;
+    }
     return null;
-  return stdout.trim() || null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("ENOENT") || msg.includes("not found")) {
+      return "Copilot CLI binary not found. Ensure GitHub Copilot is installed and your gh CLI is up to date.";
+    }
+    return `Failed to start Copilot service: ${msg}`;
+  }
 }
-async function getRemotes() {
-  const { exitCode, stdout } = await run(["remote"]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).map((r) => r.trim()).filter(Boolean);
+var _managedClient = null;
+var _clientStarted = false;
+async function getManagedClient() {
+  if (!_managedClient || !_clientStarted) {
+    suppressSubprocessWarnings();
+    _managedClient = new CopilotClient;
+    await _managedClient.start();
+    _clientStarted = true;
+    const cleanup = () => {
+      if (_managedClient && _clientStarted) {
+        try {
+          _managedClient.stop();
+        } catch {}
+        _clientStarted = false;
+        _managedClient = null;
+      }
+    };
+    process.once("exit", cleanup);
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
+  }
+  return _managedClient;
 }
-async function getRemoteUrl(remote) {
-  const { exitCode, stdout } = await run(["remote", "get-url", remote]);
-  if (exitCode !== 0)
+async function callCopilot(systemMessage, userMessage, model, timeoutMs = COPILOT_TIMEOUT_MS) {
+  const client = await getManagedClient();
+  const sessionConfig = {
+    systemMessage: { mode: "replace", content: systemMessage }
+  };
+  if (model)
+    sessionConfig.model = model;
+  const session = await client.createSession(sessionConfig);
+  try {
+    const response = await withTimeout(session.sendAndWait({ prompt: userMessage }), timeoutMs);
+    if (!response?.data?.content)
+      return null;
+    return response.data.content;
+  } finally {
+    await session.destroy();
+  }
+}
+function getCommitSystemPrompt(convention) {
+  if (convention === "conventional")
+    return CONVENTIONAL_COMMIT_SYSTEM_PROMPT;
+  return CLEAN_COMMIT_SYSTEM_PROMPT;
+}
+function extractJson(raw) {
+  let text2 = raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+  if (text2.startsWith("[") || text2.startsWith("{"))
+    return text2;
+  const arrayStart = text2.indexOf("[");
+  const objStart = text2.indexOf("{");
+  let start;
+  let closeChar;
+  if (arrayStart === -1 && objStart === -1)
+    return text2;
+  if (arrayStart === -1) {
+    start = objStart;
+    closeChar = "}";
+  } else if (objStart === -1) {
+    start = arrayStart;
+    closeChar = "]";
+  } else if (arrayStart < objStart) {
+    start = arrayStart;
+    closeChar = "]";
+  } else {
+    start = objStart;
+    closeChar = "}";
+  }
+  const end = text2.lastIndexOf(closeChar);
+  if (end > start) {
+    text2 = text2.slice(start, end + 1);
+  }
+  return text2;
+}
+async function generateCommitMessage(diff, stagedFiles, model, convention = "clean-commit") {
+  try {
+    const multiFileHint = stagedFiles.length > 1 ? `
+
+IMPORTANT: Multiple files are staged. Generate ONE commit message that captures the high-level purpose of ALL changes together. Focus on the overall intent, not individual file changes. Be specific but concise — do not list every file.` : "";
+    const userMessage = `Generate a commit message for these staged changes:
+
+Files: ${stagedFiles.join(", ")}
+
+Diff:
+${diff.slice(0, 4000)}${multiFileHint}`;
+    const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model);
+    return result?.trim() ?? null;
+  } catch {
     return null;
-  return stdout.trim() || null;
+  }
 }
-async function hasUncommittedChanges() {
-  const { exitCode, stdout } = await run(["status", "--porcelain"]);
-  if (exitCode !== 0)
-    return false;
-  return stdout.trim().length > 0;
+async function generatePRDescription(commits, diff, model, convention = "clean-commit") {
+  try {
+    const userMessage = `Generate a PR description for these changes:
+
+Commits:
+${commits.join(`
+`)}
+
+Diff (truncated):
+${diff.slice(0, 4000)}`;
+    const result = await callCopilot(getPRDescriptionSystemPrompt(convention), userMessage, model);
+    if (!result)
+      return null;
+    const cleaned = extractJson(result);
+    return JSON.parse(cleaned);
+  } catch {
+    return null;
+  }
 }
-async function fetchRemote(remote) {
-  return run(["fetch", remote]);
+async function suggestBranchName(description, model) {
+  try {
+    const result = await callCopilot(BRANCH_NAME_SYSTEM_PROMPT, description, model);
+    const trimmed = result?.trim() ?? null;
+    if (trimmed && /^[a-z]+\/[a-z0-9-]+$/.test(trimmed)) {
+      return trimmed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
 }
-async function fetchAll() {
-  return run(["fetch", "--all", "--quiet"]);
+async function suggestConflictResolution(conflictDiff, model) {
+  try {
+    const userMessage = `Help me resolve this merge conflict:
+
+${conflictDiff.slice(0, 4000)}`;
+    const result = await callCopilot(CONFLICT_RESOLUTION_SYSTEM_PROMPT, userMessage, model);
+    return result?.trim() ?? null;
+  } catch {
+    return null;
+  }
 }
-async function checkoutBranch(branch) {
-  return run(["checkout", branch]);
+async function generateCommitGroups(files, diffs, model, convention = "clean-commit") {
+  const userMessage = `Group these changed files into logical atomic commits:
+
+Files:
+${files.join(`
+`)}
+
+Diffs (truncated):
+${diffs.slice(0, 6000)}`;
+  const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+  if (!result) {
+    throw new Error("AI returned an empty response");
+  }
+  const cleaned = extractJson(result);
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    throw new Error(`AI response is not valid JSON. Raw start: "${result.slice(0, 120)}..."`);
+  }
+  const groups = parsed;
+  if (!Array.isArray(groups) || groups.length === 0) {
+    throw new Error("AI response was not a valid JSON array of commit groups");
+  }
+  for (const group of groups) {
+    if (!Array.isArray(group.files) || typeof group.message !== "string") {
+      throw new Error("AI returned groups with invalid structure (missing files or message)");
+    }
+  }
+  return groups;
 }
-async function createBranch(branch, from) {
-  const args = from ? ["checkout", "-b", branch, from] : ["checkout", "-b", branch];
-  return run(args);
+async function regenerateAllGroupMessages(groups, diffs, model, convention = "clean-commit") {
+  const groupSummary = groups.map((g, i) => `Group ${i + 1}: [${g.files.join(", ")}]`).join(`
+`);
+  const userMessage = `Regenerate ONLY the commit messages for these pre-defined file groups. Do NOT change the file groupings.
+
+Groups:
+${groupSummary}
+
+Diffs (truncated):
+${diffs.slice(0, 6000)}`;
+  const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+  if (!result)
+    return groups;
+  try {
+    const cleaned = extractJson(result);
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed) || parsed.length !== groups.length)
+      return groups;
+    return groups.map((g, i) => ({
+      files: g.files,
+      message: typeof parsed[i]?.message === "string" ? parsed[i].message : g.message
+    }));
+  } catch {
+    return groups;
+  }
 }
-async function resetHard(ref) {
-  return run(["reset", "--hard", ref]);
+async function regenerateGroupMessage(files, diffs, model, convention = "clean-commit") {
+  try {
+    const userMessage = `Generate a single commit message for these files:
+
+Files: ${files.join(", ")}
+
+Diff:
+${diffs.slice(0, 4000)}`;
+    const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model);
+    return result?.trim() ?? null;
+  } catch {
+    return null;
+  }
 }
-async function pushSetUpstream(remote, branch) {
-  return run(["push", "-u", remote, branch]);
+
+// src/utils/gh.ts
+import { execFile as execFileCb } from "node:child_process";
+function run(args) {
+  return new Promise((resolve) => {
+    execFileCb("gh", args, (error, stdout, stderr) => {
+      resolve({
+        exitCode: error ? error.code === "ENOENT" ? 127 : error.status ?? 1 : 0,
+        stdout: stdout ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
 }
-async function rebase(branch) {
-  return run(["rebase", branch]);
+async function checkGhInstalled() {
+  try {
+    const { exitCode } = await run(["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
 }
-async function getStagedDiff() {
-  const { stdout } = await run(["diff", "--cached"]);
-  return stdout;
+async function checkGhAuth() {
+  try {
+    const { exitCode } = await run(["auth", "status"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
 }
-async function getStagedFiles() {
-  const { exitCode, stdout } = await run(["diff", "--cached", "--name-only"]);
+var SAFE_SLUG = /^[\w.-]+$/;
+async function checkRepoPermissions(owner, repo) {
+  if (!SAFE_SLUG.test(owner) || !SAFE_SLUG.test(repo))
+    return null;
+  const { exitCode, stdout } = await run(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
   if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).filter(Boolean);
+    return null;
+  try {
+    return JSON.parse(stdout.trim());
+  } catch {
+    return null;
+  }
 }
-async function getChangedFiles() {
-  const { exitCode, stdout } = await run(["status", "--porcelain"]);
+async function isRepoFork() {
+  const { exitCode, stdout } = await run(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
   if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).filter(Boolean).map((l) => l.slice(3));
+    return null;
+  const val = stdout.trim();
+  if (val === "true")
+    return true;
+  if (val === "false")
+    return false;
+  return null;
 }
-async function getDivergence(branch, base) {
+async function getCurrentRepoInfo() {
   const { exitCode, stdout } = await run([
-    "rev-list",
-    "--left-right",
-    "--count",
-    `${base}...${branch}`
+    "repo",
+    "view",
+    "--json",
+    "nameWithOwner",
+    "-q",
+    ".nameWithOwner"
   ]);
   if (exitCode !== 0)
-    return { ahead: 0, behind: 0 };
-  const parts = stdout.trim().split(/\s+/);
-  return {
-    behind: Number.parseInt(parts[0] ?? "0", 10),
-    ahead: Number.parseInt(parts[1] ?? "0", 10)
-  };
-}
-async function getMergedBranches(base) {
-  const { exitCode, stdout } = await run(["branch", "--merged", base]);
-  if (exitCode !== 0)
-    return [];
-  return stdout.trim().split(`
-`).map((b) => b.replace(/^\*?\s+/, "").trim()).filter(Boolean);
+    return null;
+  const nameWithOwner = stdout.trim();
+  if (!nameWithOwner)
+    return null;
+  const [owner, repo] = nameWithOwner.split("/");
+  if (!owner || !repo)
+    return null;
+  return { owner, repo };
+}
+async function createPR(options) {
+  const args = [
+    "pr",
+    "create",
+    "--base",
+    options.base,
+    "--title",
+    options.title,
+    "--body",
+    options.body
+  ];
+  if (options.draft)
+    args.push("--draft");
+  return run(args);
+}
+async function createPRFill(base, draft) {
+  const args = ["pr", "create", "--base", base, "--fill"];
+  if (draft)
+    args.push("--draft");
+  return run(args);
+}
+async function getPRForBranch(headBranch) {
+  const { exitCode, stdout } = await run([
+    "pr",
+    "list",
+    "--head",
+    headBranch,
+    "--state",
+    "open",
+    "--json",
+    "number,url,title,state",
+    "--limit",
+    "1"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    const prs = JSON.parse(stdout.trim());
+    return prs.length > 0 ? prs[0] : null;
+  } catch {
+    return null;
+  }
+}
+async function getMergedPRForBranch(headBranch) {
+  const { exitCode, stdout } = await run([
+    "pr",
+    "list",
+    "--head",
+    headBranch,
+    "--state",
+    "merged",
+    "--json",
+    "number,url,title,state",
+    "--limit",
+    "1"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    const prs = JSON.parse(stdout.trim());
+    return prs.length > 0 ? prs[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/git.ts
+import { execFile as execFileCb2 } from "node:child_process";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function run2(args) {
+  return new Promise((resolve) => {
+    execFileCb2("git", args, (error, stdout, stderr) => {
+      resolve({
+        exitCode: error ? error.code === "ENOENT" ? 127 : error.status ?? 1 : 0,
+        stdout: stdout ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
+}
+async function isGitRepo() {
+  const { exitCode } = await run2(["rev-parse", "--is-inside-work-tree"]);
+  return exitCode === 0;
+}
+async function getCurrentBranch() {
+  const { exitCode, stdout } = await run2(["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function getRemotes() {
+  const { exitCode, stdout } = await run2(["remote"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).map((r) => r.trim()).filter(Boolean);
+}
+async function getRemoteUrl(remote) {
+  const { exitCode, stdout } = await run2(["remote", "get-url", remote]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function hasUncommittedChanges() {
+  const { exitCode, stdout } = await run2(["status", "--porcelain"]);
+  if (exitCode !== 0)
+    return false;
+  return stdout.trim().length > 0;
+}
+async function fetchRemote(remote) {
+  return run2(["fetch", remote]);
+}
+async function fetchAll() {
+  return run2(["fetch", "--all", "--quiet"]);
+}
+async function checkoutBranch2(branch) {
+  return run2(["checkout", branch]);
+}
+async function createBranch(branch, from) {
+  const args = from ? ["checkout", "-b", branch, from] : ["checkout", "-b", branch];
+  return run2(args);
+}
+async function resetHard(ref) {
+  return run2(["reset", "--hard", ref]);
+}
+async function updateLocalBranch(branch, target) {
+  const current = await getCurrentBranch();
+  if (current === branch) {
+    return resetHard(target);
+  }
+  return run2(["branch", "-f", branch, target]);
+}
+async function pushSetUpstream(remote, branch) {
+  return run2(["push", "-u", remote, branch]);
+}
+async function rebase(branch) {
+  return run2(["rebase", branch]);
+}
+async function getUpstreamRef() {
+  const { exitCode, stdout } = await run2([
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{u}"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function unsetUpstream() {
+  return run2(["branch", "--unset-upstream"]);
+}
+async function rebaseOnto(newBase, oldBase) {
+  return run2(["rebase", "--onto", newBase, oldBase]);
+}
+async function getMergeBase(ref1, ref2) {
+  const { exitCode, stdout } = await run2(["merge-base", ref1, ref2]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function getCommitHash(ref) {
+  const { exitCode, stdout } = await run2(["rev-parse", ref]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function determineRebaseStrategy(currentBranch, syncRef) {
+  const upstreamRef = await getUpstreamRef();
+  if (!upstreamRef) {
+    return { strategy: "plain" };
+  }
+  const upstreamHash = await getCommitHash(upstreamRef);
+  if (!upstreamHash) {
+    return { strategy: "plain" };
+  }
+  const slashIdx = upstreamRef.indexOf("/");
+  const upstreamBranchName = slashIdx !== -1 ? upstreamRef.slice(slashIdx + 1) : upstreamRef;
+  if (upstreamBranchName === currentBranch) {
+    return { strategy: "plain" };
+  }
+  const [forkFromUpstream, forkFromSync] = await Promise.all([
+    getMergeBase("HEAD", upstreamRef),
+    getMergeBase("HEAD", syncRef)
+  ]);
+  if (forkFromUpstream && forkFromSync && forkFromUpstream === forkFromSync) {
+    return { strategy: "plain" };
+  }
+  if (forkFromUpstream) {
+    return { strategy: "onto", ontoOldBase: forkFromUpstream };
+  }
+  return { strategy: "plain" };
+}
+async function getStagedDiff() {
+  const { stdout } = await run2(["diff", "--cached"]);
+  return stdout;
+}
+async function getStagedFiles() {
+  const { exitCode, stdout } = await run2(["diff", "--cached", "--name-only"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).filter(Boolean);
+}
+async function getChangedFiles() {
+  const { exitCode, stdout } = await run2(["status", "--porcelain"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter(Boolean).map((l) => {
+    const line = l.replace(/\r$/, "");
+    const match = line.match(/^..\s+(.*)/);
+    if (!match)
+      return "";
+    const file = match[1];
+    const renameIdx = file.indexOf(" -> ");
+    return renameIdx !== -1 ? file.slice(renameIdx + 4) : file;
+  }).filter(Boolean);
+}
+async function getDivergence(branch, base) {
+  const { exitCode, stdout } = await run2([
+    "rev-list",
+    "--left-right",
+    "--count",
+    `${base}...${branch}`
+  ]);
+  if (exitCode !== 0)
+    return { ahead: 0, behind: 0 };
+  const parts = stdout.trim().split(/\s+/);
+  return {
+    behind: Number.parseInt(parts[0] ?? "0", 10),
+    ahead: Number.parseInt(parts[1] ?? "0", 10)
+  };
+}
+async function getMergedBranches(base) {
+  const { exitCode, stdout } = await run2(["branch", "--merged", base]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).map((b) => b.replace(/^\*?\s+/, "").trim()).filter(Boolean);
+}
+async function getGoneBranches() {
+  const { exitCode, stdout } = await run2(["branch", "-vv"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter((line) => line.includes(": gone]")).map((line) => line.replace(/^\*?\s+/, "").split(/\s+/)[0]).filter(Boolean);
 }
 async function deleteBranch(branch) {
-  return run(["branch", "-d", branch]);
+  return run2(["branch", "-d", branch]);
+}
+async function forceDeleteBranch(branch) {
+  return run2(["branch", "-D", branch]);
+}
+async function renameBranch(oldName, newName) {
+  return run2(["branch", "-m", oldName, newName]);
+}
+async function hasLocalWork(remote, branch) {
+  const uncommitted = await hasUncommittedChanges();
+  const trackingRef = `${remote}/${branch}`;
+  const { exitCode, stdout } = await run2(["rev-list", "--count", `${trackingRef}..${branch}`]);
+  const unpushedCommits = exitCode === 0 ? Number.parseInt(stdout.trim(), 10) || 0 : 0;
+  return { uncommitted, unpushedCommits };
+}
+async function deleteRemoteBranch(remote, branch) {
+  return run2(["push", remote, "--delete", branch]);
+}
+async function mergeSquash(branch) {
+  return run2(["merge", "--squash", branch]);
+}
+async function pushBranch(remote, branch) {
+  return run2(["push", remote, branch]);
 }
 async function pruneRemote(remote) {
-  return run(["remote", "prune", remote]);
+  return run2(["remote", "prune", remote]);
 }
 async function commitWithMessage(message) {
-  return run(["commit", "-m", message]);
+  return run2(["commit", "-m", message]);
 }
 async function getLogDiff(base, head) {
-  const { stdout } = await run(["diff", `${base}...${head}`]);
+  const { stdout } = await run2(["diff", `${base}...${head}`]);
   return stdout;
 }
 async function getLog(base, head) {
-  const { exitCode, stdout } = await run(["log", `${base}..${head}`, "--oneline"]);
+  const { exitCode, stdout } = await run2(["log", `${base}..${head}`, "--oneline"]);
   if (exitCode !== 0)
     return [];
   return stdout.trim().split(`
 `).filter(Boolean);
 }
 async function pullBranch(remote, branch) {
-  return run(["pull", remote, branch]);
+  return run2(["pull", remote, branch]);
+}
+async function stageFiles(files) {
+  return run2(["add", "--", ...files]);
+}
+async function unstageFiles(files) {
+  return run2(["reset", "HEAD", "--", ...files]);
+}
+async function stageAll() {
+  return run2(["add", "-A"]);
+}
+async function getFullDiffForFiles(files) {
+  const [unstaged, staged, untracked] = await Promise.all([
+    run2(["diff", "--", ...files]),
+    run2(["diff", "--cached", "--", ...files]),
+    getUntrackedFiles()
+  ]);
+  const parts = [staged.stdout, unstaged.stdout].filter(Boolean);
+  const untrackedSet = new Set(untracked);
+  const MAX_FILE_CONTENT = 2000;
+  for (const file of files) {
+    if (untrackedSet.has(file)) {
+      try {
+        const content = readFileSync2(join2(process.cwd(), file), "utf-8");
+        const truncated = content.length > MAX_FILE_CONTENT ? `${content.slice(0, MAX_FILE_CONTENT)}
+... (truncated)` : content;
+        const lines = truncated.split(`
+`).map((l) => `+${l}`);
+        parts.push(`diff --git a/${file} b/${file}
+new file
+--- /dev/null
++++ b/${file}
+${lines.join(`
+`)}`);
+      } catch {}
+    }
+  }
+  return parts.join(`
+`);
+}
+async function getUntrackedFiles() {
+  const { exitCode, stdout } = await run2(["ls-files", "--others", "--exclude-standard"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).filter(Boolean);
+}
+async function getFileStatus() {
+  const { exitCode, stdout } = await run2(["status", "--porcelain"]);
+  if (exitCode !== 0)
+    return { staged: [], modified: [], untracked: [] };
+  const result = { staged: [], modified: [], untracked: [] };
+  const STATUS_LABELS = {
+    A: "new file",
+    M: "modified",
+    D: "deleted",
+    R: "renamed",
+    C: "copied",
+    T: "type changed"
+  };
+  for (const raw of stdout.trimEnd().split(`
+`).filter(Boolean)) {
+    const line = raw.replace(/\r$/, "");
+    const indexStatus = line[0];
+    const workTreeStatus = line[1];
+    const pathPart = line.slice(3);
+    const renameIdx = pathPart.indexOf(" -> ");
+    const file = renameIdx !== -1 ? pathPart.slice(renameIdx + 4) : pathPart;
+    if (indexStatus === "?" && workTreeStatus === "?") {
+      result.untracked.push(file);
+      continue;
+    }
+    if (indexStatus && indexStatus !== " " && indexStatus !== "?") {
+      result.staged.push({ file, status: STATUS_LABELS[indexStatus] ?? indexStatus });
+    }
+    if (workTreeStatus && workTreeStatus !== " " && workTreeStatus !== "?") {
+      result.modified.push({ file, status: STATUS_LABELS[workTreeStatus] ?? workTreeStatus });
+    }
+  }
+  return result;
 }
 
 // src/utils/logger.ts
@@ -267,6 +905,53 @@ function heading(msg) {
 ${pc2.bold(msg)}`);
 }
 
+// src/utils/spinner.ts
+import pc3 from "picocolors";
+var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function createSpinner(text2) {
+  let frameIdx = 0;
+  let currentText = text2;
+  let stopped = false;
+  const clearLine = () => {
+    process.stderr.write("\r\x1B[K");
+  };
+  const render = () => {
+    if (stopped)
+      return;
+    const frame = pc3.cyan(FRAMES[frameIdx % FRAMES.length]);
+    clearLine();
+    process.stderr.write(`${frame} ${currentText}`);
+    frameIdx++;
+  };
+  const timer = setInterval(render, 80);
+  render();
+  const stop = () => {
+    if (stopped)
+      return;
+    stopped = true;
+    clearInterval(timer);
+    clearLine();
+  };
+  return {
+    update(newText) {
+      currentText = newText;
+    },
+    success(msg) {
+      stop();
+      process.stderr.write(`${pc3.green("✔")} ${msg}
+`);
+    },
+    fail(msg) {
+      stop();
+      process.stderr.write(`${pc3.red("✖")} ${msg}
+`);
+    },
+    stop() {
+      stop();
+    }
+  };
+}
+
 // src/utils/workflow.ts
 var WORKFLOW_DESCRIPTIONS = {
   "clean-flow": "Clean Flow — main + dev, squash features into dev, merge dev into main",
@@ -315,6 +1000,91 @@ function getProtectedBranches(config) {
 }
 
 // src/commands/clean.ts
+async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
+  if (!config)
+    return "skipped";
+  const { origin } = config;
+  const localWork = await hasLocalWork(origin, currentBranch);
+  const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
+  if (hasWork) {
+    if (localWork.uncommitted) {
+      warn("You have uncommitted changes in your working tree.");
+    }
+    if (localWork.unpushedCommits > 0) {
+      warn(`You have ${pc4.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not pushed.`);
+    }
+    const SAVE_NEW_BRANCH = "Save changes to a new branch";
+    const DISCARD = "Discard all changes and clean up";
+    const CANCEL = "Skip this branch";
+    const action = await selectPrompt(`${pc4.bold(currentBranch)} has local changes. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
+    if (action === CANCEL)
+      return "skipped";
+    if (action === SAVE_NEW_BRANCH) {
+      if (!config)
+        return "skipped";
+      info(pc4.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
+      const description = await inputPrompt("What are you working on?");
+      let newBranchName = description;
+      if (looksLikeNaturalLanguage(description)) {
+        const spinner = createSpinner("Generating branch name suggestion...");
+        const suggested = await suggestBranchName(description);
+        if (suggested) {
+          spinner.success("Branch name suggestion ready.");
+          console.log(`
+  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(suggested))}`);
+          const accepted = await confirmPrompt(`Use ${pc4.bold(suggested)} as your branch name?`);
+          newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
+        } else {
+          spinner.fail("AI did not return a suggestion.");
+          newBranchName = await inputPrompt("Enter branch name", description);
+        }
+      }
+      if (!hasPrefix(newBranchName, config.branchPrefixes)) {
+        const prefix = await selectPrompt(`Choose a branch type for ${pc4.bold(newBranchName)}:`, config.branchPrefixes);
+        newBranchName = formatBranchName(prefix, newBranchName);
+      }
+      if (!isValidBranchName(newBranchName)) {
+        error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
+        return "skipped";
+      }
+      const renameResult = await renameBranch(currentBranch, newBranchName);
+      if (renameResult.exitCode !== 0) {
+        error(`Failed to rename branch: ${renameResult.stderr}`);
+        return "skipped";
+      }
+      success(`Renamed ${pc4.bold(currentBranch)} → ${pc4.bold(newBranchName)}`);
+      const syncSource2 = getSyncSource(config);
+      await fetchRemote(syncSource2.remote);
+      const savedUpstreamRef = await getUpstreamRef();
+      const rebaseResult = savedUpstreamRef && savedUpstreamRef !== syncSource2.ref ? await rebaseOnto(syncSource2.ref, savedUpstreamRef) : await rebase(syncSource2.ref);
+      if (rebaseResult.exitCode !== 0) {
+        warn("Rebase encountered conflicts. Resolve them after cleanup:");
+        info(`  ${pc4.bold(`git checkout ${newBranchName} && git rebase --continue`)}`);
+      } else {
+        success(`Rebased ${pc4.bold(newBranchName)} onto ${pc4.bold(syncSource2.ref)}.`);
+      }
+      const coResult2 = await checkoutBranch(baseBranch);
+      if (coResult2.exitCode !== 0) {
+        error(`Failed to checkout ${baseBranch}: ${coResult2.stderr}`);
+        return "saved";
+      }
+      await updateLocalBranch(baseBranch, syncSource2.ref);
+      success(`Synced ${pc4.bold(baseBranch)} with ${pc4.bold(syncSource2.ref)}.`);
+      return "saved";
+    }
+  }
+  const syncSource = getSyncSource(config);
+  info(`Switching to ${pc4.bold(baseBranch)} and syncing...`);
+  await fetchRemote(syncSource.remote);
+  const coResult = await checkoutBranch(baseBranch);
+  if (coResult.exitCode !== 0) {
+    error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
+    return "skipped";
+  }
+  await updateLocalBranch(baseBranch, syncSource.ref);
+  success(`Synced ${pc4.bold(baseBranch)} with ${pc4.bold(syncSource.ref)}.`);
+  return "switched";
+}
 var clean_default = defineCommand({
   meta: {
     name: "clean",
@@ -340,47 +1110,114 @@ var clean_default = defineCommand({
     }
     const { origin } = config;
     const baseBranch = getBaseBranch(config);
-    const currentBranch = await getCurrentBranch();
+    let currentBranch = await getCurrentBranch();
     heading("\uD83E\uDDF9 contrib clean");
-    const mergedBranches = await getMergedBranches(baseBranch);
-    const protectedBranches = new Set([...getProtectedBranches(config), currentBranch ?? ""]);
-    const candidates = mergedBranches.filter((b) => !protectedBranches.has(b));
-    if (candidates.length === 0) {
-      info("No merged branches to clean up.");
+    info(`Pruning ${origin} remote refs...`);
+    const pruneResult = await pruneRemote(origin);
+    if (pruneResult.exitCode === 0) {
+      success(`Pruned ${origin} remote refs.`);
     } else {
+      warn(`Could not prune remote: ${pruneResult.stderr.trim()}`);
+    }
+    const protectedBranches = new Set(getProtectedBranches(config));
+    const mergedBranches = await getMergedBranches(baseBranch);
+    const mergedCandidates = mergedBranches.filter((b) => !protectedBranches.has(b));
+    const goneBranches = await getGoneBranches();
+    const goneCandidates = goneBranches.filter((b) => !protectedBranches.has(b) && !mergedCandidates.includes(b));
+    if (currentBranch && !protectedBranches.has(currentBranch) && !mergedCandidates.includes(currentBranch) && !goneCandidates.includes(currentBranch)) {
+      const ghInstalled = await checkGhInstalled();
+      const ghAuthed = ghInstalled && await checkGhAuth();
+      if (ghInstalled && ghAuthed) {
+        const mergedPR = await getMergedPRForBranch(currentBranch);
+        if (mergedPR) {
+          warn(`PR #${mergedPR.number} (${pc4.bold(mergedPR.title)}) has already been merged.`);
+          info(`Link: ${pc4.underline(mergedPR.url)}`);
+          goneCandidates.push(currentBranch);
+        }
+      }
+    }
+    if (mergedCandidates.length > 0) {
       console.log(`
-${pc3.bold("Branches to delete:")}`);
-      for (const b of candidates) {
-        console.log(`  ${pc3.dim("•")} ${b}`);
+${pc4.bold("Merged branches to delete:")}`);
+      for (const b of mergedCandidates) {
+        const marker = b === currentBranch ? pc4.yellow(" (current)") : "";
+        console.log(`  ${pc4.dim("•")} ${b}${marker}`);
       }
       console.log();
-      const ok = args.yes || await confirmPrompt(`Delete ${pc3.bold(String(candidates.length))} merged branch${candidates.length !== 1 ? "es" : ""}?`);
-      if (!ok) {
-        info("Skipped branch deletion.");
-      } else {
-        for (const branch of candidates) {
+      const ok = args.yes || await confirmPrompt(`Delete ${pc4.bold(String(mergedCandidates.length))} merged branch${mergedCandidates.length !== 1 ? "es" : ""}?`);
+      if (ok) {
+        for (const branch of mergedCandidates) {
+          if (branch === currentBranch) {
+            const result2 = await handleCurrentBranchDeletion(currentBranch, baseBranch, config);
+            if (result2 === "skipped") {
+              warn(`  Skipped ${branch}.`);
+              continue;
+            }
+            if (result2 === "saved") {
+              currentBranch = baseBranch;
+              continue;
+            }
+            currentBranch = baseBranch;
+          }
           const result = await deleteBranch(branch);
           if (result.exitCode === 0) {
-            success(`  Deleted ${pc3.bold(branch)}`);
+            success(`  Deleted ${pc4.bold(branch)}`);
+          } else {
+            warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
+          }
+        }
+      } else {
+        info("Skipped merged branch deletion.");
+      }
+    }
+    if (goneCandidates.length > 0) {
+      console.log(`
+${pc4.bold("Stale branches (remote deleted, likely squash-merged):")}`);
+      for (const b of goneCandidates) {
+        const marker = b === currentBranch ? pc4.yellow(" (current)") : "";
+        console.log(`  ${pc4.dim("•")} ${b}${marker}`);
+      }
+      console.log();
+      const ok = args.yes || await confirmPrompt(`Delete ${pc4.bold(String(goneCandidates.length))} stale branch${goneCandidates.length !== 1 ? "es" : ""}?`);
+      if (ok) {
+        for (const branch of goneCandidates) {
+          if (branch === currentBranch) {
+            const result2 = await handleCurrentBranchDeletion(currentBranch, baseBranch, config);
+            if (result2 === "skipped") {
+              warn(`  Skipped ${branch}.`);
+              continue;
+            }
+            if (result2 === "saved") {
+              currentBranch = baseBranch;
+              continue;
+            }
+            currentBranch = baseBranch;
+          }
+          const result = await forceDeleteBranch(branch);
+          if (result.exitCode === 0) {
+            success(`  Deleted ${pc4.bold(branch)}`);
           } else {
             warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
           }
         }
+      } else {
+        info("Skipped stale branch deletion.");
       }
     }
-    info(`Pruning ${origin} remote refs...`);
-    const pruneResult = await pruneRemote(origin);
-    if (pruneResult.exitCode === 0) {
-      success(`✅ Pruned ${origin} remote refs.`);
-    } else {
-      warn(`Could not prune remote: ${pruneResult.stderr.trim()}`);
+    if (mergedCandidates.length === 0 && goneCandidates.length === 0) {
+      info("No branches to clean up. Everything is tidy! \uD83E\uDDF9");
+    }
+    const finalBranch = await getCurrentBranch();
+    if (finalBranch && protectedBranches.has(finalBranch)) {
+      console.log();
+      info(`You're on ${pc4.bold(finalBranch)}. Run ${pc4.bold("contrib start")} to begin a new feature.`);
     }
   }
 });
 
 // src/commands/commit.ts
 import { defineCommand as defineCommand2 } from "citty";
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 
 // src/utils/convention.ts
 var CLEAN_COMMIT_PATTERN = /^(📦|🔧|🗑\uFE0F?|🔒|⚙\uFE0F?|☕|🧪|📖|🚀) (new|update|remove|security|setup|chore|test|docs|release)(!?)( \([a-zA-Z0-9][a-zA-Z0-9-]*\))?: .{1,72}$/u;
@@ -425,339 +1262,734 @@ function getValidationError(convention) {
   ];
 }
 
-// src/utils/copilot.ts
-import { CopilotClient } from "@github/copilot-sdk";
-var CONVENTIONAL_COMMIT_SYSTEM_PROMPT = `You are a git commit message generator. Generate a Conventional Commit message following this exact format:
-<type>[!][(<scope>)]: <description>
-
-Types:
-feat     – a new feature
-fix      – a bug fix
-docs     – documentation only changes
-style    – changes that do not affect code meaning (whitespace, formatting)
-refactor – code change that neither fixes a bug nor adds a feature
-perf     – performance improvement
-test     – adding or correcting tests
-build    – changes to the build system or external dependencies
-ci       – changes to CI configuration files and scripts
-chore    – other changes that don't modify src or test files
-revert   – reverts a previous commit
-
-Rules:
-- Breaking change (!) only for: feat, fix, refactor, perf
-- Description: concise, imperative mood, max 72 chars, lowercase start
-- Scope: optional, camelCase or kebab-case component name
-- Return ONLY the commit message line, nothing else
-
-Examples:
-feat: add user authentication system
-fix(auth): resolve token expiry issue
-docs: update contributing guidelines
-feat!: redesign authentication API`;
-var CLEAN_COMMIT_SYSTEM_PROMPT = `You are a git commit message generator. Generate a Clean Commit message following this exact format:
-<emoji> <type>[!][(<scope>)]: <description>
-
-Emoji and type table:
-\uD83D\uDCE6 new      – new features, files, or capabilities
-\uD83D\uDD27 update   – changes, refactoring, improvements
-\uD83D\uDDD1️ remove   – removing code, files, or dependencies
-\uD83D\uDD12 security – security fixes or patches
-⚙️ setup    – configs, CI/CD, tooling, build systems
-☕ chore    – maintenance, dependency updates
-\uD83E\uDDEA test     – adding or updating tests
-\uD83D\uDCD6 docs     – documentation changes
-\uD83D\uDE80 release  – version releases
-
-Rules:
-- Breaking change (!) only for: new, update, remove, security
-- Description: concise, imperative mood, max 72 chars
-- Scope: optional, camelCase or kebab-case component name
-- Return ONLY the commit message line, nothing else
-
-Examples:
-\uD83D\uDCE6 new: user authentication system
-\uD83D\uDD27 update (api): improve error handling
-⚙️ setup (ci): configure github actions workflow
-\uD83D\uDCE6 new!: completely redesign authentication system`;
-var BRANCH_NAME_SYSTEM_PROMPT = `You are a git branch name generator. Convert natural language descriptions into proper git branch names.
-
-Format: <prefix>/<kebab-case-name>
-Prefixes: feature, fix, docs, chore, test, refactor
-
-Rules:
-- Use lowercase kebab-case for the name part
-- Keep it short and descriptive (2-5 words max)
-- Return ONLY the branch name, nothing else
-
-Examples:
-Input: "fix the login timeout bug" → fix/login-timeout
-Input: "add user profile page" → feature/user-profile-page
-Input: "update readme documentation" → docs/update-readme`;
-var PR_DESCRIPTION_SYSTEM_PROMPT = `You are a GitHub pull request description generator. Create a clear, structured PR description.
-
-Return a JSON object with this exact structure:
-{
-  "title": "Brief PR title (50 chars max)",
-  "body": "## Summary\\n...\\n\\n## Changes\\n...\\n\\n## Test Plan\\n..."
-}
-
-Rules:
-- title: concise, present tense, describes what the PR does
-- body: markdown with Summary, Changes (bullet list), and Test Plan sections
-- Return ONLY the JSON object, no markdown fences, no extra text`;
-var CONFLICT_RESOLUTION_SYSTEM_PROMPT = `You are a git merge conflict resolution advisor. Analyze the conflict markers and provide guidance.
-
-Rules:
-- Explain what each side of the conflict contains
-- Suggest the most likely correct resolution strategy
-- Never auto-resolve — provide guidance only
-- Be concise and actionable`;
-async function checkCopilotAvailable() {
-  let client = null;
-  try {
-    client = new CopilotClient;
-    await client.start();
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("ENOENT") || msg.includes("not found")) {
-      return "Copilot CLI binary not found. Ensure GitHub Copilot is installed and your gh CLI is up to date.";
+// src/commands/commit.ts
+var commit_default = defineCommand2({
+  meta: {
+    name: "commit",
+    description: "Stage changes and create a commit message (AI-powered)"
+  },
+  args: {
+    model: {
+      type: "string",
+      description: "AI model to use for commit message generation"
+    },
+    "no-ai": {
+      type: "boolean",
+      description: "Skip AI and write commit message manually",
+      default: false
+    },
+    group: {
+      type: "boolean",
+      description: "AI groups related changes into separate atomic commits",
+      default: false
     }
-    return `Failed to start Copilot service: ${msg}`;
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    heading("\uD83D\uDCBE contrib commit");
+    if (args.group) {
+      await runGroupCommit(args.model, config);
+      return;
+    }
+    let stagedFiles = await getStagedFiles();
+    if (stagedFiles.length === 0) {
+      const changedFiles = await getChangedFiles();
+      if (changedFiles.length === 0) {
+        error("No changes to commit.");
+        process.exit(1);
+      }
+      console.log(`
+${pc5.bold("Changed files:")}`);
+      for (const f of changedFiles) {
+        console.log(`  ${pc5.dim("•")} ${f}`);
+      }
+      const stageAction = await selectPrompt("No staged changes. How would you like to stage?", [
+        "Stage all changes",
+        "Select files to stage",
+        "Cancel"
+      ]);
+      if (stageAction === "Cancel") {
+        process.exit(0);
+      }
+      if (stageAction === "Stage all changes") {
+        const result2 = await stageAll();
+        if (result2.exitCode !== 0) {
+          error(`Failed to stage files: ${result2.stderr}`);
+          process.exit(1);
+        }
+        success("Staged all changes.");
+      } else {
+        const selected = await multiSelectPrompt("Select files to stage:", changedFiles);
+        if (selected.length === 0) {
+          error("No files selected.");
+          process.exit(1);
+        }
+        const result2 = await stageFiles(selected);
+        if (result2.exitCode !== 0) {
+          error(`Failed to stage files: ${result2.stderr}`);
+          process.exit(1);
+        }
+        success(`Staged ${selected.length} file(s).`);
+      }
+      stagedFiles = await getStagedFiles();
+      if (stagedFiles.length === 0) {
+        error("No staged changes after staging attempt.");
+        process.exit(1);
+      }
+    }
+    info(`Staged files: ${stagedFiles.join(", ")}`);
+    let commitMessage = null;
+    const useAI = !args["no-ai"];
+    if (useAI) {
+      const [copilotError, diff] = await Promise.all([checkCopilotAvailable(), getStagedDiff()]);
+      if (copilotError) {
+        warn(`AI unavailable: ${copilotError}`);
+        warn("Falling back to manual commit message entry.");
+      } else {
+        const spinner = createSpinner("Generating commit message with AI...");
+        commitMessage = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
+        if (commitMessage) {
+          spinner.success("AI commit message generated.");
+          console.log(`
+  ${pc5.dim("AI suggestion:")} ${pc5.bold(pc5.cyan(commitMessage))}`);
+        } else {
+          spinner.fail("AI did not return a commit message.");
+          warn("Falling back to manual entry.");
+        }
+      }
+    }
+    let finalMessage = null;
+    if (commitMessage) {
+      const action = await selectPrompt("What would you like to do?", [
+        "Accept this message",
+        "Edit this message",
+        "Regenerate",
+        "Write manually"
+      ]);
+      if (action === "Accept this message") {
+        finalMessage = commitMessage;
+      } else if (action === "Edit this message") {
+        finalMessage = await inputPrompt("Edit commit message", commitMessage);
+      } else if (action === "Regenerate") {
+        const spinner = createSpinner("Regenerating commit message...");
+        const diff = await getStagedDiff();
+        const regen = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
+        if (regen) {
+          spinner.success("Commit message regenerated.");
+          console.log(`
+  ${pc5.dim("AI suggestion:")} ${pc5.bold(pc5.cyan(regen))}`);
+          const ok = await confirmPrompt("Use this message?");
+          finalMessage = ok ? regen : await inputPrompt("Enter commit message manually");
+        } else {
+          spinner.fail("Regeneration failed.");
+          finalMessage = await inputPrompt("Enter commit message");
+        }
+      } else {
+        finalMessage = await inputPrompt("Enter commit message");
+      }
+    } else {
+      const convention2 = config.commitConvention;
+      if (convention2 !== "none") {
+        console.log();
+        for (const hint of CONVENTION_FORMAT_HINTS[convention2]) {
+          console.log(pc5.dim(hint));
+        }
+        console.log();
+      }
+      finalMessage = await inputPrompt("Enter commit message");
+    }
+    if (!finalMessage) {
+      error("No commit message provided.");
+      process.exit(1);
+    }
+    const convention = config.commitConvention;
+    if (!validateCommitMessage(finalMessage, convention)) {
+      for (const line of getValidationError(convention)) {
+        warn(line);
+      }
+      const proceed = await confirmPrompt("Commit anyway?");
+      if (!proceed)
+        process.exit(1);
+    }
+    const result = await commitWithMessage(finalMessage);
+    if (result.exitCode !== 0) {
+      error(`Failed to commit: ${result.stderr}`);
+      process.exit(1);
+    }
+    success(`✅ Committed: ${pc5.bold(finalMessage)}`);
+  }
+});
+async function runGroupCommit(model, config) {
+  const [copilotError, changedFiles] = await Promise.all([
+    checkCopilotAvailable(),
+    getChangedFiles()
+  ]);
+  if (copilotError) {
+    error(`AI is required for --group mode but unavailable: ${copilotError}`);
+    process.exit(1);
+  }
+  if (changedFiles.length === 0) {
+    error("No changes to group-commit.");
+    process.exit(1);
   }
+  console.log(`
+${pc5.bold("Changed files:")}`);
+  for (const f of changedFiles) {
+    console.log(`  ${pc5.dim("•")} ${f}`);
+  }
+  const spinner = createSpinner(`Asking AI to group ${changedFiles.length} file(s) into logical commits...`);
+  const diffs = await getFullDiffForFiles(changedFiles);
+  if (!diffs.trim()) {
+    spinner.stop();
+    warn("Could not retrieve diff context for any files. AI needs diffs to produce groups.");
+  }
+  let groups;
   try {
-    await client.ping();
+    groups = await generateCommitGroups(changedFiles, diffs, model, config.commitConvention);
+    spinner.success(`AI generated ${groups.length} commit group(s).`);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("auth") || msg.includes("token") || msg.includes("401") || msg.includes("403")) {
-      return "Copilot authentication failed. Run `gh auth login` to refresh your token.";
+    const reason = err instanceof Error ? err.message : String(err);
+    spinner.fail(`AI grouping failed: ${reason}`);
+    process.exit(1);
+  }
+  if (groups.length === 0) {
+    error("AI could not produce commit groups. Try committing files manually.");
+    process.exit(1);
+  }
+  const changedSet = new Set(changedFiles);
+  for (const group of groups) {
+    const invalid = group.files.filter((f) => !changedSet.has(f));
+    if (invalid.length > 0) {
+      warn(`AI suggested unknown file(s): ${invalid.join(", ")} — removed from group.`);
     }
-    if (msg.includes("ECONNREFUSED") || msg.includes("timeout") || msg.includes("network")) {
-      return "Could not reach GitHub Copilot service. Check your internet connection.";
+    group.files = group.files.filter((f) => changedSet.has(f));
+  }
+  let validGroups = groups.filter((g) => g.files.length > 0);
+  if (validGroups.length === 0) {
+    error("No valid groups remain after validation. Try committing files manually.");
+    process.exit(1);
+  }
+  let proceedToCommit = false;
+  let commitAll = false;
+  while (!proceedToCommit) {
+    console.log(`
+${pc5.bold(`AI suggested ${validGroups.length} commit group(s):`)}
+`);
+    for (let i = 0;i < validGroups.length; i++) {
+      const g = validGroups[i];
+      console.log(`  ${pc5.cyan(`Group ${i + 1}:`)} ${pc5.bold(g.message)}`);
+      for (const f of g.files) {
+        console.log(`    ${pc5.dim("•")} ${f}`);
+      }
+      console.log();
     }
-    return `Copilot health check failed: ${msg}`;
-  } finally {
-    try {
-      await client.stop();
-    } catch {}
+    const summaryAction = await selectPrompt("What would you like to do?", [
+      "Commit all",
+      "Review each group",
+      "Regenerate all messages",
+      "Cancel"
+    ]);
+    if (summaryAction === "Cancel") {
+      warn("Group commit cancelled.");
+      process.exit(0);
+    }
+    if (summaryAction === "Regenerate all messages") {
+      const regenSpinner = createSpinner("Regenerating all commit messages...");
+      try {
+        validGroups = await regenerateAllGroupMessages(validGroups, diffs, model, config.commitConvention);
+        regenSpinner.success("All commit messages regenerated.");
+      } catch {
+        regenSpinner.fail("Failed to regenerate messages. Keeping current ones.");
+      }
+      continue;
+    }
+    proceedToCommit = true;
+    commitAll = summaryAction === "Commit all";
   }
-  return null;
-}
-async function callCopilot(systemMessage, userMessage, model) {
-  const client = new CopilotClient;
-  await client.start();
-  try {
-    const sessionConfig = {
-      systemMessage: { content: systemMessage }
-    };
-    if (model)
-      sessionConfig.model = model;
-    const session = await client.createSession(sessionConfig);
-    try {
-      const response = await session.sendAndWait({ content: userMessage });
-      if (!response?.data?.content)
-        return null;
-      return response.data.content;
-    } finally {
-      await session.destroy();
+  let committed = 0;
+  if (commitAll) {
+    for (let i = 0;i < validGroups.length; i++) {
+      const group = validGroups[i];
+      const stageResult = await stageFiles(group.files);
+      if (stageResult.exitCode !== 0) {
+        error(`Failed to stage group ${i + 1}: ${stageResult.stderr}`);
+        continue;
+      }
+      const commitResult = await commitWithMessage(group.message);
+      if (commitResult.exitCode !== 0) {
+        const detail = (commitResult.stderr || commitResult.stdout).trim();
+        error(`Failed to commit group ${i + 1}: ${detail}`);
+        await unstageFiles(group.files);
+        continue;
+      }
+      committed++;
+      success(`✅ Committed group ${i + 1}: ${pc5.bold(group.message)}`);
+    }
+  } else {
+    for (let i = 0;i < validGroups.length; i++) {
+      const group = validGroups[i];
+      console.log(pc5.bold(`
+── Group ${i + 1}/${validGroups.length} ──`));
+      console.log(`  ${pc5.cyan(group.message)}`);
+      for (const f of group.files) {
+        console.log(`  ${pc5.dim("•")} ${f}`);
+      }
+      let message = group.message;
+      let actionDone = false;
+      while (!actionDone) {
+        const action = await selectPrompt("Action for this group:", [
+          "Commit as-is",
+          "Edit message and commit",
+          "Regenerate message",
+          "Skip this group"
+        ]);
+        if (action === "Skip this group") {
+          warn(`Skipped group ${i + 1}.`);
+          actionDone = true;
+          continue;
+        }
+        if (action === "Regenerate message") {
+          const regenSpinner = createSpinner("Regenerating commit message for this group...");
+          const newMsg = await regenerateGroupMessage(group.files, diffs, model, config.commitConvention);
+          if (newMsg) {
+            message = newMsg;
+            group.message = newMsg;
+            regenSpinner.success(`New message: ${pc5.bold(message)}`);
+          } else {
+            regenSpinner.fail("AI could not generate a new message. Keeping current one.");
+          }
+          continue;
+        }
+        if (action === "Edit message and commit") {
+          message = await inputPrompt("Edit commit message", message);
+          if (!message) {
+            warn(`Skipped group ${i + 1} (empty message).`);
+            actionDone = true;
+            continue;
+          }
+        }
+        if (!validateCommitMessage(message, config.commitConvention)) {
+          for (const line of getValidationError(config.commitConvention)) {
+            warn(line);
+          }
+          const proceed = await confirmPrompt("Commit anyway?");
+          if (!proceed) {
+            warn(`Skipped group ${i + 1}.`);
+            actionDone = true;
+            continue;
+          }
+        }
+        const stageResult = await stageFiles(group.files);
+        if (stageResult.exitCode !== 0) {
+          error(`Failed to stage group ${i + 1}: ${stageResult.stderr}`);
+          actionDone = true;
+          continue;
+        }
+        const commitResult = await commitWithMessage(message);
+        if (commitResult.exitCode !== 0) {
+          const detail = (commitResult.stderr || commitResult.stdout).trim();
+          error(`Failed to commit group ${i + 1}: ${detail}`);
+          await unstageFiles(group.files);
+          actionDone = true;
+          continue;
+        }
+        committed++;
+        success(`✅ Committed group ${i + 1}: ${pc5.bold(message)}`);
+        actionDone = true;
+      }
     }
-  } finally {
-    await client.stop();
   }
+  if (committed === 0) {
+    warn("No groups were committed.");
+  } else {
+    success(`
+\uD83C\uDF89 ${committed} of ${validGroups.length} group(s) committed successfully.`);
+  }
+  process.exit(0);
 }
-function getCommitSystemPrompt(convention) {
-  if (convention === "conventional")
-    return CONVENTIONAL_COMMIT_SYSTEM_PROMPT;
-  return CLEAN_COMMIT_SYSTEM_PROMPT;
-}
-async function generateCommitMessage(diff, stagedFiles, model, convention = "clean-commit") {
-  try {
-    const userMessage = `Generate a commit message for these staged changes:
 
-Files: ${stagedFiles.join(", ")}
+// 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.0de9dbd",
+  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"
+  }
+};
 
-Diff:
-${diff.slice(0, 4000)}`;
-    const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model);
-    return result?.trim() ?? null;
-  } catch {
+// 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 generatePRDescription(commits, diff, model) {
+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 {
-    const userMessage = `Generate a PR description for these changes:
-
-Commits:
-${commits.join(`
-`)}
-
-Diff (truncated):
-${diff.slice(0, 4000)}`;
-    const result = await callCopilot(PR_DESCRIPTION_SYSTEM_PROMPT, userMessage, model);
-    if (!result)
-      return null;
-    const cleaned = result.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
-    return JSON.parse(cleaned);
+    await import("@github/copilot-sdk");
+    checks.push({ label: "Copilot SDK importable", ok: true });
   } catch {
-    return null;
+    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 });
+    }
   }
-}
-async function suggestBranchName(description, model) {
-  try {
-    const result = await callCopilot(BRANCH_NAME_SYSTEM_PROMPT, description, model);
-    return result?.trim() ?? null;
-  } catch {
-    return null;
+  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 suggestConflictResolution(conflictDiff, model) {
-  try {
-    const userMessage = `Help me resolve this merge conflict:
-
-${conflictDiff.slice(0, 4000)}`;
-    const result = await callCopilot(CONFLICT_RESOLUTION_SYSTEM_PROMPT, userMessage, model);
-    return result?.trim() ?? null;
-  } catch {
-    return null;
+async function 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 };
 }
-
-// src/commands/commit.ts
-var commit_default = defineCommand2({
+var doctor_default = defineCommand3({
   meta: {
-    name: "commit",
-    description: "Stage changes and create a commit message (AI-powered)"
+    name: "doctor",
+    description: "Diagnose the contribute-now CLI environment and configuration"
   },
   args: {
-    model: {
-      type: "string",
-      description: "AI model to use for commit message generation"
-    },
-    "no-ai": {
+    json: {
       type: "boolean",
-      description: "Skip AI and write commit message manually",
+      description: "Output report as JSON",
       default: false
     }
   },
   async run({ args }) {
-    if (!await isGitRepo()) {
-      error("Not inside a git repository.");
-      process.exit(1);
-    }
-    const config = readConfig();
-    if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
-      process.exit(1);
-    }
-    heading("\uD83D\uDCBE contrib commit");
-    const stagedFiles = await getStagedFiles();
-    if (stagedFiles.length === 0) {
-      const changedFiles = await getChangedFiles();
-      if (changedFiles.length === 0) {
-        error("No changes to commit.");
-        process.exit(1);
-      }
-      console.log(`
-${pc4.bold("Changed files:")}`);
-      for (const f of changedFiles) {
-        console.log(`  ${pc4.dim("•")} ${f}`);
-      }
-      console.log();
-      warn("No staged changes. Stage your files with `git add` and re-run.");
-      process.exit(1);
-    }
-    info(`Staged files: ${stagedFiles.join(", ")}`);
-    let commitMessage = null;
-    const useAI = !args["no-ai"];
-    if (useAI) {
-      const copilotError = await checkCopilotAvailable();
-      if (copilotError) {
-        warn(`AI unavailable: ${copilotError}`);
-        warn("Falling back to manual commit message entry.");
-      } else {
-        info("Generating commit message with AI...");
-        const diff = await getStagedDiff();
-        commitMessage = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
-        if (commitMessage) {
-          console.log(`
-  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(commitMessage))}`);
-        } else {
-          warn("AI did not return a commit message. Falling back to manual entry.");
-        }
-      }
+    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;
     }
-    let finalMessage = null;
-    if (commitMessage) {
-      const action = await selectPrompt("What would you like to do?", [
-        "Accept this message",
-        "Edit this message",
-        "Regenerate",
-        "Write manually"
-      ]);
-      if (action === "Accept this message") {
-        finalMessage = commitMessage;
-      } else if (action === "Edit this message") {
-        finalMessage = await inputPrompt("Edit commit message", commitMessage);
-      } else if (action === "Regenerate") {
-        info("Regenerating...");
-        const diff = await getStagedDiff();
-        const regen = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
-        if (regen) {
-          console.log(`
-  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(regen))}`);
-          const ok = await confirmPrompt("Use this message?");
-          finalMessage = ok ? regen : await inputPrompt("Enter commit message manually");
-        } else {
-          warn("Regeneration failed. Falling back to manual entry.");
-          finalMessage = await inputPrompt("Enter commit message");
-        }
-      } else {
-        finalMessage = await inputPrompt("Enter commit message");
-      }
+    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 {
-      const convention2 = config.commitConvention;
-      if (convention2 !== "none") {
-        console.log();
-        for (const hint of CONVENTION_FORMAT_HINTS[convention2]) {
-          console.log(pc4.dim(hint));
-        }
-        console.log();
+      if (failures.length > 0) {
+        console.log(`  ${pc6.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
       }
-      finalMessage = await inputPrompt("Enter commit message");
-    }
-    if (!finalMessage) {
-      error("No commit message provided.");
-      process.exit(1);
-    }
-    const convention = config.commitConvention;
-    if (!validateCommitMessage(finalMessage, convention)) {
-      for (const line of getValidationError(convention)) {
-        warn(line);
+      if (warnings.length > 0) {
+        console.log(`  ${pc6.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
       }
-      const proceed = await confirmPrompt("Commit anyway?");
-      if (!proceed)
-        process.exit(1);
-    }
-    const result = await commitWithMessage(finalMessage);
-    if (result.exitCode !== 0) {
-      error(`Failed to commit: ${result.stderr}`);
-      process.exit(1);
+      console.log();
     }
-    success(`✅ Committed: ${pc4.bold(finalMessage)}`);
   }
 });
 
 // src/commands/hook.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-import { defineCommand as defineCommand3 } from "citty";
-import pc5 from "picocolors";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { defineCommand as defineCommand4 } from "citty";
+import pc7 from "picocolors";
 var HOOK_MARKER = "# managed by contribute-now";
 function getHooksDir(cwd = process.cwd()) {
-  return join2(cwd, ".git", "hooks");
+  return join3(cwd, ".git", "hooks");
 }
 function getHookPath(cwd = process.cwd()) {
-  return join2(getHooksDir(cwd), "commit-msg");
+  return join3(getHooksDir(cwd), "commit-msg");
 }
 function generateHookScript() {
   return `#!/bin/sh
@@ -774,11 +2006,22 @@ case "$commit_msg" in
   Merge\\ *|fixup!*|squash!*|amend!*) exit 0 ;;
 esac
 
-# Validate using contrib CLI
-npx contrib validate "$commit_msg"
+# Detect available package runner
+if command -v contrib >/dev/null 2>&1; then
+  contrib validate "$commit_msg"
+elif command -v bunx >/dev/null 2>&1; then
+  bunx contrib validate "$commit_msg"
+elif command -v pnpx >/dev/null 2>&1; then
+  pnpx contrib validate "$commit_msg"
+elif command -v npx >/dev/null 2>&1; then
+  npx contrib validate "$commit_msg"
+else
+  echo "Warning: No package runner found. Skipping commit message validation."
+  exit 0
+fi
 `;
 }
-var hook_default = defineCommand3({
+var hook_default = defineCommand4({
   meta: {
     name: "hook",
     description: "Install or uninstall the commit-msg git hook"
@@ -822,155 +2065,43 @@ async function installHook() {
   const hookPath = getHookPath();
   const hooksDir = getHooksDir();
   if (existsSync2(hookPath)) {
-    const existing = readFileSync2(hookPath, "utf-8");
-    if (!existing.includes(HOOK_MARKER)) {
-      error("A commit-msg hook already exists and was not installed by contribute-now.");
-      warn(`Path: ${hookPath}`);
-      warn("Remove it manually or back it up before installing.");
-      process.exit(1);
-    }
-    info("Updating existing contribute-now hook...");
-  }
-  if (!existsSync2(hooksDir)) {
-    mkdirSync(hooksDir, { recursive: true });
-  }
-  writeFileSync2(hookPath, generateHookScript(), { mode: 493 });
-  success(`commit-msg hook installed.`);
-  info(`Convention: ${pc5.bold(CONVENTION_LABELS[config.commitConvention])}`);
-  info(`Path: ${pc5.dim(hookPath)}`);
-}
-async function uninstallHook() {
-  heading("\uD83E\uDE9D hook uninstall");
-  const hookPath = getHookPath();
-  if (!existsSync2(hookPath)) {
-    info("No commit-msg hook found. Nothing to uninstall.");
-    return;
-  }
-  const content = readFileSync2(hookPath, "utf-8");
-  if (!content.includes(HOOK_MARKER)) {
-    error("The commit-msg hook was not installed by contribute-now. Leaving it untouched.");
-    process.exit(1);
-  }
-  rmSync(hookPath);
-  success("commit-msg hook removed.");
-}
-
-// src/commands/setup.ts
-import { defineCommand as defineCommand4 } from "citty";
-import pc6 from "picocolors";
-
-// src/utils/gh.ts
-import { execFile as execFileCb2 } from "node:child_process";
-function run2(args) {
-  return new Promise((resolve) => {
-    execFileCb2("gh", args, (error2, stdout, stderr) => {
-      resolve({
-        exitCode: error2 ? error2.code != null ? Number(error2.code) : 1 : 0,
-        stdout: stdout ?? "",
-        stderr: stderr ?? ""
-      });
-    });
-  });
-}
-async function checkGhInstalled() {
-  try {
-    const { exitCode } = await run2(["--version"]);
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-async function checkGhAuth() {
-  try {
-    const { exitCode } = await run2(["auth", "status"]);
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-async function checkRepoPermissions(owner, repo) {
-  const { exitCode, stdout } = await run2(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
-  if (exitCode !== 0)
-    return null;
-  try {
-    return JSON.parse(stdout.trim());
-  } catch {
-    return null;
-  }
-}
-async function isRepoFork() {
-  const { exitCode, stdout } = await run2(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
-  if (exitCode !== 0)
-    return null;
-  const val = stdout.trim();
-  if (val === "true")
-    return true;
-  if (val === "false")
-    return false;
-  return null;
-}
-async function getCurrentRepoInfo() {
-  const { exitCode, stdout } = await run2([
-    "repo",
-    "view",
-    "--json",
-    "nameWithOwner",
-    "-q",
-    ".nameWithOwner"
-  ]);
-  if (exitCode !== 0)
-    return null;
-  const nameWithOwner = stdout.trim();
-  if (!nameWithOwner)
-    return null;
-  const [owner, repo] = nameWithOwner.split("/");
-  if (!owner || !repo)
-    return null;
-  return { owner, repo };
-}
-async function createPR(options) {
-  const args = [
-    "pr",
-    "create",
-    "--base",
-    options.base,
-    "--title",
-    options.title,
-    "--body",
-    options.body
-  ];
-  if (options.draft)
-    args.push("--draft");
-  return run2(args);
-}
-async function createPRFill(base, draft) {
-  const args = ["pr", "create", "--base", base, "--fill"];
-  if (draft)
-    args.push("--draft");
-  return run2(args);
-}
-
-// src/utils/remote.ts
-function parseRepoFromUrl(url) {
-  const httpsMatch = url.match(/https?:\/\/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?$/);
-  if (httpsMatch) {
-    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+    const existing = readFileSync3(hookPath, "utf-8");
+    if (!existing.includes(HOOK_MARKER)) {
+      error("A commit-msg hook already exists and was not installed by contribute-now.");
+      warn(`Path: ${hookPath}`);
+      warn("Remove it manually or back it up before installing.");
+      process.exit(1);
+    }
+    info("Updating existing contribute-now hook...");
   }
-  const sshMatch = url.match(/git@github\.com:([^/]+)\/([^/.]+?)(?:\.git)?$/);
-  if (sshMatch) {
-    return { owner: sshMatch[1], repo: sshMatch[2] };
+  if (!existsSync2(hooksDir)) {
+    mkdirSync(hooksDir, { recursive: true });
   }
-  return null;
+  writeFileSync2(hookPath, generateHookScript(), { mode: 493 });
+  success(`commit-msg hook installed.`);
+  info(`Convention: ${pc7.bold(CONVENTION_LABELS[config.commitConvention])}`);
+  info(`Path: ${pc7.dim(hookPath)}`);
 }
-async function getRepoInfoFromRemote(remote = "origin") {
-  const url = await getRemoteUrl(remote);
-  if (!url)
-    return null;
-  return parseRepoFromUrl(url);
+async function uninstallHook() {
+  heading("\uD83E\uDE9D hook uninstall");
+  const hookPath = getHookPath();
+  if (!existsSync2(hookPath)) {
+    info("No commit-msg hook found. Nothing to uninstall.");
+    return;
+  }
+  const content = readFileSync3(hookPath, "utf-8");
+  if (!content.includes(HOOK_MARKER)) {
+    error("The commit-msg hook was not installed by contribute-now. Leaving it untouched.");
+    process.exit(1);
+  }
+  rmSync(hookPath);
+  success("commit-msg hook removed.");
 }
 
 // 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)"
@@ -991,7 +2122,7 @@ var setup_default = defineCommand4({
       workflow = "github-flow";
     else if (workflowChoice.startsWith("Git Flow"))
       workflow = "git-flow";
-    info(`Workflow: ${pc6.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
+    info(`Workflow: ${pc8.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
     const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
       `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
       CONVENTION_DESCRIPTIONS.conventional,
@@ -1044,8 +2175,8 @@ var setup_default = defineCommand4({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${pc6.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${pc6.bold(detectedRole)}. Is this correct?`);
+      info(`Detected role: ${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;
@@ -1090,37 +2221,22 @@ var setup_default = defineCommand4({
       warn('  echo ".contributerc.json" >> .gitignore');
     }
     console.log();
-    info(`Workflow: ${pc6.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    info(`Convention: ${pc6.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-    info(`Role: ${pc6.bold(config.role)}`);
+    info(`Workflow: ${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: ${pc6.bold(config.mainBranch)} | Dev: ${pc6.bold(config.devBranch)}`);
+      info(`Main: ${pc8.bold(config.mainBranch)} | Dev: ${pc8.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${pc6.bold(config.mainBranch)}`);
+      info(`Main: ${pc8.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${pc6.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc6.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 pc7 from "picocolors";
-
-// src/utils/branch.ts
-var DEFAULT_PREFIXES = ["feature", "fix", "docs", "chore", "test", "refactor"];
-function hasPrefix(branchName, prefixes = DEFAULT_PREFIXES) {
-  return prefixes.some((p) => branchName.startsWith(`${p}/`));
-}
-function formatBranchName(prefix, name) {
-  const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return `${prefix}/${sanitized}`;
-}
-function looksLikeNaturalLanguage(input) {
-  return input.includes(" ") && !input.includes("/");
-}
-
-// src/commands/start.ts
-var start_default = defineCommand5({
+import { defineCommand as 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"
@@ -1162,40 +2278,47 @@ var start_default = defineCommand5({
     heading("\uD83C\uDF3F contrib start");
     const useAI = !args["no-ai"] && looksLikeNaturalLanguage(branchName);
     if (useAI) {
-      info("Generating branch name suggestion from description...");
+      const spinner = createSpinner("Generating branch name suggestion...");
       const suggested = await suggestBranchName(branchName, args.model);
       if (suggested) {
+        spinner.success("Branch name suggestion ready.");
         console.log(`
-  ${pc7.dim("AI suggestion:")} ${pc7.bold(pc7.cyan(suggested))}`);
-        const accepted = await confirmPrompt(`Use ${pc7.bold(suggested)} as your branch name?`);
+  ${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 {
           branchName = await inputPrompt("Enter branch name", branchName);
         }
+      } else {
+        spinner.fail("AI did not return a branch name suggestion.");
       }
     }
     if (!hasPrefix(branchName, branchPrefixes)) {
-      const prefix = await selectPrompt(`Choose a branch type for ${pc7.bold(branchName)}:`, branchPrefixes);
+      const prefix = await selectPrompt(`Choose a branch type for ${pc9.bold(branchName)}:`, branchPrefixes);
       branchName = formatBranchName(prefix, branchName);
     }
-    info(`Creating branch: ${pc7.bold(branchName)}`);
+    if (!isValidBranchName(branchName)) {
+      error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
+      process.exit(1);
+    }
+    info(`Creating branch: ${pc9.bold(branchName)}`);
     await fetchRemote(syncSource.remote);
-    const resetResult = await resetHard(syncSource.ref);
-    if (resetResult.exitCode !== 0) {}
+    const updateResult = await updateLocalBranch(baseBranch, syncSource.ref);
+    if (updateResult.exitCode !== 0) {}
     const result = await createBranch(branchName, baseBranch);
     if (result.exitCode !== 0) {
       error(`Failed to create branch: ${result.stderr}`);
       process.exit(1);
     }
-    success(`✅ Created ${pc7.bold(branchName)} from latest ${pc7.bold(baseBranch)}`);
+    success(`✅ Created ${pc9.bold(branchName)} from latest ${pc9.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand6 } from "citty";
-import pc8 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"
@@ -1211,17 +2334,17 @@ var status_default = defineCommand6({
       process.exit(1);
     }
     heading("\uD83D\uDCCA contribute-now status");
-    console.log(`  ${pc8.dim("Workflow:")} ${pc8.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    console.log(`  ${pc8.dim("Role:")} ${pc8.bold(config.role)}`);
+    console.log(`  ${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 = await hasUncommittedChanges();
+    const [dirty, fileStatus] = await Promise.all([hasUncommittedChanges(), getFileStatus()]);
     if (dirty) {
-      console.log(`  ${pc8.yellow("⚠")}  ${pc8.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${pc10.yellow("⚠")}  ${pc10.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -1237,31 +2360,131 @@ var status_default = defineCommand6({
     if (currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
       const branchDiv = await getDivergence(currentBranch, baseBranch);
       const branchLine = formatStatus(currentBranch, baseBranch, branchDiv.ahead, branchDiv.behind);
-      console.log(branchLine + pc8.dim(` (current ${pc8.green("*")})`));
+      console.log(branchLine + pc10.dim(` (current ${pc10.green("*")})`));
     } else if (currentBranch) {
-      console.log(pc8.dim(`  (on ${pc8.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(`  ${pc10.green("Staged for commit:")}`);
+        for (const { file, status } of fileStatus.staged) {
+          console.log(`    ${pc10.green("+")} ${pc10.dim(`${status}:`)} ${file}`);
+        }
+      }
+      if (fileStatus.modified.length > 0) {
+        console.log(`  ${pc10.yellow("Unstaged changes:")}`);
+        for (const { file, status } of fileStatus.modified) {
+          console.log(`    ${pc10.yellow("~")} ${pc10.dim(`${status}:`)} ${file}`);
+        }
+      }
+      if (fileStatus.untracked.length > 0) {
+        console.log(`  ${pc10.red("Untracked files:")}`);
+        for (const file of fileStatus.untracked) {
+          console.log(`    ${pc10.red("?")} ${file}`);
+        }
+      }
+    } else if (!dirty) {
+      console.log(`  ${pc10.green("✓")}  ${pc10.dim("Working tree clean")}`);
+    }
+    const tips = [];
+    if (fileStatus.staged.length > 0) {
+      tips.push(`Run ${pc10.bold("contrib commit")} to commit staged changes`);
+    }
+    if (fileStatus.modified.length > 0 || fileStatus.untracked.length > 0) {
+      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 ${pc10.bold("contrib submit")} to push and create/update your PR`);
+      }
+    }
+    if (tips.length > 0) {
+      console.log();
+      console.log(`  ${pc10.dim("\uD83D\uDCA1 Tip:")}`);
+      for (const tip of tips) {
+        console.log(`     ${pc10.dim(tip)}`);
+      }
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = pc8.bold(branch.padEnd(20));
+  const label = pc10.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${pc8.green("✓")}  ${label} ${pc8.dim(`in sync with ${base}`)}`;
+    return `  ${pc10.green("✓")}  ${label} ${pc10.dim(`in sync with ${base}`)}`;
   }
   if (ahead > 0 && behind === 0) {
-    return `  ${pc8.yellow("↑")}  ${label} ${pc8.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 `  ${pc8.red("↓")}  ${label} ${pc8.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+    return `  ${pc10.red("↓")}  ${label} ${pc10.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
   }
-  return `  ${pc8.red("⚡")}  ${label} ${pc8.yellow(`${ahead} ahead`)}${pc8.dim(", ")}${pc8.red(`${behind} behind`)} ${pc8.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 pc9 from "picocolors";
-var submit_default = defineCommand7({
+import { defineCommand as defineCommand8 } from "citty";
+import pc11 from "picocolors";
+async function performSquashMerge(origin, baseBranch, featureBranch, options) {
+  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 ${pc11.bold(featureBranch)} into ${pc11.bold(baseBranch)}...`);
+  const mergeResult = await mergeSquash(featureBranch);
+  if (mergeResult.exitCode !== 0) {
+    error(`Squash merge failed: ${mergeResult.stderr}`);
+    process.exit(1);
+  }
+  let message = options?.defaultMsg;
+  if (!message) {
+    const copilotError = await checkCopilotAvailable();
+    if (!copilotError) {
+      const spinner = createSpinner("Generating AI commit message for squash merge...");
+      const [stagedDiff, stagedFiles] = await Promise.all([getStagedDiff(), getStagedFiles()]);
+      const aiMsg = await generateCommitMessage(stagedDiff, stagedFiles, options?.model, options?.convention ?? "clean-commit");
+      if (aiMsg) {
+        message = aiMsg;
+        spinner.success("AI commit message generated.");
+      } else {
+        spinner.fail("AI did not return a commit message.");
+      }
+    } else {
+      warn(`AI unavailable: ${copilotError}`);
+    }
+  }
+  const fallback = message || `squash merge ${featureBranch}`;
+  const finalMsg = await inputPrompt("Commit message", fallback);
+  const commitResult = await commitWithMessage(finalMsg);
+  if (commitResult.exitCode !== 0) {
+    error(`Commit failed: ${commitResult.stderr}`);
+    process.exit(1);
+  }
+  info(`Pushing ${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 ${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 ${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 ${pc11.bold(featureBranch)} into ${pc11.bold(baseBranch)} and pushed.`);
+  info(`Run ${pc11.bold("contrib start")} to begin a new feature.`);
+}
+var submit_default = defineCommand8({
   meta: {
     name: "submit",
     description: "Push current branch and create a pull request"
@@ -1301,89 +2524,251 @@ var submit_default = defineCommand7({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      error(`Cannot submit ${protectedBranches.map((b) => pc9.bold(b)).join(" or ")} as a PR. Switch to your feature branch.`);
+      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");
-    info(`Pushing ${pc9.bold(currentBranch)} to ${origin}...`);
-    const pushResult = await pushSetUpstream(origin, currentBranch);
-    if (pushResult.exitCode !== 0) {
-      error(`Failed to push: ${pushResult.stderr}`);
-      process.exit(1);
-    }
     const ghInstalled = await checkGhInstalled();
     const ghAuthed = ghInstalled && await checkGhAuth();
-    if (!ghInstalled || !ghAuthed) {
-      const repoInfo = await getRepoInfoFromRemote(origin);
-      if (repoInfo) {
-        const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/compare/${baseBranch}...${currentBranch}?expand=1`;
+    if (ghInstalled && ghAuthed) {
+      const mergedPR = await getMergedPRForBranch(currentBranch);
+      if (mergedPR) {
+        warn(`PR #${mergedPR.number} (${pc11.bold(mergedPR.title)}) was already merged.`);
+        const localWork = await hasLocalWork(origin, currentBranch);
+        const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
+        if (hasWork) {
+          if (localWork.uncommitted) {
+            warn("You have uncommitted changes in your working tree.");
+          }
+          if (localWork.unpushedCommits > 0) {
+            warn(`You have ${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";
+          const CANCEL2 = "Cancel";
+          const action = await selectPrompt("This branch was merged but you have local changes. What would you like to do?", [SAVE_NEW_BRANCH, DISCARD, CANCEL2]);
+          if (action === CANCEL2) {
+            info("No changes made. You are still on your current branch.");
+            return;
+          }
+          if (action === SAVE_NEW_BRANCH) {
+            info(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)) {
+              const spinner = createSpinner("Generating branch name suggestion...");
+              const suggested = await suggestBranchName(description, args.model);
+              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?`);
+                newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
+              } else {
+                spinner.fail("AI did not return a suggestion.");
+                newBranchName = await inputPrompt("Enter branch name", description);
+              }
+            }
+            if (!hasPrefix(newBranchName, config.branchPrefixes)) {
+              const prefix = await selectPrompt(`Choose a branch type for ${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 ${pc11.bold(currentBranch)} → ${pc11.bold(newBranchName)}`);
+            await unsetUpstream();
+            const syncSource2 = getSyncSource(config);
+            info(`Syncing ${pc11.bold(newBranchName)} with latest ${pc11.bold(baseBranch)}...`);
+            await fetchRemote(syncSource2.remote);
+            let rebaseResult;
+            if (staleUpstreamHash) {
+              rebaseResult = await rebaseOnto(syncSource2.ref, staleUpstreamHash);
+            } else {
+              const savedStrategy = await determineRebaseStrategy(newBranchName, syncSource2.ref);
+              rebaseResult = savedStrategy.strategy === "onto" && savedStrategy.ontoOldBase ? await rebaseOnto(syncSource2.ref, savedStrategy.ontoOldBase) : await rebase(syncSource2.ref);
+            }
+            if (rebaseResult.exitCode !== 0) {
+              warn("Rebase encountered conflicts. Resolve them manually, then run:");
+              info(`  ${pc11.bold("git rebase --continue")}`);
+            } else {
+              success(`Rebased ${pc11.bold(newBranchName)} onto ${pc11.bold(syncSource2.ref)}.`);
+            }
+            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 ${pc11.bold(baseBranch)} and syncing...`);
+        await fetchRemote(syncSource.remote);
+        const coResult = await checkoutBranch2(baseBranch);
+        if (coResult.exitCode !== 0) {
+          error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
+          process.exit(1);
+        }
+        await updateLocalBranch(baseBranch, syncSource.ref);
+        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 ${pc11.bold(currentBranch)}.`);
+        } else {
+          warn(`Could not delete branch: ${delResult.stderr.trim()}`);
+        }
         console.log();
-        info("Create your PR manually:");
-        console.log(`  ${pc9.cyan(prUrl)}`);
-      } else {
-        info("gh CLI not available. Create your PR manually on GitHub.");
+        info(`You're now on ${pc11.bold(baseBranch)}. Run ${pc11.bold("contrib start")} to begin a new feature.`);
+        return;
       }
-      return;
     }
     let prTitle = null;
     let prBody = null;
-    if (!args["no-ai"]) {
-      const copilotError = await checkCopilotAvailable();
+    async function tryGenerateAI() {
+      const [copilotError, commits, diff] = await Promise.all([
+        checkCopilotAvailable(),
+        getLog(baseBranch, "HEAD"),
+        getLogDiff(baseBranch, "HEAD")
+      ]);
       if (!copilotError) {
-        info("Generating AI PR description...");
-        const commits = await getLog(baseBranch, "HEAD");
-        const diff = await getLogDiff(baseBranch, "HEAD");
-        const result = await generatePRDescription(commits, diff, args.model);
+        const spinner = createSpinner("Generating AI PR description...");
+        const result = await generatePRDescription(commits, diff, args.model, config.commitConvention);
         if (result) {
           prTitle = result.title;
           prBody = result.body;
+          spinner.success("PR description generated.");
           console.log(`
-  ${pc9.dim("AI title:")} ${pc9.bold(pc9.cyan(prTitle))}`);
+  ${pc11.dim("AI title:")} ${pc11.bold(pc11.cyan(prTitle))}`);
           console.log(`
-${pc9.dim("AI body preview:")}`);
-          console.log(pc9.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 {
-          warn("AI did not return a PR description.");
+          spinner.fail("AI did not return a PR description.");
         }
       } else {
         warn(`AI unavailable: ${copilotError}`);
       }
     }
-    if (prTitle && prBody) {
-      const action = await selectPrompt("What would you like to do with the PR description?", [
-        "Use AI description",
-        "Edit title",
-        "Write manually",
-        "Use gh --fill (auto-fill from commits)"
-      ]);
-      if (action === "Use AI description") {} else if (action === "Edit title") {
-        prTitle = await inputPrompt("PR title", prTitle);
-      } else if (action === "Write manually") {
-        prTitle = await inputPrompt("PR title");
-        prBody = await inputPrompt("PR body (markdown)");
+    if (!args["no-ai"]) {
+      await tryGenerateAI();
+    }
+    const CANCEL = "Cancel";
+    const SQUASH_LOCAL = `Squash merge to ${baseBranch} locally (no PR)`;
+    const REGENERATE = "Regenerate AI description";
+    let submitAction = "cancel";
+    const isMaintainer = config.role === "maintainer";
+    let actionResolved = false;
+    while (!actionResolved) {
+      if (prTitle && prBody) {
+        const choices = ["Use AI description"];
+        if (isMaintainer)
+          choices.push(SQUASH_LOCAL);
+        choices.push("Edit title", "Write manually", "Use gh --fill (auto-fill from commits)", REGENERATE, CANCEL);
+        const action = await selectPrompt("What would you like to do with the PR description?", choices);
+        if (action === CANCEL) {
+          submitAction = "cancel";
+          actionResolved = true;
+        } else if (action === REGENERATE) {
+          prTitle = null;
+          prBody = null;
+          await tryGenerateAI();
+        } else if (action === SQUASH_LOCAL) {
+          submitAction = "squash";
+          actionResolved = true;
+        } else if (action === "Use AI description") {
+          submitAction = "create-pr";
+          actionResolved = true;
+        } else if (action === "Edit title") {
+          prTitle = await inputPrompt("PR title", prTitle);
+          submitAction = "create-pr";
+          actionResolved = true;
+        } else if (action === "Write manually") {
+          prTitle = await inputPrompt("PR title");
+          prBody = await inputPrompt("PR body (markdown)");
+          submitAction = "create-pr";
+          actionResolved = true;
+        } else {
+          submitAction = "fill";
+          actionResolved = true;
+        }
       } else {
-        const fillResult = await createPRFill(baseBranch, args.draft);
-        if (fillResult.exitCode !== 0) {
-          error(`Failed to create PR: ${fillResult.stderr}`);
-          process.exit(1);
+        const choices = [];
+        if (isMaintainer)
+          choices.push(SQUASH_LOCAL);
+        if (!args["no-ai"])
+          choices.push(REGENERATE);
+        choices.push("Write title & body manually", "Use gh --fill (auto-fill from commits)", CANCEL);
+        const action = await selectPrompt("How would you like to create the PR?", choices);
+        if (action === CANCEL) {
+          submitAction = "cancel";
+          actionResolved = true;
+        } else if (action === REGENERATE) {
+          await tryGenerateAI();
+        } else if (action === SQUASH_LOCAL) {
+          submitAction = "squash";
+          actionResolved = true;
+        } else if (action === "Write title & body manually") {
+          prTitle = await inputPrompt("PR title");
+          prBody = await inputPrompt("PR body (markdown)");
+          submitAction = "create-pr";
+          actionResolved = true;
+        } else {
+          submitAction = "fill";
+          actionResolved = true;
         }
-        success(`✅ PR created: ${fillResult.stdout.trim()}`);
-        return;
       }
-    } else {
-      const useManual = await confirmPrompt("Create PR with manual title/body?");
-      if (useManual) {
-        prTitle = await inputPrompt("PR title");
-        prBody = await inputPrompt("PR body (markdown)");
+    }
+    if (submitAction === "cancel") {
+      warn("Submit cancelled.");
+      return;
+    }
+    if (submitAction === "squash") {
+      await performSquashMerge(origin, baseBranch, currentBranch, {
+        defaultMsg: prTitle ?? undefined,
+        model: args.model,
+        convention: config.commitConvention
+      });
+      return;
+    }
+    info(`Pushing ${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.");
@@ -1404,9 +2789,9 @@ ${pc9.dim("AI body preview:")}`);
 });
 
 // src/commands/sync.ts
-import { defineCommand as defineCommand8 } from "citty";
-import pc10 from "picocolors";
-var sync_default = defineCommand8({
+import { defineCommand as defineCommand9 } from "citty";
+import pc12 from "picocolors";
+var sync_default = defineCommand9({
   meta: {
     name: "sync",
     description: "Sync your local branches with the remote"
@@ -1448,16 +2833,16 @@ var sync_default = defineCommand8({
     }
     const div = await getDivergence(baseBranch, syncSource.ref);
     if (div.ahead > 0 || div.behind > 0) {
-      info(`${pc10.bold(baseBranch)} is ${pc10.yellow(`${div.ahead} ahead`)} and ${pc10.red(`${div.behind} behind`)} ${syncSource.ref}`);
+      info(`${pc12.bold(baseBranch)} is ${pc12.yellow(`${div.ahead} ahead`)} and ${pc12.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`${pc10.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 ${pc10.bold(syncSource.ref)} into local ${pc10.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${pc12.bold(syncSource.ref)} into local ${pc12.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
-    const coResult = await checkoutBranch(baseBranch);
+    const coResult = await checkoutBranch2(baseBranch);
     if (coResult.exitCode !== 0) {
       error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
       process.exit(1);
@@ -1471,25 +2856,25 @@ 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 ${pc10.bold(config.mainBranch)}...`);
-        const mainCoResult = await checkoutBranch(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);
           if (mainPullResult.exitCode === 0) {
             success(`✅ ${config.mainBranch} is now in sync with ${origin}/${config.mainBranch}`);
           }
         }
-        await checkoutBranch(baseBranch);
+        await checkoutBranch2(baseBranch);
       }
     }
   }
 });
 
 // src/commands/update.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { defineCommand as defineCommand9 } from "citty";
-import pc11 from "picocolors";
-var update_default = defineCommand9({
+import { readFileSync as readFileSync4 } from "node:fs";
+import { defineCommand as defineCommand10 } from "citty";
+import pc13 from "picocolors";
+var update_default = defineCommand10({
   meta: {
     name: "update",
     description: "Rebase current branch onto the latest base branch"
@@ -1524,7 +2909,7 @@ var update_default = defineCommand9({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      error(`Use \`contrib sync\` to update ${protectedBranches.map((b) => pc11.bold(b)).join(" or ")} branches.`);
+      error(`Use \`contrib sync\` to update ${protectedBranches.map((b) => pc13.bold(b)).join(" or ")} branches.`);
       process.exit(1);
     }
     if (await hasUncommittedChanges()) {
@@ -1532,10 +2917,103 @@ var update_default = defineCommand9({
       process.exit(1);
     }
     heading("\uD83D\uDD03 contrib update");
-    info(`Updating ${pc11.bold(currentBranch)} with latest ${pc11.bold(baseBranch)}...`);
+    const mergedPR = await getMergedPRForBranch(currentBranch);
+    if (mergedPR) {
+      warn(`PR #${mergedPR.number} (${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) {
+        if (localWork.uncommitted) {
+          info("You have uncommitted local changes.");
+        }
+        if (localWork.unpushedCommits > 0) {
+          info(`You have ${localWork.unpushedCommits} unpushed commit(s).`);
+        }
+        const SAVE_NEW_BRANCH = "Save changes to a new branch";
+        const DISCARD = "Discard all changes and clean up";
+        const CANCEL = "Cancel";
+        const action = await selectPrompt(`${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(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)) {
+            const spinner = createSpinner("Generating branch name suggestion...");
+            const suggested = await suggestBranchName(description, args.model);
+            if (suggested) {
+              spinner.success("Branch name suggestion ready.");
+              console.log(`
+  ${pc13.dim("AI suggestion:")} ${pc13.bold(pc13.cyan(suggested))}`);
+              const accepted = await confirmPrompt(`Use ${pc13.bold(suggested)} as your branch name?`);
+              newBranchName = accepted ? suggested : await inputPrompt("Enter branch name", description);
+            } else {
+              spinner.fail("AI did not return a suggestion.");
+              newBranchName = await inputPrompt("Enter branch name", description);
+            }
+          }
+          if (!hasPrefix(newBranchName, config.branchPrefixes)) {
+            const prefix = await selectPrompt(`Choose a branch type for ${pc13.bold(newBranchName)}:`, config.branchPrefixes);
+            newBranchName = formatBranchName(prefix, newBranchName);
+          }
+          if (!isValidBranchName(newBranchName)) {
+            error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
+            process.exit(1);
+          }
+          const staleUpstream = await getUpstreamRef();
+          const staleUpstreamHash = staleUpstream ? await getCommitHash(staleUpstream) : null;
+          const renameResult = await renameBranch(currentBranch, newBranchName);
+          if (renameResult.exitCode !== 0) {
+            error(`Failed to rename branch: ${renameResult.stderr}`);
+            process.exit(1);
+          }
+          success(`Renamed ${pc13.bold(currentBranch)} → ${pc13.bold(newBranchName)}`);
+          await unsetUpstream();
+          await fetchRemote(syncSource.remote);
+          let rebaseResult2;
+          if (staleUpstreamHash) {
+            rebaseResult2 = await rebaseOnto(syncSource.ref, staleUpstreamHash);
+          } else {
+            const savedStrategy = await determineRebaseStrategy(newBranchName, syncSource.ref);
+            rebaseResult2 = savedStrategy.strategy === "onto" && savedStrategy.ontoOldBase ? await rebaseOnto(syncSource.ref, savedStrategy.ontoOldBase) : await rebase(syncSource.ref);
+          }
+          if (rebaseResult2.exitCode !== 0) {
+            warn("Rebase encountered conflicts. Resolve them manually, then run:");
+            info(`  ${pc13.bold("git rebase --continue")}`);
+          } else {
+            success(`Rebased ${pc13.bold(newBranchName)} onto ${pc13.bold(syncSource.ref)}.`);
+          }
+          info(`All your changes are preserved. Run ${pc13.bold("contrib submit")} when ready to create a new PR.`);
+          return;
+        }
+        warn("Discarding local changes...");
+      }
+      await fetchRemote(syncSource.remote);
+      const coResult = await checkoutBranch2(baseBranch);
+      if (coResult.exitCode !== 0) {
+        error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
+        process.exit(1);
+      }
+      await updateLocalBranch(baseBranch, syncSource.ref);
+      success(`Synced ${pc13.bold(baseBranch)} with ${pc13.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${pc13.bold(currentBranch)}...`);
+      await forceDeleteBranch(currentBranch);
+      success(`Deleted ${pc13.bold(currentBranch)}.`);
+      info(`Run ${pc13.bold("contrib start")} to begin a new feature branch.`);
+      return;
+    }
+    info(`Updating ${pc13.bold(currentBranch)} with latest ${pc13.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
-    await resetHard(syncSource.ref);
-    const rebaseResult = await rebase(baseBranch);
+    await updateLocalBranch(baseBranch, 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();
@@ -1547,7 +3025,7 @@ var update_default = defineCommand9({
           let conflictDiff = "";
           for (const file of conflictFiles.slice(0, 3)) {
             try {
-              const content = readFileSync3(file, "utf-8");
+              const content = readFileSync4(file, "utf-8");
               if (content.includes("<<<<<<<")) {
                 conflictDiff += `
 --- ${file} ---
@@ -1557,34 +3035,38 @@ ${content.slice(0, 2000)}
             } catch {}
           }
           if (conflictDiff) {
+            const spinner = createSpinner("Analyzing conflicts with AI...");
             const suggestion = await suggestConflictResolution(conflictDiff, args.model);
             if (suggestion) {
+              spinner.success("AI conflict guidance ready.");
               console.log(`
-${pc11.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(pc11.dim("─".repeat(60)));
+${pc13.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(pc13.dim("─".repeat(60)));
               console.log(suggestion);
-              console.log(pc11.dim("─".repeat(60)));
+              console.log(pc13.dim("─".repeat(60)));
               console.log();
+            } else {
+              spinner.fail("AI could not analyze the conflicts.");
             }
           }
         }
       }
-      console.log(pc11.bold("To resolve:"));
+      console.log(pc13.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${pc11.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${pc11.cyan("git rebase --continue")}`);
+      console.log(`  2. ${pc13.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${pc13.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${pc11.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${pc13.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`✅ ${pc11.bold(currentBranch)} has been rebased onto latest ${pc11.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 pc12 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"
@@ -1614,7 +3096,7 @@ var validate_default = defineCommand10({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(pc12.red(`  ✗ ${line}`));
+      console.error(pc14.red(`  ✗ ${line}`));
     }
     process.exit(1);
   }
@@ -1622,75 +3104,13 @@ var validate_default = defineCommand10({
 
 // src/ui/banner.ts
 import figlet from "figlet";
-import pc13 from "picocolors";
-// package.json
-var package_default = {
-  name: "contribute-now",
-  version: "0.1.2-staging.c209cc7",
-  description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
-  type: "module",
-  bin: {
-    contrib: "dist/index.js",
-    contribute: "dist/index.js"
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    build: "bun build src/index.ts --outfile dist/index.js --target node --packages external",
-    dev: "bun src/index.ts",
-    test: "bun test",
-    lint: "biome check .",
-    "lint:fix": "biome check --write .",
-    format: "biome format --write .",
-    prepare: "husky || true",
-    "www:dev": "bun run --cwd www dev",
-    "www:build": "bun run --cwd www build",
-    "www:preview": "bun run --cwd www preview"
-  },
-  engines: {
-    node: ">=18",
-    bun: ">=1.0"
-  },
-  keywords: [
-    "git",
-    "workflow",
-    "squash-merge",
-    "sync",
-    "cli",
-    "contribute",
-    "fork",
-    "dev-branch",
-    "clean-commit"
-  ],
-  author: "Waren Gonzaga",
-  license: "GPL-3.0",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/warengonzaga/contribute-now.git"
-  },
-  dependencies: {
-    "@github/copilot-sdk": "^0.1.25",
-    "@wgtechlabs/log-engine": "^2.3.1",
-    citty: "^0.1.6",
-    figlet: "^1.10.0",
-    picocolors: "^1.1.1"
-  },
-  devDependencies: {
-    "@biomejs/biome": "^2.4.4",
-    "@types/bun": "latest",
-    "@types/figlet": "^1.7.0",
-    husky: "^9.1.7",
-    typescript: "^5.7.0"
-  }
-};
-
-// src/ui/banner.ts
+import pc15 from "picocolors";
 var LOGO;
 try {
-  LOGO = figlet.textSync("contrib", { font: "ANSI Shadow" });
+  LOGO = figlet.textSync(`Contribute
+Now`, { font: "ANSI Shadow" });
 } catch {
-  LOGO = "contribute-now";
+  LOGO = "Contribute Now";
 }
 function getVersion() {
   return package_default.version ?? "unknown";
@@ -1698,16 +3118,15 @@ function getVersion() {
 function getAuthor() {
   return typeof package_default.author === "string" ? package_default.author : "unknown";
 }
-function showBanner(minimal = false) {
-  console.log(pc13.cyan(`
+function showBanner(showLinks = false) {
+  console.log(pc15.cyan(`
 ${LOGO}`));
-  console.log(`  ${pc13.dim(`v${getVersion()}`)} ${pc13.dim("—")} ${pc13.dim(`Built by ${getAuthor()}`)}`);
-  if (!minimal) {
-    console.log(`  ${pc13.dim(package_default.description)}`);
+  console.log(`  ${pc15.dim(`v${getVersion()}`)} ${pc15.dim("—")} ${pc15.dim(`Built by ${getAuthor()}`)}`);
+  if (showLinks) {
     console.log();
-    console.log(`  ${pc13.yellow("Star")}        ${pc13.cyan("https://github.com/warengonzaga/contribute-now")}`);
-    console.log(`  ${pc13.green("Contribute")}  ${pc13.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
-    console.log(`  ${pc13.magenta("Sponsor")}     ${pc13.cyan("https://warengonzaga.com/sponsor")}`);
+    console.log(`  ${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();
 }
@@ -1715,7 +3134,7 @@ ${LOGO}`));
 // src/index.ts
 var isHelp = process.argv.includes("--help") || process.argv.includes("-h");
 showBanner(isHelp);
-var main = defineCommand11({
+var main = defineCommand12({
   meta: {
     name: "contrib",
     version: getVersion(),
@@ -1738,7 +3157,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) {
@@ -1746,4 +3166,6 @@ var main = defineCommand11({
     }
   }
 });
-runMain(main);
+runMain(main).then(() => {
+  process.exit(0);
+});