contribute-now 0.1.2 → 0.2.0-dev.33be40f

package/dist/index.js

@@ -1,11 +1,27 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { defineCommand as defineCommand9, runMain } from "citty";
+import { defineCommand as defineCommand11, 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";
@@ -20,7 +36,11 @@ function readConfig(cwd = process.cwd()) {
     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;
   }
@@ -44,78 +64,515 @@ function isGitignored(cwd = process.cwd()) {
 }
 function getDefaultConfig() {
   return {
+    workflow: "clean-flow",
     role: "contributor",
     mainBranch: "main",
     devBranch: "dev",
     upstream: "upstream",
     origin: "origin",
-    branchPrefixes: ["feature", "fix", "docs", "chore", "test", "refactor"]
+    branchPrefixes: ["feature", "fix", "docs", "chore", "test", "refactor"],
+    commitConvention: "clean-commit"
   };
 }
 
 // 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}`);
+  const result = await clack.select({
+    message,
+    options: choices.map((choice) => ({ value: choice, label: 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();
+  handleCancel(result);
+  return result;
+}
+async function inputPrompt(message, defaultValue) {
+  const result = await clack.text({
+    message,
+    placeholder: defaultValue,
+    defaultValue
+  });
+  handleCancel(result);
+  return result || defaultValue || "";
+}
+async function multiSelectPrompt(message, choices) {
+  const result = await clack.multiselect({
+    message: `${message} ${pc.dim("(space to toggle, enter to confirm)")}`,
+    options: choices.map((choice) => ({ value: choice, label: choice })),
+    required: false
   });
-  const index = Number.parseInt(response, 10) - 1;
-  if (index >= 0 && index < choices.length) {
-    return choices[index];
+  handleCancel(result);
+  return result;
+}
+
+// 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>"
   }
-  return choices[0];
+]
+
+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`;
 }
-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());
+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);
     });
-    process.stdin.resume();
   });
-  return response || defaultValue || "";
 }
+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;
+  } 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}`;
+  }
+}
+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 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 ? `
 
-// src/utils/git.ts
+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;
+  }
+}
+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 suggestBranchName(description, model) {
+  try {
+    const result = await callCopilot(BRANCH_NAME_SYSTEM_PROMPT, description, model);
+    const trimmed = result?.trim() ?? null;
+    if (trimmed && /^[a-z]+\/[a-z0-9-]+$/.test(trimmed)) {
+      return trimmed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function suggestConflictResolution(conflictDiff, model) {
+  try {
+    const userMessage = `Help me resolve this merge conflict:
+
+${conflictDiff.slice(0, 4000)}`;
+    const result = await callCopilot(CONFLICT_RESOLUTION_SYSTEM_PROMPT, userMessage, model);
+    return result?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+async function generateCommitGroups(files, diffs, model, convention = "clean-commit") {
+  const userMessage = `Group these changed files into logical atomic commits:
+
+Files:
+${files.join(`
+`)}
+
+Diffs (truncated):
+${diffs.slice(0, 6000)}`;
+  const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+  if (!result) {
+    throw new Error("AI returned an empty response");
+  }
+  const cleaned = extractJson(result);
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    throw new Error(`AI response is not valid JSON. Raw start: "${result.slice(0, 120)}..."`);
+  }
+  const groups = parsed;
+  if (!Array.isArray(groups) || groups.length === 0) {
+    throw new Error("AI response was not a valid JSON array of commit groups");
+  }
+  for (const group of groups) {
+    if (!Array.isArray(group.files) || typeof group.message !== "string") {
+      throw new Error("AI returned groups with invalid structure (missing files or message)");
+    }
+  }
+  return groups;
+}
+async function regenerateAllGroupMessages(groups, diffs, model, convention = "clean-commit") {
+  const groupSummary = groups.map((g, i) => `Group ${i + 1}: [${g.files.join(", ")}]`).join(`
+`);
+  const userMessage = `Regenerate ONLY the commit messages for these pre-defined file groups. Do NOT change the file groupings.
+
+Groups:
+${groupSummary}
+
+Diffs (truncated):
+${diffs.slice(0, 6000)}`;
+  const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+  if (!result)
+    return groups;
+  try {
+    const cleaned = extractJson(result);
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed) || parsed.length !== groups.length)
+      return groups;
+    return groups.map((g, i) => ({
+      files: g.files,
+      message: typeof parsed[i]?.message === "string" ? parsed[i].message : g.message
+    }));
+  } catch {
+    return groups;
+  }
+}
+async function regenerateGroupMessage(files, diffs, model, convention = "clean-commit") {
+  try {
+    const userMessage = `Generate a single commit message for these files:
+
+Files: ${files.join(", ")}
+
+Diff:
+${diffs.slice(0, 4000)}`;
+    const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model);
+    return result?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/gh.ts
 import { execFile as execFileCb } from "node:child_process";
 function run(args) {
   return new Promise((resolve) => {
-    execFileCb("git", args, (error, stdout, stderr) => {
+    execFileCb("gh", args, (error, stdout, stderr) => {
       resolve({
-        exitCode: error ? error.code === "ENOENT" ? 127 : error.code != null ? Number(error.code) : 1 : 0,
+        exitCode: error ? error.code === "ENOENT" ? 127 : error.status ?? 1 : 0,
+        stdout: stdout ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
+}
+async function checkGhInstalled() {
+  try {
+    const { exitCode } = await run(["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function checkGhAuth() {
+  try {
+    const { exitCode } = await run(["auth", "status"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+var SAFE_SLUG = /^[\w.-]+$/;
+async function checkRepoPermissions(owner, repo) {
+  if (!SAFE_SLUG.test(owner) || !SAFE_SLUG.test(repo))
+    return null;
+  const { exitCode, stdout } = await run(["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 run(["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 run([
+    "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 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 ?? ""
       });
@@ -123,79 +580,100 @@ function run(args) {
   });
 }
 async function isGitRepo() {
-  const { exitCode } = await run(["rev-parse", "--is-inside-work-tree"]);
+  const { exitCode } = await run2(["rev-parse", "--is-inside-work-tree"]);
   return exitCode === 0;
 }
 async function getCurrentBranch() {
-  const { exitCode, stdout } = await run(["rev-parse", "--abbrev-ref", "HEAD"]);
+  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 run(["remote"]);
+  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 run(["remote", "get-url", 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 run(["status", "--porcelain"]);
+  const { exitCode, stdout } = await run2(["status", "--porcelain"]);
   if (exitCode !== 0)
     return false;
   return stdout.trim().length > 0;
 }
 async function fetchRemote(remote) {
-  return run(["fetch", remote]);
+  return run2(["fetch", remote]);
 }
 async function fetchAll() {
-  return run(["fetch", "--all", "--quiet"]);
+  return run2(["fetch", "--all", "--quiet"]);
 }
-async function checkoutBranch(branch) {
-  return run(["checkout", branch]);
+async function checkoutBranch2(branch) {
+  return run2(["checkout", branch]);
 }
 async function createBranch(branch, from) {
   const args = from ? ["checkout", "-b", branch, from] : ["checkout", "-b", branch];
-  return run(args);
+  return run2(args);
 }
 async function resetHard(ref) {
-  return run(["reset", "--hard", ref]);
+  return run2(["reset", "--hard", ref]);
 }
-async function pushForceWithLease(remote, branch) {
-  return run(["push", "--force-with-lease", remote, branch]);
+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 run(["push", "-u", remote, branch]);
+  return run2(["push", "-u", remote, branch]);
 }
 async function rebase(branch) {
-  return run(["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 rebaseOnto(newBase, oldBase) {
+  return run2(["rebase", "--onto", newBase, oldBase]);
 }
 async function getStagedDiff() {
-  const { stdout } = await run(["diff", "--cached"]);
+  const { stdout } = await run2(["diff", "--cached"]);
   return stdout;
 }
 async function getStagedFiles() {
-  const { exitCode, stdout } = await run(["diff", "--cached", "--name-only"]);
+  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 run(["status", "--porcelain"]);
+  const { exitCode, stdout } = await run2(["status", "--porcelain"]);
   if (exitCode !== 0)
     return [];
-  return stdout.trim().split(`
-`).filter(Boolean).map((l) => l.slice(3));
+  return stdout.trimEnd().split(`
+`).filter(Boolean).map((l) => {
+    const line = l.replace(/\r$/, "");
+    const match = line.match(/^..\s+(.*)/);
+    if (!match)
+      return "";
+    const file = match[1];
+    const renameIdx = file.indexOf(" -> ");
+    return renameIdx !== -1 ? file.slice(renameIdx + 4) : file;
+  }).filter(Boolean);
 }
 async function getDivergence(branch, base) {
-  const { exitCode, stdout } = await run([
+  const { exitCode, stdout } = await run2([
     "rev-list",
     "--left-right",
     "--count",
@@ -210,32 +688,143 @@ async function getDivergence(branch, base) {
   };
 }
 async function getMergedBranches(base) {
-  const { exitCode, stdout } = await run(["branch", "--merged", 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 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
 import { LogEngine, LogMode } from "@wgtechlabs/log-engine";
@@ -260,12 +849,191 @@ function warn(msg) {
 function info(msg) {
   LogEngine.info(msg);
 }
-function heading(msg) {
-  console.log(`
-${pc2.bold(msg)}`);
+function heading(msg) {
+  console.log(`
+${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",
+  "github-flow": "GitHub Flow — main + feature branches, squash/merge into main",
+  "git-flow": "Git Flow — main + develop + release + hotfix branches"
+};
+function getBaseBranch(config) {
+  switch (config.workflow) {
+    case "clean-flow":
+    case "git-flow":
+      return config.devBranch ?? "dev";
+    case "github-flow":
+      return config.mainBranch;
+  }
+}
+function hasDevBranch(workflow) {
+  return workflow === "clean-flow" || workflow === "git-flow";
+}
+function getSyncSource(config) {
+  const { workflow, role, mainBranch, origin, upstream } = config;
+  const devBranch = config.devBranch ?? "dev";
+  switch (workflow) {
+    case "clean-flow":
+      if (role === "contributor") {
+        return { remote: upstream, ref: `${upstream}/${devBranch}`, strategy: "pull" };
+      }
+      return { remote: origin, ref: `${origin}/${devBranch}`, strategy: "pull" };
+    case "github-flow":
+      if (role === "contributor") {
+        return { remote: upstream, ref: `${upstream}/${mainBranch}`, strategy: "pull" };
+      }
+      return { remote: origin, ref: `${origin}/${mainBranch}`, strategy: "pull" };
+    case "git-flow":
+      if (role === "contributor") {
+        return { remote: upstream, ref: `${upstream}/${devBranch}`, strategy: "pull" };
+      }
+      return { remote: origin, ref: `${origin}/${devBranch}`, strategy: "pull" };
+  }
+}
+function getProtectedBranches(config) {
+  const branches = [config.mainBranch];
+  if (hasDevBranch(config.workflow) && config.devBranch) {
+    branches.push(config.devBranch);
+  }
+  return branches;
 }
 
 // src/commands/clean.ts
+async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
+  if (!config)
+    return "skipped";
+  const { origin } = config;
+  const localWork = await hasLocalWork(origin, currentBranch);
+  const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
+  if (hasWork) {
+    if (localWork.uncommitted) {
+      warn("You have uncommitted changes in your working tree.");
+    }
+    if (localWork.unpushedCommits > 0) {
+      warn(`You have ${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",
@@ -289,223 +1057,165 @@ var clean_default = defineCommand({
       error("No .contributerc.json found. Run `contrib setup` first.");
       process.exit(1);
     }
-    const { mainBranch, devBranch, origin } = config;
-    const currentBranch = await getCurrentBranch();
+    const { origin } = config;
+    const baseBranch = getBaseBranch(config);
+    let currentBranch = await getCurrentBranch();
     heading("\uD83E\uDDF9 contrib clean");
-    const mergedBranches = await getMergedBranches(devBranch);
-    const protected_ = new Set([mainBranch, devBranch, currentBranch ?? ""]);
-    const candidates = mergedBranches.filter((b) => !protected_.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.");
       }
     }
-    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 (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.");
+      }
+    }
+    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";
-
-// src/utils/copilot.ts
-import { CopilotClient } from "@github/copilot-sdk";
-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.";
-    }
-    return `Failed to start Copilot service: ${msg}`;
-  }
-  try {
-    await client.ping();
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("auth") || msg.includes("token") || msg.includes("401") || msg.includes("403")) {
-      return "Copilot authentication failed. Run `gh auth login` to refresh your token.";
-    }
-    if (msg.includes("ECONNREFUSED") || msg.includes("timeout") || msg.includes("network")) {
-      return "Could not reach GitHub Copilot service. Check your internet connection.";
-    }
-    return `Copilot health check failed: ${msg}`;
-  } finally {
-    try {
-      await client.stop();
-    } catch {}
-  }
-  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();
-    }
-  } finally {
-    await client.stop();
-  }
-}
-async function generateCommitMessage(diff, stagedFiles, model) {
-  try {
-    const userMessage = `Generate a commit message for these staged changes:
-
-Files: ${stagedFiles.join(", ")}
-
-Diff:
-${diff.slice(0, 4000)}`;
-    const result = await callCopilot(CLEAN_COMMIT_SYSTEM_PROMPT, userMessage, model);
-    return result?.trim() ?? null;
-  } catch {
-    return null;
-  }
-}
-async function generatePRDescription(commits, diff, model) {
-  try {
-    const userMessage = `Generate a PR description for these changes:
-
-Commits:
-${commits.join(`
-`)}
+import pc5 from "picocolors";
 
-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);
-  } catch {
-    return null;
-  }
-}
-async function suggestBranchName(description, model) {
-  try {
-    const result = await callCopilot(BRANCH_NAME_SYSTEM_PROMPT, description, model);
-    return result?.trim() ?? null;
-  } catch {
-    return null;
-  }
+// src/utils/convention.ts
+var CLEAN_COMMIT_PATTERN = /^(📦|🔧|🗑\uFE0F?|🔒|⚙\uFE0F?|☕|🧪|📖|🚀) (new|update|remove|security|setup|chore|test|docs|release)(!?)( \([a-zA-Z0-9][a-zA-Z0-9-]*\))?: .{1,72}$/u;
+var CONVENTIONAL_COMMIT_PATTERN = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(!?)(\([a-zA-Z0-9][a-zA-Z0-9._-]*\))?: .{1,72}$/;
+var CONVENTION_LABELS = {
+  conventional: "Conventional Commits",
+  "clean-commit": "Clean Commit (by WGTech Labs)",
+  none: "No convention"
+};
+var CONVENTION_DESCRIPTIONS = {
+  conventional: "Conventional Commits — feat: | fix: | docs: | chore: etc. (conventionalcommits.org)",
+  "clean-commit": "Clean Commit — \uD83D\uDCE6 new: | \uD83D\uDD27 update: | \uD83D\uDDD1️ remove: etc. (by WGTech Labs)",
+  none: "No commit convention enforcement"
+};
+var CONVENTION_FORMAT_HINTS = {
+  conventional: [
+    "Format: <type>[!][(<scope>)]: <description>",
+    "Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert",
+    "Examples: feat: add login page | fix(auth): resolve token expiry | docs: update README"
+  ],
+  "clean-commit": [
+    "Format: <emoji> <type>[!][(<scope>)]: <description>",
+    "Types: \uD83D\uDCE6 new | \uD83D\uDD27 update | \uD83D\uDDD1️ remove | \uD83D\uDD12 security | ⚙️ setup | ☕ chore | \uD83E\uDDEA test | \uD83D\uDCD6 docs | \uD83D\uDE80 release",
+    "Examples: \uD83D\uDCE6 new: user auth | \uD83D\uDD27 update (api): improve errors | ⚙️ setup (ci): add workflow"
+  ]
+};
+function validateCommitMessage(message, convention) {
+  if (convention === "none")
+    return true;
+  if (convention === "clean-commit")
+    return CLEAN_COMMIT_PATTERN.test(message);
+  if (convention === "conventional")
+    return CONVENTIONAL_COMMIT_PATTERN.test(message);
+  return true;
 }
-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;
-  }
+function getValidationError(convention) {
+  if (convention === "none")
+    return [];
+  return [
+    `Commit message does not follow ${CONVENTION_LABELS[convention]} format.`,
+    ...CONVENTION_FORMAT_HINTS[convention]
+  ];
 }
 
 // src/commands/commit.ts
-var 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;
-function validateCleanCommit(msg) {
-  return CLEAN_COMMIT_PATTERN.test(msg);
-}
 var commit_default = defineCommand2({
   meta: {
     name: "commit",
-    description: "Stage changes and create a Clean Commit message (AI-powered)"
+    description: "Stage changes and create a commit message (AI-powered)"
   },
   args: {
     model: {
@@ -516,6 +1226,11 @@ var commit_default = defineCommand2({
       type: "boolean",
       description: "Skip AI and write commit message manually",
       default: false
+    },
+    group: {
+      type: "boolean",
+      description: "AI groups related changes into separate atomic commits",
+      default: false
     }
   },
   async run({ args }) {
@@ -529,7 +1244,11 @@ var commit_default = defineCommand2({
       process.exit(1);
     }
     heading("\uD83D\uDCBE contrib commit");
-    const stagedFiles = await getStagedFiles();
+    if (args.group) {
+      await runGroupCommit(args.model, config);
+      return;
+    }
+    let stagedFiles = await getStagedFiles();
     if (stagedFiles.length === 0) {
       const changedFiles = await getChangedFiles();
       if (changedFiles.length === 0) {
@@ -537,31 +1256,62 @@ var commit_default = defineCommand2({
         process.exit(1);
       }
       console.log(`
-${pc4.bold("Changed files:")}`);
+${pc5.bold("Changed files:")}`);
       for (const f of changedFiles) {
-        console.log(`  ${pc4.dim("•")} ${f}`);
+        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);
       }
-      console.log();
-      warn("No staged changes. Stage your files with `git add` and re-run.");
-      process.exit(1);
     }
     info(`Staged files: ${stagedFiles.join(", ")}`);
     let commitMessage = null;
     const useAI = !args["no-ai"];
     if (useAI) {
-      const copilotError = await checkCopilotAvailable();
+      const [copilotError, diff] = await Promise.all([checkCopilotAvailable(), getStagedDiff()]);
       if (copilotError) {
         warn(`AI unavailable: ${copilotError}`);
         warn("Falling back to manual commit message entry.");
       } else {
-        info("Generating commit message with AI...");
-        const diff = await getStagedDiff();
-        commitMessage = await generateCommitMessage(diff, stagedFiles, args.model);
+        const spinner = createSpinner("Generating commit message with AI...");
+        commitMessage = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
         if (commitMessage) {
+          spinner.success("AI commit message generated.");
           console.log(`
-  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(commitMessage))}`);
+  ${pc5.dim("AI suggestion:")} ${pc5.bold(pc5.cyan(commitMessage))}`);
         } else {
-          warn("AI did not return a commit message. Falling back to manual entry.");
+          spinner.fail("AI did not return a commit message.");
+          warn("Falling back to manual entry.");
         }
       }
     }
@@ -578,35 +1328,42 @@ ${pc4.bold("Changed files:")}`);
       } else if (action === "Edit this message") {
         finalMessage = await inputPrompt("Edit commit message", commitMessage);
       } else if (action === "Regenerate") {
-        info("Regenerating...");
+        const spinner = createSpinner("Regenerating commit message...");
         const diff = await getStagedDiff();
-        const regen = await generateCommitMessage(diff, stagedFiles, args.model);
+        const regen = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
         if (regen) {
+          spinner.success("Commit message regenerated.");
           console.log(`
-  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(regen))}`);
+  ${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 {
-          warn("Regeneration failed. Falling back to manual entry.");
+          spinner.fail("Regeneration failed.");
           finalMessage = await inputPrompt("Enter commit message");
         }
       } else {
         finalMessage = await inputPrompt("Enter commit message");
       }
     } else {
-      console.log();
-      console.log(pc4.dim("Clean Commit format: <emoji> <type>[!][(<scope>)]: <description>"));
-      console.log(pc4.dim("Examples: \uD83D\uDCE6 new: user auth | \uD83D\uDD27 update (api): improve errors"));
-      console.log();
+      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);
     }
-    if (!validateCleanCommit(finalMessage)) {
-      warn("Commit message does not follow Clean Commit format.");
-      warn("Format: <emoji> <type>[!][(<scope>)]: <description>");
+    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);
@@ -616,105 +1373,321 @@ ${pc4.bold("Changed files:")}`);
       error(`Failed to commit: ${result.stderr}`);
       process.exit(1);
     }
-    success(`✅ Committed: ${pc4.bold(finalMessage)}`);
+    success(`✅ Committed: ${pc5.bold(finalMessage)}`);
   }
 });
-
-// src/commands/setup.ts
-import { defineCommand as defineCommand3 } from "citty";
-import pc5 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 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);
   }
-}
-async function checkGhAuth() {
-  try {
-    const { exitCode } = await run2(["auth", "status"]);
-    return exitCode === 0;
-  } catch {
-    return false;
+  if (changedFiles.length === 0) {
+    error("No changes to group-commit.");
+    process.exit(1);
   }
-}
-async function checkRepoPermissions(owner, repo) {
-  const { exitCode, stdout } = await run2(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
-  if (exitCode !== 0)
-    return null;
+  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 {
-    return JSON.parse(stdout.trim());
-  } catch {
-    return null;
+    groups = await generateCommitGroups(changedFiles, diffs, model, config.commitConvention);
+    spinner.success(`AI generated ${groups.length} commit group(s).`);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    spinner.fail(`AI grouping failed: ${reason}`);
+    process.exit(1);
+  }
+  if (groups.length === 0) {
+    error("AI could not produce commit groups. Try committing files manually.");
+    process.exit(1);
   }
+  const changedSet = new Set(changedFiles);
+  for (const group of groups) {
+    const invalid = group.files.filter((f) => !changedSet.has(f));
+    if (invalid.length > 0) {
+      warn(`AI suggested unknown file(s): ${invalid.join(", ")} — removed from group.`);
+    }
+    group.files = group.files.filter((f) => changedSet.has(f));
+  }
+  let validGroups = groups.filter((g) => g.files.length > 0);
+  if (validGroups.length === 0) {
+    error("No valid groups remain after validation. Try committing files manually.");
+    process.exit(1);
+  }
+  let proceedToCommit = false;
+  let commitAll = false;
+  while (!proceedToCommit) {
+    console.log(`
+${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();
+    }
+    const summaryAction = await selectPrompt("What would you like to do?", [
+      "Commit all",
+      "Review each group",
+      "Regenerate all messages",
+      "Cancel"
+    ]);
+    if (summaryAction === "Cancel") {
+      warn("Group commit cancelled.");
+      process.exit(0);
+    }
+    if (summaryAction === "Regenerate all messages") {
+      const regenSpinner = createSpinner("Regenerating all commit messages...");
+      try {
+        validGroups = await regenerateAllGroupMessages(validGroups, diffs, model, config.commitConvention);
+        regenSpinner.success("All commit messages regenerated.");
+      } catch {
+        regenSpinner.fail("Failed to regenerate messages. Keeping current ones.");
+      }
+      continue;
+    }
+    proceedToCommit = true;
+    commitAll = summaryAction === "Commit all";
+  }
+  let committed = 0;
+  if (commitAll) {
+    for (let i = 0;i < validGroups.length; i++) {
+      const group = validGroups[i];
+      const stageResult = await stageFiles(group.files);
+      if (stageResult.exitCode !== 0) {
+        error(`Failed to stage group ${i + 1}: ${stageResult.stderr}`);
+        continue;
+      }
+      const commitResult = await commitWithMessage(group.message);
+      if (commitResult.exitCode !== 0) {
+        const detail = (commitResult.stderr || commitResult.stdout).trim();
+        error(`Failed to commit group ${i + 1}: ${detail}`);
+        await unstageFiles(group.files);
+        continue;
+      }
+      committed++;
+      success(`✅ Committed group ${i + 1}: ${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;
+      }
+    }
+  }
+  if (committed === 0) {
+    warn("No groups were committed.");
+  } else {
+    success(`
+\uD83C\uDF89 ${committed} of ${validGroups.length} group(s) committed successfully.`);
+  }
+  process.exit(0);
+}
+
+// src/commands/hook.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { defineCommand as defineCommand3 } from "citty";
+import pc6 from "picocolors";
+var HOOK_MARKER = "# managed by contribute-now";
+function getHooksDir(cwd = process.cwd()) {
+  return join3(cwd, ".git", "hooks");
 }
-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;
+function getHookPath(cwd = process.cwd()) {
+  return join3(getHooksDir(cwd), "commit-msg");
 }
-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 };
+function generateHookScript() {
+  return `#!/bin/sh
+${HOOK_MARKER}
+# Validates commit messages against your configured convention.
+# Install:   contrib hook install
+# Uninstall: contrib hook uninstall
+
+commit_msg_file="$1"
+commit_msg=$(head -1 "$commit_msg_file")
+
+# Skip merge commits and fixup/squash commits
+case "$commit_msg" in
+  Merge\\ *|fixup!*|squash!*|amend!*) exit 0 ;;
+esac
+
+# 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
+`;
 }
-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);
+var hook_default = defineCommand3({
+  meta: {
+    name: "hook",
+    description: "Install or uninstall the commit-msg git hook"
+  },
+  args: {
+    action: {
+      type: "positional",
+      description: "Action to perform: install or uninstall",
+      required: true
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const action = args.action;
+    if (action !== "install" && action !== "uninstall") {
+      error(`Unknown action "${action}". Use "install" or "uninstall".`);
+      process.exit(1);
+    }
+    if (action === "install") {
+      await installHook();
+    } else {
+      await uninstallHook();
+    }
+  }
+});
+async function installHook() {
+  heading("\uD83E\uDE9D hook install");
+  const config = readConfig();
+  if (!config) {
+    error("No .contributerc.json found. Run `contrib setup` first.");
+    process.exit(1);
+  }
+  if (config.commitConvention === "none") {
+    warn('Commit convention is set to "none". No hook to install.');
+    info("Change your convention with `contrib setup` first.");
+    process.exit(0);
+  }
+  const hookPath = getHookPath();
+  const hooksDir = getHooksDir();
+  if (existsSync2(hookPath)) {
+    const existing = readFileSync3(hookPath, "utf-8");
+    if (!existing.includes(HOOK_MARKER)) {
+      error("A commit-msg hook already exists and was not installed by contribute-now.");
+      warn(`Path: ${hookPath}`);
+      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: ${pc6.bold(CONVENTION_LABELS[config.commitConvention])}`);
+  info(`Path: ${pc6.dim(hookPath)}`);
 }
-async function createPRFill(base, draft) {
-  const args = ["pr", "create", "--base", base, "--fill"];
-  if (draft)
-    args.push("--draft");
-  return run2(args);
+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
+import { defineCommand as defineCommand4 } from "citty";
+import pc7 from "picocolors";
+
 // src/utils/remote.ts
 function parseRepoFromUrl(url) {
   const httpsMatch = url.match(/https?:\/\/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?$/);
@@ -735,7 +1708,7 @@ async function getRepoInfoFromRemote(remote = "origin") {
 }
 
 // src/commands/setup.ts
-var setup_default = defineCommand3({
+var setup_default = defineCommand4({
   meta: {
     name: "setup",
     description: "Initialize contribute-now config for this repo (.contributerc.json)"
@@ -746,6 +1719,27 @@ var setup_default = defineCommand3({
       process.exit(1);
     }
     heading("\uD83D\uDD27 contribute-now setup");
+    const workflowChoice = await selectPrompt("Which git workflow does this project use?", [
+      "Clean Flow — main + dev, squash features into dev, merge dev into main (recommended)",
+      "GitHub Flow — main + feature branches, squash/merge into main",
+      "Git Flow — main + develop + release + hotfix branches"
+    ]);
+    let workflow = "clean-flow";
+    if (workflowChoice.startsWith("GitHub"))
+      workflow = "github-flow";
+    else if (workflowChoice.startsWith("Git Flow"))
+      workflow = "git-flow";
+    info(`Workflow: ${pc7.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
+    const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
+      `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
+      CONVENTION_DESCRIPTIONS.conventional,
+      CONVENTION_DESCRIPTIONS.none
+    ]);
+    let commitConvention = "clean-commit";
+    if (conventionChoice.includes("Conventional Commits"))
+      commitConvention = "conventional";
+    else if (conventionChoice.includes("No commit"))
+      commitConvention = "none";
     const remotes = await getRemotes();
     if (remotes.length === 0) {
       error("No git remotes found. Add a remote first (e.g., git remote add origin <url>).");
@@ -788,8 +1782,8 @@ var setup_default = defineCommand3({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${pc5.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${pc5.bold(detectedRole)}. Is this correct?`);
+      info(`Detected role: ${pc7.bold(detectedRole)} (via ${detectionSource})`);
+      const confirmed = await confirmPrompt(`Role detected as ${pc7.bold(detectedRole)}. Is this correct?`);
       if (!confirmed) {
         const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
         detectedRole = roleChoice;
@@ -797,7 +1791,11 @@ var setup_default = defineCommand3({
     }
     const defaultConfig = getDefaultConfig();
     const mainBranch = await inputPrompt("Main branch name", defaultConfig.mainBranch);
-    const devBranch = await inputPrompt("Dev branch name", defaultConfig.devBranch);
+    let devBranch;
+    if (hasDevBranch(workflow)) {
+      const defaultDev = workflow === "git-flow" ? "develop" : "dev";
+      devBranch = await inputPrompt("Dev/develop branch name", defaultDev);
+    }
     const originRemote = await inputPrompt("Origin remote name", defaultConfig.origin);
     let upstreamRemote = defaultConfig.upstream;
     if (detectedRole === "contributor") {
@@ -814,12 +1812,14 @@ var setup_default = defineCommand3({
       }
     }
     const config = {
+      workflow,
       role: detectedRole,
       mainBranch,
-      devBranch,
+      ...devBranch ? { devBranch } : {},
       upstream: upstreamRemote,
       origin: originRemote,
-      branchPrefixes: defaultConfig.branchPrefixes
+      branchPrefixes: defaultConfig.branchPrefixes,
+      commitConvention
     };
     writeConfig(config);
     success(`✅ Config written to .contributerc.json`);
@@ -828,34 +1828,25 @@ var setup_default = defineCommand3({
       warn('  echo ".contributerc.json" >> .gitignore');
     }
     console.log();
-    info(`Role: ${pc5.bold(config.role)}`);
-    info(`Main: ${pc5.bold(config.mainBranch)} | Dev: ${pc5.bold(config.devBranch)}`);
-    info(`Origin: ${pc5.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc5.bold(config.upstream)}` : ""}`);
+    info(`Workflow: ${pc7.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    info(`Convention: ${pc7.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+    info(`Role: ${pc7.bold(config.role)}`);
+    if (config.devBranch) {
+      info(`Main: ${pc7.bold(config.mainBranch)} | Dev: ${pc7.bold(config.devBranch)}`);
+    } else {
+      info(`Main: ${pc7.bold(config.mainBranch)}`);
+    }
+    info(`Origin: ${pc7.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc7.bold(config.upstream)}` : ""}`);
   }
 });
 
 // src/commands/start.ts
-import { defineCommand as defineCommand4 } from "citty";
-import pc6 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 = defineCommand4({
+import { defineCommand as defineCommand5 } from "citty";
+import pc8 from "picocolors";
+var start_default = defineCommand5({
   meta: {
     name: "start",
-    description: "Create a new feature branch from the latest dev"
+    description: "Create a new feature branch from the latest base branch"
   },
   args: {
     name: {
@@ -887,50 +1878,57 @@ var start_default = defineCommand4({
       error("You have uncommitted changes. Please commit or stash them before creating a branch.");
       process.exit(1);
     }
-    const { devBranch, origin, upstream, branchPrefixes, role } = config;
+    const { branchPrefixes } = config;
+    const baseBranch = getBaseBranch(config);
+    const syncSource = getSyncSource(config);
     let branchName = args.name;
     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(`
-  ${pc6.dim("AI suggestion:")} ${pc6.bold(pc6.cyan(suggested))}`);
-        const accepted = await confirmPrompt(`Use ${pc6.bold(suggested)} as your branch name?`);
+  ${pc8.dim("AI suggestion:")} ${pc8.bold(pc8.cyan(suggested))}`);
+        const accepted = await confirmPrompt(`Use ${pc8.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 ${pc6.bold(branchName)}:`, branchPrefixes);
+      const prefix = await selectPrompt(`Choose a branch type for ${pc8.bold(branchName)}:`, branchPrefixes);
       branchName = formatBranchName(prefix, branchName);
     }
-    info(`Creating branch: ${pc6.bold(branchName)}`);
-    const remote = role === "contributor" ? upstream : origin;
-    const remoteDevRef = role === "contributor" ? `${upstream}/${devBranch}` : `${origin}/${devBranch}`;
-    await fetchRemote(remote);
-    const resetResult = await resetHard(remoteDevRef);
-    if (resetResult.exitCode !== 0) {}
-    const result = await createBranch(branchName, devBranch);
+    if (!isValidBranchName(branchName)) {
+      error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
+      process.exit(1);
+    }
+    info(`Creating branch: ${pc8.bold(branchName)}`);
+    await fetchRemote(syncSource.remote);
+    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 ${pc6.bold(branchName)} from latest ${pc6.bold(devBranch)}`);
+    success(`✅ Created ${pc8.bold(branchName)} from latest ${pc8.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand5 } from "citty";
-import pc7 from "picocolors";
-var status_default = defineCommand5({
+import { defineCommand as defineCommand6 } from "citty";
+import pc9 from "picocolors";
+var status_default = defineCommand6({
   meta: {
     name: "status",
-    description: "Show sync status of main, dev, and current branch"
+    description: "Show sync status of branches"
   },
   async run() {
     if (!await isGitRepo()) {
@@ -943,60 +1941,160 @@ var status_default = defineCommand5({
       process.exit(1);
     }
     heading("\uD83D\uDCCA contribute-now status");
+    console.log(`  ${pc9.dim("Workflow:")} ${pc9.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    console.log(`  ${pc9.dim("Role:")} ${pc9.bold(config.role)}`);
+    console.log();
     await fetchAll();
     const currentBranch = await getCurrentBranch();
-    const { mainBranch, devBranch, origin, upstream } = config;
+    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(`  ${pc7.yellow("⚠")}  ${pc7.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${pc9.yellow("⚠")}  ${pc9.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
     const mainDiv = await getDivergence(mainBranch, mainRemote);
     const mainStatus = formatStatus(mainBranch, mainRemote, mainDiv.ahead, mainDiv.behind);
     console.log(mainStatus);
-    const devRemoteRef = isContributor ? `${upstream}/${devBranch}` : `${origin}/${mainBranch}`;
-    const devDiv = await getDivergence(devBranch, devRemoteRef);
-    let devLine = formatStatus(devBranch, devRemoteRef, devDiv.ahead, devDiv.behind);
-    if (!isContributor && devDiv.ahead > 0 && devDiv.behind > 0) {
-      devLine += pc7.red(" (needs sync! squash-merge divergence detected)");
-    } else if (devDiv.ahead > 0 && devDiv.behind === 0) {
-      devLine += pc7.yellow(" (needs sync!)");
-    }
-    console.log(devLine);
-    if (currentBranch && currentBranch !== mainBranch && currentBranch !== devBranch) {
-      const branchDiv = await getDivergence(currentBranch, devBranch);
-      const branchLine = formatStatus(currentBranch, devBranch, branchDiv.ahead, branchDiv.behind);
-      console.log(branchLine + pc7.dim(` (current ${pc7.green("*")})`));
+    if (hasDevBranch(workflow) && config.devBranch) {
+      const devRemoteRef = isContributor ? `${upstream}/${config.devBranch}` : `${origin}/${config.devBranch}`;
+      const devDiv = await getDivergence(config.devBranch, devRemoteRef);
+      const devLine = formatStatus(config.devBranch, devRemoteRef, devDiv.ahead, devDiv.behind);
+      console.log(devLine);
+    }
+    if (currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
+      const branchDiv = await getDivergence(currentBranch, baseBranch);
+      const branchLine = formatStatus(currentBranch, baseBranch, branchDiv.ahead, branchDiv.behind);
+      console.log(branchLine + pc9.dim(` (current ${pc9.green("*")})`));
     } else if (currentBranch) {
-      if (currentBranch === mainBranch) {
-        console.log(pc7.dim(`  (on ${pc7.bold(mainBranch)} branch)`));
-      } else if (currentBranch === devBranch) {
-        console.log(pc7.dim(`  (on ${pc7.bold(devBranch)} branch)`));
+      console.log(pc9.dim(`  (on ${pc9.bold(currentBranch)} branch)`));
+    }
+    const hasFiles = fileStatus.staged.length > 0 || fileStatus.modified.length > 0 || fileStatus.untracked.length > 0;
+    if (hasFiles) {
+      console.log();
+      if (fileStatus.staged.length > 0) {
+        console.log(`  ${pc9.green("Staged for commit:")}`);
+        for (const { file, status } of fileStatus.staged) {
+          console.log(`    ${pc9.green("+")} ${pc9.dim(`${status}:`)} ${file}`);
+        }
+      }
+      if (fileStatus.modified.length > 0) {
+        console.log(`  ${pc9.yellow("Unstaged changes:")}`);
+        for (const { file, status } of fileStatus.modified) {
+          console.log(`    ${pc9.yellow("~")} ${pc9.dim(`${status}:`)} ${file}`);
+        }
+      }
+      if (fileStatus.untracked.length > 0) {
+        console.log(`  ${pc9.red("Untracked files:")}`);
+        for (const file of fileStatus.untracked) {
+          console.log(`    ${pc9.red("?")} ${file}`);
+        }
+      }
+    } else if (!dirty) {
+      console.log(`  ${pc9.green("✓")}  ${pc9.dim("Working tree clean")}`);
+    }
+    const tips = [];
+    if (fileStatus.staged.length > 0) {
+      tips.push(`Run ${pc9.bold("contrib commit")} to commit staged changes`);
+    }
+    if (fileStatus.modified.length > 0 || fileStatus.untracked.length > 0) {
+      tips.push(`Run ${pc9.bold("contrib commit")} to stage and commit changes`);
+    }
+    if (fileStatus.staged.length === 0 && fileStatus.modified.length === 0 && fileStatus.untracked.length === 0 && currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
+      const branchDiv = await getDivergence(currentBranch, `${origin}/${currentBranch}`);
+      if (branchDiv.ahead > 0) {
+        tips.push(`Run ${pc9.bold("contrib submit")} to push and create/update your PR`);
+      }
+    }
+    if (tips.length > 0) {
+      console.log();
+      console.log(`  ${pc9.dim("\uD83D\uDCA1 Tip:")}`);
+      for (const tip of tips) {
+        console.log(`     ${pc9.dim(tip)}`);
       }
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = pc7.bold(branch.padEnd(20));
+  const label = pc9.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${pc7.green("✓")}  ${label} ${pc7.dim(`in sync with ${base}`)}`;
+    return `  ${pc9.green("✓")}  ${label} ${pc9.dim(`in sync with ${base}`)}`;
   }
   if (ahead > 0 && behind === 0) {
-    return `  ${pc7.yellow("↑")}  ${label} ${pc7.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+    return `  ${pc9.yellow("↑")}  ${label} ${pc9.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
   }
   if (behind > 0 && ahead === 0) {
-    return `  ${pc7.red("↓")}  ${label} ${pc7.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+    return `  ${pc9.red("↓")}  ${label} ${pc9.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
   }
-  return `  ${pc7.red("⚡")}  ${label} ${pc7.yellow(`${ahead} ahead`)}${pc7.dim(", ")}${pc7.red(`${behind} behind`)} ${pc7.dim(base)}`;
+  return `  ${pc9.red("⚡")}  ${label} ${pc9.yellow(`${ahead} ahead`)}${pc9.dim(", ")}${pc9.red(`${behind} behind`)} ${pc9.dim(base)}`;
 }
 
 // src/commands/submit.ts
-import { defineCommand as defineCommand6 } from "citty";
-import pc8 from "picocolors";
-var submit_default = defineCommand6({
+import { defineCommand as defineCommand7 } from "citty";
+import pc10 from "picocolors";
+async function performSquashMerge(origin, baseBranch, featureBranch, options) {
+  info(`Checking out ${pc10.bold(baseBranch)}...`);
+  const coResult = await checkoutBranch2(baseBranch);
+  if (coResult.exitCode !== 0) {
+    error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
+    process.exit(1);
+  }
+  info(`Squash merging ${pc10.bold(featureBranch)} into ${pc10.bold(baseBranch)}...`);
+  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 ${pc10.bold(baseBranch)} to ${origin}...`);
+  const pushResult = await pushBranch(origin, baseBranch);
+  if (pushResult.exitCode !== 0) {
+    error(`Failed to push ${baseBranch}: ${pushResult.stderr}`);
+    process.exit(1);
+  }
+  info(`Deleting local branch ${pc10.bold(featureBranch)}...`);
+  const delLocal = await forceDeleteBranch(featureBranch);
+  if (delLocal.exitCode !== 0) {
+    warn(`Could not delete local branch: ${delLocal.stderr.trim()}`);
+  }
+  info(`Deleting remote branch ${pc10.bold(featureBranch)}...`);
+  const delRemote = await deleteRemoteBranch(origin, featureBranch);
+  if (delRemote.exitCode !== 0) {
+    warn(`Could not delete remote branch: ${delRemote.stderr.trim()}`);
+  }
+  success(`✅ Squash merged ${pc10.bold(featureBranch)} into ${pc10.bold(baseBranch)} and pushed.`);
+  info(`Run ${pc10.bold("contrib start")} to begin a new feature.`);
+}
+var submit_default = defineCommand7({
   meta: {
     name: "submit",
     description: "Push current branch and create a pull request"
@@ -1027,75 +2125,195 @@ var submit_default = defineCommand6({
       error("No .contributerc.json found. Run `contrib setup` first.");
       process.exit(1);
     }
-    const { mainBranch, devBranch, origin } = config;
+    const { origin } = config;
+    const baseBranch = getBaseBranch(config);
+    const protectedBranches = getProtectedBranches(config);
     const currentBranch = await getCurrentBranch();
     if (!currentBranch) {
       error("Could not determine current branch.");
       process.exit(1);
     }
-    if (currentBranch === mainBranch || currentBranch === devBranch) {
-      error(`Cannot submit ${pc8.bold(mainBranch)} or ${pc8.bold(devBranch)} as a PR. Switch to your feature branch.`);
+    if (protectedBranches.includes(currentBranch)) {
+      error(`Cannot submit ${protectedBranches.map((b) => pc10.bold(b)).join(" or ")} as a PR. Switch to your feature branch.`);
       process.exit(1);
     }
     heading("\uD83D\uDE80 contrib submit");
-    info(`Pushing ${pc8.bold(currentBranch)} to ${origin}...`);
+    const ghInstalled = await checkGhInstalled();
+    const ghAuthed = ghInstalled && await checkGhAuth();
+    if (ghInstalled && ghAuthed) {
+      const mergedPR = await getMergedPRForBranch(currentBranch);
+      if (mergedPR) {
+        warn(`PR #${mergedPR.number} (${pc10.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 ${pc10.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(pc10.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(`
+  ${pc10.dim("AI suggestion:")} ${pc10.bold(pc10.cyan(suggested))}`);
+                const accepted = await confirmPrompt(`Use ${pc10.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 ${pc10.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 renameResult = await renameBranch(currentBranch, newBranchName);
+            if (renameResult.exitCode !== 0) {
+              error(`Failed to rename branch: ${renameResult.stderr}`);
+              process.exit(1);
+            }
+            success(`Renamed ${pc10.bold(currentBranch)} → ${pc10.bold(newBranchName)}`);
+            const syncSource2 = getSyncSource(config);
+            info(`Syncing ${pc10.bold(newBranchName)} with latest ${pc10.bold(baseBranch)}...`);
+            await fetchRemote(syncSource2.remote);
+            const savedUpstreamRef = await getUpstreamRef();
+            const rebaseResult = savedUpstreamRef && savedUpstreamRef !== syncSource2.ref ? await rebaseOnto(syncSource2.ref, savedUpstreamRef) : await rebase(syncSource2.ref);
+            if (rebaseResult.exitCode !== 0) {
+              warn("Rebase encountered conflicts. Resolve them manually, then run:");
+              info(`  ${pc10.bold("git rebase --continue")}`);
+            } else {
+              success(`Rebased ${pc10.bold(newBranchName)} onto ${pc10.bold(syncSource2.ref)}.`);
+            }
+            info(`All your changes are preserved. Run ${pc10.bold("contrib submit")} when ready to create a new PR.`);
+            return;
+          }
+          warn("Discarding local changes...");
+        }
+        const syncSource = getSyncSource(config);
+        info(`Switching to ${pc10.bold(baseBranch)} and syncing...`);
+        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 ${pc10.bold(baseBranch)} with ${pc10.bold(syncSource.ref)}.`);
+        info(`Deleting stale branch ${pc10.bold(currentBranch)}...`);
+        const delResult = await forceDeleteBranch(currentBranch);
+        if (delResult.exitCode === 0) {
+          success(`Deleted ${pc10.bold(currentBranch)}.`);
+        } else {
+          warn(`Could not delete branch: ${delResult.stderr.trim()}`);
+        }
+        console.log();
+        info(`You're now on ${pc10.bold(baseBranch)}. Run ${pc10.bold("contrib start")} to begin a new feature.`);
+        return;
+      }
+    }
+    info(`Pushing ${pc10.bold(currentBranch)} to ${origin}...`);
     const pushResult = await pushSetUpstream(origin, currentBranch);
     if (pushResult.exitCode !== 0) {
       error(`Failed to push: ${pushResult.stderr}`);
       process.exit(1);
     }
-    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/${devBranch}...${currentBranch}?expand=1`;
+        const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/compare/${baseBranch}...${currentBranch}?expand=1`;
         console.log();
         info("Create your PR manually:");
-        console.log(`  ${pc8.cyan(prUrl)}`);
+        console.log(`  ${pc10.cyan(prUrl)}`);
       } else {
         info("gh CLI not available. Create your PR manually on GitHub.");
       }
       return;
     }
+    const existingPR = await getPRForBranch(currentBranch);
+    if (existingPR) {
+      success(`Pushed changes to existing PR #${existingPR.number}: ${pc10.bold(existingPR.title)}`);
+      console.log(`  ${pc10.cyan(existingPR.url)}`);
+      return;
+    }
     let prTitle = null;
     let prBody = null;
     if (!args["no-ai"]) {
-      const copilotError = await checkCopilotAvailable();
+      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(devBranch, "HEAD");
-        const diff = await getLogDiff(devBranch, "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(`
-  ${pc8.dim("AI title:")} ${pc8.bold(pc8.cyan(prTitle))}`);
+  ${pc10.dim("AI title:")} ${pc10.bold(pc10.cyan(prTitle))}`);
           console.log(`
-${pc8.dim("AI body preview:")}`);
-          console.log(pc8.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+${pc10.dim("AI body preview:")}`);
+          console.log(pc10.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}`);
       }
     }
+    const CANCEL = "Cancel";
+    const SQUASH_LOCAL = `Squash merge to ${baseBranch} locally (no PR)`;
     if (prTitle && prBody) {
-      const action = await selectPrompt("What would you like to do with the PR description?", [
+      const choices = [
         "Use AI description",
         "Edit title",
         "Write manually",
         "Use gh --fill (auto-fill from commits)"
-      ]);
+      ];
+      if (config.role === "maintainer")
+        choices.push(SQUASH_LOCAL);
+      choices.push(CANCEL);
+      const action = await selectPrompt("What would you like to do with the PR description?", choices);
+      if (action === CANCEL) {
+        warn("Submit cancelled.");
+        return;
+      }
+      if (action === SQUASH_LOCAL) {
+        await performSquashMerge(origin, baseBranch, currentBranch, {
+          defaultMsg: prTitle ?? undefined,
+          model: args.model,
+          convention: config.commitConvention
+        });
+        return;
+      }
       if (action === "Use AI description") {} else if (action === "Edit title") {
         prTitle = await inputPrompt("PR title", prTitle);
       } else if (action === "Write manually") {
         prTitle = await inputPrompt("PR title");
         prBody = await inputPrompt("PR body (markdown)");
       } else {
-        const fillResult = await createPRFill(devBranch, args.draft);
+        const fillResult = await createPRFill(baseBranch, args.draft);
         if (fillResult.exitCode !== 0) {
           error(`Failed to create PR: ${fillResult.stderr}`);
           process.exit(1);
@@ -1104,12 +2322,30 @@ ${pc8.dim("AI body preview:")}`);
         return;
       }
     } else {
-      const useManual = await confirmPrompt("Create PR with manual title/body?");
-      if (useManual) {
+      const choices = [
+        "Write title & body manually",
+        "Use gh --fill (auto-fill from commits)"
+      ];
+      if (config.role === "maintainer")
+        choices.push(SQUASH_LOCAL);
+      choices.push(CANCEL);
+      const action = await selectPrompt("How would you like to create the PR?", choices);
+      if (action === CANCEL) {
+        warn("Submit cancelled.");
+        return;
+      }
+      if (action === SQUASH_LOCAL) {
+        await performSquashMerge(origin, baseBranch, currentBranch, {
+          model: args.model,
+          convention: config.commitConvention
+        });
+        return;
+      }
+      if (action === "Write title & body manually") {
         prTitle = await inputPrompt("PR title");
         prBody = await inputPrompt("PR body (markdown)");
       } else {
-        const fillResult = await createPRFill(devBranch, args.draft);
+        const fillResult = await createPRFill(baseBranch, args.draft);
         if (fillResult.exitCode !== 0) {
           error(`Failed to create PR: ${fillResult.stderr}`);
           process.exit(1);
@@ -1123,7 +2359,7 @@ ${pc8.dim("AI body preview:")}`);
       process.exit(1);
     }
     const prResult = await createPR({
-      base: devBranch,
+      base: baseBranch,
       title: prTitle,
       body: prBody ?? "",
       draft: args.draft
@@ -1137,12 +2373,12 @@ ${pc8.dim("AI body preview:")}`);
 });
 
 // src/commands/sync.ts
-import { defineCommand as defineCommand7 } from "citty";
-import pc9 from "picocolors";
-var sync_default = defineCommand7({
+import { defineCommand as defineCommand8 } from "citty";
+import pc11 from "picocolors";
+var sync_default = defineCommand8({
   meta: {
     name: "sync",
-    description: "Reset dev branch to match origin/main (maintainer) or upstream/dev (contributor)"
+    description: "Sync your local branches with the remote"
   },
   args: {
     yes: {
@@ -1162,86 +2398,70 @@ var sync_default = defineCommand7({
       error("No .contributerc.json found. Run `contrib setup` first.");
       process.exit(1);
     }
-    const { role, mainBranch, devBranch, origin, upstream } = config;
+    const { workflow, role, origin } = config;
     if (await hasUncommittedChanges()) {
       error("You have uncommitted changes. Please commit or stash them before syncing.");
       process.exit(1);
     }
-    heading(`\uD83D\uDD04 contrib sync (${role})`);
-    if (role === "maintainer") {
-      info(`Fetching ${origin}...`);
-      const fetchResult = await fetchRemote(origin);
-      if (fetchResult.exitCode !== 0) {
-        error(`Failed to fetch ${origin}: ${fetchResult.stderr}`);
-        process.exit(1);
-      }
-      const div = await getDivergence(devBranch, `${origin}/${mainBranch}`);
-      if (div.ahead > 0 || div.behind > 0) {
-        info(`${pc9.bold(devBranch)} is ${pc9.yellow(`${div.ahead} ahead`)} and ${pc9.red(`${div.behind} behind`)} ${origin}/${mainBranch}`);
-      } else {
-        info(`${pc9.bold(devBranch)} is already in sync with ${origin}/${mainBranch}`);
-      }
-      if (!args.yes) {
-        const ok = await confirmPrompt(`This will reset ${pc9.bold(devBranch)} to match ${pc9.bold(`${origin}/${mainBranch}`)}.`);
-        if (!ok)
-          process.exit(0);
-      }
-      const coResult = await checkoutBranch(devBranch);
-      if (coResult.exitCode !== 0) {
-        error(`Failed to checkout ${devBranch}: ${coResult.stderr}`);
-        process.exit(1);
-      }
-      const resetResult = await resetHard(`${origin}/${mainBranch}`);
-      if (resetResult.exitCode !== 0) {
-        error(`Failed to reset: ${resetResult.stderr}`);
-        process.exit(1);
-      }
-      const pushResult = await pushForceWithLease(origin, devBranch);
-      if (pushResult.exitCode !== 0) {
-        error(`Failed to push: ${pushResult.stderr}`);
-        process.exit(1);
-      }
-      success(`✅ ${devBranch} has been reset to match ${origin}/${mainBranch} and pushed.`);
+    heading(`\uD83D\uDD04 contrib sync (${workflow}, ${role})`);
+    const baseBranch = getBaseBranch(config);
+    const syncSource = getSyncSource(config);
+    info(`Fetching ${syncSource.remote}...`);
+    const fetchResult = await fetchRemote(syncSource.remote);
+    if (fetchResult.exitCode !== 0) {
+      error(`Failed to fetch ${syncSource.remote}: ${fetchResult.stderr}`);
+      process.exit(1);
+    }
+    if (role === "contributor" && syncSource.remote !== origin) {
+      await fetchRemote(origin);
+    }
+    const div = await getDivergence(baseBranch, syncSource.ref);
+    if (div.ahead > 0 || div.behind > 0) {
+      info(`${pc11.bold(baseBranch)} is ${pc11.yellow(`${div.ahead} ahead`)} and ${pc11.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`Fetching ${upstream}...`);
-      const fetchResult = await fetchRemote(upstream);
-      if (fetchResult.exitCode !== 0) {
-        error(`Failed to fetch ${upstream}: ${fetchResult.stderr}`);
-        process.exit(1);
-      }
-      if (!args.yes) {
-        const ok = await confirmPrompt(`This will reset local ${pc9.bold(devBranch)} to match ${pc9.bold(`${upstream}/${devBranch}`)}.`);
-        if (!ok)
-          process.exit(0);
-      }
-      const coResult = await checkoutBranch(devBranch);
-      if (coResult.exitCode !== 0) {
-        error(`Failed to checkout ${devBranch}: ${coResult.stderr}`);
-        process.exit(1);
-      }
-      const resetResult = await resetHard(`${upstream}/${devBranch}`);
-      if (resetResult.exitCode !== 0) {
-        error(`Failed to reset: ${resetResult.stderr}`);
-        process.exit(1);
-      }
-      const pushResult = await pushForceWithLease(origin, devBranch);
-      if (pushResult.exitCode !== 0) {
-        error(`Failed to push: ${pushResult.stderr}`);
-        process.exit(1);
+      info(`${pc11.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+    }
+    if (!args.yes) {
+      const ok = await confirmPrompt(`This will pull ${pc11.bold(syncSource.ref)} into local ${pc11.bold(baseBranch)}.`);
+      if (!ok)
+        process.exit(0);
+    }
+    const coResult = await checkoutBranch2(baseBranch);
+    if (coResult.exitCode !== 0) {
+      error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
+      process.exit(1);
+    }
+    const pullResult = await pullBranch(syncSource.remote, baseBranch);
+    if (pullResult.exitCode !== 0) {
+      error(`Failed to pull: ${pullResult.stderr}`);
+      process.exit(1);
+    }
+    success(`✅ ${baseBranch} is now in sync with ${syncSource.ref}`);
+    if (hasDevBranch(workflow) && role === "maintainer") {
+      const mainDiv = await getDivergence(config.mainBranch, `${origin}/${config.mainBranch}`);
+      if (mainDiv.behind > 0) {
+        info(`Also syncing ${pc11.bold(config.mainBranch)}...`);
+        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 checkoutBranch2(baseBranch);
       }
-      success(`✅ ${devBranch} has been reset to match ${upstream}/${devBranch} and pushed.`);
     }
   }
 });
 
 // src/commands/update.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { defineCommand as defineCommand8 } from "citty";
-import pc10 from "picocolors";
-var update_default = defineCommand8({
+import { readFileSync as readFileSync4 } from "node:fs";
+import { defineCommand as defineCommand9 } from "citty";
+import pc12 from "picocolors";
+var update_default = defineCommand9({
   meta: {
     name: "update",
-    description: "Rebase current branch onto latest dev"
+    description: "Rebase current branch onto the latest base branch"
   },
   args: {
     model: {
@@ -1264,14 +2484,16 @@ var update_default = defineCommand8({
       error("No .contributerc.json found. Run `contrib setup` first.");
       process.exit(1);
     }
-    const { mainBranch, devBranch, origin, upstream, role } = config;
+    const baseBranch = getBaseBranch(config);
+    const protectedBranches = getProtectedBranches(config);
+    const syncSource = getSyncSource(config);
     const currentBranch = await getCurrentBranch();
     if (!currentBranch) {
       error("Could not determine current branch.");
       process.exit(1);
     }
-    if (currentBranch === mainBranch || currentBranch === devBranch) {
-      error(`Use \`contrib sync\` to update ${pc10.bold(mainBranch)} or ${pc10.bold(devBranch)} branches.`);
+    if (protectedBranches.includes(currentBranch)) {
+      error(`Use \`contrib sync\` to update ${protectedBranches.map((b) => pc12.bold(b)).join(" or ")} branches.`);
       process.exit(1);
     }
     if (await hasUncommittedChanges()) {
@@ -1279,12 +2501,92 @@ var update_default = defineCommand8({
       process.exit(1);
     }
     heading("\uD83D\uDD03 contrib update");
-    info(`Updating ${pc10.bold(currentBranch)} with latest ${pc10.bold(devBranch)}...`);
-    const remote = role === "contributor" ? upstream : origin;
-    const remoteDevRef = role === "contributor" ? `${upstream}/${devBranch}` : `${origin}/${devBranch}`;
-    await fetchRemote(remote);
-    await resetHard(remoteDevRef);
-    const rebaseResult = await rebase(devBranch);
+    const mergedPR = await getMergedPRForBranch(currentBranch);
+    if (mergedPR) {
+      warn(`PR #${mergedPR.number} (${pc12.bold(mergedPR.title)}) has already been merged.`);
+      info(`Link: ${pc12.underline(mergedPR.url)}`);
+      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(`${pc12.bold(currentBranch)} is stale but has local work. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
+        if (action === CANCEL) {
+          info("No changes made. You are still on your current branch.");
+          return;
+        }
+        if (action === SAVE_NEW_BRANCH) {
+          info(pc12.dim("Tip: Describe what you're working on in plain English and we'll generate a branch name."));
+          const description = await inputPrompt("What are you working on?");
+          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(`
+  ${pc12.dim("AI suggestion:")} ${pc12.bold(pc12.cyan(suggested))}`);
+              const accepted = await confirmPrompt(`Use ${pc12.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 ${pc12.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 renameResult = await renameBranch(currentBranch, newBranchName);
+          if (renameResult.exitCode !== 0) {
+            error(`Failed to rename branch: ${renameResult.stderr}`);
+            process.exit(1);
+          }
+          success(`Renamed ${pc12.bold(currentBranch)} → ${pc12.bold(newBranchName)}`);
+          await fetchRemote(syncSource.remote);
+          const savedUpstreamRef = await getUpstreamRef();
+          const rebaseResult2 = savedUpstreamRef && savedUpstreamRef !== syncSource.ref ? await rebaseOnto(syncSource.ref, savedUpstreamRef) : await rebase(syncSource.ref);
+          if (rebaseResult2.exitCode !== 0) {
+            warn("Rebase encountered conflicts. Resolve them manually, then run:");
+            info(`  ${pc12.bold("git rebase --continue")}`);
+          } else {
+            success(`Rebased ${pc12.bold(newBranchName)} onto ${pc12.bold(syncSource.ref)}.`);
+          }
+          info(`All your changes are preserved. Run ${pc12.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 ${pc12.bold(baseBranch)} with ${pc12.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${pc12.bold(currentBranch)}...`);
+      await forceDeleteBranch(currentBranch);
+      success(`Deleted ${pc12.bold(currentBranch)}.`);
+      info(`Run ${pc12.bold("contrib start")} to begin a new feature branch.`);
+      return;
+    }
+    info(`Updating ${pc12.bold(currentBranch)} with latest ${pc12.bold(baseBranch)}...`);
+    await fetchRemote(syncSource.remote);
+    await updateLocalBranch(baseBranch, syncSource.ref);
+    const upstreamRef = await getUpstreamRef();
+    const rebaseResult = upstreamRef && upstreamRef !== syncSource.ref ? await rebaseOnto(syncSource.ref, upstreamRef) : await rebase(syncSource.ref);
     if (rebaseResult.exitCode !== 0) {
       warn("Rebase hit conflicts. Resolve them manually.");
       console.log();
@@ -1296,7 +2598,7 @@ var update_default = defineCommand8({
           let conflictDiff = "";
           for (const file of conflictFiles.slice(0, 3)) {
             try {
-              const content = readFileSync2(file, "utf-8");
+              const content = readFileSync4(file, "utf-8");
               if (content.includes("<<<<<<<")) {
                 conflictDiff += `
 --- ${file} ---
@@ -1306,37 +2608,80 @@ ${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(`
-${pc10.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(pc10.dim("─".repeat(60)));
+${pc12.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(pc12.dim("─".repeat(60)));
               console.log(suggestion);
-              console.log(pc10.dim("─".repeat(60)));
+              console.log(pc12.dim("─".repeat(60)));
               console.log();
+            } else {
+              spinner.fail("AI could not analyze the conflicts.");
             }
           }
         }
       }
-      console.log(pc10.bold("To resolve:"));
+      console.log(pc12.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${pc10.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${pc10.cyan("git rebase --continue")}`);
+      console.log(`  2. ${pc12.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${pc12.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${pc10.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${pc12.cyan("git rebase --abort")}`);
+      process.exit(1);
+    }
+    success(`✅ ${pc12.bold(currentBranch)} has been rebased onto latest ${pc12.bold(baseBranch)}`);
+  }
+});
+
+// src/commands/validate.ts
+import { defineCommand as defineCommand10 } from "citty";
+import pc13 from "picocolors";
+var validate_default = defineCommand10({
+  meta: {
+    name: "validate",
+    description: "Validate a commit message against the configured convention"
+  },
+  args: {
+    message: {
+      type: "positional",
+      description: "The commit message to validate",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
       process.exit(1);
     }
-    success(`✅ ${pc10.bold(currentBranch)} has been rebased onto latest ${pc10.bold(devBranch)}`);
+    const convention = config.commitConvention;
+    if (convention === "none") {
+      info('Commit convention is set to "none". All messages are accepted.');
+      process.exit(0);
+    }
+    const message = args.message;
+    if (validateCommitMessage(message, convention)) {
+      success(`Valid ${CONVENTION_LABELS[convention]} message.`);
+      process.exit(0);
+    }
+    const errors = getValidationError(convention);
+    for (const line of errors) {
+      console.error(pc13.red(`  ✗ ${line}`));
+    }
+    process.exit(1);
   }
 });
 
 // src/ui/banner.ts
 import figlet from "figlet";
-import pc11 from "picocolors";
+import pc14 from "picocolors";
 // package.json
 var package_default = {
   name: "contribute-now",
-  version: "0.1.2",
+  version: "0.2.0-dev.33be40f",
   description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
   type: "module",
   bin: {
@@ -1348,12 +2693,12 @@ var package_default = {
   ],
   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 .",
-    prepare: "husky || true",
     "www:dev": "bun run --cwd www dev",
     "www:build": "bun run --cwd www build",
     "www:preview": "bun run --cwd www preview"
@@ -1380,6 +2725,7 @@ var package_default = {
     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",
@@ -1390,7 +2736,6 @@ var package_default = {
     "@biomejs/biome": "^2.4.4",
     "@types/bun": "latest",
     "@types/figlet": "^1.7.0",
-    husky: "^9.1.7",
     typescript: "^5.7.0"
   }
 };
@@ -1398,9 +2743,10 @@ var package_default = {
 // src/ui/banner.ts
 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";
@@ -1408,16 +2754,15 @@ function getVersion() {
 function getAuthor() {
   return typeof package_default.author === "string" ? package_default.author : "unknown";
 }
-function showBanner(minimal = false) {
-  console.log(pc11.cyan(`
+function showBanner(showLinks = false) {
+  console.log(pc14.cyan(`
 ${LOGO}`));
-  console.log(`  ${pc11.dim(`v${getVersion()}`)} ${pc11.dim("—")} ${pc11.dim(`Built by ${getAuthor()}`)}`);
-  if (!minimal) {
-    console.log(`  ${pc11.dim(package_default.description)}`);
+  console.log(`  ${pc14.dim(`v${getVersion()}`)} ${pc14.dim("—")} ${pc14.dim(`Built by ${getAuthor()}`)}`);
+  if (showLinks) {
     console.log();
-    console.log(`  ${pc11.yellow("Star")}        ${pc11.cyan("https://github.com/warengonzaga/contribute-now")}`);
-    console.log(`  ${pc11.green("Contribute")}  ${pc11.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
-    console.log(`  ${pc11.magenta("Sponsor")}     ${pc11.cyan("https://warengonzaga.com/sponsor")}`);
+    console.log(`  ${pc14.yellow("Star")}        ${pc14.cyan("https://github.com/warengonzaga/contribute-now")}`);
+    console.log(`  ${pc14.green("Contribute")}  ${pc14.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
+    console.log(`  ${pc14.magenta("Sponsor")}     ${pc14.cyan("https://warengonzaga.com/sponsor")}`);
   }
   console.log();
 }
@@ -1425,11 +2770,11 @@ ${LOGO}`));
 // src/index.ts
 var isHelp = process.argv.includes("--help") || process.argv.includes("-h");
 showBanner(isHelp);
-var main = defineCommand9({
+var main = defineCommand11({
   meta: {
     name: "contrib",
     version: getVersion(),
-    description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges."
+    description: "Git workflow CLI that guides contributors through clean branching, commits, and PRs."
   },
   args: {
     version: {
@@ -1446,7 +2791,9 @@ var main = defineCommand9({
     update: update_default,
     submit: submit_default,
     clean: clean_default,
-    status: status_default
+    status: status_default,
+    hook: hook_default,
+    validate: validate_default
   },
   run({ args }) {
     if (args.version) {
@@ -1454,4 +2801,6 @@ var main = defineCommand9({
     }
   }
 });
-runMain(main);
+runMain(main).then(() => {
+  process.exit(0);
+});