contribute-now 0.6.2-dev.12fb962 → 0.6.2-dev.1320af4

package/dist/index.js

@@ -2355,8 +2355,8 @@ var require_semaphore = __commonJS((exports) => {
       this._waiting = [];
     }
     lock(thunk) {
-      return new Promise((resolve2, reject) => {
-        this._waiting.push({ thunk, resolve: resolve2, reject });
+      return new Promise((resolve3, reject) => {
+        this._waiting.push({ thunk, resolve: resolve3, reject });
         this.runNext();
       });
     }
@@ -3847,9 +3847,9 @@ ${JSON.stringify(message, null, 4)}`);
         if (typeof cancellationStrategy.sender.enableCancellation === "function") {
           cancellationStrategy.sender.enableCancellation(requestMessage);
         }
-        return new Promise(async (resolve2, reject) => {
+        return new Promise(async (resolve3, reject) => {
           const resolveWithCleanup = (r3) => {
-            resolve2(r3);
+            resolve3(r3);
             cancellationStrategy.sender.cleanup(id);
             disposable?.dispose();
           };
@@ -4258,10 +4258,10 @@ var require_ril = __commonJS((exports) => {
       return api_1.Disposable.create(() => this.stream.off("end", listener));
     }
     write(data, encoding) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         const callback = (error2) => {
           if (error2 === undefined || error2 === null) {
-            resolve2();
+            resolve3();
           } else {
             reject(error2);
           }
@@ -4520,10 +4520,10 @@ var require_main = __commonJS((exports) => {
   exports.generateRandomPipeName = generateRandomPipeName;
   function createClientPipeTransport(pipeName, encoding = "utf-8") {
     let connectResolve;
-    const connected = new Promise((resolve2, _reject) => {
-      connectResolve = resolve2;
+    const connected = new Promise((resolve3, _reject) => {
+      connectResolve = resolve3;
     });
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       let server = (0, net_1.createServer)((socket) => {
         server.close();
         connectResolve([
@@ -4534,7 +4534,7 @@ var require_main = __commonJS((exports) => {
       server.on("error", reject);
       server.listen(pipeName, () => {
         server.removeListener("error", reject);
-        resolve2({
+        resolve3({
           onConnected: () => {
             return connected;
           }
@@ -4553,10 +4553,10 @@ var require_main = __commonJS((exports) => {
   exports.createServerPipeTransport = createServerPipeTransport;
   function createClientSocketTransport(port, encoding = "utf-8") {
     let connectResolve;
-    const connected = new Promise((resolve2, _reject) => {
-      connectResolve = resolve2;
+    const connected = new Promise((resolve3, _reject) => {
+      connectResolve = resolve3;
     });
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const server = (0, net_1.createServer)((socket) => {
         server.close();
         connectResolve([
@@ -4567,7 +4567,7 @@ var require_main = __commonJS((exports) => {
       server.on("error", reject);
       server.listen(port, "127.0.0.1", () => {
         server.removeListener("error", reject);
-        resolve2({
+        resolve3({
           onConnected: () => {
             return connected;
           }
@@ -4691,8 +4691,8 @@ class CopilotSession {
     const effectiveTimeout = timeout ?? 60000;
     let resolveIdle;
     let rejectWithError;
-    const idlePromise = new Promise((resolve2, reject) => {
-      resolveIdle = resolve2;
+    const idlePromise = new Promise((resolve3, reject) => {
+      resolveIdle = resolve3;
       rejectWithError = reject;
     });
     let lastAssistantMessage;
@@ -4857,7 +4857,7 @@ var init_session = __esm(() => {
 import { spawn } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
 import { Socket } from "node:net";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname3, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 function isZodSchema(value) {
   return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
@@ -4879,7 +4879,7 @@ function getNodeExecPath() {
 function getBundledCliPath() {
   const sdkUrl = import.meta.resolve("@github/copilot/sdk");
   const sdkPath = fileURLToPath(sdkUrl);
-  return join3(dirname2(dirname2(sdkPath)), "index.js");
+  return join3(dirname3(dirname3(sdkPath)), "index.js");
 }
 
 class CopilotClient {
@@ -4984,7 +4984,7 @@ class CopilotClient {
           lastError = error2 instanceof Error ? error2 : new Error(String(error2));
           if (attempt < 3) {
             const delay = 100 * Math.pow(2, attempt - 1);
-            await new Promise((resolve2) => setTimeout(resolve2, delay));
+            await new Promise((resolve3) => setTimeout(resolve3, delay));
           }
         }
       }
@@ -5184,8 +5184,8 @@ class CopilotClient {
     }
     await this.modelsCacheLock;
     let resolveLock;
-    this.modelsCacheLock = new Promise((resolve2) => {
-      resolveLock = resolve2;
+    this.modelsCacheLock = new Promise((resolve3) => {
+      resolveLock = resolve3;
     });
     try {
       if (this.modelsCache !== null) {
@@ -5290,7 +5290,7 @@ class CopilotClient {
     };
   }
   async startCLIServer() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       this.stderrBuffer = "";
       const args = [
         ...this.options.cliArgs,
@@ -5339,7 +5339,7 @@ class CopilotClient {
       let resolved = false;
       if (this.options.useStdio) {
         resolved = true;
-        resolve2();
+        resolve3();
       } else {
         this.cliProcess.stdout?.on("data", (data) => {
           stdout2 += data.toString();
@@ -5347,7 +5347,7 @@ class CopilotClient {
           if (match && !resolved) {
             this.actualPort = parseInt(match[1], 10);
             resolved = true;
-            resolve2();
+            resolve3();
           }
         });
       }
@@ -5434,13 +5434,13 @@ stderr: ${stderrOutput}`));
     if (!this.actualPort) {
       throw new Error("Server port not available");
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       this.socket = new Socket;
       this.socket.connect(this.actualPort, this.actualHost, () => {
         this.connection = import_node.createMessageConnection(new import_node.StreamMessageReader(this.socket), new import_node.StreamMessageWriter(this.socket));
         this.attachConnectionHandlers();
         this.connection.listen();
-        resolve2();
+        resolve3();
       });
       this.socket.on("error", (error2) => {
         reject(new Error(`Failed to connect to CLI server: ${error2.message}`));
@@ -7047,22 +7047,56 @@ async function runMain(cmd, opts = {}) {
 var import_picocolors2 = __toESM(require_picocolors(), 1);
 
 // src/utils/config.ts
-import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
 var CONFIG_FILENAME = ".contributerc.json";
-function getConfigPath(cwd = process.cwd()) {
-  return join(cwd, CONFIG_FILENAME);
-}
-function configExists(cwd = process.cwd()) {
-  return existsSync(getConfigPath(cwd));
+var LOCAL_CONFIG_DIRNAME = "contribute-now";
+var LOCAL_CONFIG_FILENAME = "config.json";
+function findRepoRoot(cwd = process.cwd()) {
+  let current = resolve(cwd);
+  while (true) {
+    if (existsSync(join(current, ".git"))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
 }
-var VALID_WORKFLOWS = ["clean-flow", "github-flow", "git-flow"];
-var VALID_ROLES = ["maintainer", "contributor"];
-var VALID_CONVENTIONS = ["conventional", "clean-commit", "none"];
-function readConfig(cwd = process.cwd()) {
-  const path = getConfigPath(cwd);
-  if (!existsSync(path))
+function resolveGitDir(cwd = process.cwd()) {
+  const repoRoot = findRepoRoot(cwd);
+  if (!repoRoot) {
+    return null;
+  }
+  const dotGitPath = join(repoRoot, ".git");
+  try {
+    const stat = statSync(dotGitPath);
+    if (stat.isDirectory()) {
+      return dotGitPath;
+    }
+    if (!stat.isFile()) {
+      return null;
+    }
+    const content = readFileSync(dotGitPath, "utf-8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(content);
+    if (!match) {
+      return null;
+    }
+    return resolve(repoRoot, match[1].trim());
+  } catch {
     return null;
+  }
+}
+function parseConfigFile(path) {
   try {
     const raw = readFileSync(path, "utf-8");
     const parsed = JSON.parse(raw);
@@ -7070,44 +7104,112 @@ function readConfig(cwd = process.cwd()) {
       return null;
     }
     if (!VALID_WORKFLOWS.includes(parsed.workflow)) {
-      console.error(`Invalid workflow "${parsed.workflow}" in .contributerc.json. Valid: ${VALID_WORKFLOWS.join(", ")}`);
+      console.error(`Invalid workflow "${parsed.workflow}" in ${path.endsWith(CONFIG_FILENAME) ? CONFIG_FILENAME : LOCAL_CONFIG_FILENAME}. Valid: ${VALID_WORKFLOWS.join(", ")}`);
       return null;
     }
     if (!VALID_ROLES.includes(parsed.role)) {
-      console.error(`Invalid role "${parsed.role}" in .contributerc.json. Valid: ${VALID_ROLES.join(", ")}`);
+      console.error(`Invalid role "${parsed.role}" in ${path.endsWith(CONFIG_FILENAME) ? CONFIG_FILENAME : LOCAL_CONFIG_FILENAME}. Valid: ${VALID_ROLES.join(", ")}`);
       return null;
     }
     if (!VALID_CONVENTIONS.includes(parsed.commitConvention)) {
-      console.error(`Invalid commitConvention "${parsed.commitConvention}" in .contributerc.json. Valid: ${VALID_CONVENTIONS.join(", ")}`);
+      console.error(`Invalid commitConvention "${parsed.commitConvention}" in ${path.endsWith(CONFIG_FILENAME) ? CONFIG_FILENAME : LOCAL_CONFIG_FILENAME}. Valid: ${VALID_CONVENTIONS.join(", ")}`);
       return null;
     }
     if (!parsed.mainBranch.trim()) {
-      console.error("Invalid .contributerc.json: mainBranch must not be empty.");
+      console.error(`Invalid config (${path}): mainBranch must not be empty.`);
       return null;
     }
     if (!parsed.origin.trim()) {
-      console.error("Invalid .contributerc.json: origin must not be empty.");
+      console.error(`Invalid config (${path}): origin must not be empty.`);
       return null;
     }
     if (parsed.role === "contributor" && !parsed.upstream.trim()) {
-      console.error("Invalid .contributerc.json: upstream must not be empty for contributors.");
+      console.error(`Invalid config (${path}): upstream must not be empty for contributors.`);
       return null;
     }
     if (parsed.branchPrefixes.length === 0) {
-      console.error("Invalid .contributerc.json: branchPrefixes must not be empty.");
+      console.error(`Invalid config (${path}): branchPrefixes must not be empty.`);
       return null;
     }
     if (!parsed.branchPrefixes.every((p) => typeof p === "string" && p.trim().length > 0)) {
-      console.error("Invalid .contributerc.json: all branchPrefixes must be non-empty strings.");
+      console.error(`Invalid config (${path}): all branchPrefixes must be non-empty strings.`);
       return null;
     }
-    return parsed;
+    return {
+      ...parsed,
+      aiEnabled: parsed.aiEnabled !== false,
+      showTips: parsed.showTips !== false,
+      guideRotation: parsed.guideRotation && typeof parsed.guideRotation === "object" ? parsed.guideRotation : {}
+    };
   } catch {
     return null;
   }
 }
+function getConfigPath(cwd = process.cwd()) {
+  const legacyPath = getLegacyConfigPath(cwd);
+  if (existsSync(legacyPath)) {
+    return legacyPath;
+  }
+  return getLocalConfigPath(cwd) ?? legacyPath;
+}
+function getLegacyConfigPath(cwd = process.cwd()) {
+  return join(findRepoRoot(cwd) ?? cwd, CONFIG_FILENAME);
+}
+function getLocalConfigPath(cwd = process.cwd()) {
+  const gitDir = resolveGitDir(cwd);
+  if (!gitDir) {
+    return null;
+  }
+  return join(gitDir, LOCAL_CONFIG_DIRNAME, LOCAL_CONFIG_FILENAME);
+}
+function getConfigSource(cwd = process.cwd()) {
+  if (existsSync(getLegacyConfigPath(cwd))) {
+    return "legacy";
+  }
+  const localPath = getLocalConfigPath(cwd);
+  if (localPath && existsSync(localPath)) {
+    return "local";
+  }
+  return null;
+}
+function hasLegacyConfig(cwd = process.cwd()) {
+  return existsSync(getLegacyConfigPath(cwd));
+}
+function hasLocalConfig(cwd = process.cwd()) {
+  const localPath = getLocalConfigPath(cwd);
+  return !!localPath && existsSync(localPath);
+}
+function getConfigLocationLabel(cwd = process.cwd()) {
+  const source = getConfigSource(cwd);
+  if (source === "legacy") {
+    return CONFIG_FILENAME;
+  }
+  return getLocalConfigPath(cwd) ? `.git/${LOCAL_CONFIG_DIRNAME}/${LOCAL_CONFIG_FILENAME}` : CONFIG_FILENAME;
+}
+function configExists(cwd = process.cwd()) {
+  return getConfigSource(cwd) !== null;
+}
+var VALID_WORKFLOWS = ["clean-flow", "github-flow", "git-flow"];
+var VALID_ROLES = ["maintainer", "contributor"];
+var VALID_CONVENTIONS = ["conventional", "clean-commit", "none"];
+function isAIEnabled(config, cliNoAI = false) {
+  return config.aiEnabled !== false && !cliNoAI;
+}
+function shouldShowTips(config) {
+  return config?.showTips !== false;
+}
+function readConfig(cwd = process.cwd()) {
+  const source = getConfigSource(cwd);
+  if (!source)
+    return null;
+  const path = source === "local" ? getLocalConfigPath(cwd) : getLegacyConfigPath(cwd);
+  if (!path)
+    return null;
+  return parseConfigFile(path);
+}
 function writeConfig(config, cwd = process.cwd()) {
   const path = getConfigPath(cwd);
+  mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
 }
@@ -7123,23 +7225,6 @@ function isGitignored(cwd = process.cwd()) {
     return false;
   }
 }
-function ensureGitignored(cwd = process.cwd()) {
-  if (isGitignored(cwd))
-    return false;
-  const gitignorePath = join(cwd, ".gitignore");
-  const line = `${CONFIG_FILENAME}
-`;
-  if (!existsSync(gitignorePath)) {
-    writeFileSync(gitignorePath, line, "utf-8");
-    return true;
-  }
-  const content = readFileSync(gitignorePath, "utf-8");
-  const needsLeadingNewline = content.length > 0 && !content.endsWith(`
-`);
-  appendFileSync(gitignorePath, `${needsLeadingNewline ? `
-` : ""}${line}`, "utf-8");
-  return true;
-}
 function getDefaultConfig() {
   return {
     workflow: "clean-flow",
@@ -7149,7 +7234,10 @@ function getDefaultConfig() {
     upstream: "upstream",
     origin: "origin",
     branchPrefixes: ["feature", "fix", "docs", "chore", "test", "refactor"],
-    commitConvention: "clean-commit"
+    commitConvention: "clean-commit",
+    aiEnabled: true,
+    showTips: true,
+    guideRotation: {}
   };
 }
 
@@ -7158,9 +7246,9 @@ import { execFile as execFileCb } from "node:child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
 function run(args) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     execFileCb("git", args, (error, stdout2, stderr) => {
-      resolve({
+      resolve2({
         exitCode: error ? error.code === "ENOENT" ? 127 : error.status ?? 1 : 0,
         stdout: stdout2 ?? "",
         stderr: stderr ?? ""
@@ -7625,41 +7713,6 @@ async function getLocalCommitsEntries(options) {
     return { hash: hash.trim(), subject: subject.trim(), refs: refs.trim() };
   });
 }
-async function getRemoteOnlyCommitsGraph(options) {
-  const count = options?.count ?? 20;
-  const upstream = options?.upstream;
-  if (!upstream)
-    return [];
-  const args = [
-    "log",
-    "--oneline",
-    "--graph",
-    "--decorate",
-    `--max-count=${count}`,
-    "--color=never",
-    `HEAD..${upstream}`
-  ];
-  const { exitCode, stdout: stdout2 } = await run(args);
-  if (exitCode !== 0)
-    return [];
-  return stdout2.trimEnd().split(`
-`).filter(Boolean);
-}
-async function getRemoteOnlyCommitsEntries(options) {
-  const count = options?.count ?? 20;
-  const upstream = options?.upstream;
-  if (!upstream)
-    return [];
-  const args = ["log", `--format=%h||%s||%D`, `--max-count=${count}`, `HEAD..${upstream}`];
-  const { exitCode, stdout: stdout2 } = await run(args);
-  if (exitCode !== 0)
-    return [];
-  return stdout2.trimEnd().split(`
-`).filter(Boolean).map((line) => {
-    const [hash = "", subject = "", refs = ""] = line.split("||");
-    return { hash: hash.trim(), subject: subject.trim(), refs: refs.trim() };
-  });
-}
 async function getLocalBranches() {
   const { exitCode, stdout: stdout2 } = await run(["branch", "-vv", "--no-color"]);
   if (exitCode !== 0)
@@ -8756,6 +8809,233 @@ var LogEngine = {
 
 // src/utils/logger.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
+
+// src/utils/tips.ts
+var COMMAND_GUIDES = {
+  setup: {
+    summary: "Initialize workflow rules, remotes, AI settings, and personal repo defaults.",
+    examples: [
+      { command: "cn setup --help", description: "learn all setup options and prompts" },
+      { command: "cn setup", description: "initialize workflow, conventions, and remotes" },
+      {
+        command: "cn setup",
+        description: "re-run setup to update repo preferences for this clone"
+      },
+      {
+        command: "cn setup",
+        description: "migrate legacy repo-root config into local Git storage"
+      }
+    ]
+  },
+  start: {
+    summary: "Create a new working branch from the correct base branch for your workflow.",
+    examples: [
+      { command: "cn start --help", description: "learn branch naming and creation flags" },
+      {
+        command: "cn start feature/user-auth",
+        description: "create a branch from an explicit name"
+      },
+      {
+        command: 'cn start "fix login timeout"',
+        description: "describe the work and let the CLI help"
+      },
+      {
+        command: 'cn start "fix login timeout" --no-ai',
+        description: "skip AI and keep control manual"
+      }
+    ]
+  },
+  sync: {
+    summary: "Sync your protected branches with the right upstream source for your role.",
+    examples: [
+      { command: "cn sync --help", description: "learn sync modes and confirmation flags" },
+      { command: "cn sync", description: "pull the right base branch for your workflow" },
+      { command: "cn sync --yes", description: "skip the confirmation prompt" },
+      { command: "cn sync", description: "refresh local protected branches before feature work" }
+    ]
+  },
+  commit: {
+    summary: "Stage changes, validate the message format, and create one or more commits.",
+    examples: [
+      { command: "cn commit --help", description: "learn commit generation and grouping flags" },
+      { command: "cn commit", description: "stage and create one commit" },
+      { command: "cn commit --no-ai", description: "write the commit message yourself" },
+      { command: "cn commit --group", description: "split a large changeset into atomic commits" }
+    ]
+  },
+  update: {
+    summary: "Rebase your current feature branch onto the latest configured base branch.",
+    examples: [
+      { command: "cn update --help", description: "learn rebase and conflict guidance options" },
+      { command: "cn update", description: "rebase your branch onto the latest base branch" },
+      { command: "cn update --no-ai", description: "skip AI conflict guidance" },
+      { command: "cn update", description: "refresh your branch before pushing or opening a PR" }
+    ]
+  },
+  submit: {
+    summary: "Push your branch and submit it through a pull request or local merge flow.",
+    examples: [
+      { command: "cn submit --help", description: "learn PR and local submit modes" },
+      { command: "cn submit", description: "push and create or update a PR" },
+      { command: "cn submit --pullrequest", description: "go straight to the PR flow" },
+      { command: "cn submit -l", description: "maintainers can squash-merge locally" }
+    ]
+  },
+  switch: {
+    summary: "Switch branches safely and protect uncommitted work before moving around.",
+    examples: [
+      { command: "cn switch --help", description: "learn interactive and direct switch usage" },
+      { command: "cn switch", description: "pick a branch interactively" },
+      { command: "cn switch feature/login-fix", description: "switch directly to a named branch" },
+      { command: "cn switch dev", description: "jump back to a protected branch directly" }
+    ]
+  },
+  save: {
+    summary: "Store uncommitted work for later and restore or delete saved change sets.",
+    examples: [
+      { command: "cn save --help", description: "learn save, restore, list, and drop actions" },
+      { command: "cn save", description: "stash current uncommitted work" },
+      { command: "cn save --restore", description: "bring back a saved change set" },
+      { command: "cn save --list", description: "review what you saved before restoring" },
+      { command: "cn save --drop", description: "discard a saved change set you no longer need" }
+    ]
+  },
+  clean: {
+    summary: "Delete merged or stale branches and keep the local repo tidy.",
+    examples: [
+      { command: "cn clean --help", description: "learn cleanup behavior and shortcuts" },
+      { command: "cn clean", description: "review merged and stale branches before deleting" },
+      { command: "cn clean --yes", description: "skip the confirmation prompt" },
+      { command: "cn clean", description: "remove stale local branches after merge cleanup" }
+    ]
+  },
+  status: {
+    summary: "Inspect branch alignment, working tree state, and next recommended actions.",
+    examples: [
+      { command: "cn status --help", description: "learn what the status dashboard shows" },
+      { command: "cn status", description: "see branch alignment and working tree state" },
+      { command: "cn status", description: "check whether protected branches are aligned" },
+      { command: "cn status", description: "review staged, modified, and untracked files" }
+    ]
+  },
+  log: {
+    summary: "View commit history for your current branch, remote diffs, or the full repo graph.",
+    examples: [
+      { command: "cn log --help", description: "learn all log views and filtering flags" },
+      { command: "cn log", description: "show local and remote history in one split view" },
+      { command: "cn log --local", description: "show only local unpushed commits" },
+      { command: "cn log --remote", description: "show only remote branch history" },
+      { command: "cn log --full", description: "show full history for the current branch" },
+      { command: "cn log --all", description: "show history across all branches" },
+      { command: "cn log -b dev", description: "inspect a specific branch" }
+    ]
+  },
+  branch: {
+    summary: "List branches with workflow-aware labels and local or remote tracking details.",
+    examples: [
+      { command: "cn branch --help", description: "learn branch list modes and filters" },
+      { command: "cn branch", description: "list local branches and tracking info" },
+      { command: "cn branch --all", description: "include local and remote branches" },
+      { command: "cn branch --remote", description: "show only remote branches" }
+    ]
+  },
+  hook: {
+    summary: "Install or remove a managed commit-msg hook for commit convention validation.",
+    examples: [
+      { command: "cn hook --help", description: "learn hook install and uninstall usage" },
+      { command: "cn hook install", description: "validate commit messages automatically" },
+      { command: "cn hook uninstall", description: "remove the managed git hook" },
+      {
+        command: "cn hook install",
+        description: "keep commit convention checks active in this clone"
+      }
+    ]
+  },
+  validate: {
+    summary: "Check a commit message against the repository commit convention rules.",
+    examples: [
+      {
+        command: "cn validate --help",
+        description: "learn direct and file-based validation usage"
+      },
+      {
+        command: 'cn validate "\uD83D\uDD27 update: tidy config"',
+        description: "validate one message inline"
+      },
+      {
+        command: "cn validate --file .git/COMMIT_EDITMSG",
+        description: "validate a commit message file"
+      },
+      {
+        command: 'cn validate "\uD83D\uDCE6 new: add API client"',
+        description: "check another message before committing"
+      }
+    ]
+  },
+  doctor: {
+    summary: "Run environment, dependency, config, and workflow diagnostics for the CLI.",
+    examples: [
+      { command: "cn doctor --help", description: "learn human and JSON output modes" },
+      { command: "cn doctor", description: "run a full environment and config check" },
+      { command: "cn doctor --json", description: "export machine-readable diagnostics" },
+      {
+        command: "cn doctor",
+        description: "check config, remotes, and workflow resolution together"
+      }
+    ]
+  }
+};
+var LOADING_TIPS = [
+  "Manual commit mode: cn commit --no-ai",
+  'Disable AI for this clone: set "aiEnabled": false',
+  'Describe work for naming help: cn start "fix login timeout"',
+  "Remote-only history: cn log --remote",
+  "Skip PR mode prompt: cn submit --pullrequest"
+];
+function getVisibleCommandGuide(command, rotationIndex = 0) {
+  const key = normalizeCommandKey(command);
+  const guide = COMMAND_GUIDES[key];
+  if (!guide)
+    return null;
+  const helpExample = guide.examples.find((example) => example.command.endsWith("--help")) ?? null;
+  const rotatingExamples = dedupeGuideExamples(helpExample ? guide.examples.filter((example) => example !== helpExample) : [...guide.examples]);
+  const visibleExamples = [];
+  if (helpExample) {
+    visibleExamples.push(helpExample);
+  }
+  const remainingSlots = Math.max(0, 3 - visibleExamples.length);
+  if (rotatingExamples.length <= remainingSlots) {
+    visibleExamples.push(...rotatingExamples);
+  } else {
+    for (let index = 0;index < remainingSlots; index++) {
+      visibleExamples.push(rotatingExamples[(rotationIndex + index) % rotatingExamples.length]);
+    }
+  }
+  return {
+    guide,
+    examples: visibleExamples.slice(0, 3),
+    rotatableCount: rotatingExamples.length,
+    key
+  };
+}
+function normalizeCommandKey(command) {
+  const normalized = command.replace(/\s*\(.+\)$/, "").trim();
+  return normalized.split(/\s+/)[0] ?? normalized;
+}
+function dedupeGuideExamples(examples) {
+  const seen = new Set;
+  const deduped = [];
+  for (const example of examples) {
+    if (seen.has(example.command)) {
+      continue;
+    }
+    seen.add(example.command);
+    deduped.push(example);
+  }
+  return deduped;
+}
+
+// src/utils/logger.ts
 LogEngine.configure({
   mode: LogMode.INFO,
   format: {
@@ -8776,9 +9056,63 @@ function warn(msg, emoji = "⚠️") {
 function info(msg, emoji = "ℹ️") {
   LogEngine.info(msg, undefined, { emoji });
 }
-function heading(msg) {
-  console.log(`
-${import_picocolors.default.bold(msg)}`);
+function projectHeading(command, emoji) {
+  const prefix = emoji ? `${emoji} ` : "";
+  console.log(`  ${import_picocolors.default.bold(import_picocolors.default.cyan(`${prefix}${command}`))}`);
+  const config = readConfig();
+  const rotationIndex = config?.guideRotation?.[normalizeGuideKey(command)] ?? 0;
+  const visibleGuide = getVisibleCommandGuide(command, rotationIndex);
+  if (visibleGuide) {
+    console.log(`  ${import_picocolors.default.dim(visibleGuide.guide.summary)}`);
+  }
+  if (!shouldShowTips(config)) {
+    return;
+  }
+  if (!visibleGuide || visibleGuide.examples.length === 0) {
+    return;
+  }
+  if (config && visibleGuide.rotatableCount > 0) {
+    config.guideRotation = config.guideRotation ?? {};
+    config.guideRotation[visibleGuide.key] = (rotationIndex + 1) % visibleGuide.rotatableCount;
+    writeConfig(config);
+  }
+  console.log();
+  const terminalWidth = process.stdout.columns ?? 80;
+  const maxContentWidth = Math.max(28, terminalWidth - 8);
+  const commandWidth = visibleGuide.examples.reduce((max, example) => Math.max(max, example.command.length), 0);
+  const descriptionWidth = Math.max(12, maxContentWidth - commandWidth - 2);
+  const rows = visibleGuide.examples.map((example) => {
+    const description = truncateText(example.description, descriptionWidth);
+    const commandText = example.command.padEnd(commandWidth + 2);
+    return {
+      commandText,
+      description,
+      rawLength: commandText.length + description.length
+    };
+  });
+  const contentWidth = Math.min(maxContentWidth, Math.max(28, ...rows.map((row) => row.rawLength)));
+  const label = "─ quick guide ";
+  const topBorder = `┌${label}${"─".repeat(Math.max(1, contentWidth - label.length + 1))}┐`;
+  console.log(`  ${import_picocolors.default.dim(topBorder)}`);
+  for (const row of rows) {
+    const left = import_picocolors.default.cyan(row.commandText);
+    const right = import_picocolors.default.dim(row.description);
+    const trailing = " ".repeat(Math.max(0, contentWidth - row.rawLength));
+    console.log(`  ${import_picocolors.default.dim("│")} ${left}${right}${trailing}${import_picocolors.default.dim("│")}`);
+  }
+  console.log(`  ${import_picocolors.default.dim(`└${"─".repeat(contentWidth + 1)}┘`)}`);
+}
+function normalizeGuideKey(command) {
+  return command.replace(/\s*\(.+\)$/, "").trim().split(/\s+/)[0] ?? command;
+}
+function truncateText(text, maxWidth) {
+  if (text.length <= maxWidth) {
+    return text;
+  }
+  if (maxWidth <= 1) {
+    return text.slice(0, maxWidth);
+  }
+  return `${text.slice(0, maxWidth - 1)}…`;
 }
 
 // src/utils/workflow.ts
@@ -8871,7 +9205,7 @@ var branch_default = defineCommand({
     const currentBranch = await getCurrentBranch();
     const showRemoteOnly = args.remote;
     const showAll = args.all;
-    heading("\uD83C\uDF3F branches");
+    projectHeading("branch", "\uD83C\uDF3F");
     console.log();
     if (!showRemoteOnly) {
       const localBranches = await getLocalBranches();
@@ -8926,20 +9260,6 @@ var branch_default = defineCommand({
         }
       }
     }
-    const tips = [];
-    if (!showAll && !showRemoteOnly) {
-      tips.push(`Use ${import_picocolors2.default.bold("contrib branch -a")} to include remote branches`);
-    }
-    if (!showRemoteOnly) {
-      tips.push(`Use ${import_picocolors2.default.bold("contrib start")} to create a new feature branch`);
-      tips.push(`Use ${import_picocolors2.default.bold("contrib clean")} to remove merged/stale branches`);
-    }
-    if (tips.length > 0) {
-      console.log(`  ${import_picocolors2.default.dim("\uD83D\uDCA1 Tip:")}`);
-      for (const tip of tips) {
-        console.log(`     ${import_picocolors2.default.dim(tip)}`);
-      }
-    }
     console.log();
   }
 });
@@ -8981,6 +9301,9 @@ function groupByRemote(branches) {
 }
 
 // src/commands/clean.ts
+var import_picocolors8 = __toESM(require_picocolors(), 1);
+
+// src/utils/branchPrompt.ts
 var import_picocolors7 = __toESM(require_picocolors(), 1);
 
 // src/utils/branch.ts
@@ -10168,11 +10491,11 @@ function suppressSubprocessWarnings() {
   process.env.NODE_NO_WARNINGS = "1";
 }
 function withTimeout(promise, ms) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const timer = setTimeout(() => reject(new Error(`Copilot request timed out after ${ms / 1000}s`)), ms);
     promise.then((val) => {
       clearTimeout(timer);
-      resolve2(val);
+      resolve3(val);
     }, (err) => {
       clearTimeout(timer);
       reject(err);
@@ -10183,10 +10506,84 @@ var COPILOT_TIMEOUT_MS = 30000;
 var COPILOT_LONG_TIMEOUT_MS = 90000;
 var BATCH_CONFIG = {
   LARGE_CHANGESET_THRESHOLD: 15,
+  DIRECT_BATCH_THRESHOLD: 40,
   COMPACT_PER_FILE_CHARS: 300,
   MAX_COMPACT_PAYLOAD: 1e4,
-  FALLBACK_BATCH_SIZE: 15
+  FALLBACK_BATCH_SIZE: 8
 };
+function getRecoveryGroupKey(file) {
+  const parts = file.split("/").filter(Boolean);
+  const [topLevel = "", secondLevel = ""] = parts;
+  const extension = parts.at(-1)?.split(".").at(-1)?.toLowerCase() ?? "";
+  if (topLevel === "src" || topLevel === "tests") {
+    return `${topLevel}/${secondLevel || "root"}`;
+  }
+  if (topLevel === "docs" || topLevel === "landing") {
+    return topLevel;
+  }
+  if (!topLevel.includes(".")) {
+    return topLevel || "root";
+  }
+  if (extension === "md" || extension === "mdx") {
+    return "root-docs";
+  }
+  if (["json", "yaml", "yml", "toml"].includes(extension)) {
+    return "root-config";
+  }
+  return "root";
+}
+function createFallbackMessageForGroup(files, key, convention) {
+  const countLabel = files.length === 1 ? "file" : "files";
+  if (key === "docs" || key === "root-docs") {
+    return convention === "conventional" ? `docs: update ${files.length} documentation ${countLabel}` : convention === "clean-commit" ? `\uD83D\uDCD6 docs: update ${files.length} documentation ${countLabel}` : `update ${files.length} documentation ${countLabel}`;
+  }
+  if (key.startsWith("tests/")) {
+    const scope = key.split("/")[1];
+    return convention === "conventional" ? `test${scope && scope !== "root" ? `(${scope})` : ""}: update ${files.length} test ${countLabel}` : convention === "clean-commit" ? `\uD83E\uDDEA test${scope && scope !== "root" ? ` (${scope})` : ""}: update ${files.length} test ${countLabel}` : `update ${files.length} test ${countLabel}`;
+  }
+  if (key === "landing") {
+    return convention === "conventional" ? `chore(ui): update ${files.length} landing ${countLabel}` : convention === "clean-commit" ? `\uD83D\uDD27 update (ui): update ${files.length} landing ${countLabel}` : `update ${files.length} landing ${countLabel}`;
+  }
+  if (key === "root-config") {
+    return convention === "conventional" ? `chore(config): update ${files.length} config ${countLabel}` : convention === "clean-commit" ? `⚙️ setup (config): update ${files.length} config ${countLabel}` : `update ${files.length} config ${countLabel}`;
+  }
+  if (key.startsWith("src/")) {
+    const scope = key.split("/")[1];
+    const scopeLabel = scope && scope !== "root" ? scope : "code";
+    return convention === "conventional" ? `chore(${scopeLabel}): update ${files.length} source ${countLabel}` : convention === "clean-commit" ? `\uD83D\uDD27 update (${scopeLabel}): update ${files.length} source ${countLabel}` : `update ${files.length} source ${countLabel}`;
+  }
+  return convention === "conventional" ? `chore: update ${files.length} repo ${countLabel}` : convention === "clean-commit" ? `☕ chore: update ${files.length} repo ${countLabel}` : `update ${files.length} repo ${countLabel}`;
+}
+function createRecoveryCommitGroups(files, convention = "clean-commit") {
+  if (files.length === 0) {
+    return [];
+  }
+  const grouped = new Map;
+  for (const file of files) {
+    const key = getRecoveryGroupKey(file);
+    const entry = grouped.get(key);
+    if (entry) {
+      entry.push(file);
+    } else {
+      grouped.set(key, [file]);
+    }
+  }
+  const result = [];
+  for (const [key, groupedFiles] of grouped.entries()) {
+    for (let index = 0;index < groupedFiles.length; index += BATCH_CONFIG.FALLBACK_BATCH_SIZE) {
+      const chunk = groupedFiles.slice(index, index + BATCH_CONFIG.FALLBACK_BATCH_SIZE);
+      result.push({
+        files: chunk,
+        message: createFallbackMessageForGroup(chunk, key, convention)
+      });
+    }
+  }
+  return result;
+}
+function hasIncompleteDiffCoverage(files, rawDiff) {
+  const diffSections = parseDiffByFile(rawDiff);
+  return files.some((file) => !diffSections.has(file));
+}
 function parseDiffByFile(rawDiff) {
   const sections = new Map;
   const headerPattern = /^diff --git a\/(.+?) b\/(.+?)$/gm;
@@ -10254,7 +10651,7 @@ ${truncated}
   return result.length > maxTotalChars ? `${result.slice(0, maxTotalChars - 15)}
 ...(truncated)` : result;
 }
-async function checkCopilotAvailable() {
+async function checkCopilotAvailable2() {
   try {
     const client = await getManagedClient();
     try {
@@ -10358,13 +10755,14 @@ function sanitizeGeneratedCommitMessage(message) {
 async function generateCommitMessage(diff, stagedFiles, model, convention = "clean-commit", context) {
   try {
     const isLarge = stagedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD;
+    const hasMissingDiffCoverage = hasIncompleteDiffCoverage(stagedFiles, diff);
     const multiFileHint = stagedFiles.length > 1 ? `
 
 IMPORTANT: Multiple files are staged. Generate ONE commit message that captures the high-level purpose of ALL changes together. Focus on the overall intent, not individual file changes. Be specific but concise — do not list every file.` : "";
     const squashHint = context === "squash-merge" ? `
 
 CONTEXT: This is a squash merge of an entire feature branch into the base branch. All commits are being combined into ONE single commit. Generate a single high-level summary that describes the overall feature or change — NOT a list of individual commits. Think: what capability was added or what problem was solved? Be specific but concise.` : "";
-    const diffContent = isLarge ? createCompactDiff(stagedFiles, diff) : diff.slice(0, 4000);
+    const diffContent = isLarge || hasMissingDiffCoverage ? createCompactDiff(stagedFiles, diff) : diff.slice(0, 4000);
     const userMessage = `Generate a commit message for these staged changes:
 
 Files (${stagedFiles.length}): ${stagedFiles.join(", ")}
@@ -10453,9 +10851,15 @@ function normalizeCommitGroups(changedFiles, groups) {
     unassignedFiles
   };
 }
-async function generateCommitGroups(files, diffs, model, convention = "clean-commit") {
+async function generateCommitGroups(files, diffs, model, convention = "clean-commit", onProgress) {
   const isLarge = files.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD;
-  const diffContent = isLarge ? createCompactDiff(files, diffs) : diffs.slice(0, 6000);
+  const shouldBatchImmediately = files.length >= BATCH_CONFIG.DIRECT_BATCH_THRESHOLD;
+  const hasMissingDiffCoverage = hasIncompleteDiffCoverage(files, diffs);
+  if (shouldBatchImmediately) {
+    onProgress?.(`Large changeset detected. Grouping in focused batches of ${BATCH_CONFIG.FALLBACK_BATCH_SIZE} files...`);
+    return generateCommitGroupsInBatches(files, diffs, model, convention, onProgress);
+  }
+  const diffContent = isLarge || hasMissingDiffCoverage ? createCompactDiff(files, diffs) : diffs.slice(0, 6000);
   const largeHint = isLarge ? `
 
 NOTE: This is a large changeset (${files.length} files). Compact diffs are provided for every file. Focus on creating well-organized logical groups.` : "";
@@ -10467,10 +10871,22 @@ ${files.join(`
 
 Diffs:
 ${diffContent}${largeHint}`;
-  const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+  let result = null;
+  try {
+    onProgress?.(`Analyzing ${files.length} files together before batching fallback...`);
+    result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+  } catch {
+    if (isLarge) {
+      onProgress?.(`Initial grouping timed out. Switching to focused batches of ${BATCH_CONFIG.FALLBACK_BATCH_SIZE} files...`);
+      return generateCommitGroupsInBatches(files, diffs, model, convention, onProgress);
+    }
+    throw new Error("AI grouping failed before a response was returned");
+  }
   if (!result) {
-    if (isLarge)
-      return generateCommitGroupsInBatches(files, diffs, model, convention);
+    if (isLarge) {
+      onProgress?.(`AI returned an empty response. Switching to focused batches...`);
+      return generateCommitGroupsInBatches(files, diffs, model, convention, onProgress);
+    }
     throw new Error("AI returned an empty response");
   }
   const cleaned = extractJson(result);
@@ -10478,14 +10894,18 @@ ${diffContent}${largeHint}`;
   try {
     parsed = JSON.parse(cleaned);
   } catch {
-    if (isLarge)
-      return generateCommitGroupsInBatches(files, diffs, model, convention);
+    if (isLarge) {
+      onProgress?.("AI returned invalid JSON for the full changeset. Switching to focused batches...");
+      return generateCommitGroupsInBatches(files, diffs, model, convention, onProgress);
+    }
     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) {
-    if (isLarge)
-      return generateCommitGroupsInBatches(files, diffs, model, convention);
+    if (isLarge) {
+      onProgress?.("AI returned no usable groups for the full changeset. Switching to focused batches...");
+      return generateCommitGroupsInBatches(files, diffs, model, convention, onProgress);
+    }
     throw new Error("AI response was not a valid JSON array of commit groups");
   }
   for (const group of groups) {
@@ -10498,17 +10918,18 @@ ${diffContent}${largeHint}`;
     message: sanitizeGeneratedCommitMessage(group.message)
   }));
 }
-async function generateCommitGroupsInBatches(files, diffs, model, convention = "clean-commit") {
+async function generateCommitGroupsInBatches(files, diffs, model, convention = "clean-commit", onProgress) {
   const batchSize = BATCH_CONFIG.FALLBACK_BATCH_SIZE;
   const allGroups = [];
   const diffSections = parseDiffByFile(diffs);
+  const totalBatches = Math.ceil(files.length / batchSize);
   for (let i2 = 0;i2 < files.length; i2 += batchSize) {
     const batchFiles = files.slice(i2, i2 + batchSize);
     const batchDiff = batchFiles.map((f3) => diffSections.get(f3) ?? "").filter(Boolean).join(`
 `);
-    const batchDiffContent = batchFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD ? createCompactDiff(batchFiles, batchDiff) : batchDiff.slice(0, 6000);
+    const batchDiffContent = batchFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD || hasIncompleteDiffCoverage(batchFiles, batchDiff) ? createCompactDiff(batchFiles, batchDiff) : batchDiff.slice(0, 6000);
     const batchNum = Math.floor(i2 / batchSize) + 1;
-    const totalBatches = Math.ceil(files.length / batchSize);
+    onProgress?.(`Grouping batch ${batchNum}/${totalBatches} (${batchFiles.length} files)...`);
     const userMessage = `Group these changed files into logical atomic commits:
 
 Files:
@@ -10545,10 +10966,7 @@ NOTE: Processing batch ${batchNum}/${totalBatches} of a large changeset. Group o
   const groupedFiles = new Set(allGroups.flatMap((g3) => g3.files));
   const ungrouped = files.filter((f3) => !groupedFiles.has(f3));
   if (ungrouped.length > 0) {
-    allGroups.push({
-      files: ungrouped,
-      message: `chore: update ${ungrouped.length} remaining file${ungrouped.length !== 1 ? "s" : ""}`
-    });
+    allGroups.push(...createRecoveryCommitGroups(ungrouped, convention));
   }
   if (allGroups.length === 0) {
     throw new Error("AI could not group any files even with batch processing");
@@ -10601,56 +11019,299 @@ ${diffContent}`;
   }
 }
 
-// src/utils/gh.ts
-import { execFile as execFileCb2 } from "node:child_process";
-function run2(args) {
-  return new Promise((resolve2) => {
-    execFileCb2("gh", args, (error2, stdout2, stderr) => {
-      resolve2({
-        exitCode: error2 ? error2.code === "ENOENT" ? 127 : error2.status ?? 1 : 0,
-        stdout: stdout2 ?? "",
-        stderr: stderr ?? ""
-      });
-    });
-  });
-}
-async function checkGhInstalled() {
-  try {
-    const { exitCode } = await run2(["--version"]);
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-async function checkGhAuth() {
-  try {
-    const { exitCode } = await run2(["auth", "status"]);
-    return exitCode === 0;
-  } catch {
-    return false;
+// src/utils/spinner.ts
+var import_picocolors6 = __toESM(require_picocolors(), 1);
+var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+var MIN_LINE_WIDTH = 20;
+var DEFAULT_TIP_INTERVAL_MS = 3960;
+function formatSpinnerLines(text, tip, maxWidth) {
+  if (maxWidth <= 0) {
+    return [];
   }
-}
-var SAFE_SLUG = /^[\w.-]+$/;
-async function checkRepoPermissions(owner, repo) {
-  if (!SAFE_SLUG.test(owner) || !SAFE_SLUG.test(repo))
-    return null;
-  const { exitCode, stdout: stdout2 } = await run2(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
-  if (exitCode !== 0)
-    return null;
-  try {
-    return JSON.parse(stdout2.trim());
-  } catch {
-    return null;
+  const normalizedText = text.trim();
+  const normalizedTip = formatSpinnerTip(tip);
+  const primary = truncateText2(normalizedText, Math.max(MIN_LINE_WIDTH, maxWidth));
+  if (!normalizedTip) {
+    return [primary];
   }
+  const secondary = truncateText2(normalizedTip, Math.max(MIN_LINE_WIDTH, maxWidth - 2));
+  return [primary, secondary];
 }
-async function isRepoFork() {
-  const { exitCode, stdout: stdout2 } = await run2(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
-  if (exitCode !== 0)
-    return null;
-  const val = stdout2.trim();
-  if (val === "true")
-    return true;
-  if (val === "false")
+function createSpinner(text, options = {}) {
+  let frameIdx = 0;
+  let currentText = text;
+  let stopped = false;
+  let tipIdx = 0;
+  let renderedLineCount = 0;
+  let lastPrimaryLine = "";
+  let lastSecondaryLine = "";
+  const tips = options.tips?.filter(Boolean) ?? [];
+  const tipIntervalMs = options.tipIntervalMs ?? DEFAULT_TIP_INTERVAL_MS;
+  const clearBlock = () => {
+    if (renderedLineCount === 0) {
+      return;
+    }
+    for (let index = 0;index < renderedLineCount; index++) {
+      process.stderr.write("\r\x1B[2K");
+      if (index < renderedLineCount - 1) {
+        process.stderr.write("\x1B[1A");
+      }
+    }
+    process.stderr.write("\r");
+    lastPrimaryLine = "";
+    lastSecondaryLine = "";
+  };
+  const renderNextState = (primaryLine, secondaryLine) => {
+    if (renderedLineCount === 0) {
+      process.stderr.write(primaryLine);
+      if (secondaryLine) {
+        process.stderr.write(`
+${secondaryLine}`);
+        renderedLineCount = 2;
+      } else {
+        renderedLineCount = 1;
+      }
+      lastPrimaryLine = primaryLine;
+      lastSecondaryLine = secondaryLine ?? "";
+      return;
+    }
+    if (renderedLineCount === 1) {
+      if (lastPrimaryLine !== primaryLine) {
+        process.stderr.write(`\r\x1B[2K${primaryLine}`);
+      }
+      if (secondaryLine) {
+        process.stderr.write(`
+${secondaryLine}`);
+        renderedLineCount = 2;
+      }
+      lastPrimaryLine = primaryLine;
+      lastSecondaryLine = secondaryLine ?? "";
+      return;
+    }
+    process.stderr.write(`\x1B[1A\r\x1B[2K${primaryLine}
+`);
+    if (secondaryLine) {
+      if (lastSecondaryLine !== secondaryLine) {
+        process.stderr.write(`\r\x1B[2K${secondaryLine}`);
+      }
+      renderedLineCount = 2;
+    } else {
+      process.stderr.write("\r\x1B[2K\x1B[1A\r");
+      renderedLineCount = 1;
+    }
+    lastPrimaryLine = primaryLine;
+    lastSecondaryLine = secondaryLine ?? "";
+  };
+  const render = () => {
+    if (stopped)
+      return;
+    const frame = import_picocolors6.default.cyan(FRAMES[frameIdx % FRAMES.length]);
+    const width = Math.max(MIN_LINE_WIDTH, (process.stderr.columns ?? process.stdout.columns ?? 100) - 4);
+    const lines = formatSpinnerLines(currentText, tips[tipIdx % tips.length], width);
+    renderNextState(`${frame} ${import_picocolors6.default.cyan(lines[0] ?? "")}`, lines[1] ? `  ${import_picocolors6.default.dim(lines[1])}` : undefined);
+    frameIdx++;
+  };
+  const timer = setInterval(render, 80);
+  const tipTimer = tips.length > 1 ? setInterval(() => {
+    tipIdx = (tipIdx + 1) % tips.length;
+  }, tipIntervalMs) : null;
+  render();
+  const stop = () => {
+    if (stopped)
+      return;
+    stopped = true;
+    clearInterval(timer);
+    if (tipTimer)
+      clearInterval(tipTimer);
+    clearBlock();
+    renderedLineCount = 0;
+  };
+  return {
+    update(newText) {
+      currentText = newText;
+    },
+    success(msg) {
+      stop();
+      process.stderr.write(`${import_picocolors6.default.green("✔")} ${msg}
+`);
+    },
+    fail(msg) {
+      stop();
+      process.stderr.write(`${import_picocolors6.default.red("✖")} ${msg}
+`);
+    },
+    stop() {
+      stop();
+    }
+  };
+}
+function formatSpinnerTip(tip) {
+  const normalizedTip = tip?.trim() ?? "";
+  return normalizedTip ? `\uD83D\uDCA1 TIP: ${normalizedTip}` : "";
+}
+function truncateText2(text, maxWidth) {
+  if (text.length <= maxWidth) {
+    return text;
+  }
+  if (maxWidth <= 1) {
+    return text.slice(0, maxWidth);
+  }
+  return `${text.slice(0, maxWidth - 1)}…`;
+}
+
+// src/utils/branchPrompt.ts
+async function promptForBranchName(options) {
+  const promptMessage = options.promptMessage ?? "What are you going to work on?";
+  let branchInput = options.initialValue?.trim() ?? "";
+  while (!branchInput) {
+    branchInput = (await inputPrompt(promptMessage)).trim();
+    if (branchInput)
+      break;
+    warn("A branch name or description is required.");
+    const action = await selectPrompt("What would you like to do?", ["Try again", "Cancel"]);
+    if (action === "Cancel")
+      return null;
+  }
+  let branchName = branchInput;
+  const useAI = options.useAI !== false && looksLikeNaturalLanguage(branchInput);
+  if (useAI) {
+    const copilotError = await checkCopilotAvailable2();
+    if (copilotError) {
+      warn(`AI unavailable: ${copilotError}`);
+    } else {
+      while (true) {
+        const spinner = createSpinner("Generating branch name suggestion...", {
+          tips: LOADING_TIPS
+        });
+        const suggested = await suggestBranchName(branchInput, options.model);
+        if (suggested) {
+          spinner.success("Branch name suggestion ready.");
+          console.log(`
+  ${import_picocolors7.default.dim("AI suggestion:")} ${import_picocolors7.default.bold(import_picocolors7.default.cyan(suggested))}`);
+          const action2 = await selectPrompt("What would you like to do with this branch name?", [
+            "Use this suggestion",
+            "Try again with AI",
+            "Enter branch name manually",
+            "Use my original description",
+            "Cancel"
+          ]);
+          if (action2 === "Use this suggestion") {
+            branchName = suggested;
+            break;
+          }
+          if (action2 === "Try again with AI") {
+            continue;
+          }
+          if (action2 === "Enter branch name manually") {
+            branchName = (await inputPrompt("Enter branch name", branchInput)).trim();
+            break;
+          }
+          if (action2 === "Use my original description") {
+            branchName = branchInput;
+            break;
+          }
+          return null;
+        }
+        spinner.fail("AI did not return a branch name suggestion.");
+        const action = await selectPrompt("AI could not generate a branch name. What would you like to do?", [
+          "Try again with AI",
+          "Enter branch name manually",
+          "Use my original description",
+          "Cancel"
+        ]);
+        if (action === "Try again with AI") {
+          continue;
+        }
+        if (action === "Enter branch name manually") {
+          branchName = (await inputPrompt("Enter branch name", branchInput)).trim();
+          break;
+        }
+        if (action === "Use my original description") {
+          branchName = branchInput;
+          break;
+        }
+        return null;
+      }
+    }
+  }
+  while (true) {
+    if (!branchName) {
+      branchName = (await inputPrompt("Enter branch name", branchInput)).trim();
+      if (!branchName) {
+        const action = await selectPrompt("What would you like to do?", ["Try again", "Cancel"]);
+        if (action === "Cancel")
+          return null;
+        continue;
+      }
+    }
+    if (!hasPrefix(branchName, options.branchPrefixes)) {
+      const prefix = await selectPrompt(`Choose a branch type for ${import_picocolors7.default.bold(branchName)}:`, options.branchPrefixes);
+      branchName = formatBranchName(prefix, branchName);
+    }
+    if (!isValidBranchName(branchName)) {
+      warn("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
+      branchName = (await inputPrompt("Enter branch name", branchName)).trim();
+      continue;
+    }
+    if (await branchExists(branchName)) {
+      warn(`Branch ${import_picocolors7.default.bold(branchName)} already exists. Choose a different name.`);
+      branchName = (await inputPrompt("Enter branch name", branchName)).trim();
+      continue;
+    }
+    return branchName;
+  }
+}
+
+// src/utils/gh.ts
+import { execFile as execFileCb2 } from "node:child_process";
+function run2(args) {
+  return new Promise((resolve3) => {
+    execFileCb2("gh", args, (error2, stdout2, stderr) => {
+      resolve3({
+        exitCode: error2 ? error2.code === "ENOENT" ? 127 : error2.status ?? 1 : 0,
+        stdout: stdout2 ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
+}
+async function checkGhInstalled() {
+  try {
+    const { exitCode } = await run2(["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function checkGhAuth() {
+  try {
+    const { exitCode } = await run2(["auth", "status"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+var SAFE_SLUG = /^[\w.-]+$/;
+async function checkRepoPermissions(owner, repo) {
+  if (!SAFE_SLUG.test(owner) || !SAFE_SLUG.test(repo))
+    return null;
+  const { exitCode, stdout: stdout2 } = await run2(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    return JSON.parse(stdout2.trim());
+  } catch {
+    return null;
+  }
+}
+async function isRepoFork() {
+  const { exitCode, stdout: stdout2 } = await run2(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
+  if (exitCode !== 0)
+    return null;
+  const val = stdout2.trim();
+  if (val === "true")
+    return true;
+  if (val === "false")
     return false;
   return null;
 }
@@ -10739,53 +11400,6 @@ async function getMergedPRForBranch(headBranch) {
   }
 }
 
-// src/utils/spinner.ts
-var import_picocolors6 = __toESM(require_picocolors(), 1);
-var FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-function createSpinner(text) {
-  let frameIdx = 0;
-  let currentText = text;
-  let stopped = false;
-  const clearLine = () => {
-    process.stderr.write("\r\x1B[K");
-  };
-  const render = () => {
-    if (stopped)
-      return;
-    const frame = import_picocolors6.default.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(`${import_picocolors6.default.green("✔")} ${msg}
-`);
-    },
-    fail(msg) {
-      stop();
-      process.stderr.write(`${import_picocolors6.default.red("✖")} ${msg}
-`);
-    },
-    stop() {
-      stop();
-    }
-  };
-}
-
 // src/commands/clean.ts
 async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
   if (!config)
@@ -10798,44 +11412,22 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
       warn("You have uncommitted changes in your working tree.");
     }
     if (localWork.unpushedCommits > 0) {
-      warn(`You have ${import_picocolors7.default.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not pushed.`);
+      warn(`You have ${import_picocolors8.default.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(`${import_picocolors7.default.bold(currentBranch)} has local changes. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
+    const action = await selectPrompt(`${import_picocolors8.default.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(import_picocolors7.default.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
-      const description = await inputPrompt("What are you going to work on?");
-      let newBranchName = description;
-      if (looksLikeNaturalLanguage(description)) {
-        const spinner = createSpinner("Generating branch name suggestion...");
-        const suggested = await suggestBranchName(description);
-        if (suggested) {
-          spinner.success("Branch name suggestion ready.");
-          console.log(`
-  ${import_picocolors7.default.dim("AI suggestion:")} ${import_picocolors7.default.bold(import_picocolors7.default.cyan(suggested))}`);
-          const accepted = await confirmPrompt(`Use ${import_picocolors7.default.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 ${import_picocolors7.default.bold(newBranchName)}:`, config.branchPrefixes);
-        newBranchName = formatBranchName(prefix, newBranchName);
-      }
-      if (!isValidBranchName(newBranchName)) {
-        error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
-        return "skipped";
-      }
-      if (await branchExists(newBranchName)) {
-        error(`Branch ${import_picocolors7.default.bold(newBranchName)} already exists. Choose a different name.`);
+      const newBranchName = await promptForBranchName({
+        branchPrefixes: config.branchPrefixes,
+        useAI: isAIEnabled(config)
+      });
+      if (!newBranchName) {
         return "skipped";
       }
       const renameResult = await renameBranch(currentBranch, newBranchName);
@@ -10843,7 +11435,7 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
         error(`Failed to rename branch: ${renameResult.stderr}`);
         return "skipped";
       }
-      success(`Renamed ${import_picocolors7.default.bold(currentBranch)} → ${import_picocolors7.default.bold(newBranchName)}`);
+      success(`Renamed ${import_picocolors8.default.bold(currentBranch)} → ${import_picocolors8.default.bold(newBranchName)}`);
       const syncSource2 = getSyncSource(config);
       await fetchRemote(syncSource2.remote);
       const savedUpstreamRef = await getUpstreamRef();
@@ -10851,10 +11443,10 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
       if (rebaseResult.exitCode !== 0) {
         await rebaseAbort();
         warn("Rebase had conflicts — aborted to keep the repo in a clean state.");
-        info(`Your work is saved on ${import_picocolors7.default.bold(newBranchName)}. After cleanup, rebase manually:`, "");
-        info(`  ${import_picocolors7.default.bold(`git checkout ${newBranchName} && git rebase ${syncSource2.ref}`)}`, "");
+        info(`Your work is saved on ${import_picocolors8.default.bold(newBranchName)}. After cleanup, rebase manually:`, "");
+        info(`  ${import_picocolors8.default.bold(`git checkout ${newBranchName} && git rebase ${syncSource2.ref}`)}`, "");
       } else {
-        success(`Rebased ${import_picocolors7.default.bold(newBranchName)} onto ${import_picocolors7.default.bold(syncSource2.ref)}.`);
+        success(`Rebased ${import_picocolors8.default.bold(newBranchName)} onto ${import_picocolors8.default.bold(syncSource2.ref)}.`);
       }
       const coResult2 = await checkoutBranch(baseBranch);
       if (coResult2.exitCode !== 0) {
@@ -10862,12 +11454,12 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
         return "saved";
       }
       await updateLocalBranch(baseBranch, syncSource2.ref);
-      success(`Synced ${import_picocolors7.default.bold(baseBranch)} with ${import_picocolors7.default.bold(syncSource2.ref)}.`);
+      success(`Synced ${import_picocolors8.default.bold(baseBranch)} with ${import_picocolors8.default.bold(syncSource2.ref)}.`);
       return "saved";
     }
   }
   const syncSource = getSyncSource(config);
-  info(`Switching to ${import_picocolors7.default.bold(baseBranch)} and syncing...`);
+  info(`Switching to ${import_picocolors8.default.bold(baseBranch)} and syncing...`);
   await fetchRemote(syncSource.remote);
   await resetHard("HEAD");
   const coResult = await checkoutBranch(baseBranch);
@@ -10876,7 +11468,7 @@ async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
     return "skipped";
   }
   await updateLocalBranch(baseBranch, syncSource.ref);
-  success(`Synced ${import_picocolors7.default.bold(baseBranch)} with ${import_picocolors7.default.bold(syncSource.ref)}.`);
+  success(`Synced ${import_picocolors8.default.bold(baseBranch)} with ${import_picocolors8.default.bold(syncSource.ref)}.`);
   return "switched";
 }
 var clean_default = defineCommand({
@@ -10900,13 +11492,13 @@ var clean_default = defineCommand({
     await assertCleanGitState("cleaning");
     const config = readConfig();
     if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
+      error("No repo config found. Run `contrib setup` first.");
       process.exit(1);
     }
     const { origin } = config;
     const baseBranch = getBaseBranch(config);
     let currentBranch = await getCurrentBranch();
-    heading("\uD83E\uDDF9 contrib clean");
+    projectHeading("clean", "\uD83E\uDDF9");
     info(`Pruning ${origin} remote refs...`);
     const pruneResult = await pruneRemote(origin);
     if (pruneResult.exitCode === 0) {
@@ -10926,21 +11518,21 @@ var clean_default = defineCommand({
       if (ghInstalled && ghAuthed) {
         const mergedPR = await getMergedPRForBranch(currentBranch);
         if (mergedPR) {
-          warn(`PR #${mergedPR.number} (${import_picocolors7.default.bold(mergedPR.title)}) has already been merged.`);
-          info(`Link: ${import_picocolors7.default.underline(mergedPR.url)}`, "");
+          warn(`PR #${mergedPR.number} (${import_picocolors8.default.bold(mergedPR.title)}) has already been merged.`);
+          info(`Link: ${import_picocolors8.default.underline(mergedPR.url)}`, "");
           goneCandidates.push(currentBranch);
         }
       }
     }
     if (mergedCandidates.length > 0) {
       console.log(`
-${import_picocolors7.default.bold("Merged branches to delete:")}`);
+${import_picocolors8.default.bold("Merged branches to delete:")}`);
       for (const b2 of mergedCandidates) {
-        const marker = b2 === currentBranch ? import_picocolors7.default.yellow(" (current)") : "";
-        console.log(`  ${import_picocolors7.default.dim("•")} ${b2}${marker}`);
+        const marker = b2 === currentBranch ? import_picocolors8.default.yellow(" (current)") : "";
+        console.log(`  ${import_picocolors8.default.dim("•")} ${b2}${marker}`);
       }
       console.log();
-      const ok = args.yes || await confirmPrompt(`Delete ${import_picocolors7.default.bold(String(mergedCandidates.length))} merged branch${mergedCandidates.length !== 1 ? "es" : ""}?`);
+      const ok = args.yes || await confirmPrompt(`Delete ${import_picocolors8.default.bold(String(mergedCandidates.length))} merged branch${mergedCandidates.length !== 1 ? "es" : ""}?`);
       if (ok) {
         for (const branch of mergedCandidates) {
           if (branch === currentBranch) {
@@ -10957,7 +11549,7 @@ ${import_picocolors7.default.bold("Merged branches to delete:")}`);
           }
           const result = await deleteBranch(branch);
           if (result.exitCode === 0) {
-            success(`  Deleted ${import_picocolors7.default.bold(branch)}`);
+            success(`  Deleted ${import_picocolors8.default.bold(branch)}`);
           } else {
             warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
           }
@@ -10968,13 +11560,13 @@ ${import_picocolors7.default.bold("Merged branches to delete:")}`);
     }
     if (goneCandidates.length > 0) {
       console.log(`
-${import_picocolors7.default.bold("Stale branches (remote deleted, likely squash-merged):")}`);
+${import_picocolors8.default.bold("Stale branches (remote deleted, likely squash-merged):")}`);
       for (const b2 of goneCandidates) {
-        const marker = b2 === currentBranch ? import_picocolors7.default.yellow(" (current)") : "";
-        console.log(`  ${import_picocolors7.default.dim("•")} ${b2}${marker}`);
+        const marker = b2 === currentBranch ? import_picocolors8.default.yellow(" (current)") : "";
+        console.log(`  ${import_picocolors8.default.dim("•")} ${b2}${marker}`);
       }
       console.log();
-      const ok = args.yes || await confirmPrompt(`Delete ${import_picocolors7.default.bold(String(goneCandidates.length))} stale branch${goneCandidates.length !== 1 ? "es" : ""}?`);
+      const ok = args.yes || await confirmPrompt(`Delete ${import_picocolors8.default.bold(String(goneCandidates.length))} stale branch${goneCandidates.length !== 1 ? "es" : ""}?`);
       if (ok) {
         for (const branch of goneCandidates) {
           if (branch === currentBranch) {
@@ -10991,7 +11583,7 @@ ${import_picocolors7.default.bold("Stale branches (remote deleted, likely squash
           }
           const result = await forceDeleteBranch(branch);
           if (result.exitCode === 0) {
-            success(`  Deleted ${import_picocolors7.default.bold(branch)}`);
+            success(`  Deleted ${import_picocolors8.default.bold(branch)}`);
           } else {
             warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
           }
@@ -11006,13 +11598,13 @@ ${import_picocolors7.default.bold("Stale branches (remote deleted, likely squash
     const finalBranch = await getCurrentBranch();
     if (finalBranch && protectedBranches.has(finalBranch)) {
       console.log();
-      info(`You're on ${import_picocolors7.default.bold(finalBranch)}. Run ${import_picocolors7.default.bold("contrib start")} to begin a new feature.`);
+      info(`You're on ${import_picocolors8.default.bold(finalBranch)}. Run ${import_picocolors8.default.bold("contrib start")} to begin a new feature.`);
     }
   }
 });
 
 // src/commands/commit.ts
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 
 // 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;
@@ -11066,6 +11658,9 @@ function getValidationError(convention) {
 }
 
 // src/commands/commit.ts
+function isEmptyGroupCommitResult(detail) {
+  return /no changes added to commit|nothing to commit/i.test(detail);
+}
 var commit_default = defineCommand({
   meta: {
     name: "commit",
@@ -11095,11 +11690,16 @@ var commit_default = defineCommand({
     await assertCleanGitState("committing");
     const config = readConfig();
     if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
+      error("No repo config found. Run `contrib setup` first.");
       process.exit(1);
     }
-    heading("\uD83D\uDCBE contrib commit");
+    projectHeading("commit", "\uD83D\uDCBE");
+    const aiEnabled = isAIEnabled(config, args["no-ai"]);
     if (args.group) {
+      if (!aiEnabled) {
+        error("AI group commit is unavailable because AI is disabled. Re-run without --group or enable AI in your repo config.");
+        process.exit(1);
+      }
       await runGroupCommit(args.model, config);
       return;
     }
@@ -11111,9 +11711,9 @@ var commit_default = defineCommand({
         process.exit(1);
       }
       console.log(`
-${import_picocolors8.default.bold("Changed files:")}`);
+${import_picocolors9.default.bold("Changed files:")}`);
       for (const f3 of changedFiles) {
-        console.log(`  ${import_picocolors8.default.dim("•")} ${f3}`);
+        console.log(`  ${import_picocolors9.default.dim("•")} ${f3}`);
       }
       const stageAction = await selectPrompt("No staged changes. How would you like to stage?", [
         "Stage all changes",
@@ -11155,8 +11755,8 @@ ${import_picocolors8.default.bold("Changed files:")}`);
       const dirs = new Set(stagedFiles.map((f3) => f3.split("/")[0]));
       if (dirs.size > 1) {
         console.log();
-        warn(`You're staging ${import_picocolors8.default.bold(String(stagedFiles.length))} files across ${import_picocolors8.default.bold(String(dirs.size))} directories in a single commit.`);
-        info(import_picocolors8.default.dim("Large commits mixing different topics make history harder to read and bisect. " + "For cleaner history, consider splitting into atomic commits."));
+        warn(`You're staging ${import_picocolors9.default.bold(String(stagedFiles.length))} files across ${import_picocolors9.default.bold(String(dirs.size))} directories in a single commit.`);
+        info(import_picocolors9.default.dim("Large commits mixing different topics make history harder to read and bisect. " + "For cleaner history, consider splitting into atomic commits."));
         const choice = await selectPrompt("How would you like to proceed?", [
           "Continue as single commit",
           "Switch to group mode (AI splits into atomic commits)",
@@ -11172,20 +11772,22 @@ ${import_picocolors8.default.bold("Changed files:")}`);
       }
     }
     let commitMessage = null;
-    const useAI = !args["no-ai"];
+    const useAI = aiEnabled;
     if (useAI) {
-      const [copilotError, diff] = await Promise.all([checkCopilotAvailable(), getStagedDiff()]);
+      const [copilotError, diff] = await Promise.all([checkCopilotAvailable2(), getStagedDiff()]);
       if (copilotError) {
         warn(`AI unavailable: ${copilotError}`);
         warn("Falling back to manual commit message entry.");
       } else {
         const spinnerMsg = stagedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD ? `Generating commit message with AI (${stagedFiles.length} files — using optimized batching)...` : "Generating commit message with AI...";
-        const spinner = createSpinner(spinnerMsg);
+        const spinner = createSpinner(spinnerMsg, {
+          tips: LOADING_TIPS
+        });
         commitMessage = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
         if (commitMessage) {
           spinner.success("AI commit message generated.");
           console.log(`
-  ${import_picocolors8.default.dim("AI suggestion:")} ${import_picocolors8.default.bold(import_picocolors8.default.cyan(commitMessage))}`);
+  ${import_picocolors9.default.dim("AI suggestion:")} ${import_picocolors9.default.bold(import_picocolors9.default.cyan(commitMessage))}`);
         } else {
           spinner.fail("AI did not return a commit message.");
           warn("Falling back to manual entry.");
@@ -11205,13 +11807,15 @@ ${import_picocolors8.default.bold("Changed files:")}`);
       } else if (action === "Edit this message") {
         finalMessage = await inputPrompt("Edit commit message", commitMessage);
       } else if (action === "Regenerate") {
-        const spinner = createSpinner("Regenerating commit message...");
+        const spinner = createSpinner("Regenerating commit message...", {
+          tips: LOADING_TIPS
+        });
         const diff = await getStagedDiff();
         const regen = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
         if (regen) {
           spinner.success("Commit message regenerated.");
           console.log(`
-  ${import_picocolors8.default.dim("AI suggestion:")} ${import_picocolors8.default.bold(import_picocolors8.default.cyan(regen))}`);
+  ${import_picocolors9.default.dim("AI suggestion:")} ${import_picocolors9.default.bold(import_picocolors9.default.cyan(regen))}`);
           const ok = await confirmPrompt("Use this message?");
           finalMessage = ok ? regen : await inputPrompt("Enter commit message manually");
         } else {
@@ -11226,7 +11830,7 @@ ${import_picocolors8.default.bold("Changed files:")}`);
       if (convention2 !== "none") {
         console.log();
         for (const hint of CONVENTION_FORMAT_HINTS[convention2]) {
-          console.log(import_picocolors8.default.dim(hint));
+          console.log(import_picocolors9.default.dim(hint));
         }
         console.log();
       }
@@ -11250,21 +11854,12 @@ ${import_picocolors8.default.bold("Changed files:")}`);
       error(`Failed to commit: ${result.stderr}`);
       process.exit(1);
     }
-    success(`Committed: ${import_picocolors8.default.bold(finalMessage)}`);
+    success(`Committed: ${import_picocolors9.default.bold(finalMessage)}`);
   }
 });
-function getFallbackGroupMessage(convention) {
-  if (convention === "conventional") {
-    return "chore: commit remaining changes";
-  }
-  if (convention === "clean-commit") {
-    return "☕ chore: commit remaining changes";
-  }
-  return "commit remaining changes";
-}
 async function runGroupCommit(model, config) {
   const [copilotError, changedFiles] = await Promise.all([
-    checkCopilotAvailable(),
+    checkCopilotAvailable2(),
     getChangedFiles()
   ]);
   if (copilotError) {
@@ -11276,11 +11871,13 @@ async function runGroupCommit(model, config) {
     process.exit(1);
   }
   console.log(`
-${import_picocolors8.default.bold("Changed files:")}`);
+${import_picocolors9.default.bold("Changed files:")}`);
   for (const f3 of changedFiles) {
-    console.log(`  ${import_picocolors8.default.dim("•")} ${f3}`);
+    console.log(`  ${import_picocolors9.default.dim("•")} ${f3}`);
   }
-  const spinner = createSpinner(changedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD ? `Asking AI to group ${changedFiles.length} file(s) into logical commits (using optimized batching)...` : `Asking AI to group ${changedFiles.length} file(s) into logical commits...`);
+  const spinner = createSpinner(changedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD ? `Asking AI to group ${changedFiles.length} file(s) into logical commits (using optimized batching)...` : `Asking AI to group ${changedFiles.length} file(s) into logical commits...`, {
+    tips: LOADING_TIPS
+  });
   const diffs = await getFullDiffForFiles(changedFiles);
   if (!diffs.trim()) {
     spinner.stop();
@@ -11288,7 +11885,7 @@ ${import_picocolors8.default.bold("Changed files:")}`);
   }
   let groups;
   try {
-    groups = await generateCommitGroups(changedFiles, diffs, model, config.commitConvention);
+    groups = await generateCommitGroups(changedFiles, diffs, model, config.commitConvention, (message) => spinner.update(message));
     spinner.success(`AI generated ${groups.length} commit group(s).`);
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
@@ -11308,14 +11905,10 @@ ${import_picocolors8.default.bold("Changed files:")}`);
   }
   let validGroups = normalized.groups;
   if (normalized.unassignedFiles.length > 0) {
-    warn(`AI left ${normalized.unassignedFiles.length} file(s) ungrouped: ${normalized.unassignedFiles.join(", ")}. Creating a fallback group.`);
-    const fallbackMessage = await regenerateGroupMessage(normalized.unassignedFiles, diffs, model, config.commitConvention) ?? getFallbackGroupMessage(config.commitConvention);
+    warn(`AI left ${normalized.unassignedFiles.length} file(s) ungrouped: ${normalized.unassignedFiles.join(", ")}. Auto-resolving recovery groups.`);
     validGroups = [
       ...validGroups,
-      {
-        files: normalized.unassignedFiles,
-        message: fallbackMessage
-      }
+      ...createRecoveryCommitGroups(normalized.unassignedFiles, config.commitConvention)
     ];
   }
   if (validGroups.length === 0) {
@@ -11326,13 +11919,13 @@ ${import_picocolors8.default.bold("Changed files:")}`);
   let commitAll = false;
   while (!proceedToCommit) {
     console.log(`
-${import_picocolors8.default.bold(`AI suggested ${validGroups.length} commit group(s):`)}
+${import_picocolors9.default.bold(`AI suggested ${validGroups.length} commit group(s):`)}
 `);
     for (let i2 = 0;i2 < validGroups.length; i2++) {
       const g3 = validGroups[i2];
-      console.log(`  ${import_picocolors8.default.cyan(`Group ${i2 + 1}:`)} ${import_picocolors8.default.bold(g3.message)}`);
+      console.log(`  ${import_picocolors9.default.cyan(`Group ${i2 + 1}:`)} ${import_picocolors9.default.bold(g3.message)}`);
       for (const f3 of g3.files) {
-        console.log(`    ${import_picocolors8.default.dim("•")} ${f3}`);
+        console.log(`    ${import_picocolors9.default.dim("•")} ${f3}`);
       }
       console.log();
     }
@@ -11347,7 +11940,9 @@ ${import_picocolors8.default.bold(`AI suggested ${validGroups.length} commit gro
       process.exit(0);
     }
     if (summaryAction === "Regenerate all messages") {
-      const regenSpinner = createSpinner("Regenerating all commit messages...");
+      const regenSpinner = createSpinner("Regenerating all commit messages...", {
+        tips: LOADING_TIPS
+      });
       try {
         validGroups = await regenerateAllGroupMessages(validGroups, diffs, model, config.commitConvention);
         regenSpinner.success("All commit messages regenerated.");
@@ -11378,24 +11973,34 @@ ${import_picocolors8.default.bold(`AI suggested ${validGroups.length} commit gro
         error(`Failed to stage group ${i2 + 1}: ${stageResult.stderr}`);
         continue;
       }
+      const stagedFiles = new Set(await getStagedFiles());
+      const stagedGroupFiles = stageableFiles.filter((file) => stagedFiles.has(file));
+      if (stagedGroupFiles.length === 0) {
+        warn(`Skipped group ${i2 + 1}: no files were staged for commit.`);
+        continue;
+      }
       const commitResult = await commitWithMessage(group.message);
       if (commitResult.exitCode !== 0) {
         const detail = (commitResult.stderr || commitResult.stdout).trim();
+        if (isEmptyGroupCommitResult(detail)) {
+          warn(`Skipped group ${i2 + 1}: nothing remained to commit.`);
+          continue;
+        }
         error(`Failed to commit group ${i2 + 1}: ${detail}`);
         await unstageFiles(stageableFiles);
         continue;
       }
       committed++;
-      success(`Committed group ${i2 + 1}: ${import_picocolors8.default.bold(group.message)}`);
+      success(`Committed group ${i2 + 1}: ${import_picocolors9.default.bold(group.message)}`);
     }
   } else {
     for (let i2 = 0;i2 < validGroups.length; i2++) {
       const group = validGroups[i2];
-      console.log(import_picocolors8.default.bold(`
+      console.log(import_picocolors9.default.bold(`
 ── Group ${i2 + 1}/${validGroups.length} ──`));
-      console.log(`  ${import_picocolors8.default.cyan(group.message)}`);
+      console.log(`  ${import_picocolors9.default.cyan(group.message)}`);
       for (const f3 of group.files) {
-        console.log(`  ${import_picocolors8.default.dim("•")} ${f3}`);
+        console.log(`  ${import_picocolors9.default.dim("•")} ${f3}`);
       }
       let message = group.message;
       let actionDone = false;
@@ -11412,12 +12017,14 @@ ${import_picocolors8.default.bold(`AI suggested ${validGroups.length} commit gro
           continue;
         }
         if (action === "Regenerate message") {
-          const regenSpinner = createSpinner("Regenerating commit message for this group...");
+          const regenSpinner = createSpinner("Regenerating commit message for this group...", {
+            tips: LOADING_TIPS
+          });
           const newMsg = await regenerateGroupMessage(group.files, diffs, model, config.commitConvention);
           if (newMsg) {
             message = newMsg;
             group.message = newMsg;
-            regenSpinner.success(`New message: ${import_picocolors8.default.bold(message)}`);
+            regenSpinner.success(`New message: ${import_picocolors9.default.bold(message)}`);
           } else {
             regenSpinner.fail("AI could not generate a new message. Keeping current one.");
           }
@@ -11459,16 +12066,28 @@ ${import_picocolors8.default.bold(`AI suggested ${validGroups.length} commit gro
           actionDone = true;
           continue;
         }
+        const stagedFiles = new Set(await getStagedFiles());
+        const stagedGroupFiles = stageableFiles.filter((file) => stagedFiles.has(file));
+        if (stagedGroupFiles.length === 0) {
+          warn(`Skipped group ${i2 + 1}: no files were staged for commit.`);
+          actionDone = true;
+          continue;
+        }
         const commitResult = await commitWithMessage(message);
         if (commitResult.exitCode !== 0) {
           const detail = (commitResult.stderr || commitResult.stdout).trim();
+          if (isEmptyGroupCommitResult(detail)) {
+            warn(`Skipped group ${i2 + 1}: nothing remained to commit.`);
+            actionDone = true;
+            continue;
+          }
           error(`Failed to commit group ${i2 + 1}: ${detail}`);
           await unstageFiles(stageableFiles);
           actionDone = true;
           continue;
         }
         committed++;
-        success(`Committed group ${i2 + 1}: ${import_picocolors8.default.bold(message)}`);
+        success(`Committed group ${i2 + 1}: ${import_picocolors9.default.bold(message)}`);
         actionDone = true;
       }
     }
@@ -11484,11 +12103,11 @@ ${import_picocolors8.default.bold(`AI suggested ${validGroups.length} commit gro
 
 // src/commands/doctor.ts
 import { execFile as execFileCb3 } from "node:child_process";
-var import_picocolors9 = __toESM(require_picocolors(), 1);
+var import_picocolors10 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "contribute-now",
-  version: "0.6.2-dev.12fb962",
+  version: "0.6.2-dev.1320af4",
   description: "Developer CLI that automates git workflows — branching, syncing, committing, and PRs — with multi-workflow and commit convention support.",
   type: "module",
   bin: {
@@ -11579,16 +12198,16 @@ async function getRepoInfoFromRemote(remote = "origin") {
 }
 
 // src/commands/doctor.ts
-var PASS = `  ${import_picocolors9.default.green("✔")} `;
-var FAIL = `  ${import_picocolors9.default.red("✗")} `;
-var WARN = `  ${import_picocolors9.default.yellow("⚠")} `;
+var PASS = `  ${import_picocolors10.default.green("✔")} `;
+var FAIL = `  ${import_picocolors10.default.red("✗")} `;
+var WARN = `  ${import_picocolors10.default.yellow("⚠")} `;
 function printReport(report) {
   for (const section of report.sections) {
     console.log(`
-  ${import_picocolors9.default.bold(import_picocolors9.default.underline(section.title))}`);
+  ${import_picocolors10.default.bold(import_picocolors10.default.underline(section.title))}`);
     for (const check of section.checks) {
       const prefix = check.ok ? check.warning ? WARN : PASS : FAIL;
-      const text = check.detail ? `${check.label} ${import_picocolors9.default.dim(`— ${check.detail}`)}` : check.label;
+      const text = check.detail ? `${check.label} ${import_picocolors10.default.dim(`— ${check.detail}`)}` : check.label;
       console.log(`${prefix}${text}`);
     }
   }
@@ -11606,9 +12225,9 @@ function toJson(report) {
   })), null, 2);
 }
 function runCmd(cmd, args) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     execFileCb3(cmd, args, (error2, stdout2) => {
-      resolve2({
+      resolve3({
         ok: !error2,
         stdout: (stdout2 ?? "").trim()
       });
@@ -11670,18 +12289,32 @@ async function configSection() {
   const exists = configExists();
   if (!exists) {
     checks.push({
-      label: ".contributerc.json not found",
+      label: "Repo config not found",
       ok: false,
-      detail: "run `contrib setup` to create it"
+      detail: "run `contrib setup` to create local config for this clone"
     });
     return { title: "Config", checks };
   }
   const config = readConfig();
   if (!config) {
-    checks.push({ label: ".contributerc.json found but invalid", ok: false });
+    checks.push({ label: "Repo config found but invalid", ok: false });
     return { title: "Config", checks };
   }
-  checks.push({ label: ".contributerc.json found and valid", ok: true });
+  const configSource = getConfigSource();
+  const hasBothConfigSources = hasLegacyConfig() && hasLocalConfig();
+  checks.push({
+    label: `${configSource === "local" ? "Local Git config" : "Legacy repo config"} found and valid`,
+    ok: true,
+    detail: getConfigLocationLabel()
+  });
+  if (hasBothConfigSources) {
+    checks.push({
+      label: "Both legacy and local config files exist",
+      ok: true,
+      warning: true,
+      detail: "legacy .contributerc.json currently takes precedence"
+    });
+  }
   const desc = WORKFLOW_DESCRIPTIONS[config.workflow] ?? config.workflow;
   checks.push({
     label: `Workflow: ${config.workflow}`,
@@ -11696,13 +12329,21 @@ async function configSection() {
       ok: !!config.devBranch
     });
   }
-  const ignored = isGitignored();
-  checks.push({
-    label: ignored ? ".contributerc.json in .gitignore" : ".contributerc.json NOT in .gitignore",
-    ok: true,
-    warning: !ignored,
-    detail: ignored ? undefined : "consider adding it to .gitignore"
-  });
+  if (configSource === "legacy") {
+    const ignored = isGitignored();
+    checks.push({
+      label: ignored ? ".contributerc.json in .gitignore" : ".contributerc.json NOT in .gitignore",
+      ok: true,
+      warning: !ignored,
+      detail: ignored ? undefined : "consider adding it to .gitignore"
+    });
+  } else {
+    checks.push({
+      label: "Config stored in local Git metadata",
+      ok: true,
+      detail: "does not modify tracked files or require .gitignore changes"
+    });
+  }
   return { title: "Config", checks };
 }
 async function gitSection() {
@@ -11851,20 +12492,20 @@ var doctor_default = defineCommand({
       console.log(toJson(report));
       return;
     }
-    heading("\uD83E\uDE7A contribute-now doctor");
+    projectHeading("doctor", "\uD83E\uDE7A");
     printReport(report);
     const total = report.sections.flatMap((s2) => s2.checks);
     const failures = total.filter((c3) => !c3.ok);
     const warnings = total.filter((c3) => c3.ok && c3.warning);
     if (failures.length === 0 && warnings.length === 0) {
-      console.log(`  ${import_picocolors9.default.green("All checks passed!")} No issues detected.
+      console.log(`  ${import_picocolors10.default.green("All checks passed!")} No issues detected.
 `);
     } else {
       if (failures.length > 0) {
-        console.log(`  ${import_picocolors9.default.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
+        console.log(`  ${import_picocolors10.default.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
       }
       if (warnings.length > 0) {
-        console.log(`  ${import_picocolors9.default.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
+        console.log(`  ${import_picocolors10.default.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
       }
       console.log();
     }
@@ -11872,9 +12513,9 @@ var doctor_default = defineCommand({
 });
 
 // src/commands/hook.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { join as join4 } from "node:path";
-var import_picocolors10 = __toESM(require_picocolors(), 1);
+var import_picocolors11 = __toESM(require_picocolors(), 1);
 var HOOK_MARKER = "# managed by contribute-now";
 function getHooksDir(cwd = process.cwd()) {
   return join4(cwd, ".git", "hooks");
@@ -11942,10 +12583,10 @@ var hook_default = defineCommand({
   }
 });
 async function installHook() {
-  heading("\uD83E\uDE9D hook install");
+  projectHeading("hook install", "\uD83E\uDE9D");
   const config = readConfig();
   if (!config) {
-    error("No .contributerc.json found. Run `contrib setup` first.");
+    error("No repo config found. Run `contrib setup` first.");
     process.exit(1);
   }
   if (config.commitConvention === "none") {
@@ -11966,16 +12607,16 @@ async function installHook() {
     info("Updating existing contribute-now hook...");
   }
   if (!existsSync4(hooksDir)) {
-    mkdirSync2(hooksDir, { recursive: true });
+    mkdirSync3(hooksDir, { recursive: true });
   }
   writeFileSync3(hookPath, generateHookScript(), { mode: 493 });
   success(`commit-msg hook installed.`);
-  info(`Convention: ${import_picocolors10.default.bold(CONVENTION_LABELS[config.commitConvention])}`, "");
-  info(`Path: ${import_picocolors10.default.dim(hookPath)}`, "");
+  info(`Convention: ${import_picocolors11.default.bold(CONVENTION_LABELS[config.commitConvention])}`, "");
+  info(`Path: ${import_picocolors11.default.dim(hookPath)}`, "");
   warn("Note: hooks can be bypassed with `git commit --no-verify`.");
 }
 async function uninstallHook() {
-  heading("\uD83E\uDE9D hook uninstall");
+  projectHeading("hook uninstall", "\uD83E\uDE9D");
   const hookPath = getHookPath();
   if (!existsSync4(hookPath)) {
     info("No commit-msg hook found. Nothing to uninstall.");
@@ -11991,7 +12632,10 @@ async function uninstallHook() {
 }
 
 // src/commands/log.ts
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_picocolors12 = __toESM(require_picocolors(), 1);
+function getDefaultOverviewRemoteCommitCount(hasLocalUnpushedCommits) {
+  return hasLocalUnpushedCommits ? 10 : 20;
+}
 var log_default = defineCommand({
   meta: {
     name: "log",
@@ -12012,7 +12656,13 @@ var log_default = defineCommand({
     remote: {
       type: "boolean",
       alias: "r",
-      description: "Show only remote commits not yet pulled locally",
+      description: "Show only the remote branch history",
+      default: false
+    },
+    local: {
+      type: "boolean",
+      alias: "l",
+      description: "Show only local unpushed commits",
       default: false
     },
     full: {
@@ -12039,12 +12689,15 @@ var log_default = defineCommand({
       process.exit(1);
     }
     const config = readConfig();
-    const count = args.count ? Number.parseInt(args.count, 10) : 20;
+    const requestedCount = args.count ? Number.parseInt(args.count, 10) : null;
+    const localCount = requestedCount ?? 20;
     const showGraph = args.graph;
     const targetBranch = args.branch;
-    let mode = "local";
+    let mode = "overview";
     if (args.all)
       mode = "all";
+    else if (args.local)
+      mode = "local";
     else if (args.remote)
       mode = "remote";
     else if (args.full || targetBranch)
@@ -12060,33 +12713,74 @@ var log_default = defineCommand({
         compareRef = fallback;
         usingFallback = true;
       }
-    }
-    heading("\uD83D\uDCDC commit log");
-    printModeHeader(mode, currentBranch, compareRef, usingFallback);
-    if (mode === "local" || mode === "remote") {
-      if (!compareRef) {
+    }
+    const overviewRemoteCount = requestedCount ?? await getOverviewRemoteCommitCount(currentBranch, compareRef);
+    projectHeading("log", "\uD83D\uDCDC");
+    printModeHeader(mode, currentBranch, compareRef, usingFallback);
+    if (mode === "overview") {
+      await renderOverviewLog({
+        localCount,
+        remoteCount: overviewRemoteCount,
+        compareRef,
+        showGraph,
+        protectedBranches,
+        currentBranch,
+        usingFallback
+      });
+    } else if (mode === "local") {
+      if (!compareRef) {
+        console.log();
+        console.log(import_picocolors12.default.yellow("  ⚠ Could not determine a comparison branch."));
+        console.log(import_picocolors12.default.dim("    No upstream tracking set and no remote base branch found."));
+        console.log(import_picocolors12.default.dim(`    Use ${import_picocolors12.default.bold("contrib log --full")} to see the full commit history instead.`));
+        console.log();
+        return;
+      }
+      const hasCommits = await renderScopedLog({
+        mode,
+        count: localCount,
+        upstream: compareRef,
+        showGraph,
+        protectedBranches,
+        currentBranch
+      });
+      if (!hasCommits) {
+        return;
+      }
+    } else if (mode === "remote") {
+      const remoteBranch = compareRef ?? targetBranch;
+      if (!remoteBranch) {
         console.log();
-        console.log(import_picocolors11.default.yellow("  ⚠ Could not determine a comparison branch."));
-        console.log(import_picocolors11.default.dim("    No upstream tracking set and no remote base branch found."));
-        console.log(import_picocolors11.default.dim(`    Use ${import_picocolors11.default.bold("contrib log --full")} to see the full commit history instead.`));
+        console.log(import_picocolors12.default.yellow("  ⚠ Could not determine a remote branch to display."));
+        console.log(import_picocolors12.default.dim("    Set an upstream tracking branch or configure your base branch first."));
         console.log();
-        printGuidance();
         return;
       }
-      const hasCommits = await renderScopedLog({ mode, count, upstream: compareRef, showGraph, protectedBranches, currentBranch });
+      const hasCommits = await renderFullLog({
+        count: localCount,
+        all: false,
+        showGraph,
+        targetBranch: remoteBranch,
+        protectedBranches,
+        currentBranch
+      });
       if (!hasCommits) {
-        printGuidance();
         return;
       }
     } else {
-      const hasCommits = await renderFullLog({ count, all: mode === "all", showGraph, targetBranch, protectedBranches, currentBranch });
+      const hasCommits = await renderFullLog({
+        count: localCount,
+        all: mode === "all",
+        showGraph,
+        targetBranch,
+        protectedBranches,
+        currentBranch
+      });
       if (!hasCommits) {
-        printGuidance();
         return;
       }
     }
-    printFooter(mode, count, targetBranch);
-    printGuidance();
+    printFooter(mode, localCount, overviewRemoteCount, targetBranch);
   }
 });
 async function resolveBaseBranchRef(config) {
@@ -12108,38 +12802,49 @@ async function resolveBaseBranchRef(config) {
   }
   return null;
 }
+async function getOverviewRemoteCommitCount(currentBranch, compareRef) {
+  if (!currentBranch || !compareRef) {
+    return getDefaultOverviewRemoteCommitCount(false);
+  }
+  const divergence = await getDivergence(currentBranch, compareRef);
+  return getDefaultOverviewRemoteCommitCount(divergence.ahead > 0);
+}
 function printModeHeader(mode, currentBranch, compareRef, usingFallback = false) {
   const branch = currentBranch ?? "HEAD";
-  const fallbackNote = usingFallback ? import_picocolors11.default.yellow(" (no upstream — comparing against base branch)") : "";
-  console.log();
+  const fallbackNote = usingFallback ? import_picocolors12.default.yellow(" (no upstream — comparing against base branch)") : "";
   switch (mode) {
+    case "overview":
+      console.log(import_picocolors12.default.dim(`  mode: ${import_picocolors12.default.bold("overview")} — local unpushed commits and remote branch history for ${import_picocolors12.default.bold(branch)}`) + fallbackNote);
+      if (compareRef) {
+        console.log(import_picocolors12.default.dim(`  remote source: ${import_picocolors12.default.bold(compareRef)}`));
+      }
+      break;
     case "local":
-      console.log(import_picocolors11.default.dim(`  mode: ${import_picocolors11.default.bold("local")} — unpushed commits on ${import_picocolors11.default.bold(branch)}`) + fallbackNote);
+      console.log(import_picocolors12.default.dim(`  mode: ${import_picocolors12.default.bold("local")} — unpushed commits on ${import_picocolors12.default.bold(branch)}`) + fallbackNote);
       if (compareRef) {
-        console.log(import_picocolors11.default.dim(`  comparing: ${import_picocolors11.default.bold(compareRef)} ➜ ${import_picocolors11.default.bold("HEAD")}`));
+        console.log(import_picocolors12.default.dim(`  comparing: ${import_picocolors12.default.bold(compareRef)} ➜ ${import_picocolors12.default.bold("HEAD")}`));
       }
       break;
     case "remote":
-      console.log(import_picocolors11.default.dim(`  mode: ${import_picocolors11.default.bold("remote")} — commits on remote not yet pulled into ${import_picocolors11.default.bold(branch)}`) + fallbackNote);
+      console.log(import_picocolors12.default.dim(`  mode: ${import_picocolors12.default.bold("remote")} — remote branch history relevant to ${import_picocolors12.default.bold(branch)}`) + fallbackNote);
       if (compareRef) {
-        console.log(import_picocolors11.default.dim(`  comparing: ${import_picocolors11.default.bold("HEAD")} ➜ ${import_picocolors11.default.bold(compareRef)}`));
+        console.log(import_picocolors12.default.dim(`  branch: ${import_picocolors12.default.bold(compareRef)}`));
       }
       break;
     case "full":
-      console.log(import_picocolors11.default.dim(`  mode: ${import_picocolors11.default.bold("full")} — complete commit history for ${import_picocolors11.default.bold(branch)}`));
+      console.log(import_picocolors12.default.dim(`  mode: ${import_picocolors12.default.bold("full")} — complete commit history for ${import_picocolors12.default.bold(branch)}`));
       break;
     case "all":
-      console.log(import_picocolors11.default.dim(`  mode: ${import_picocolors11.default.bold("all")} — commits across all branches`));
+      console.log(import_picocolors12.default.dim(`  mode: ${import_picocolors12.default.bold("all")} — commits across all branches`));
       break;
   }
 }
 async function renderScopedLog(options) {
-  const { mode, count, upstream, showGraph, protectedBranches, currentBranch } = options;
+  const { count, upstream, showGraph, protectedBranches, currentBranch } = options;
   if (showGraph) {
-    const graphFn = mode === "local" ? getLocalCommitsGraph : getRemoteOnlyCommitsGraph;
-    const lines = await graphFn({ count, upstream });
+    const lines = await getLocalCommitsGraph({ count, upstream });
     if (lines.length === 0) {
-      printEmptyState(mode);
+      printEmptyState("local");
       return false;
     }
     console.log();
@@ -12147,15 +12852,14 @@ async function renderScopedLog(options) {
       console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
     }
   } else {
-    const entryFn = mode === "local" ? getLocalCommitsEntries : getRemoteOnlyCommitsEntries;
-    const entries = await entryFn({ count, upstream });
+    const entries = await getLocalCommitsEntries({ count, upstream });
     if (entries.length === 0) {
-      printEmptyState(mode);
+      printEmptyState("local");
       return false;
     }
     console.log();
     for (const entry of entries) {
-      const hashStr = import_picocolors11.default.yellow(entry.hash);
+      const hashStr = import_picocolors12.default.yellow(entry.hash);
       const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
       const subjectStr = colorizeSubject(entry.subject);
       console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
@@ -12163,12 +12867,58 @@ async function renderScopedLog(options) {
   }
   return true;
 }
+async function renderOverviewLog(options) {
+  const {
+    localCount,
+    remoteCount,
+    compareRef,
+    showGraph,
+    protectedBranches,
+    currentBranch,
+    usingFallback
+  } = options;
+  console.log();
+  console.log(import_picocolors12.default.bold(import_picocolors12.default.cyan("  Local Unpushed Commits")));
+  if (!compareRef) {
+    console.log(import_picocolors12.default.dim("  No comparison branch detected for local commit status."));
+    console.log(import_picocolors12.default.dim("  Set an upstream tracking branch or run cn log --full to inspect the current branch history."));
+  } else {
+    await renderScopedLog({
+      mode: "local",
+      count: localCount,
+      upstream: compareRef,
+      showGraph,
+      protectedBranches,
+      currentBranch
+    });
+  }
+  console.log();
+  console.log(import_picocolors12.default.bold(import_picocolors12.default.cyan("  Remote Branch History")));
+  if (!compareRef) {
+    console.log(import_picocolors12.default.dim("  No remote branch detected."));
+    if (usingFallback) {
+      console.log(import_picocolors12.default.dim("  Configure your base branch or upstream tracking to enable the split view."));
+    }
+    return;
+  }
+  const hasRemoteHistory = await renderFullLog({
+    count: remoteCount,
+    all: false,
+    showGraph,
+    targetBranch: compareRef,
+    protectedBranches,
+    currentBranch
+  });
+  if (!hasRemoteHistory) {
+    console.log(import_picocolors12.default.dim("  No remote history found for the selected branch."));
+  }
+}
 function printEmptyState(mode) {
   console.log();
   if (mode === "local") {
-    console.log(import_picocolors11.default.dim("  No local unpushed commits — you're up to date with remote!"));
+    console.log(import_picocolors12.default.dim("  No local unpushed commits — you're up to date with remote!"));
   } else {
-    console.log(import_picocolors11.default.dim("  No remote-only commits — your local branch is up to date!"));
+    console.log(import_picocolors12.default.dim("  No remote-only commits — your local branch is up to date!"));
   }
   console.log();
 }
@@ -12177,7 +12927,7 @@ async function renderFullLog(options) {
   if (showGraph) {
     const lines = await getLogGraph({ count, all, branch: targetBranch });
     if (lines.length === 0) {
-      console.log(import_picocolors11.default.dim("  No commits found."));
+      console.log(import_picocolors12.default.dim("  No commits found."));
       console.log();
       return false;
     }
@@ -12188,13 +12938,13 @@ async function renderFullLog(options) {
   } else {
     const entries = await getLogEntries({ count, all, branch: targetBranch });
     if (entries.length === 0) {
-      console.log(import_picocolors11.default.dim("  No commits found."));
+      console.log(import_picocolors12.default.dim("  No commits found."));
       console.log();
       return false;
     }
     console.log();
     for (const entry of entries) {
-      const hashStr = import_picocolors11.default.yellow(entry.hash);
+      const hashStr = import_picocolors12.default.yellow(entry.hash);
       const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
       const subjectStr = colorizeSubject(entry.subject);
       console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
@@ -12202,46 +12952,37 @@ async function renderFullLog(options) {
   }
   return true;
 }
-function printFooter(mode, count, targetBranch) {
+function printFooter(mode, count, overviewRemoteCount, targetBranch) {
   console.log();
   switch (mode) {
+    case "overview":
+      console.log(import_picocolors12.default.dim(`  Showing up to ${count} local commits and ${overviewRemoteCount} remote commits`));
+      break;
     case "local":
-      console.log(import_picocolors11.default.dim(`  Showing up to ${count} unpushed commits`));
+      console.log(import_picocolors12.default.dim(`  Showing up to ${count} unpushed commits`));
       break;
     case "remote":
-      console.log(import_picocolors11.default.dim(`  Showing up to ${count} remote-only commits`));
+      console.log(import_picocolors12.default.dim(`  Showing ${count} most recent commits from the remote branch`));
       break;
     case "full":
-      console.log(import_picocolors11.default.dim(`  Showing ${count} most recent commits${targetBranch ? ` (${targetBranch})` : ""}`));
+      console.log(import_picocolors12.default.dim(`  Showing ${count} most recent commits${targetBranch ? ` (${targetBranch})` : ""}`));
       break;
     case "all":
-      console.log(import_picocolors11.default.dim(`  Showing ${count} most recent commits (all branches)`));
+      console.log(import_picocolors12.default.dim(`  Showing ${count} most recent commits (all branches)`));
       break;
   }
 }
-function printGuidance() {
-  console.log();
-  console.log(import_picocolors11.default.dim("  ─── quick guide ───"));
-  console.log(import_picocolors11.default.dim(`  ${import_picocolors11.default.bold("contrib log")}            local unpushed commits (default)`));
-  console.log(import_picocolors11.default.dim(`  ${import_picocolors11.default.bold("contrib log --remote")}   commits on remote not yet pulled`));
-  console.log(import_picocolors11.default.dim(`  ${import_picocolors11.default.bold("contrib log --full")}     full history for the current branch`));
-  console.log(import_picocolors11.default.dim(`  ${import_picocolors11.default.bold("contrib log --all")}      commits across all branches`));
-  console.log(import_picocolors11.default.dim(`  ${import_picocolors11.default.bold("contrib log -n 50")}      change the commit limit (default: 20)`));
-  console.log(import_picocolors11.default.dim(`  ${import_picocolors11.default.bold("contrib log -b dev")}     view log for a specific branch`));
-  console.log(import_picocolors11.default.dim(`  ${import_picocolors11.default.bold("contrib log --no-graph")} flat list without graph lines`));
-  console.log();
-}
 function colorizeGraphLine(line, protectedBranches, currentBranch) {
   const match = line.match(/^([|/\\*\s_.-]*)([a-f0-9]{7,12})(\s+\(([^)]+)\))?\s*(.*)/);
   if (!match) {
-    return import_picocolors11.default.cyan(line);
+    return import_picocolors12.default.cyan(line);
   }
   const [, graphPart = "", hash, , refs, subject = ""] = match;
   const parts = [];
   if (graphPart) {
     parts.push(colorizeGraphChars(graphPart));
   }
-  parts.push(import_picocolors11.default.yellow(hash));
+  parts.push(import_picocolors12.default.yellow(hash));
   if (refs) {
     parts.push(` (${colorizeRefs(refs, protectedBranches, currentBranch)})`);
   }
@@ -12252,15 +12993,15 @@ function colorizeGraphChars(graphPart) {
   return graphPart.split("").map((ch) => {
     switch (ch) {
       case "*":
-        return import_picocolors11.default.green(ch);
+        return import_picocolors12.default.green(ch);
       case "|":
-        return import_picocolors11.default.cyan(ch);
+        return import_picocolors12.default.cyan(ch);
       case "/":
       case "\\":
-        return import_picocolors11.default.cyan(ch);
+        return import_picocolors12.default.cyan(ch);
       case "-":
       case "_":
-        return import_picocolors11.default.cyan(ch);
+        return import_picocolors12.default.cyan(ch);
       default:
         return ch;
     }
@@ -12272,50 +13013,50 @@ function colorizeRefs(refs, protectedBranches, currentBranch) {
     if (trimmed.startsWith("HEAD ->") || trimmed === "HEAD") {
       const branchName = trimmed.replace("HEAD -> ", "");
       if (trimmed === "HEAD") {
-        return import_picocolors11.default.bold(import_picocolors11.default.cyan("HEAD"));
+        return import_picocolors12.default.bold(import_picocolors12.default.cyan("HEAD"));
       }
-      return `${import_picocolors11.default.bold(import_picocolors11.default.cyan("HEAD"))} ${import_picocolors11.default.dim("->")} ${colorizeRefName(branchName, protectedBranches, currentBranch)}`;
+      return `${import_picocolors12.default.bold(import_picocolors12.default.cyan("HEAD"))} ${import_picocolors12.default.dim("->")} ${colorizeRefName(branchName, protectedBranches, currentBranch)}`;
     }
     if (trimmed.startsWith("tag:")) {
-      return import_picocolors11.default.bold(import_picocolors11.default.magenta(trimmed));
+      return import_picocolors12.default.bold(import_picocolors12.default.magenta(trimmed));
     }
     return colorizeRefName(trimmed, protectedBranches, currentBranch);
-  }).join(import_picocolors11.default.dim(", "));
+  }).join(import_picocolors12.default.dim(", "));
 }
 function colorizeRefName(name, protectedBranches, currentBranch) {
   const isRemote = name.includes("/");
   const localName = isRemote ? name.split("/").slice(1).join("/") : name;
   if (protectedBranches.includes(localName)) {
-    return isRemote ? import_picocolors11.default.bold(import_picocolors11.default.red(name)) : import_picocolors11.default.bold(import_picocolors11.default.red(name));
+    return isRemote ? import_picocolors12.default.bold(import_picocolors12.default.red(name)) : import_picocolors12.default.bold(import_picocolors12.default.red(name));
   }
   if (localName === currentBranch) {
-    return import_picocolors11.default.bold(import_picocolors11.default.green(name));
+    return import_picocolors12.default.bold(import_picocolors12.default.green(name));
   }
   if (isRemote) {
-    return import_picocolors11.default.blue(name);
+    return import_picocolors12.default.blue(name);
   }
-  return import_picocolors11.default.green(name);
+  return import_picocolors12.default.green(name);
 }
 function colorizeSubject(subject) {
   const emojiMatch = subject.match(/^((?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F)+\s*)/u);
   if (emojiMatch) {
     const emoji = emojiMatch[1];
     const rest = subject.slice(emoji.length);
-    return `${emoji}${import_picocolors11.default.white(rest)}`;
+    return `${emoji}${import_picocolors12.default.white(rest)}`;
   }
   if (subject.startsWith("Merge ")) {
-    return import_picocolors11.default.dim(subject);
+    return import_picocolors12.default.dim(subject);
   }
-  return import_picocolors11.default.white(subject);
+  return import_picocolors12.default.white(subject);
 }
 
 // src/commands/save.ts
-var import_picocolors12 = __toESM(require_picocolors(), 1);
 import { execFile as execFileCb4 } from "node:child_process";
+var import_picocolors13 = __toESM(require_picocolors(), 1);
 function gitRun(args) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     execFileCb4("git", args, (err, stdout2, stderr) => {
-      resolve2({
+      resolve3({
         exitCode: err ? err.code === "ENOENT" ? 127 : err.status ?? 1 : 0,
         stdout: stdout2 ?? "",
         stderr: stderr ?? ""
@@ -12372,7 +13113,7 @@ var save_default = defineCommand({
   }
 });
 async function handleSave(message) {
-  heading("\uD83D\uDCBE contrib save");
+  projectHeading("save", "\uD83D\uDCBE");
   const currentBranch = await getCurrentBranch();
   const label = message ?? `work-in-progress on ${currentBranch ?? "unknown"}`;
   const stashMsg = `contrib-save: ${label}`;
@@ -12385,11 +13126,11 @@ async function handleSave(message) {
     info("No uncommitted changes to save.");
     return;
   }
-  success(`Saved: ${import_picocolors12.default.dim(label)}`);
-  info(`Use ${import_picocolors12.default.bold("contrib save --restore")} to bring them back.`, "");
+  success(`Saved: ${import_picocolors13.default.dim(label)}`);
+  info(`Use ${import_picocolors13.default.bold("contrib save --restore")} to bring them back.`, "");
 }
 async function handleRestore() {
-  heading("\uD83D\uDCBE contrib save --restore");
+  projectHeading("save --restore", "\uD83D\uDCBE");
   const stashes = await getStashList();
   if (stashes.length === 0) {
     info("No saved changes found.");
@@ -12402,7 +13143,7 @@ async function handleRestore() {
       warn("You may have conflicts. Resolve them and run `git stash drop` when done.");
       process.exit(1);
     }
-    success(`Restored: ${import_picocolors12.default.dim(stashes[0].message)}`);
+    success(`Restored: ${import_picocolors13.default.dim(stashes[0].message)}`);
     return;
   }
   const choices = stashes.map((s2) => `${s2.index}  ${s2.message}`);
@@ -12415,10 +13156,10 @@ async function handleRestore() {
     process.exit(1);
   }
   const match = stashes.find((s2) => String(s2.index) === idx);
-  success(`Restored: ${import_picocolors12.default.dim(match?.message ?? "saved changes")}`);
+  success(`Restored: ${import_picocolors13.default.dim(match?.message ?? "saved changes")}`);
 }
 async function handleList() {
-  heading("\uD83D\uDCBE contrib save --list");
+  projectHeading("save --list", "\uD83D\uDCBE");
   const stashes = await getStashList();
   if (stashes.length === 0) {
     info("No saved changes.");
@@ -12426,16 +13167,16 @@ async function handleList() {
   }
   console.log();
   for (const s2 of stashes) {
-    const idx = import_picocolors12.default.dim(`[${s2.index}]`);
+    const idx = import_picocolors13.default.dim(`[${s2.index}]`);
     const msg = s2.message;
     console.log(`  ${idx}  ${msg}`);
   }
   console.log();
-  info(`Use ${import_picocolors12.default.bold("contrib save --restore")} to bring changes back.`, "");
-  info(`Use ${import_picocolors12.default.bold("contrib save --drop")} to discard saved changes.`, "");
+  info(`Use ${import_picocolors13.default.bold("contrib save --restore")} to bring changes back.`, "");
+  info(`Use ${import_picocolors13.default.bold("contrib save --drop")} to discard saved changes.`, "");
 }
 async function handleDrop() {
-  heading("\uD83D\uDCBE contrib save --drop");
+  projectHeading("save --drop", "\uD83D\uDCBE");
   const stashes = await getStashList();
   if (stashes.length === 0) {
     info("No saved changes to drop.");
@@ -12450,7 +13191,7 @@ async function handleDrop() {
     process.exit(1);
   }
   const match = stashes.find((s2) => String(s2.index) === idx);
-  success(`Dropped: ${import_picocolors12.default.dim(match?.message ?? "saved changes")}`);
+  success(`Dropped: ${import_picocolors13.default.dim(match?.message ?? "saved changes")}`);
 }
 async function getStashList() {
   const result = await gitRun(["stash", "list"]);
@@ -12467,38 +13208,23 @@ async function getStashList() {
 }
 
 // src/commands/setup.ts
-var import_picocolors13 = __toESM(require_picocolors(), 1);
+var import_picocolors14 = __toESM(require_picocolors(), 1);
 async function shouldContinueSetupWithExistingConfig(options) {
-  const {
-    existingConfig,
-    hasConfigFile,
-    confirm,
-    ensureIgnored,
-    onInfo,
-    onWarn,
-    onSuccess,
-    summary
-  } = options;
+  const { existingConfig, hasConfigFile, confirm, onInfo, onWarn, onSuccess, summary } = options;
   if (existingConfig) {
-    onInfo("Existing .contributerc.json detected:");
+    onInfo("Existing repo config detected:");
     summary(existingConfig);
     const shouldContinue = await confirm("Continue setup and overwrite existing config?");
     if (!shouldContinue) {
-      if (ensureIgnored()) {
-        onInfo("Added .contributerc.json to .gitignore to avoid committing personal config.");
-      }
       onSuccess("Keeping existing setup.");
       return false;
     }
     return true;
   }
   if (hasConfigFile) {
-    onWarn("Found .contributerc.json but it appears invalid.");
+    onWarn("Found an existing repo config but it appears invalid.");
     const shouldContinue = await confirm("Continue setup and overwrite invalid config?");
     if (!shouldContinue) {
-      if (ensureIgnored()) {
-        onInfo("Added .contributerc.json to .gitignore to avoid committing personal config.");
-      }
       onInfo("Keeping existing file. Run setup again when ready to repair it.");
       return false;
     }
@@ -12508,20 +13234,19 @@ async function shouldContinueSetupWithExistingConfig(options) {
 var setup_default = defineCommand({
   meta: {
     name: "setup",
-    description: "Initialize contribute-now config for this repo (.contributerc.json)"
+    description: "Initialize contribute-now config for this repo using local Git storage"
   },
   async run() {
     if (!await isGitRepo()) {
       error("Not inside a git repository. Run this command from within a git repo.");
       process.exit(1);
     }
-    heading("\uD83D\uDD27 contribute-now setup");
+    projectHeading("setup", "\uD83D\uDD27");
     const existingConfig = readConfig();
     const shouldContinue = await shouldContinueSetupWithExistingConfig({
       existingConfig,
       hasConfigFile: configExists(),
       confirm: confirmPrompt,
-      ensureIgnored: ensureGitignored,
       onInfo: info,
       onWarn: warn,
       onSuccess: success,
@@ -12540,7 +13265,7 @@ var setup_default = defineCommand({
       workflow = "github-flow";
     else if (workflowChoice.startsWith("Git Flow"))
       workflow = "git-flow";
-    info(`Workflow: ${import_picocolors13.default.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
+    info(`Workflow: ${import_picocolors14.default.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
     const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
       `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
       CONVENTION_DESCRIPTIONS.conventional,
@@ -12551,6 +13276,8 @@ var setup_default = defineCommand({
       commitConvention = "conventional";
     else if (conventionChoice.includes("No commit"))
       commitConvention = "none";
+    const enableAI = await confirmPrompt("Enable AI-assisted features like commit messages, branch naming, PR text, and conflict guidance?");
+    const showTips = await confirmPrompt("Show beginner quick guides and loading tips in command output?");
     const remotes = await getRemotes();
     if (remotes.length === 0) {
       error("No git remotes found. Add a remote first (e.g., git remote add origin <url>).");
@@ -12604,15 +13331,15 @@ var setup_default = defineCommand({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${import_picocolors13.default.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${import_picocolors13.default.bold(detectedRole)}. Is this correct?`);
+      info(`Detected role: ${import_picocolors14.default.bold(detectedRole)} (via ${detectionSource})`);
+      const confirmed = await confirmPrompt(`Role detected as ${import_picocolors14.default.bold(detectedRole)}. Is this correct?`);
       if (!confirmed) {
         const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
         detectedRole = roleChoice;
       }
     }
     const defaultConfig = getDefaultConfig();
-    info(import_picocolors13.default.dim("Tip: press Enter to keep the default branch name shown in each prompt."));
+    info(import_picocolors14.default.dim("Tip: press Enter to keep the default branch name shown in each prompt."));
     const mainBranchDefault = defaultConfig.mainBranch;
     const mainBranch = await inputPrompt(`Main branch name (default: ${mainBranchDefault} — press Enter to keep)`, mainBranchDefault);
     let devBranch;
@@ -12638,7 +13365,7 @@ var setup_default = defineCommand({
             error("Setup cannot continue without the upstream remote for contributors.");
             process.exit(1);
           }
-          success(`Added remote ${import_picocolors13.default.bold(upstreamRemote)} → ${upstreamUrl}`);
+          success(`Added remote ${import_picocolors14.default.bold(upstreamRemote)} → ${upstreamUrl}`);
         } else {
           error("An upstream remote URL is required for contributors.");
           info("Add it manually: git remote add upstream <url>", "");
@@ -12654,54 +13381,58 @@ var setup_default = defineCommand({
       upstream: upstreamRemote,
       origin: originRemote,
       branchPrefixes: defaultConfig.branchPrefixes,
-      commitConvention
+      commitConvention,
+      aiEnabled: enableAI,
+      showTips
     };
     writeConfig(config);
-    success(`Config written to .contributerc.json`);
+    success(`Config written to ${import_picocolors14.default.bold(getConfigLocationLabel())}`);
+    info("This setup is stored locally for this clone and does not modify tracked files.", "");
     const syncRemote = config.role === "contributor" ? config.upstream : config.origin;
-    info(`Fetching ${import_picocolors13.default.bold(syncRemote)} to verify branch configuration...`, "");
+    info(`Fetching ${import_picocolors14.default.bold(syncRemote)} to verify branch configuration...`, "");
     await fetchRemote(syncRemote);
     const mainRef = `${syncRemote}/${config.mainBranch}`;
     if (!await refExists(mainRef)) {
-      warn(`Main branch ref ${import_picocolors13.default.bold(mainRef)} not found on remote.`);
+      warn(`Main branch ref ${import_picocolors14.default.bold(mainRef)} not found on remote.`);
       warn("Config was saved — verify the branch name and re-run setup if needed.");
     }
     if (config.devBranch) {
       const devRef = `${syncRemote}/${config.devBranch}`;
       if (!await refExists(devRef)) {
-        warn(`Dev branch ref ${import_picocolors13.default.bold(devRef)} not found on remote.`);
+        warn(`Dev branch ref ${import_picocolors14.default.bold(devRef)} not found on remote.`);
         warn("Config was saved — verify the branch name and re-run setup if needed.");
       }
     }
-    if (ensureGitignored()) {
-      info("Added .contributerc.json to .gitignore to avoid committing personal config.");
-    }
     console.log();
-    info(`Workflow: ${import_picocolors13.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    info(`Convention: ${import_picocolors13.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-    info(`Role: ${import_picocolors13.default.bold(config.role)}`);
+    info(`Workflow: ${import_picocolors14.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    info(`Convention: ${import_picocolors14.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+    info(`AI: ${import_picocolors14.default.bold(isAIEnabled(config) ? "enabled" : "disabled")}`);
+    info(`Guides: ${import_picocolors14.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
+    info(`Role: ${import_picocolors14.default.bold(config.role)}`);
     if (config.devBranch) {
-      info(`Main: ${import_picocolors13.default.bold(config.mainBranch)} | Dev: ${import_picocolors13.default.bold(config.devBranch)}`);
+      info(`Main: ${import_picocolors14.default.bold(config.mainBranch)} | Dev: ${import_picocolors14.default.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${import_picocolors13.default.bold(config.mainBranch)}`);
+      info(`Main: ${import_picocolors14.default.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${import_picocolors13.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors13.default.bold(config.upstream)}` : ""}`);
+    info(`Origin: ${import_picocolors14.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors14.default.bold(config.upstream)}` : ""}`);
   }
 });
 function logConfigSummary(config) {
-  info(`Workflow: ${import_picocolors13.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-  info(`Convention: ${import_picocolors13.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-  info(`Role: ${import_picocolors13.default.bold(config.role)}`);
+  info(`Workflow: ${import_picocolors14.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+  info(`Convention: ${import_picocolors14.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+  info(`AI: ${import_picocolors14.default.bold(isAIEnabled(config) ? "enabled" : "disabled")}`);
+  info(`Guides: ${import_picocolors14.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
+  info(`Role: ${import_picocolors14.default.bold(config.role)}`);
   if (config.devBranch) {
-    info(`Main: ${import_picocolors13.default.bold(config.mainBranch)} | Dev: ${import_picocolors13.default.bold(config.devBranch)}`);
+    info(`Main: ${import_picocolors14.default.bold(config.mainBranch)} | Dev: ${import_picocolors14.default.bold(config.devBranch)}`);
   } else {
-    info(`Main: ${import_picocolors13.default.bold(config.mainBranch)}`);
+    info(`Main: ${import_picocolors14.default.bold(config.mainBranch)}`);
   }
-  info(`Origin: ${import_picocolors13.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors13.default.bold(config.upstream)}` : ""}`);
+  info(`Origin: ${import_picocolors14.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors14.default.bold(config.upstream)}` : ""}`);
 }
 
 // src/commands/start.ts
-var import_picocolors14 = __toESM(require_picocolors(), 1);
+var import_picocolors15 = __toESM(require_picocolors(), 1);
 var start_default = defineCommand({
   meta: {
     name: "start",
@@ -12731,7 +13462,7 @@ var start_default = defineCommand({
     await assertCleanGitState("starting a new branch");
     const config = readConfig();
     if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
+      error("No repo config found. Run `contrib setup` first.");
       process.exit(1);
     }
     if (await hasUncommittedChanges()) {
@@ -12741,57 +13472,28 @@ var start_default = defineCommand({
     const { branchPrefixes } = config;
     const baseBranch = getBaseBranch(config);
     const syncSource = getSyncSource(config);
-    let branchName = args.name;
-    heading("\uD83C\uDF3F contrib start");
+    let branchName = args.name?.trim();
+    projectHeading("start", "\uD83C\uDF3F");
+    branchName = await promptForBranchName({
+      initialValue: branchName,
+      branchPrefixes,
+      useAI: isAIEnabled(config, args["no-ai"]),
+      model: args.model
+    });
     if (!branchName) {
-      branchName = await inputPrompt("What are you going to work on?");
-      if (!branchName || branchName.trim().length === 0) {
-        error("A branch name or description is required.");
-        process.exit(1);
-      }
-      branchName = branchName.trim();
-    }
-    const useAI = !args["no-ai"] && looksLikeNaturalLanguage(branchName);
-    if (useAI) {
-      const spinner = createSpinner("Generating branch name suggestion...");
-      const suggested = await suggestBranchName(branchName, args.model);
-      if (suggested) {
-        spinner.success("Branch name suggestion ready.");
-        console.log(`
-  ${import_picocolors14.default.dim("AI suggestion:")} ${import_picocolors14.default.bold(import_picocolors14.default.cyan(suggested))}`);
-        const accepted = await confirmPrompt(`Use ${import_picocolors14.default.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 ${import_picocolors14.default.bold(branchName)}:`, branchPrefixes);
-      branchName = formatBranchName(prefix, branchName);
-    }
-    if (!isValidBranchName(branchName)) {
-      error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
-      process.exit(1);
-    }
-    info(`Creating branch: ${import_picocolors14.default.bold(branchName)}`);
-    if (await branchExists(branchName)) {
-      error(`Branch ${import_picocolors14.default.bold(branchName)} already exists.`);
-      info(`  Use ${import_picocolors14.default.bold(`git checkout ${branchName}`)} to switch to it, or choose a different name.`, "");
-      process.exit(1);
+      warn("Start cancelled.");
+      process.exit(0);
     }
+    info(`Creating branch: ${import_picocolors15.default.bold(branchName)}`);
     await fetchRemote(syncSource.remote);
     if (!await refExists(syncSource.ref)) {
-      warn(`Remote ref ${import_picocolors14.default.bold(syncSource.ref)} not found. Creating branch from local ${import_picocolors14.default.bold(baseBranch)}.`);
+      warn(`Remote ref ${import_picocolors15.default.bold(syncSource.ref)} not found. Creating branch from local ${import_picocolors15.default.bold(baseBranch)}.`);
     }
     const currentBranch = await getCurrentBranch();
     if (currentBranch === baseBranch && await refExists(syncSource.ref)) {
       const ahead = await countCommitsAhead(baseBranch, syncSource.ref);
       if (ahead > 0) {
-        warn(`You are on ${import_picocolors14.default.bold(baseBranch)} with ${import_picocolors14.default.bold(String(ahead))} local commit${ahead > 1 ? "s" : ""} not in ${import_picocolors14.default.bold(syncSource.ref)}.`);
+        warn(`You are on ${import_picocolors15.default.bold(baseBranch)} with ${import_picocolors15.default.bold(String(ahead))} local commit${ahead > 1 ? "s" : ""} not in ${import_picocolors15.default.bold(syncSource.ref)}.`);
         info("  Syncing will discard those commits. Consider backing them up first (e.g. create a branch).");
         const proceed = await confirmPrompt("Discard local commits and sync to remote?");
         if (!proceed) {
@@ -12808,10 +13510,10 @@ var start_default = defineCommand({
           error(`Failed to create branch: ${result2.stderr}`);
           process.exit(1);
         }
-        success(`Created ${import_picocolors14.default.bold(branchName)} from ${import_picocolors14.default.bold(syncSource.ref)}`);
+        success(`Created ${import_picocolors15.default.bold(branchName)} from ${import_picocolors15.default.bold(syncSource.ref)}`);
         return;
       }
-      error(`Failed to update ${import_picocolors14.default.bold(baseBranch)}: ${updateResult.stderr}`);
+      error(`Failed to update ${import_picocolors15.default.bold(baseBranch)}: ${updateResult.stderr}`);
       info("Make sure your base branch exists locally or the remote ref is available.", "");
       process.exit(1);
     }
@@ -12820,12 +13522,12 @@ var start_default = defineCommand({
       error(`Failed to create branch: ${result.stderr}`);
       process.exit(1);
     }
-    success(`Created ${import_picocolors14.default.bold(branchName)} from latest ${import_picocolors14.default.bold(baseBranch)}`);
+    success(`Created ${import_picocolors15.default.bold(branchName)} from latest ${import_picocolors15.default.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-var import_picocolors15 = __toESM(require_picocolors(), 1);
+var import_picocolors16 = __toESM(require_picocolors(), 1);
 var status_default = defineCommand({
   meta: {
     name: "status",
@@ -12838,12 +13540,12 @@ var status_default = defineCommand({
     }
     const config = readConfig();
     if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
+      error("No repo config found. Run `contrib setup` first.");
       process.exit(1);
     }
-    heading("\uD83D\uDCCA contribute-now status");
-    console.log(`  ${import_picocolors15.default.dim("Workflow:")} ${import_picocolors15.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    console.log(`  ${import_picocolors15.default.dim("Role:")} ${import_picocolors15.default.bold(config.role)}`);
+    projectHeading("status", "\uD83D\uDCCA");
+    console.log(`  ${import_picocolors16.default.dim("Workflow:")} ${import_picocolors16.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    console.log(`  ${import_picocolors16.default.dim("Role:")} ${import_picocolors16.default.bold(config.role)}`);
     console.log();
     await fetchAll();
     const currentBranch = await getCurrentBranch();
@@ -12852,7 +13554,7 @@ var status_default = defineCommand({
     const isContributor = config.role === "contributor";
     const [dirty, fileStatus] = await Promise.all([hasUncommittedChanges(), getFileStatus()]);
     if (dirty) {
-      console.log(`  ${import_picocolors15.default.yellow("⚠")}  ${import_picocolors15.default.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${import_picocolors16.default.yellow("⚠")}  ${import_picocolors16.default.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -12871,28 +13573,32 @@ var status_default = defineCommand({
     if (isFeatureBranch) {
       const branchDiv = await getDivergence(currentBranch, baseBranch);
       const branchLine = formatStatus(currentBranch, baseBranch, branchDiv.ahead, branchDiv.behind);
-      console.log(branchLine + import_picocolors15.default.dim(` (current ${import_picocolors15.default.green("*")})`));
+      console.log(branchLine + import_picocolors16.default.dim(` (current ${import_picocolors16.default.green("*")})`));
       branchStatus = await detectBranchStatus(currentBranch, baseBranch);
       if (branchStatus.merged) {
-        console.log(`  ${import_picocolors15.default.green("✓")}  ${import_picocolors15.default.green("Branch merged")} — ${import_picocolors15.default.dim(branchStatus.mergedReason ?? "all commits reachable from base")}`);
+        console.log(`  ${import_picocolors16.default.green("✓")}  ${import_picocolors16.default.green("Branch merged")} — ${import_picocolors16.default.dim(branchStatus.mergedReason ?? "all commits reachable from base")}`);
       }
       if (branchStatus.stale) {
-        console.log(`  ${import_picocolors15.default.yellow("⏳")}  ${import_picocolors15.default.yellow("Branch is stale")} — ${import_picocolors15.default.dim(`last commit ${branchStatus.staleDaysAgo} days ago`)}`);
+        console.log(`  ${import_picocolors16.default.yellow("⏳")}  ${import_picocolors16.default.yellow("Branch is stale")} — ${import_picocolors16.default.dim(`last commit ${branchStatus.staleDaysAgo} days ago`)}`);
       }
     } else if (currentBranch) {
-      console.log(import_picocolors15.default.dim(`  (on ${import_picocolors15.default.bold(currentBranch)} branch)`));
+      console.log(import_picocolors16.default.dim(`  (on ${import_picocolors16.default.bold(currentBranch)} branch)`));
     }
     let branchesAligned = true;
     {
       const alignRefs = [];
       const devRemote = isContributor ? upstream : origin;
+      const devBranch = hasDevBranch(workflow) ? config.devBranch : undefined;
       const hashResults = await Promise.all([
         getCommitHash(mainBranch).then((h2) => ({ name: mainBranch, hash: h2 })),
-        getCommitHash(`${origin}/${mainBranch}`).then((h2) => ({ name: `${origin}/${mainBranch}`, hash: h2 })),
-        ...hasDevBranch(workflow) && config.devBranch ? [
-          getCommitHash(config.devBranch).then((h2) => ({ name: config.devBranch, hash: h2 })),
-          getCommitHash(`${devRemote}/${config.devBranch}`).then((h2) => ({
-            name: `${devRemote}/${config.devBranch}`,
+        getCommitHash(`${origin}/${mainBranch}`).then((h2) => ({
+          name: `${origin}/${mainBranch}`,
+          hash: h2
+        })),
+        ...devBranch ? [
+          getCommitHash(devBranch).then((h2) => ({ name: devBranch, hash: h2 })),
+          getCommitHash(`${devRemote}/${devBranch}`).then((h2) => ({
+            name: `${devRemote}/${devBranch}`,
             hash: h2
           }))
         ] : []
@@ -12906,24 +13612,27 @@ var status_default = defineCommand({
         for (const { name, hash } of alignRefs) {
           if (!groups.has(hash))
             groups.set(hash, []);
-          groups.get(hash).push(name);
+          const group = groups.get(hash);
+          if (group) {
+            group.push(name);
+          }
         }
         branchesAligned = groups.size === 1;
         console.log();
-        console.log(`  ${import_picocolors15.default.bold("\uD83D\uDD17 Branch Alignment")}`);
+        console.log(`  ${import_picocolors16.default.bold("\uD83D\uDD17 Branch Alignment")}`);
         for (const [hash, names] of groups) {
           const short = hash.slice(0, 7);
-          const nameStr = names.map((n2) => import_picocolors15.default.bold(n2)).join(import_picocolors15.default.dim(" · "));
-          console.log(`     ${import_picocolors15.default.yellow(short)} ${import_picocolors15.default.dim("──")} ${nameStr}`);
+          const nameStr = names.map((n2) => import_picocolors16.default.bold(n2)).join(import_picocolors16.default.dim(" · "));
+          console.log(`     ${import_picocolors16.default.yellow(short)} ${import_picocolors16.default.dim("──")} ${nameStr}`);
           const subject = await getCommitSubject(hash);
           if (subject) {
-            console.log(`                ${import_picocolors15.default.dim(subject)}`);
+            console.log(`                ${import_picocolors16.default.dim(subject)}`);
           }
         }
         if (branchesAligned) {
-          console.log(`     ${import_picocolors15.default.green("✓")} ${import_picocolors15.default.green("All branches aligned")} ${import_picocolors15.default.dim("— ready to start")}`);
+          console.log(`     ${import_picocolors16.default.green("✓")} ${import_picocolors16.default.green("All branches aligned")} ${import_picocolors16.default.dim("— ready to start")}`);
         } else {
-          console.log(`     ${import_picocolors15.default.yellow("⚠")} ${import_picocolors15.default.yellow("Branches are not fully aligned")}`);
+          console.log(`     ${import_picocolors16.default.yellow("⚠")} ${import_picocolors16.default.yellow("Branches are not fully aligned")}`);
         }
       }
     }
@@ -12931,74 +13640,50 @@ var status_default = defineCommand({
     if (hasFiles) {
       console.log();
       if (fileStatus.staged.length > 0) {
-        console.log(`  ${import_picocolors15.default.green("Staged for commit:")}`);
+        console.log(`  ${import_picocolors16.default.green("Staged for commit:")}`);
         for (const { file, status } of fileStatus.staged) {
-          console.log(`    ${import_picocolors15.default.green("+")} ${import_picocolors15.default.dim(`${status}:`)} ${file}`);
+          console.log(`    ${import_picocolors16.default.green("+")} ${import_picocolors16.default.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.modified.length > 0) {
-        console.log(`  ${import_picocolors15.default.yellow("Unstaged changes:")}`);
+        console.log(`  ${import_picocolors16.default.yellow("Unstaged changes:")}`);
         for (const { file, status } of fileStatus.modified) {
-          console.log(`    ${import_picocolors15.default.yellow("~")} ${import_picocolors15.default.dim(`${status}:`)} ${file}`);
+          console.log(`    ${import_picocolors16.default.yellow("~")} ${import_picocolors16.default.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.untracked.length > 0) {
-        console.log(`  ${import_picocolors15.default.red("Untracked files:")}`);
+        console.log(`  ${import_picocolors16.default.red("Untracked files:")}`);
         for (const file of fileStatus.untracked) {
-          console.log(`    ${import_picocolors15.default.red("?")} ${file}`);
+          console.log(`    ${import_picocolors16.default.red("?")} ${file}`);
         }
       }
     } else if (!dirty) {
-      console.log(`  ${import_picocolors15.default.green("✓")}  ${import_picocolors15.default.dim("Working tree clean")}`);
-    }
-    const tips = [];
-    if (!branchesAligned) {
-      tips.push(`Run ${import_picocolors15.default.bold("contrib sync")} to align your local branches with the remote`);
-    }
-    if (fileStatus.staged.length > 0) {
-      tips.push(`Run ${import_picocolors15.default.bold("contrib commit")} to commit staged changes`);
-    }
-    if (fileStatus.modified.length > 0 || fileStatus.untracked.length > 0) {
-      tips.push(`Run ${import_picocolors15.default.bold("contrib commit")} to stage and commit changes`);
-    }
-    if (isFeatureBranch && branchStatus) {
-      if (branchStatus.merged) {
-        tips.push(`Run ${import_picocolors15.default.bold("contrib clean")} to delete this merged branch`);
-      } else if (branchStatus.stale) {
-        tips.push(`Run ${import_picocolors15.default.bold("contrib sync")} to rebase on latest changes, or ${import_picocolors15.default.bold("contrib clean")} if no longer needed`);
-      } else if (fileStatus.staged.length === 0 && fileStatus.modified.length === 0 && fileStatus.untracked.length === 0) {
-        const branchDiv = await getDivergence(currentBranch, `${origin}/${currentBranch}`);
-        if (branchDiv.ahead > 0) {
-          tips.push(`Run ${import_picocolors15.default.bold("contrib submit")} to push and create/update your PR`);
-        }
-      }
-    }
-    if (tips.length > 0) {
-      console.log();
-      console.log(`  ${import_picocolors15.default.dim("\uD83D\uDCA1 Tip:")}`);
-      for (const tip of tips) {
-        console.log(`     ${import_picocolors15.default.dim(tip)}`);
-      }
+      console.log(`  ${import_picocolors16.default.green("✓")}  ${import_picocolors16.default.dim("Working tree clean")}`);
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = import_picocolors15.default.bold(branch.padEnd(20));
+  const label = import_picocolors16.default.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${import_picocolors15.default.green("✓")}  ${label} ${import_picocolors15.default.dim(`in sync with ${base}`)}`;
+    return `  ${import_picocolors16.default.green("✓")}  ${label} ${import_picocolors16.default.dim(`in sync with ${base}`)}`;
   }
   if (ahead > 0 && behind === 0) {
-    return `  ${import_picocolors15.default.yellow("↑")}  ${label} ${import_picocolors15.default.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+    return `  ${import_picocolors16.default.yellow("↑")}  ${label} ${import_picocolors16.default.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
   }
   if (behind > 0 && ahead === 0) {
-    return `  ${import_picocolors15.default.red("↓")}  ${label} ${import_picocolors15.default.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+    return `  ${import_picocolors16.default.red("↓")}  ${label} ${import_picocolors16.default.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
   }
-  return `  ${import_picocolors15.default.red("⚡")}  ${label} ${import_picocolors15.default.yellow(`${ahead} ahead`)}${import_picocolors15.default.dim(", ")}${import_picocolors15.default.red(`${behind} behind`)} ${import_picocolors15.default.dim(base)}`;
+  return `  ${import_picocolors16.default.red("⚡")}  ${label} ${import_picocolors16.default.yellow(`${ahead} ahead`)}${import_picocolors16.default.dim(", ")}${import_picocolors16.default.red(`${behind} behind`)} ${import_picocolors16.default.dim(base)}`;
 }
 var STALE_THRESHOLD_DAYS = 14;
 async function detectBranchStatus(branch, baseBranch) {
-  const result = { merged: false, mergedReason: null, stale: false, staleDaysAgo: null };
+  const result = {
+    merged: false,
+    mergedReason: null,
+    stale: false,
+    staleDaysAgo: null
+  };
   const div = await getDivergence(branch, baseBranch);
   const hasWork = div.ahead > 0;
   if (hasWork) {
@@ -13040,34 +13725,47 @@ async function detectBranchStatus(branch, baseBranch) {
 }
 
 // src/commands/submit.ts
-var import_picocolors16 = __toESM(require_picocolors(), 1);
+var import_picocolors17 = __toESM(require_picocolors(), 1);
 async function performSquashMerge(origin, baseBranch, featureBranch, options) {
-  info(`Checking out ${import_picocolors16.default.bold(baseBranch)}...`);
+  info(`Checking out ${import_picocolors17.default.bold(baseBranch)}...`);
   const coResult = await checkoutBranch(baseBranch);
   if (coResult.exitCode !== 0) {
     error(`Failed to checkout ${baseBranch}: ${coResult.stderr}`);
     process.exit(1);
   }
-  info(`Squash merging ${import_picocolors16.default.bold(featureBranch)} into ${import_picocolors16.default.bold(baseBranch)}...`);
+  info(`Squash merging ${import_picocolors17.default.bold(featureBranch)} into ${import_picocolors17.default.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 (!message && options?.useAI !== false) {
+    const copilotError = await checkCopilotAvailable2();
     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", "squash-merge");
-      if (aiMsg) {
-        message = aiMsg;
-        spinner.success("AI commit message generated.");
-        console.log(`
-  ${import_picocolors16.default.dim("AI suggestion:")} ${import_picocolors16.default.bold(import_picocolors16.default.cyan(message))}`);
-      } else {
+      while (!message) {
+        const spinner = createSpinner("Generating AI commit message for squash merge...", {
+          tips: LOADING_TIPS
+        });
+        const [stagedDiff, stagedFiles] = await Promise.all([getStagedDiff(), getStagedFiles()]);
+        const aiMsg = await generateCommitMessage(stagedDiff, stagedFiles, options?.model, options?.convention ?? "clean-commit", "squash-merge");
+        if (aiMsg) {
+          message = aiMsg;
+          spinner.success("AI commit message generated.");
+          console.log(`
+  ${import_picocolors17.default.dim("AI suggestion:")} ${import_picocolors17.default.bold(import_picocolors17.default.cyan(message))}`);
+          break;
+        }
         spinner.fail("AI did not return a commit message.");
+        const retryAction = await selectPrompt("AI could not generate a commit message. What would you like to do?", ["Try again with AI", "Write manually", "Cancel"]);
+        if (retryAction === "Try again with AI") {
+          continue;
+        }
+        if (retryAction === "Cancel") {
+          warn("Squash merge commit cancelled.");
+          process.exit(0);
+        }
+        break;
       }
     } else {
       warn(`AI unavailable: ${copilotError}`);
@@ -13076,28 +13774,28 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
   let finalMsg = null;
   if (message) {
     while (!finalMsg) {
-      const action = await selectPrompt("What would you like to do?", [
-        "Accept this message",
-        "Edit this message",
-        "Regenerate",
-        "Write manually"
-      ]);
+      const actions = ["Accept this message", "Edit this message", "Write manually"];
+      if (options?.useAI !== false) {
+        actions.splice(2, 0, "Regenerate");
+      }
+      const action = await selectPrompt("What would you like to do?", actions);
       if (action === "Accept this message") {
         finalMsg = message;
       } else if (action === "Edit this message") {
         finalMsg = await inputPrompt("Edit commit message", message);
       } else if (action === "Regenerate") {
-        const spinner = createSpinner("Regenerating commit message...");
+        const spinner = createSpinner("Regenerating commit message...", {
+          tips: LOADING_TIPS
+        });
         const [stagedDiff, stagedFiles] = await Promise.all([getStagedDiff(), getStagedFiles()]);
         const regen = await generateCommitMessage(stagedDiff, stagedFiles, options?.model, options?.convention ?? "clean-commit", "squash-merge");
         if (regen) {
           message = regen;
           spinner.success("Commit message regenerated.");
           console.log(`
-  ${import_picocolors16.default.dim("AI suggestion:")} ${import_picocolors16.default.bold(import_picocolors16.default.cyan(regen))}`);
+  ${import_picocolors17.default.dim("AI suggestion:")} ${import_picocolors17.default.bold(import_picocolors17.default.cyan(regen))}`);
         } else {
           spinner.fail("Regeneration failed.");
-          finalMsg = await inputPrompt("Enter commit message");
         }
       } else {
         finalMsg = await inputPrompt("Enter commit message");
@@ -13111,13 +13809,13 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
     error(`Commit failed: ${commitResult.stderr}`);
     process.exit(1);
   }
-  info(`Pushing ${import_picocolors16.default.bold(baseBranch)} to ${origin}...`);
+  info(`Pushing ${import_picocolors17.default.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 ${import_picocolors16.default.bold(featureBranch)}...`);
+  info(`Deleting local branch ${import_picocolors17.default.bold(featureBranch)}...`);
   const delLocal = await forceDeleteBranch(featureBranch);
   if (delLocal.exitCode !== 0) {
     warn(`Could not delete local branch: ${delLocal.stderr.trim()}`);
@@ -13125,14 +13823,14 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
   const remoteBranchRef = `${origin}/${featureBranch}`;
   const remoteExists = await branchExists(remoteBranchRef);
   if (remoteExists) {
-    info(`Deleting remote branch ${import_picocolors16.default.bold(featureBranch)}...`);
+    info(`Deleting remote branch ${import_picocolors17.default.bold(featureBranch)}...`);
     const delRemote = await deleteRemoteBranch(origin, featureBranch);
     if (delRemote.exitCode !== 0) {
       warn(`Could not delete remote branch: ${delRemote.stderr.trim()}`);
     }
   }
-  success(`Squash merged ${import_picocolors16.default.bold(featureBranch)} into ${import_picocolors16.default.bold(baseBranch)} and pushed.`);
-  info(`Run ${import_picocolors16.default.bold("contrib start")} to begin a new feature.`, "");
+  success(`Squash merged ${import_picocolors17.default.bold(featureBranch)} into ${import_picocolors17.default.bold(baseBranch)} and pushed.`);
+  info(`Run ${import_picocolors17.default.bold("contrib start")} to begin a new feature.`, "");
 }
 var submit_default = defineCommand({
   meta: {
@@ -13145,6 +13843,18 @@ var submit_default = defineCommand({
       description: "Create PR as draft",
       default: false
     },
+    pullrequest: {
+      type: "boolean",
+      alias: "pr",
+      description: "Submit directly to PR flow without prompting for mode",
+      default: false
+    },
+    local: {
+      type: "boolean",
+      alias: "l",
+      description: "Squash merge locally without PR (maintainers only)",
+      default: false
+    },
     "no-ai": {
       type: "boolean",
       description: "Skip AI PR description generation",
@@ -13163,10 +13873,11 @@ var submit_default = defineCommand({
     await assertCleanGitState("submitting");
     const config = readConfig();
     if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
+      error("No repo config found. Run `contrib setup` first.");
       process.exit(1);
     }
     const { origin } = config;
+    const aiEnabled = isAIEnabled(config, args["no-ai"]);
     const baseBranch = getBaseBranch(config);
     const protectedBranches = getProtectedBranches(config);
     const currentBranch = await getCurrentBranch();
@@ -13175,8 +13886,8 @@ var submit_default = defineCommand({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      heading("\uD83D\uDE80 contrib submit");
-      warn(`You're on ${import_picocolors16.default.bold(currentBranch)}, which is a protected branch. PRs should come from feature branches.`);
+      projectHeading("submit", "\uD83D\uDE80");
+      warn(`You're on ${import_picocolors17.default.bold(currentBranch)}, which is a protected branch. PRs should come from feature branches.`);
       await fetchAll();
       const remoteRef = `${origin}/${currentBranch}`;
       const localWork = await hasLocalWork(origin, currentBranch);
@@ -13185,11 +13896,11 @@ var submit_default = defineCommand({
       const hasAnything = hasCommits || dirty;
       if (!hasAnything) {
         error("No local changes or commits to move. Switch to a feature branch first.");
-        info(`  Run ${import_picocolors16.default.bold("contrib start")} to create a new feature branch.`, "");
+        info(`  Run ${import_picocolors17.default.bold("contrib start")} to create a new feature branch.`, "");
         process.exit(1);
       }
       if (hasCommits) {
-        info(`Found ${import_picocolors16.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors16.default.bold(currentBranch)}.`);
+        info(`Found ${import_picocolors17.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors17.default.bold(currentBranch)}.`);
       }
       if (dirty) {
         info("You also have uncommitted changes in the working tree.");
@@ -13205,58 +13916,35 @@ var submit_default = defineCommand({
         info("No changes made. You are still on your current branch.");
         return;
       }
-      info(import_picocolors16.default.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
-      const description = await inputPrompt("What are you going to work on?");
-      let newBranchName = description;
-      if (looksLikeNaturalLanguage(description)) {
-        const copilotError = await checkCopilotAvailable();
-        if (!copilotError) {
-          const spinner = createSpinner("Generating branch name suggestion...");
-          const suggested = await suggestBranchName(description, args.model);
-          if (suggested) {
-            spinner.success("Branch name suggestion ready.");
-            console.log(`
-  ${import_picocolors16.default.dim("AI suggestion:")} ${import_picocolors16.default.bold(import_picocolors16.default.cyan(suggested))}`);
-            const accepted = await confirmPrompt(`Use ${import_picocolors16.default.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 ${import_picocolors16.default.bold(newBranchName)}:`, config.branchPrefixes);
-        newBranchName = formatBranchName(prefix, newBranchName);
-      }
-      if (!isValidBranchName(newBranchName)) {
-        error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
-        process.exit(1);
-      }
-      if (await branchExists(newBranchName)) {
-        error(`Branch ${import_picocolors16.default.bold(newBranchName)} already exists. Choose a different name.`);
-        process.exit(1);
+      const newBranchName = await promptForBranchName({
+        branchPrefixes: config.branchPrefixes,
+        useAI: aiEnabled,
+        model: args.model
+      });
+      if (!newBranchName) {
+        info("No changes made. You are still on your current branch.");
+        return;
       }
       const branchResult = await createBranch(newBranchName);
       if (branchResult.exitCode !== 0) {
         error(`Failed to create branch: ${branchResult.stderr}`);
         process.exit(1);
       }
-      success(`Created ${import_picocolors16.default.bold(newBranchName)} with your changes.`);
+      success(`Created ${import_picocolors17.default.bold(newBranchName)} with your changes.`);
       await updateLocalBranch(currentBranch, remoteRef);
-      info(`Reset ${import_picocolors16.default.bold(currentBranch)} back to ${import_picocolors16.default.bold(remoteRef)} — no damage done.`, "");
+      info(`Reset ${import_picocolors17.default.bold(currentBranch)} back to ${import_picocolors17.default.bold(remoteRef)} — no damage done.`, "");
       console.log();
-      success(`You're now on ${import_picocolors16.default.bold(newBranchName)} with all your work intact.`);
-      info(`Run ${import_picocolors16.default.bold("contrib submit")} again to push and create your PR.`, "");
+      success(`You're now on ${import_picocolors17.default.bold(newBranchName)} with all your work intact.`);
+      info(`Run ${import_picocolors17.default.bold("contrib submit")} again to push and create your PR.`, "");
       return;
     }
-    heading("\uD83D\uDE80 contrib submit");
+    projectHeading("submit", "\uD83D\uDE80");
     const ghInstalled = await checkGhInstalled();
     const ghAuthed = ghInstalled && await checkGhAuth();
     if (ghInstalled && ghAuthed) {
       const mergedPR = await getMergedPRForBranch(currentBranch);
       if (mergedPR) {
-        warn(`PR #${mergedPR.number} (${import_picocolors16.default.bold(mergedPR.title)}) was already merged.`);
+        warn(`PR #${mergedPR.number} (${import_picocolors17.default.bold(mergedPR.title)}) was already merged.`);
         const localWork = await hasLocalWork(origin, currentBranch);
         const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
         if (hasWork) {
@@ -13264,7 +13952,7 @@ var submit_default = defineCommand({
             warn("You have uncommitted changes in your working tree.");
           }
           if (localWork.unpushedCommits > 0) {
-            warn(`You have ${import_picocolors16.default.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not in the merged PR.`);
+            warn(`You have ${import_picocolors17.default.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";
@@ -13275,46 +13963,26 @@ var submit_default = defineCommand({
             return;
           }
           if (action === SAVE_NEW_BRANCH) {
-            info(import_picocolors16.default.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
-            const description = await inputPrompt("What are you going to work on?");
-            let newBranchName = description;
-            if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
-              const spinner = createSpinner("Generating branch name suggestion...");
-              const suggested = await suggestBranchName(description, args.model);
-              if (suggested) {
-                spinner.success("Branch name suggestion ready.");
-                console.log(`
-  ${import_picocolors16.default.dim("AI suggestion:")} ${import_picocolors16.default.bold(import_picocolors16.default.cyan(suggested))}`);
-                const accepted = await confirmPrompt(`Use ${import_picocolors16.default.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 ${import_picocolors16.default.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 newBranchName = await promptForBranchName({
+              branchPrefixes: config.branchPrefixes,
+              useAI: aiEnabled,
+              model: args.model
+            });
+            if (!newBranchName) {
+              info("No changes made. You are still on your current branch.");
+              return;
             }
             const staleUpstream = await getUpstreamRef();
             const staleUpstreamHash = staleUpstream ? await getCommitHash(staleUpstream) : null;
-            if (await branchExists(newBranchName)) {
-              error(`Branch ${import_picocolors16.default.bold(newBranchName)} already exists. Choose a different name.`);
-              process.exit(1);
-            }
             const renameResult = await renameBranch(currentBranch, newBranchName);
             if (renameResult.exitCode !== 0) {
               error(`Failed to rename branch: ${renameResult.stderr}`);
               process.exit(1);
             }
-            success(`Renamed ${import_picocolors16.default.bold(currentBranch)} → ${import_picocolors16.default.bold(newBranchName)}`);
+            success(`Renamed ${import_picocolors17.default.bold(currentBranch)} → ${import_picocolors17.default.bold(newBranchName)}`);
             await unsetUpstream();
             const syncSource2 = getSyncSource(config);
-            info(`Syncing ${import_picocolors16.default.bold(newBranchName)} with latest ${import_picocolors16.default.bold(baseBranch)}...`);
+            info(`Syncing ${import_picocolors17.default.bold(newBranchName)} with latest ${import_picocolors17.default.bold(baseBranch)}...`);
             await fetchRemote(syncSource2.remote);
             let rebaseResult;
             if (staleUpstreamHash) {
@@ -13325,17 +13993,17 @@ var submit_default = defineCommand({
             }
             if (rebaseResult.exitCode !== 0) {
               warn("Rebase encountered conflicts. Resolve them manually, then run:");
-              info(`  ${import_picocolors16.default.bold("git rebase --continue")}`, "");
+              info(`  ${import_picocolors17.default.bold("git rebase --continue")}`, "");
             } else {
-              success(`Rebased ${import_picocolors16.default.bold(newBranchName)} onto ${import_picocolors16.default.bold(syncSource2.ref)}.`);
+              success(`Rebased ${import_picocolors17.default.bold(newBranchName)} onto ${import_picocolors17.default.bold(syncSource2.ref)}.`);
             }
-            info(`All your changes are preserved. Run ${import_picocolors16.default.bold("contrib submit")} when ready to create a new PR.`, "");
+            info(`All your changes are preserved. Run ${import_picocolors17.default.bold("contrib submit")} when ready to create a new PR.`, "");
             return;
           }
           warn("Discarding local changes...");
         }
         const syncSource = getSyncSource(config);
-        info(`Switching to ${import_picocolors16.default.bold(baseBranch)} and syncing...`);
+        info(`Switching to ${import_picocolors17.default.bold(baseBranch)} and syncing...`);
         await fetchRemote(syncSource.remote);
         await resetHard("HEAD");
         const coResult = await checkoutBranch(baseBranch);
@@ -13344,23 +14012,23 @@ var submit_default = defineCommand({
           process.exit(1);
         }
         await updateLocalBranch(baseBranch, syncSource.ref);
-        success(`Synced ${import_picocolors16.default.bold(baseBranch)} with ${import_picocolors16.default.bold(syncSource.ref)}.`);
-        info(`Deleting stale branch ${import_picocolors16.default.bold(currentBranch)}...`);
+        success(`Synced ${import_picocolors17.default.bold(baseBranch)} with ${import_picocolors17.default.bold(syncSource.ref)}.`);
+        info(`Deleting stale branch ${import_picocolors17.default.bold(currentBranch)}...`);
         const delResult = await forceDeleteBranch(currentBranch);
         if (delResult.exitCode === 0) {
-          success(`Deleted ${import_picocolors16.default.bold(currentBranch)}.`);
+          success(`Deleted ${import_picocolors17.default.bold(currentBranch)}.`);
         } else {
           warn(`Could not delete branch: ${delResult.stderr.trim()}`);
         }
         console.log();
-        info(`You're now on ${import_picocolors16.default.bold(baseBranch)}. Run ${import_picocolors16.default.bold("contrib start")} to begin a new feature.`);
+        info(`You're now on ${import_picocolors17.default.bold(baseBranch)}. Run ${import_picocolors17.default.bold("contrib start")} to begin a new feature.`);
         return;
       }
     }
     if (ghInstalled && ghAuthed) {
       const existingPR = await getPRForBranch(currentBranch);
       if (existingPR) {
-        info(`Pushing ${import_picocolors16.default.bold(currentBranch)} to ${origin}...`);
+        info(`Pushing ${import_picocolors17.default.bold(currentBranch)} to ${origin}...`);
         const pushResult2 = await pushSetUpstream(origin, currentBranch);
         if (pushResult2.exitCode !== 0) {
           error(`Failed to push: ${pushResult2.stderr}`);
@@ -13371,8 +14039,8 @@ var submit_default = defineCommand({
           }
           process.exit(1);
         }
-        success(`Pushed changes to existing PR #${existingPR.number}: ${import_picocolors16.default.bold(existingPR.title)}`);
-        console.log(`  ${import_picocolors16.default.cyan(existingPR.url)}`);
+        success(`Pushed changes to existing PR #${existingPR.number}: ${import_picocolors17.default.bold(existingPR.title)}`);
+        console.log(`  ${import_picocolors17.default.cyan(existingPR.url)}`);
         return;
       }
     }
@@ -13380,22 +14048,24 @@ var submit_default = defineCommand({
     let prBody = null;
     async function tryGenerateAI() {
       const [copilotError, commits, diff] = await Promise.all([
-        checkCopilotAvailable(),
+        checkCopilotAvailable2(),
         getLog(baseBranch, "HEAD"),
         getLogDiff(baseBranch, "HEAD")
       ]);
       if (!copilotError) {
-        const spinner = createSpinner("Generating AI PR description...");
+        const spinner = createSpinner("Generating AI PR description...", {
+          tips: LOADING_TIPS
+        });
         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(`
-  ${import_picocolors16.default.dim("AI title:")} ${import_picocolors16.default.bold(import_picocolors16.default.cyan(prTitle))}`);
+  ${import_picocolors17.default.dim("AI title:")} ${import_picocolors17.default.bold(import_picocolors17.default.cyan(prTitle))}`);
           console.log(`
-${import_picocolors16.default.dim("AI body preview:")}`);
-          console.log(import_picocolors16.default.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+${import_picocolors17.default.dim("AI body preview:")}`);
+          console.log(import_picocolors17.default.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
         } else {
           spinner.fail("AI did not return a PR description.");
         }
@@ -13408,8 +14078,28 @@ ${import_picocolors16.default.dim("AI body preview:")}`);
     const REGENERATE = "Regenerate AI description";
     let submitAction = "cancel";
     const isMaintainer = config.role === "maintainer";
-    if (isMaintainer) {
-      const maintainerChoice = await selectPrompt("How would you like to submit your changes?", ["Create a PR", SQUASH_LOCAL, CANCEL]);
+    if (args.pullrequest && args.local) {
+      error("Use only one submit mode flag at a time: --pullrequest/--pr/-pr or -l for local squash merge.");
+      process.exit(1);
+    }
+    if (args.local && !isMaintainer) {
+      error("The -l flag is only available for maintainers. Contributors must submit via PR.");
+      process.exit(1);
+    }
+    if (args.local) {
+      await performSquashMerge(origin, baseBranch, currentBranch, {
+        model: args.model,
+        convention: config.commitConvention,
+        useAI: aiEnabled
+      });
+      return;
+    }
+    if (isMaintainer && !args.pullrequest) {
+      const maintainerChoice = await selectPrompt("How would you like to submit your changes?", [
+        "Create a PR",
+        SQUASH_LOCAL,
+        CANCEL
+      ]);
       if (maintainerChoice === CANCEL) {
         warn("Submit cancelled.");
         return;
@@ -13417,12 +14107,13 @@ ${import_picocolors16.default.dim("AI body preview:")}`);
       if (maintainerChoice === SQUASH_LOCAL) {
         await performSquashMerge(origin, baseBranch, currentBranch, {
           model: args.model,
-          convention: config.commitConvention
+          convention: config.commitConvention,
+          useAI: aiEnabled
         });
         return;
       }
     }
-    if (!args["no-ai"]) {
+    if (aiEnabled) {
       await tryGenerateAI();
     }
     let actionResolved = false;
@@ -13461,7 +14152,7 @@ ${import_picocolors16.default.dim("AI body preview:")}`);
         }
       } else {
         const choices = [];
-        if (!args["no-ai"])
+        if (aiEnabled)
           choices.push(REGENERATE);
         choices.push("Write title & body manually", "Use gh --fill (auto-fill from commits)", CANCEL);
         const action = await selectPrompt("How would you like to create the PR?", choices);
@@ -13485,7 +14176,7 @@ ${import_picocolors16.default.dim("AI body preview:")}`);
       warn("Submit cancelled.");
       return;
     }
-    info(`Pushing ${import_picocolors16.default.bold(currentBranch)} to ${origin}...`);
+    info(`Pushing ${import_picocolors17.default.bold(currentBranch)} to ${origin}...`);
     const pushResult = await pushSetUpstream(origin, currentBranch);
     if (pushResult.exitCode !== 0) {
       error(`Failed to push: ${pushResult.stderr}`);
@@ -13504,7 +14195,7 @@ ${import_picocolors16.default.dim("AI body preview:")}`);
         const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/compare/${baseBranch}...${currentBranch}?expand=1`;
         console.log();
         info("Create your PR manually:", "");
-        console.log(`  ${import_picocolors16.default.cyan(prUrl)}`);
+        console.log(`  ${import_picocolors17.default.cyan(prUrl)}`);
       } else {
         info("gh CLI not available. Create your PR manually on GitHub.", "");
       }
@@ -13538,7 +14229,7 @@ ${import_picocolors16.default.dim("AI body preview:")}`);
 });
 
 // src/commands/switch.ts
-var import_picocolors17 = __toESM(require_picocolors(), 1);
+var import_picocolors18 = __toESM(require_picocolors(), 1);
 var switch_default = defineCommand({
   meta: {
     name: "switch",
@@ -13559,7 +14250,7 @@ var switch_default = defineCommand({
     const config = readConfig();
     const protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
     const currentBranch = await getCurrentBranch();
-    heading("\uD83D\uDD00 contrib switch");
+    projectHeading("switch", "\uD83D\uDD00");
     let targetBranch = args.name;
     if (!targetBranch) {
       const localBranches = await getLocalBranches();
@@ -13570,11 +14261,11 @@ var switch_default = defineCommand({
       const choices = localBranches.filter((b2) => b2.name !== currentBranch).map((b2) => {
         const labels = [];
         if (protectedBranches.includes(b2.name))
-          labels.push(import_picocolors17.default.red("protected"));
+          labels.push(import_picocolors18.default.red("protected"));
         if (b2.upstream)
-          labels.push(import_picocolors17.default.dim(`→ ${b2.upstream}`));
+          labels.push(import_picocolors18.default.dim(`→ ${b2.upstream}`));
         if (b2.gone)
-          labels.push(import_picocolors17.default.red("remote gone"));
+          labels.push(import_picocolors18.default.red("remote gone"));
         const suffix = labels.length > 0 ? `  ${labels.join(" · ")}` : "";
         return `${b2.name}${suffix}`;
       });
@@ -13586,7 +14277,7 @@ var switch_default = defineCommand({
       targetBranch = selected.split(/\s{2,}/)[0].trim();
     }
     if (targetBranch === currentBranch) {
-      info(`Already on ${import_picocolors17.default.bold(targetBranch)}.`);
+      info(`Already on ${import_picocolors18.default.bold(targetBranch)}.`);
       return;
     }
     if (await hasUncommittedChanges()) {
@@ -13605,7 +14296,7 @@ var switch_default = defineCommand({
       const stashMsg = `contrib-save: auto-save from ${currentBranch}`;
       try {
         await exec("git", ["stash", "push", "-m", stashMsg]);
-        info(`Saved changes: ${import_picocolors17.default.dim(stashMsg)}`);
+        info(`Saved changes: ${import_picocolors18.default.dim(stashMsg)}`);
       } catch {
         error("Failed to save changes. Please commit or save manually.");
         process.exit(1);
@@ -13621,9 +14312,9 @@ var switch_default = defineCommand({
         }
         process.exit(1);
       }
-      success(`Switched to ${import_picocolors17.default.bold(targetBranch)}`);
-      info(`Your changes from ${import_picocolors17.default.bold(currentBranch ?? "previous branch")} are saved.`, "");
-      info(`Use ${import_picocolors17.default.bold("contrib save --restore")} to bring them back.`, "");
+      success(`Switched to ${import_picocolors18.default.bold(targetBranch)}`);
+      info(`Your changes from ${import_picocolors18.default.bold(currentBranch ?? "previous branch")} are saved.`, "");
+      info(`Use ${import_picocolors18.default.bold("contrib save --restore")} to bring them back.`, "");
       return;
     }
     const result = await checkoutBranch(targetBranch);
@@ -13631,12 +14322,12 @@ var switch_default = defineCommand({
       error(`Failed to switch to ${targetBranch}: ${result.stderr}`);
       process.exit(1);
     }
-    success(`Switched to ${import_picocolors17.default.bold(targetBranch)}`);
+    success(`Switched to ${import_picocolors18.default.bold(targetBranch)}`);
   }
 });
 
 // src/commands/sync.ts
-var import_picocolors18 = __toESM(require_picocolors(), 1);
+var import_picocolors19 = __toESM(require_picocolors(), 1);
 var sync_default = defineCommand({
   meta: {
     name: "sync",
@@ -13667,7 +14358,7 @@ var sync_default = defineCommand({
     await assertCleanGitState("syncing");
     const config = readConfig();
     if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
+      error("No repo config found. Run `contrib setup` first.");
       process.exit(1);
     }
     const { workflow, role, origin } = config;
@@ -13675,7 +14366,7 @@ var sync_default = defineCommand({
       error("You have uncommitted changes. Please commit or stash them before syncing.");
       process.exit(1);
     }
-    heading(`\uD83D\uDD04 contrib sync (${workflow}, ${role})`);
+    projectHeading(`sync (${workflow}, ${role})`, "\uD83D\uDD04");
     const baseBranch = getBaseBranch(config);
     const syncSource = getSyncSource(config);
     info(`Fetching ${syncSource.remote}...`);
@@ -13688,24 +14379,24 @@ var sync_default = defineCommand({
       await fetchRemote(origin);
     }
     if (!await refExists(syncSource.ref)) {
-      error(`Remote ref ${import_picocolors18.default.bold(syncSource.ref)} does not exist.`);
+      error(`Remote ref ${import_picocolors19.default.bold(syncSource.ref)} does not exist.`);
       info("This can happen if the branch was renamed or deleted on the remote.", "");
-      info(`Check your config: the base branch may need updating via ${import_picocolors18.default.bold("contrib setup")}.`, "");
+      info(`Check your config: the base branch may need updating via ${import_picocolors19.default.bold("contrib setup")}.`, "");
       process.exit(1);
     }
     let allowMergeCommit = false;
     const div = await getDivergence(baseBranch, syncSource.ref);
     if (div.ahead > 0 || div.behind > 0) {
-      info(`${import_picocolors18.default.bold(baseBranch)} is ${import_picocolors18.default.yellow(`${div.ahead} ahead`)} and ${import_picocolors18.default.red(`${div.behind} behind`)} ${syncSource.ref}`);
+      info(`${import_picocolors19.default.bold(baseBranch)} is ${import_picocolors19.default.yellow(`${div.ahead} ahead`)} and ${import_picocolors19.default.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`${import_picocolors18.default.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+      info(`${import_picocolors19.default.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
     }
     if (div.ahead > 0) {
       const currentBranch = await getCurrentBranch();
       const protectedBranches = getProtectedBranches(config);
       const isOnProtected = currentBranch && protectedBranches.includes(currentBranch);
       if (isOnProtected) {
-        warn(`You have ${import_picocolors18.default.bold(String(div.ahead))} local commit${div.ahead !== 1 ? "s" : ""} on ${import_picocolors18.default.bold(baseBranch)} that aren't on the remote.`);
+        warn(`You have ${import_picocolors19.default.bold(String(div.ahead))} local commit${div.ahead !== 1 ? "s" : ""} on ${import_picocolors19.default.bold(baseBranch)} that aren't on the remote.`);
         info("Pulling now could create a merge commit, which breaks clean history.");
         console.log();
         const MOVE_BRANCH = "Move my commits to a new feature branch, then sync";
@@ -13721,44 +14412,21 @@ var sync_default = defineCommand({
           return;
         }
         if (action === MOVE_BRANCH) {
-          info(import_picocolors18.default.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
-          const description = await inputPrompt("What are you going to work on?");
-          let newBranchName = description;
-          if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
-            const copilotError = await checkCopilotAvailable();
-            if (!copilotError) {
-              const spinner = createSpinner("Generating branch name suggestion...");
-              const suggested = await suggestBranchName(description, args.model);
-              if (suggested) {
-                spinner.success("Branch name suggestion ready.");
-                console.log(`
-  ${import_picocolors18.default.dim("AI suggestion:")} ${import_picocolors18.default.bold(import_picocolors18.default.cyan(suggested))}`);
-                const accepted = await confirmPrompt(`Use ${import_picocolors18.default.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 ${import_picocolors18.default.bold(newBranchName)}:`, config.branchPrefixes);
-            newBranchName = formatBranchName(prefix, newBranchName);
-          }
-          if (!isValidBranchName(newBranchName)) {
-            error("Invalid branch name. Use only alphanumeric characters, dots, hyphens, underscores, and slashes.");
-            process.exit(1);
-          }
-          if (await branchExists(newBranchName)) {
-            error(`Branch ${import_picocolors18.default.bold(newBranchName)} already exists. Choose a different name.`);
-            process.exit(1);
+          const newBranchName = await promptForBranchName({
+            branchPrefixes: config.branchPrefixes,
+            useAI: isAIEnabled(config, args["no-ai"]),
+            model: args.model
+          });
+          if (!newBranchName) {
+            info("No changes made.");
+            return;
           }
           const branchResult = await createBranch(newBranchName);
           if (branchResult.exitCode !== 0) {
             error(`Failed to create branch: ${branchResult.stderr}`);
             process.exit(1);
           }
-          success(`Created ${import_picocolors18.default.bold(newBranchName)} with your commits.`);
+          success(`Created ${import_picocolors19.default.bold(newBranchName)} with your commits.`);
           const coResult2 = await checkoutBranch(baseBranch);
           if (coResult2.exitCode !== 0) {
             error(`Failed to checkout ${baseBranch}: ${coResult2.stderr}`);
@@ -13766,11 +14434,11 @@ var sync_default = defineCommand({
           }
           const remoteRef = syncSource.ref;
           await updateLocalBranch(baseBranch, remoteRef);
-          success(`Reset ${import_picocolors18.default.bold(baseBranch)} to ${import_picocolors18.default.bold(remoteRef)}.`);
-          success(`${import_picocolors18.default.bold(baseBranch)} is now in sync with ${syncSource.ref}`);
+          success(`Reset ${import_picocolors19.default.bold(baseBranch)} to ${import_picocolors19.default.bold(remoteRef)}.`);
+          success(`${import_picocolors19.default.bold(baseBranch)} is now in sync with ${syncSource.ref}`);
           console.log();
-          info(`Your commits are safe on ${import_picocolors18.default.bold(newBranchName)}.`, "");
-          info(`Run ${import_picocolors18.default.bold(`git checkout ${newBranchName}`)} then ${import_picocolors18.default.bold("contrib update")} to rebase onto the synced ${import_picocolors18.default.bold(baseBranch)}.`, "");
+          info(`Your commits are safe on ${import_picocolors19.default.bold(newBranchName)}.`, "");
+          info(`Run ${import_picocolors19.default.bold(`git checkout ${newBranchName}`)} then ${import_picocolors19.default.bold("contrib update")} to rebase onto the synced ${import_picocolors19.default.bold(baseBranch)}.`, "");
           return;
         }
         allowMergeCommit = true;
@@ -13778,7 +14446,7 @@ var sync_default = defineCommand({
       }
     }
     if (!args.yes) {
-      const ok = await confirmPrompt(`This will pull ${import_picocolors18.default.bold(syncSource.ref)} into local ${import_picocolors18.default.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${import_picocolors19.default.bold(syncSource.ref)} into local ${import_picocolors19.default.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
@@ -13792,8 +14460,8 @@ var sync_default = defineCommand({
       if (allowMergeCommit) {
         error(`Pull failed: ${pullResult.stderr.trim()}`);
       } else {
-        error(`Fast-forward pull failed. Your local ${import_picocolors18.default.bold(baseBranch)} may have diverged.`);
-        info(`Use ${import_picocolors18.default.bold("contrib sync")} again and choose "Move my commits to a new feature branch" to fix this.`, "");
+        error(`Fast-forward pull failed. Your local ${import_picocolors19.default.bold(baseBranch)} may have diverged.`);
+        info(`Use ${import_picocolors19.default.bold("contrib sync")} again and choose "Move my commits to a new feature branch" to fix this.`, "");
       }
       process.exit(1);
     }
@@ -13801,7 +14469,7 @@ var sync_default = defineCommand({
     if (hasDevBranch(workflow) && role === "maintainer") {
       const mainDiv = await getDivergence(config.mainBranch, `${origin}/${config.mainBranch}`);
       if (mainDiv.behind > 0) {
-        info(`Also syncing ${import_picocolors18.default.bold(config.mainBranch)}...`);
+        info(`Also syncing ${import_picocolors19.default.bold(config.mainBranch)}...`);
         const mainCoResult = await checkoutBranch(config.mainBranch);
         if (mainCoResult.exitCode === 0) {
           const mainPullResult = await pullFastForwardOnly(origin, config.mainBranch);
@@ -13836,23 +14504,26 @@ var sync_default = defineCommand({
         for (const { name, hash } of refs) {
           if (!groups.has(hash))
             groups.set(hash, []);
-          groups.get(hash).push(name);
+          const group = groups.get(hash);
+          if (group) {
+            group.push(name);
+          }
         }
         console.log();
-        console.log(`  ${import_picocolors18.default.bold("\uD83D\uDD17 Branch Alignment")}`);
+        console.log(`  ${import_picocolors19.default.bold("\uD83D\uDD17 Branch Alignment")}`);
         for (const [hash, names] of groups) {
           const short = hash.slice(0, 7);
-          const nameStr = names.map((n2) => import_picocolors18.default.bold(n2)).join(import_picocolors18.default.dim(" · "));
-          console.log(`     ${import_picocolors18.default.yellow(short)} ${import_picocolors18.default.dim("──")} ${nameStr}`);
+          const nameStr = names.map((n2) => import_picocolors19.default.bold(n2)).join(import_picocolors19.default.dim(" · "));
+          console.log(`     ${import_picocolors19.default.yellow(short)} ${import_picocolors19.default.dim("──")} ${nameStr}`);
           const subject = await getCommitSubject(hash);
           if (subject) {
-            console.log(`                ${import_picocolors18.default.dim(subject)}`);
+            console.log(`                ${import_picocolors19.default.dim(subject)}`);
           }
         }
         if (groups.size === 1) {
-          console.log(`     ${import_picocolors18.default.green("✓")} ${import_picocolors18.default.green("All branches aligned")} ${import_picocolors18.default.dim("— ready to start")}`);
+          console.log(`     ${import_picocolors19.default.green("✓")} ${import_picocolors19.default.green("All branches aligned")} ${import_picocolors19.default.dim("— ready to start")}`);
         } else {
-          console.log(`     ${import_picocolors18.default.yellow("⚠")} ${import_picocolors18.default.yellow("Branches are not fully aligned")}`);
+          console.log(`     ${import_picocolors19.default.yellow("⚠")} ${import_picocolors19.default.yellow("Branches are not fully aligned")}`);
         }
       }
     }
@@ -13861,7 +14532,10 @@ var sync_default = defineCommand({
 
 // src/commands/update.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-var import_picocolors19 = __toESM(require_picocolors(), 1);
+var import_picocolors20 = __toESM(require_picocolors(), 1);
+function hasStaleBranchWorkToPreserve(uniqueCommitsAheadOfBase, hasUncommittedChanges2) {
+  return hasUncommittedChanges2 || uniqueCommitsAheadOfBase > 0;
+}
 var update_default = defineCommand({
   meta: {
     name: "update",
@@ -13886,7 +14560,7 @@ var update_default = defineCommand({
     await assertCleanGitState("updating");
     const config = readConfig();
     if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
+      error("No repo config found. Run `contrib setup` first.");
       process.exit(1);
     }
     const baseBranch = getBaseBranch(config);
@@ -13898,8 +14572,8 @@ var update_default = defineCommand({
       process.exit(1);
     }
     if (protectedBranches.includes(currentBranch)) {
-      heading("\uD83D\uDD03 contrib update");
-      warn(`You're on ${import_picocolors19.default.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
+      projectHeading("update", "\uD83D\uDD03");
+      warn(`You're on ${import_picocolors20.default.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
       await fetchAll();
       const { origin } = config;
       const remoteRef = `${origin}/${currentBranch}`;
@@ -13908,12 +14582,12 @@ var update_default = defineCommand({
       const hasCommits = localWork.unpushedCommits > 0;
       const hasAnything = hasCommits || dirty;
       if (!hasAnything) {
-        info(`No local changes found on ${import_picocolors19.default.bold(currentBranch)}.`);
-        info(`Use ${import_picocolors19.default.bold("contrib sync")} to sync protected branches, or ${import_picocolors19.default.bold("contrib start")} to create a feature branch.`);
+        info(`No local changes found on ${import_picocolors20.default.bold(currentBranch)}.`);
+        info(`Use ${import_picocolors20.default.bold("contrib sync")} to sync protected branches, or ${import_picocolors20.default.bold("contrib start")} to create a feature branch.`);
         process.exit(1);
       }
       if (hasCommits) {
-        info(`Found ${import_picocolors19.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors19.default.bold(currentBranch)}.`);
+        info(`Found ${import_picocolors20.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors20.default.bold(currentBranch)}.`);
       }
       if (dirty) {
         info("You also have uncommitted changes in the working tree.");
@@ -13929,111 +14603,73 @@ var update_default = defineCommand({
         info("No changes made. You are still on your current branch.");
         return;
       }
-      info(import_picocolors19.default.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
-      const description = await inputPrompt("What are you going to work on?");
-      let newBranchName = description;
-      if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
-        const copilotError = await checkCopilotAvailable();
-        if (!copilotError) {
-          const spinner = createSpinner("Generating branch name suggestion...");
-          const suggested = await suggestBranchName(description, args.model);
-          if (suggested) {
-            spinner.success("Branch name suggestion ready.");
-            console.log(`
-  ${import_picocolors19.default.dim("AI suggestion:")} ${import_picocolors19.default.bold(import_picocolors19.default.cyan(suggested))}`);
-            const accepted = await confirmPrompt(`Use ${import_picocolors19.default.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 ${import_picocolors19.default.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 newBranchName = await promptForBranchName({
+        branchPrefixes: config.branchPrefixes,
+        useAI: isAIEnabled(config, args["no-ai"]),
+        model: args.model
+      });
+      if (!newBranchName) {
+        info("No changes made. You are still on your current branch.");
+        return;
       }
       const branchResult = await createBranch(newBranchName);
       if (branchResult.exitCode !== 0) {
         error(`Failed to create branch: ${branchResult.stderr}`);
         process.exit(1);
       }
-      success(`Created ${import_picocolors19.default.bold(newBranchName)} with your changes.`);
+      success(`Created ${import_picocolors20.default.bold(newBranchName)} with your changes.`);
       await updateLocalBranch(currentBranch, remoteRef);
-      info(`Reset ${import_picocolors19.default.bold(currentBranch)} back to ${import_picocolors19.default.bold(remoteRef)} — no damage done.`, "");
+      info(`Reset ${import_picocolors20.default.bold(currentBranch)} back to ${import_picocolors20.default.bold(remoteRef)} — no damage done.`, "");
       console.log();
-      success(`You're now on ${import_picocolors19.default.bold(newBranchName)} with all your work intact.`);
-      info(`Run ${import_picocolors19.default.bold("contrib update")} again to rebase onto latest ${import_picocolors19.default.bold(baseBranch)}.`, "");
+      success(`You're now on ${import_picocolors20.default.bold(newBranchName)} with all your work intact.`);
+      info(`Run ${import_picocolors20.default.bold("contrib update")} again to rebase onto latest ${import_picocolors20.default.bold(baseBranch)}.`, "");
       return;
     }
     if (await hasUncommittedChanges()) {
       error("You have uncommitted changes. Please commit or stash them first.");
       process.exit(1);
     }
-    heading("\uD83D\uDD03 contrib update");
+    projectHeading("update", "\uD83D\uDD03");
     const mergedPR = await getMergedPRForBranch(currentBranch);
     if (mergedPR) {
-      warn(`PR #${mergedPR.number} (${import_picocolors19.default.bold(mergedPR.title)}) has already been merged.`);
-      info(`Link: ${import_picocolors19.default.underline(mergedPR.url)}`, "");
-      const localWork = await hasLocalWork(syncSource.remote, currentBranch);
-      const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
+      warn(`PR #${mergedPR.number} (${import_picocolors20.default.bold(mergedPR.title)}) has already been merged.`);
+      info(`Link: ${import_picocolors20.default.underline(mergedPR.url)}`, "");
+      const uniqueCommitsAheadOfBase = await countCommitsAhead(currentBranch, syncSource.ref);
+      const dirty = await hasUncommittedChanges();
+      const hasWork = hasStaleBranchWorkToPreserve(uniqueCommitsAheadOfBase, dirty);
       if (hasWork) {
-        if (localWork.uncommitted) {
+        if (dirty) {
           info("You have uncommitted local changes.");
         }
-        if (localWork.unpushedCommits > 0) {
-          info(`You have ${localWork.unpushedCommits} unpushed commit(s).`);
+        if (uniqueCommitsAheadOfBase > 0) {
+          info(`You have ${uniqueCommitsAheadOfBase} local commit(s) not in ${import_picocolors20.default.bold(syncSource.ref)}.`);
         }
         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(`${import_picocolors19.default.bold(currentBranch)} is stale but has local work. What would you like to do?`, [SAVE_NEW_BRANCH, DISCARD, CANCEL]);
+        const action = await selectPrompt(`${import_picocolors20.default.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(import_picocolors19.default.dim("Tip: Describe what you're going to work on in plain English and we'll generate a branch name."));
-          const description = await inputPrompt("What are you going to work on?");
-          let newBranchName = description;
-          if (!args["no-ai"] && looksLikeNaturalLanguage(description)) {
-            const spinner = createSpinner("Generating branch name suggestion...");
-            const suggested = await suggestBranchName(description, args.model);
-            if (suggested) {
-              spinner.success("Branch name suggestion ready.");
-              console.log(`
-  ${import_picocolors19.default.dim("AI suggestion:")} ${import_picocolors19.default.bold(import_picocolors19.default.cyan(suggested))}`);
-              const accepted = await confirmPrompt(`Use ${import_picocolors19.default.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 ${import_picocolors19.default.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 newBranchName = await promptForBranchName({
+            branchPrefixes: config.branchPrefixes,
+            useAI: isAIEnabled(config, args["no-ai"]),
+            model: args.model
+          });
+          if (!newBranchName) {
+            info("No changes made. You are still on your current branch.");
+            return;
           }
           const staleUpstream = await getUpstreamRef();
           const staleUpstreamHash = staleUpstream ? await getCommitHash(staleUpstream) : null;
-          if (await branchExists(newBranchName)) {
-            error(`Branch ${import_picocolors19.default.bold(newBranchName)} already exists. Choose a different name.`);
-            process.exit(1);
-          }
           const renameResult = await renameBranch(currentBranch, newBranchName);
           if (renameResult.exitCode !== 0) {
             error(`Failed to rename branch: ${renameResult.stderr}`);
             process.exit(1);
           }
-          success(`Renamed ${import_picocolors19.default.bold(currentBranch)} → ${import_picocolors19.default.bold(newBranchName)}`);
+          success(`Renamed ${import_picocolors20.default.bold(currentBranch)} → ${import_picocolors20.default.bold(newBranchName)}`);
           await unsetUpstream();
           await fetchRemote(syncSource.remote);
           let rebaseResult2;
@@ -14045,14 +14681,20 @@ var update_default = defineCommand({
           }
           if (rebaseResult2.exitCode !== 0) {
             warn("Rebase encountered conflicts. Resolve them manually, then run:");
-            info(`  ${import_picocolors19.default.bold("git rebase --continue")}`, "");
+            info(`  ${import_picocolors20.default.bold("git rebase --continue")}`, "");
           } else {
-            success(`Rebased ${import_picocolors19.default.bold(newBranchName)} onto ${import_picocolors19.default.bold(syncSource.ref)}.`);
+            success(`Rebased ${import_picocolors20.default.bold(newBranchName)} onto ${import_picocolors20.default.bold(syncSource.ref)}.`);
           }
-          info(`All your changes are preserved. Run ${import_picocolors19.default.bold("contrib submit")} when ready to create a new PR.`, "");
+          info(`All your changes are preserved. Run ${import_picocolors20.default.bold("contrib submit")} when ready to create a new PR.`, "");
           return;
         }
         warn("Discarding local changes...");
+      } else {
+        const proceed = await confirmPrompt(`Switch to ${baseBranch} and delete stale branch ${currentBranch}?`);
+        if (!proceed) {
+          info("No changes made. You are still on your current branch.");
+          return;
+        }
       }
       await fetchRemote(syncSource.remote);
       await resetHard("HEAD");
@@ -14062,30 +14704,30 @@ var update_default = defineCommand({
         process.exit(1);
       }
       await updateLocalBranch(baseBranch, syncSource.ref);
-      success(`Synced ${import_picocolors19.default.bold(baseBranch)} with ${import_picocolors19.default.bold(syncSource.ref)}.`);
-      info(`Deleting stale branch ${import_picocolors19.default.bold(currentBranch)}...`);
+      success(`Synced ${import_picocolors20.default.bold(baseBranch)} with ${import_picocolors20.default.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${import_picocolors20.default.bold(currentBranch)}...`);
       await forceDeleteBranch(currentBranch);
-      success(`Deleted ${import_picocolors19.default.bold(currentBranch)}.`);
-      info(`Run ${import_picocolors19.default.bold("contrib start")} to begin a new feature branch.`, "");
+      success(`Deleted ${import_picocolors20.default.bold(currentBranch)}.`);
+      info(`Run ${import_picocolors20.default.bold("contrib start")} to begin a new feature branch.`, "");
       return;
     }
-    info(`Updating ${import_picocolors19.default.bold(currentBranch)} with latest ${import_picocolors19.default.bold(baseBranch)}...`);
+    info(`Updating ${import_picocolors20.default.bold(currentBranch)} with latest ${import_picocolors20.default.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
     if (!await refExists(syncSource.ref)) {
-      error(`Remote ref ${import_picocolors19.default.bold(syncSource.ref)} does not exist.`);
+      error(`Remote ref ${import_picocolors20.default.bold(syncSource.ref)} does not exist.`);
       error("Run `git fetch --all` and verify your remote configuration.");
       process.exit(1);
     }
     await updateLocalBranch(baseBranch, syncSource.ref);
     const rebaseStrategy = await determineRebaseStrategy(currentBranch, syncSource.ref);
     if (rebaseStrategy.strategy === "onto" && rebaseStrategy.ontoOldBase) {
-      info(import_picocolors19.default.dim(`Using --onto rebase (branch was based on a different ref)`));
+      info(import_picocolors20.default.dim(`Using --onto rebase (branch was based on a different ref)`));
     }
     const rebaseResult = rebaseStrategy.strategy === "onto" && rebaseStrategy.ontoOldBase ? await rebaseOnto(syncSource.ref, rebaseStrategy.ontoOldBase) : await rebase(syncSource.ref);
     if (rebaseResult.exitCode !== 0) {
       warn("Rebase hit conflicts. Resolve them manually.");
       console.log();
-      if (!args["no-ai"]) {
+      if (isAIEnabled(config, args["no-ai"])) {
         const copilotError = await checkCopilotAvailable();
         if (!copilotError) {
           info("Fetching AI conflict resolution suggestions...");
@@ -14103,15 +14745,17 @@ ${content.slice(0, 2000)}
             } catch {}
           }
           if (conflictDiff) {
-            const spinner = createSpinner("Analyzing conflicts with AI...");
+            const spinner = createSpinner("Analyzing conflicts with AI...", {
+              tips: LOADING_TIPS
+            });
             const suggestion = await suggestConflictResolution(conflictDiff, args.model);
             if (suggestion) {
               spinner.success("AI conflict guidance ready.");
               console.log(`
-${import_picocolors19.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(import_picocolors19.default.dim("─".repeat(60)));
+${import_picocolors20.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(import_picocolors20.default.dim("─".repeat(60)));
               console.log(suggestion);
-              console.log(import_picocolors19.default.dim("─".repeat(60)));
+              console.log(import_picocolors20.default.dim("─".repeat(60)));
               console.log();
             } else {
               spinner.fail("AI could not analyze the conflicts.");
@@ -14119,21 +14763,21 @@ ${import_picocolors19.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance
           }
         }
       }
-      console.log(import_picocolors19.default.bold("To resolve:"));
+      console.log(import_picocolors20.default.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${import_picocolors19.default.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${import_picocolors19.default.cyan("git rebase --continue")}`);
+      console.log(`  2. ${import_picocolors20.default.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${import_picocolors20.default.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${import_picocolors19.default.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${import_picocolors20.default.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`${import_picocolors19.default.bold(currentBranch)} has been rebased onto latest ${import_picocolors19.default.bold(baseBranch)}`);
+    success(`${import_picocolors20.default.bold(currentBranch)} has been rebased onto latest ${import_picocolors20.default.bold(baseBranch)}`);
   }
 });
 
 // src/commands/validate.ts
-var import_picocolors20 = __toESM(require_picocolors(), 1);
 import { readFileSync as readFileSync5 } from "node:fs";
+var import_picocolors21 = __toESM(require_picocolors(), 1);
 var validate_default = defineCommand({
   meta: {
     name: "validate",
@@ -14153,9 +14797,10 @@ var validate_default = defineCommand({
   async run({ args }) {
     const config = readConfig();
     if (!config) {
-      error("No .contributerc.json found. Run `contrib setup` first.");
+      error("No repo config found. Run `contrib setup` first.");
       process.exit(1);
     }
+    projectHeading("validate", "✅");
     const convention = config.commitConvention;
     if (convention === "none") {
       info('Commit convention is set to "none". All messages are accepted.');
@@ -14172,7 +14817,7 @@ var validate_default = defineCommand({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(import_picocolors20.default.red(`  ✗ ${line}`));
+      console.error(import_picocolors21.default.red(`  ✗ ${line}`));
     }
     process.exit(1);
   }
@@ -15471,8 +16116,8 @@ var figlet = (() => {
     }
   };
   me2.fonts = function(callback) {
-    return new Promise(function(resolve2, reject) {
-      resolve2(fontList);
+    return new Promise(function(resolve3, reject) {
+      resolve3(fontList);
       if (callback) {
         callback(null, fontList);
       }
@@ -15494,12 +16139,12 @@ var nodeFiglet = figlet;
 nodeFiglet.defaults({ fontPath });
 nodeFiglet.loadFont = function(name, callback) {
   const actualFontName = getFontName(name);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     if (nodeFiglet.figFonts[actualFontName]) {
       if (callback) {
         callback(null, nodeFiglet.figFonts[actualFontName].options);
       }
-      resolve2(nodeFiglet.figFonts[actualFontName].options);
+      resolve3(nodeFiglet.figFonts[actualFontName].options);
       return;
     }
     fs2.readFile(path2.join(nodeFiglet.defaults().fontPath, actualFontName + ".flf"), { encoding: "utf-8" }, (err, fontData) => {
@@ -15516,7 +16161,7 @@ nodeFiglet.loadFont = function(name, callback) {
         if (callback) {
           callback(null, font);
         }
-        resolve2(font);
+        resolve3(font);
       } catch (error2) {
         const typedError = error2 instanceof Error ? error2 : new Error(String(error2));
         if (callback) {
@@ -15538,7 +16183,7 @@ nodeFiglet.loadFontSync = function(font) {
   return nodeFiglet.parseFont(actualFontName, fontData);
 };
 nodeFiglet.fonts = function(next) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const fontList2 = [];
     fs2.readdir(nodeFiglet.defaults().fontPath, (err, files) => {
       if (err) {
@@ -15552,7 +16197,7 @@ nodeFiglet.fonts = function(next) {
         }
       });
       next && next(null, fontList2);
-      resolve2(fontList2);
+      resolve3(fontList2);
     });
   });
 };
@@ -15567,7 +16212,37 @@ nodeFiglet.fontsSync = function() {
 };
 
 // src/ui/banner.ts
-var import_picocolors21 = __toESM(require_picocolors(), 1);
+var import_picocolors22 = __toESM(require_picocolors(), 1);
+
+// src/data/announcements.json
+var announcements_default = [
+  {
+    id: "legacy-config-migration",
+    kind: "notice",
+    title: "Legacy Config Detected",
+    message: "Run cn setup to migrate this clone to local Git config, then delete .contributerc.json.",
+    when: "legacy-config-present"
+  }
+];
+
+// src/utils/announcements.ts
+var DEFINITIONS = announcements_default;
+function getActiveAnnouncements(cwd = process.cwd()) {
+  return DEFINITIONS.filter((announcement) => shouldShowAnnouncement(announcement, cwd)).map(({ id, kind, title, message }) => ({ id, kind, title, message }));
+}
+function shouldShowAnnouncement(announcement, cwd) {
+  if (!announcement.when) {
+    return true;
+  }
+  switch (announcement.when) {
+    case "legacy-config-present":
+      return hasLegacyConfig(cwd);
+    default:
+      return false;
+  }
+}
+
+// src/ui/banner.ts
 var LOGO_BIG;
 try {
   LOGO_BIG = nodeFiglet.textSync(`Contribute
@@ -15589,19 +16264,194 @@ function getAuthor() {
 }
 function showBanner(variant = "small") {
   const logo = variant === "big" ? LOGO_BIG : LOGO_SMALL;
-  console.log(import_picocolors21.default.cyan(`
+  console.log(import_picocolors22.default.cyan(`
 ${logo}`));
-  console.log(`  ${import_picocolors21.default.dim(`v${getVersion()}`)} ${import_picocolors21.default.dim("—")} ${import_picocolors21.default.dim(`Built by ${getAuthor()}`)}`);
+  console.log(`  ${import_picocolors22.default.dim(`v${getVersion()}`)} ${import_picocolors22.default.dim("—")} ${import_picocolors22.default.dim(`Built by ${getAuthor()}`)}`);
+  const announcements = getActiveAnnouncements();
+  if (announcements.length > 0) {
+    console.log();
+    renderAnnouncements(announcements);
+  }
   if (variant === "big") {
+    const panelLines = [
+      {
+        label: import_picocolors22.default.bold(import_picocolors22.default.cyan("Getting Started")),
+        rawLabel: "Getting Started",
+        value: "",
+        rawValue: ""
+      },
+      {
+        label: import_picocolors22.default.cyan("cn setup"),
+        rawLabel: "cn setup",
+        value: import_picocolors22.default.dim("configure workflow, remotes, and defaults"),
+        rawValue: "configure workflow, remotes, and defaults"
+      },
+      {
+        label: import_picocolors22.default.cyan("cn doctor"),
+        rawLabel: "cn doctor",
+        value: import_picocolors22.default.dim("verify your environment before doing any work"),
+        rawValue: "verify your environment before doing any work"
+      },
+      {
+        label: import_picocolors22.default.cyan("cn start"),
+        rawLabel: "cn start",
+        value: import_picocolors22.default.dim("create a branch and begin the next task"),
+        rawValue: "create a branch and begin the next task"
+      },
+      {
+        label: "",
+        rawLabel: "",
+        value: "",
+        rawValue: ""
+      },
+      {
+        label: import_picocolors22.default.bold(import_picocolors22.default.cyan("Workflow")),
+        rawLabel: "Workflow",
+        value: "",
+        rawValue: ""
+      },
+      {
+        label: import_picocolors22.default.dim("cn setup → cn commit → cn update → cn submit"),
+        rawLabel: "cn setup → cn commit → cn update → cn submit",
+        value: "",
+        rawValue: ""
+      }
+    ];
+    const terminalWidth = process.stdout.columns ?? 80;
+    const maxContentWidth = Math.max(36, terminalWidth - 8);
+    const unclampedLabelWidth = panelLines.reduce((max, line) => Math.max(max, line.rawLabel.length), 0);
+    const labelWidth = Math.min(unclampedLabelWidth, 18);
+    const valueWidth = Math.max(14, maxContentWidth - labelWidth - 2);
+    const rows = panelLines.map((line) => {
+      const rawLabel = line.rawValue ? truncateText3(line.rawLabel, labelWidth) : line.rawLabel;
+      const rawValue = line.rawValue ? truncateText3(line.rawValue, valueWidth) : "";
+      return {
+        ...line,
+        rawLabel,
+        rawValue
+      };
+    });
+    const contentWidth = Math.min(maxContentWidth, rows.reduce((max, line) => {
+      const lineLength = line.rawValue ? labelWidth + 2 + line.rawValue.length : line.rawLabel.length;
+      return Math.max(max, lineLength);
+    }, 0));
+    console.log();
+    console.log(`  ${import_picocolors22.default.dim(`┌${"─".repeat(contentWidth + 2)}┐`)}`);
+    for (const line of rows) {
+      if (!line.rawLabel && !line.rawValue) {
+        console.log(`  ${import_picocolors22.default.dim("│")} ${" ".repeat(contentWidth)} ${import_picocolors22.default.dim("│")}`);
+        continue;
+      }
+      const left = line.rawValue ? `${line.label}${" ".repeat(Math.max(0, labelWidth - line.rawLabel.length + 2))}` : line.label;
+      const value = line.rawValue ? import_picocolors22.default.dim(line.rawValue) : "";
+      const rawLength = line.rawValue ? labelWidth + 2 + line.rawValue.length : line.rawLabel.length;
+      const trailing = " ".repeat(Math.max(0, contentWidth - rawLength));
+      console.log(`  ${import_picocolors22.default.dim("│")} ${left}${value}${trailing} ${import_picocolors22.default.dim("│")}`);
+    }
+    console.log(`  ${import_picocolors22.default.dim(`└${"─".repeat(contentWidth + 2)}┘`)}`);
     console.log();
-    console.log(`  ${import_picocolors21.default.yellow("Star")}        ${import_picocolors21.default.cyan("https://github.com/warengonzaga/contribute-now")}`);
-    console.log(`  ${import_picocolors21.default.green("Contribute")}  ${import_picocolors21.default.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
-    console.log(`  ${import_picocolors21.default.magenta("Sponsor")}     ${import_picocolors21.default.cyan("https://warengonzaga.com/sponsor")}`);
+    console.log(`  ${import_picocolors22.default.dim("Star or contribute:")} ${import_picocolors22.default.dim(linkify("gh.waren.build/contribute-now", "https://gh.waren.build/contribute-now"))}`);
+    console.log(`  ${import_picocolors22.default.dim("Sponsor:")} ${import_picocolors22.default.dim(linkify("warengonzaga.com/sponsor", "https://warengonzaga.com/sponsor"))}`);
   }
   console.log();
 }
+function truncateText3(text, maxWidth) {
+  if (text.length <= maxWidth) {
+    return text;
+  }
+  if (maxWidth <= 1) {
+    return text.slice(0, maxWidth);
+  }
+  return `${text.slice(0, maxWidth - 1)}…`;
+}
+function linkify(label, url) {
+  return `\x1B]8;;${url}\x07${label}\x1B]8;;\x07`;
+}
+function renderAnnouncements(announcements) {
+  for (const announcement of announcements) {
+    renderAnnouncementBanner(announcement);
+  }
+}
+function renderAnnouncementBanner(announcement) {
+  const terminalWidth = process.stdout.columns ?? 80;
+  const contentWidth = Math.max(36, Math.min(terminalWidth - 8, 92));
+  const tone = getAnnouncementTone(announcement.kind);
+  const title = `${tone.emoji} ${announcement.title}`;
+  const messageLines = wrapText(announcement.message, contentWidth);
+  const lines = [title, ...messageLines];
+  const rawWidth = Math.max(...lines.map((line) => line.length));
+  console.log(`  ${tone.border(`┌${"─".repeat(rawWidth + 2)}┐`)}`);
+  for (const line of lines) {
+    const trailing = " ".repeat(Math.max(0, rawWidth - line.length));
+    const content = line === title ? tone.title(line) : import_picocolors22.default.dim(line);
+    console.log(`  ${tone.border("│")} ${content}${trailing} ${tone.border("│")}`);
+  }
+  console.log(`  ${tone.border(`└${"─".repeat(rawWidth + 2)}┘`)}`);
+}
+function wrapText(text, maxWidth) {
+  if (text.length <= maxWidth) {
+    return [text];
+  }
+  const words = text.split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (candidate.length <= maxWidth) {
+      current = candidate;
+      continue;
+    }
+    if (current) {
+      lines.push(current);
+      current = word;
+    } else {
+      lines.push(word.slice(0, maxWidth));
+      current = word.slice(maxWidth);
+    }
+  }
+  if (current) {
+    lines.push(current);
+  }
+  return lines;
+}
+function getAnnouncementTone(kind) {
+  switch (kind) {
+    case "info":
+      return {
+        emoji: "ℹ",
+        border: import_picocolors22.default.blue,
+        title: (value) => import_picocolors22.default.bold(import_picocolors22.default.blue(value))
+      };
+    case "warning":
+      return {
+        emoji: "\uD83D\uDEA8",
+        border: import_picocolors22.default.red,
+        title: (value) => import_picocolors22.default.bold(import_picocolors22.default.red(value))
+      };
+    default:
+      return {
+        emoji: "⚠",
+        border: import_picocolors22.default.yellow,
+        title: (value) => import_picocolors22.default.bold(import_picocolors22.default.yellow(value))
+      };
+  }
+}
 
 // src/index.ts
+function normalizeCliArgs(argv2) {
+  return argv2.map((arg, index) => {
+    const previous = argv2[index - 1];
+    const isSubmitCommand = previous === "submit" || argv2.includes("submit");
+    if (!isSubmitCommand) {
+      return arg;
+    }
+    if (arg === "-pr" || arg === "--pr") {
+      return "--pullrequest";
+    }
+    return arg;
+  });
+}
+process.argv = normalizeCliArgs(process.argv);
 var isVersion = process.argv.includes("--version") || process.argv.includes("-v");
 if (!isVersion) {
   const subCommands = [