contribute-now 0.8.0-dev.7eaa951 → 0.8.0-dev.a835394

package/dist/cli.js

@@ -5644,6 +5644,242 @@ var init_dist = __esm(() => {
   init_types2();
 });
 
+// src/utils/gh.ts
+var exports_gh = {};
+__export(exports_gh, {
+  isRepoFork: () => isRepoFork,
+  getRepoLabels: () => getRepoLabels,
+  getPRForBranch: () => getPRForBranch,
+  getPRContent: () => getPRContent,
+  getMergedPRForBranch: () => getMergedPRForBranch,
+  getIssueContent: () => getIssueContent,
+  getCurrentRepoInfo: () => getCurrentRepoInfo,
+  createPRFill: () => createPRFill,
+  createPR: () => createPR,
+  checkRepoPermissions: () => checkRepoPermissions,
+  checkGhInstalled: () => checkGhInstalled,
+  checkGhAuth: () => checkGhAuth,
+  addLabelsToPR: () => addLabelsToPR,
+  addLabelsToIssue: () => addLabelsToIssue
+});
+import { execFile as execFileCb2 } from "child_process";
+function run2(args) {
+  return new Promise((resolve5) => {
+    execFileCb2("gh", args, (error2, stdout2, stderr) => {
+      resolve5({
+        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;
+  }
+}
+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;
+}
+async function getCurrentRepoInfo() {
+  const { exitCode, stdout: stdout2 } = await run2([
+    "repo",
+    "view",
+    "--json",
+    "nameWithOwner",
+    "-q",
+    ".nameWithOwner"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  const nameWithOwner = stdout2.trim();
+  if (!nameWithOwner)
+    return null;
+  const [owner, repo] = nameWithOwner.split("/");
+  if (!owner || !repo)
+    return null;
+  return { owner, repo };
+}
+async function createPR(options) {
+  const args = [
+    "pr",
+    "create",
+    "--base",
+    options.base,
+    "--title",
+    options.title,
+    "--body",
+    options.body
+  ];
+  if (options.draft)
+    args.push("--draft");
+  return run2(args);
+}
+async function createPRFill(base, draft) {
+  const args = ["pr", "create", "--base", base, "--fill"];
+  if (draft)
+    args.push("--draft");
+  return run2(args);
+}
+async function getPRForBranch(headBranch) {
+  const { exitCode, stdout: stdout2 } = await run2([
+    "pr",
+    "list",
+    "--head",
+    headBranch,
+    "--state",
+    "open",
+    "--json",
+    "number,url,title,state",
+    "--limit",
+    "1"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    const prs = JSON.parse(stdout2.trim());
+    return prs.length > 0 ? prs[0] : null;
+  } catch {
+    return null;
+  }
+}
+async function getMergedPRForBranch(headBranch) {
+  const { exitCode, stdout: stdout2 } = await run2([
+    "pr",
+    "list",
+    "--head",
+    headBranch,
+    "--state",
+    "merged",
+    "--json",
+    "number,url,title,state",
+    "--limit",
+    "1"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    const prs = JSON.parse(stdout2.trim());
+    return prs.length > 0 ? prs[0] : null;
+  } catch {
+    return null;
+  }
+}
+async function getRepoLabels() {
+  const PAGE_SIZE = 100;
+  const allLabels = [];
+  let page = 1;
+  while (true) {
+    const { exitCode, stdout: stdout2 } = await run2([
+      "label",
+      "list",
+      "--json",
+      "name,description,color",
+      "--limit",
+      String(PAGE_SIZE),
+      "--page",
+      String(page)
+    ]);
+    if (exitCode !== 0)
+      break;
+    let batch = [];
+    try {
+      batch = JSON.parse(stdout2.trim());
+    } catch {
+      break;
+    }
+    if (!Array.isArray(batch) || batch.length === 0)
+      break;
+    for (const item of batch) {
+      if (typeof item.name === "string" && item.name.trim().length > 0) {
+        allLabels.push({
+          name: item.name.trim(),
+          description: typeof item.description === "string" ? item.description.trim() : "",
+          color: typeof item.color === "string" ? item.color.trim().replace(/^#/, "") : ""
+        });
+      }
+    }
+    if (batch.length < PAGE_SIZE)
+      break;
+    page++;
+  }
+  return allLabels;
+}
+async function getIssueContent(issueNumber) {
+  const { exitCode, stdout: stdout2 } = await run2([
+    "issue",
+    "view",
+    String(issueNumber),
+    "--json",
+    "title,body"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    const parsed = JSON.parse(stdout2.trim());
+    const title = typeof parsed.title === "string" ? parsed.title : "";
+    const body = typeof parsed.body === "string" ? parsed.body : "";
+    return { title, body };
+  } catch {
+    return null;
+  }
+}
+async function getPRContent(prNumber) {
+  const { exitCode, stdout: stdout2 } = await run2(["pr", "view", String(prNumber), "--json", "title,body"]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    const parsed = JSON.parse(stdout2.trim());
+    const title = typeof parsed.title === "string" ? parsed.title : "";
+    const body = typeof parsed.body === "string" ? parsed.body : "";
+    return { title, body };
+  } catch {
+    return null;
+  }
+}
+async function addLabelsToIssue(issueNumber, labels) {
+  return run2(["issue", "edit", String(issueNumber), "--add-label", labels.join(",")]);
+}
+async function addLabelsToPR(prNumber, labels) {
+  return run2(["pr", "edit", String(prNumber), "--add-label", labels.join(",")]);
+}
+var SAFE_SLUG;
+var init_gh = __esm(() => {
+  SAFE_SLUG = /^[\w.-]+$/;
+});
+
 // node_modules/consola/dist/core.mjs
 var LogLevels = {
   silent: Number.NEGATIVE_INFINITY,
@@ -7055,10 +7291,13 @@ import {
   statSync,
   writeFileSync
 } from "fs";
+import { homedir } from "os";
 import { dirname, join, resolve } from "path";
 var CONFIG_FILENAME = ".contributerc.json";
 var LOCAL_CONFIG_DIRNAME = "contribute-now";
 var LOCAL_CONFIG_FILENAME = "config.json";
+var GLOBAL_CONFIG_DIRNAME = ".contribute-now";
+var GLOBAL_CONFIG_FILENAME = "config.json";
 function findRepoRoot(cwd = process.cwd()) {
   let current = resolve(cwd);
   while (true) {
@@ -7148,13 +7387,44 @@ function parseConfigFile(path) {
       aiHost: _aiHost,
       ...config
     } = parsed;
-    return {
+    const normalizedConfig = {
       ...config,
-      aiEnabled: parsed.aiEnabled !== false,
       aiProvider: parsed.aiProvider,
       aiModel: parsed.aiModel?.trim() || undefined,
       showTips: parsed.showTips !== false
     };
+    if (typeof parsed.aiEnabled === "boolean") {
+      normalizedConfig.aiEnabled = parsed.aiEnabled;
+    }
+    return normalizedConfig;
+  } catch {
+    return null;
+  }
+}
+function parseGlobalConfigFile(path) {
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    if (parsed.aiProvider !== undefined && (typeof parsed.aiProvider !== "string" || !VALID_AI_PROVIDERS.includes(parsed.aiProvider))) {
+      console.error(`Invalid aiProvider "${String(parsed.aiProvider)}" in ${GLOBAL_CONFIG_FILENAME}. Valid: ${VALID_AI_PROVIDERS.join(", ")}`);
+      return null;
+    }
+    if (parsed.aiModel !== undefined && (typeof parsed.aiModel !== "string" || !parsed.aiModel.trim())) {
+      console.error(`Invalid ${GLOBAL_CONFIG_FILENAME}: aiModel must be a non-empty string.`);
+      return null;
+    }
+    if (parsed.aiEnabled !== undefined && typeof parsed.aiEnabled !== "boolean") {
+      console.error(`Invalid ${GLOBAL_CONFIG_FILENAME}: aiEnabled must be a boolean when set.`);
+      return null;
+    }
+    return {
+      aiEnabled: parsed.aiEnabled,
+      aiProvider: parsed.aiProvider,
+      aiModel: parsed.aiModel?.trim() || undefined
+    };
   } catch {
     return null;
   }
@@ -7169,6 +7439,9 @@ function getConfigPath(cwd = process.cwd()) {
 function getLegacyConfigPath(cwd = process.cwd()) {
   return join(findRepoRoot(cwd) ?? cwd, CONFIG_FILENAME);
 }
+function getGlobalConfigPath(baseDir = homedir()) {
+  return join(baseDir, GLOBAL_CONFIG_DIRNAME, GLOBAL_CONFIG_FILENAME);
+}
 function getLocalConfigPath(cwd = process.cwd()) {
   const gitDir = resolveGitDir(cwd);
   if (!gitDir) {
@@ -7203,12 +7476,25 @@ function getConfigLocationLabel(cwd = process.cwd()) {
 function configExists(cwd = process.cwd()) {
   return getConfigSource(cwd) !== null;
 }
+function globalConfigExists(baseDir = homedir()) {
+  return existsSync(getGlobalConfigPath(baseDir));
+}
 var VALID_WORKFLOWS = ["clean-flow", "github-flow", "git-flow"];
 var VALID_ROLES = ["maintainer", "contributor"];
 var VALID_CONVENTIONS = ["conventional", "clean-commit", "none"];
 var VALID_AI_PROVIDERS = ["copilot", "ollama-cloud", "openrouter"];
-function isAIEnabled(config, cliNoAI = false) {
-  return config.aiEnabled !== false && !cliNoAI;
+function isAIEnabled(config, cliNoAI = false, globalConfig) {
+  if (cliNoAI) {
+    return false;
+  }
+  if (typeof config.aiEnabled === "boolean") {
+    return config.aiEnabled;
+  }
+  const resolvedGlobalConfig = globalConfig === undefined ? readGlobalConfig() : globalConfig;
+  if (typeof resolvedGlobalConfig?.aiEnabled === "boolean") {
+    return resolvedGlobalConfig.aiEnabled;
+  }
+  return true;
 }
 function shouldShowTips(config) {
   return config?.showTips !== false;
@@ -7222,6 +7508,13 @@ function readConfig(cwd = process.cwd()) {
     return null;
   return parseConfigFile(path);
 }
+function readGlobalConfig(baseDir = homedir()) {
+  const path = getGlobalConfigPath(baseDir);
+  if (!existsSync(path)) {
+    return null;
+  }
+  return parseGlobalConfigFile(path);
+}
 function writeConfig(config, cwd = process.cwd()) {
   const path = getConfigPath(cwd);
   const { aiHost: _aiHost, ...storedConfig } = config;
@@ -7229,6 +7522,15 @@ function writeConfig(config, cwd = process.cwd()) {
   writeFileSync(path, `${JSON.stringify(storedConfig, null, 2)}
 `, "utf-8");
 }
+function writeGlobalConfig(config, baseDir = homedir()) {
+  const path = getGlobalConfigPath(baseDir);
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`, {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
 function isGitignored(cwd = process.cwd()) {
   const gitignorePath = join(cwd, ".gitignore");
   if (!existsSync(gitignorePath))
@@ -9115,6 +9417,24 @@ var COMMAND_GUIDES = {
         description: "check config, remotes, and workflow resolution together"
       }
     ]
+  },
+  label: {
+    summary: "Apply existing labels or get ranked suggestions for issues and pull requests.",
+    examples: [
+      { command: "cn label --help", description: "learn label add and suggest usage" },
+      {
+        command: "cn label add --issue 42 bug,enhancement",
+        description: "apply labels to an issue"
+      },
+      {
+        command: 'cn label add --pr 7 "good first issue"',
+        description: "apply a label with spaces to a PR"
+      },
+      {
+        command: "cn label suggest --issue 42",
+        description: "get ranked label suggestions from content"
+      }
+    ]
   }
 };
 var LOADING_TIPS = [
@@ -10619,19 +10939,19 @@ init_dist();
 
 // src/utils/secrets.ts
 import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import { join as join5, resolve as resolve4 } from "path";
 var CONTRIBUTE_NOW_SECRETS_DIRNAME = ".contribute-now";
 var CONTRIBUTE_NOW_SECRETS_STORE_DIRNAME = "secrets";
 var OLLAMA_CLOUD_API_KEY = "ollama.cloud.apiKey";
 var OPENROUTER_API_KEY = "openrouter.apiKey";
-function getSecretsStorePath(baseDir = homedir()) {
+function getSecretsStorePath(baseDir = homedir2()) {
   return resolve4(baseDir, CONTRIBUTE_NOW_SECRETS_DIRNAME, CONTRIBUTE_NOW_SECRETS_STORE_DIRNAME);
 }
-function getSecretsFilePath(baseDir = homedir()) {
+function getSecretsFilePath(baseDir = homedir2()) {
   return join5(getSecretsStorePath(baseDir), "store.json");
 }
-function readSecretsStore(baseDir = homedir()) {
+function readSecretsStore(baseDir = homedir2()) {
   const filePath = getSecretsFilePath(baseDir);
   if (!existsSync5(filePath)) {
     return null;
@@ -10643,7 +10963,7 @@ function readSecretsStore(baseDir = homedir()) {
     return null;
   }
 }
-function writeSecretsStore(store, baseDir = homedir()) {
+function writeSecretsStore(store, baseDir = homedir2()) {
   const storePath = getSecretsStorePath(baseDir);
   const filePath = getSecretsFilePath(baseDir);
   mkdirSync4(storePath, { recursive: true, mode: 448 });
@@ -10657,23 +10977,23 @@ function writeSecretsStore(store, baseDir = homedir()) {
     chmodSync(filePath, 384);
   } catch {}
 }
-function hasSecretsStore(baseDir = homedir()) {
+function hasSecretsStore(baseDir = homedir2()) {
   return existsSync5(getSecretsFilePath(baseDir));
 }
-async function hasOllamaCloudApiKey(baseDir = homedir()) {
+async function hasOllamaCloudApiKey(baseDir = homedir2()) {
   return typeof readSecretsStore(baseDir)?.[OLLAMA_CLOUD_API_KEY] === "string";
 }
-async function getOllamaCloudApiKey(baseDir = homedir()) {
+async function getOllamaCloudApiKey(baseDir = homedir2()) {
   return readSecretsStore(baseDir)?.[OLLAMA_CLOUD_API_KEY] ?? null;
 }
-async function setOllamaCloudApiKey(value, baseDir = homedir()) {
+async function setOllamaCloudApiKey(value, baseDir = homedir2()) {
   const existingStore = readSecretsStore(baseDir) ?? {};
   writeSecretsStore({
     ...existingStore,
     [OLLAMA_CLOUD_API_KEY]: value
   }, baseDir);
 }
-async function deleteOllamaCloudApiKey(baseDir = homedir()) {
+async function deleteOllamaCloudApiKey(baseDir = homedir2()) {
   const existingStore = readSecretsStore(baseDir);
   if (!existingStore || !(OLLAMA_CLOUD_API_KEY in existingStore)) {
     return false;
@@ -10690,20 +11010,20 @@ async function deleteOllamaCloudApiKey(baseDir = homedir()) {
   writeSecretsStore(nextStore, baseDir);
   return true;
 }
-async function hasOpenRouterApiKey(baseDir = homedir()) {
+async function hasOpenRouterApiKey(baseDir = homedir2()) {
   return typeof readSecretsStore(baseDir)?.[OPENROUTER_API_KEY] === "string";
 }
-async function getOpenRouterApiKey(baseDir = homedir()) {
+async function getOpenRouterApiKey(baseDir = homedir2()) {
   return readSecretsStore(baseDir)?.[OPENROUTER_API_KEY] ?? null;
 }
-async function setOpenRouterApiKey(value, baseDir = homedir()) {
+async function setOpenRouterApiKey(value, baseDir = homedir2()) {
   const existingStore = readSecretsStore(baseDir) ?? {};
   writeSecretsStore({
     ...existingStore,
     [OPENROUTER_API_KEY]: value
   }, baseDir);
 }
-async function deleteOpenRouterApiKey(baseDir = homedir()) {
+async function deleteOpenRouterApiKey(baseDir = homedir2()) {
   const existingStore = readSecretsStore(baseDir);
   if (!existingStore || !(OPENROUTER_API_KEY in existingStore)) {
     return false;
@@ -10789,6 +11109,31 @@ var DEFAULT_OLLAMA_CLOUD_MODEL = "gpt-oss:120b";
 var DEFAULT_OLLAMA_CLOUD_HOST = "https://ollama.com/v1";
 var DEFAULT_OPENROUTER_MODEL = "openai/gpt-4o-mini";
 var DEFAULT_OPENROUTER_HOST = "https://openrouter.ai/api/v1";
+function resolveAIConfigFromSources(repoConfig, globalConfig) {
+  const provider = repoConfig?.aiProvider ?? globalConfig?.aiProvider ?? "copilot";
+  const useGlobalModel = !repoConfig?.aiModel && globalConfig?.aiProvider === provider;
+  const globalModel = useGlobalModel ? globalConfig?.aiModel?.trim() : undefined;
+  if (provider === "ollama-cloud") {
+    return {
+      provider,
+      providerLabel: "Ollama Cloud",
+      model: repoConfig?.aiModel?.trim() || globalModel || DEFAULT_OLLAMA_CLOUD_MODEL,
+      host: DEFAULT_OLLAMA_CLOUD_HOST
+    };
+  }
+  if (provider === "openrouter") {
+    return {
+      provider,
+      providerLabel: "OpenRouter",
+      model: repoConfig?.aiModel?.trim() || globalModel || DEFAULT_OPENROUTER_MODEL,
+      host: DEFAULT_OPENROUTER_HOST
+    };
+  }
+  return {
+    provider: "copilot",
+    providerLabel: "GitHub Copilot"
+  };
+}
 function prioritizeOllamaCloudModels(models, preferredModel = DEFAULT_OLLAMA_CLOUD_MODEL) {
   const uniqueModels = [...new Set(models.map((model) => model.trim()).filter(Boolean))];
   const sortedModels = [...uniqueModels].sort((left, right) => left.localeCompare(right));
@@ -10862,28 +11207,9 @@ function prioritizeOpenRouterModels(models, preferredModel = DEFAULT_OPENROUTER_
   return sortedModels.includes(preferredModel) ? [preferredModel, ...sortedModels.filter((model) => model !== preferredModel)] : sortedModels;
 }
 function resolveAIConfig(config) {
-  const resolvedConfig = config ?? readConfig();
-  const provider = resolvedConfig?.aiProvider ?? "copilot";
-  if (provider === "ollama-cloud") {
-    return {
-      provider,
-      providerLabel: "Ollama Cloud",
-      model: resolvedConfig?.aiModel?.trim() || DEFAULT_OLLAMA_CLOUD_MODEL,
-      host: DEFAULT_OLLAMA_CLOUD_HOST
-    };
-  }
-  if (provider === "openrouter") {
-    return {
-      provider,
-      providerLabel: "OpenRouter",
-      model: resolvedConfig?.aiModel?.trim() || DEFAULT_OPENROUTER_MODEL,
-      host: DEFAULT_OPENROUTER_HOST
-    };
-  }
-  return {
-    provider: "copilot",
-    providerLabel: "GitHub Copilot"
-  };
+  const repoConfig = config ?? readConfig();
+  const globalConfig = readGlobalConfig();
+  return resolveAIConfigFromSources(repoConfig, globalConfig);
 }
 function suppressSubprocessWarnings() {
   process.env.NODE_NO_WARNINGS = "1";
@@ -11793,145 +12119,8 @@ async function promptForBranchName(options) {
   }
 }
 
-// src/utils/gh.ts
-import { execFile as execFileCb2 } from "child_process";
-function run2(args) {
-  return new Promise((resolve5) => {
-    execFileCb2("gh", args, (error2, stdout2, stderr) => {
-      resolve5({
-        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;
-}
-async function getCurrentRepoInfo() {
-  const { exitCode, stdout: stdout2 } = await run2([
-    "repo",
-    "view",
-    "--json",
-    "nameWithOwner",
-    "-q",
-    ".nameWithOwner"
-  ]);
-  if (exitCode !== 0)
-    return null;
-  const nameWithOwner = stdout2.trim();
-  if (!nameWithOwner)
-    return null;
-  const [owner, repo] = nameWithOwner.split("/");
-  if (!owner || !repo)
-    return null;
-  return { owner, repo };
-}
-async function createPR(options) {
-  const args = [
-    "pr",
-    "create",
-    "--base",
-    options.base,
-    "--title",
-    options.title,
-    "--body",
-    options.body
-  ];
-  if (options.draft)
-    args.push("--draft");
-  return run2(args);
-}
-async function createPRFill(base, draft) {
-  const args = ["pr", "create", "--base", base, "--fill"];
-  if (draft)
-    args.push("--draft");
-  return run2(args);
-}
-async function getPRForBranch(headBranch) {
-  const { exitCode, stdout: stdout2 } = await run2([
-    "pr",
-    "list",
-    "--head",
-    headBranch,
-    "--state",
-    "open",
-    "--json",
-    "number,url,title,state",
-    "--limit",
-    "1"
-  ]);
-  if (exitCode !== 0)
-    return null;
-  try {
-    const prs = JSON.parse(stdout2.trim());
-    return prs.length > 0 ? prs[0] : null;
-  } catch {
-    return null;
-  }
-}
-async function getMergedPRForBranch(headBranch) {
-  const { exitCode, stdout: stdout2 } = await run2([
-    "pr",
-    "list",
-    "--head",
-    headBranch,
-    "--state",
-    "merged",
-    "--json",
-    "number,url,title,state",
-    "--limit",
-    "1"
-  ]);
-  if (exitCode !== 0)
-    return null;
-  try {
-    const prs = JSON.parse(stdout2.trim());
-    return prs.length > 0 ? prs[0] : null;
-  } catch {
-    return null;
-  }
-}
-
 // src/commands/clean.ts
+init_gh();
 async function handleCurrentBranchDeletion(currentBranch, baseBranch, config) {
   if (!config)
     return "skipped";
@@ -12723,6 +12912,62 @@ function buildConfigSnapshot(config, meta) {
     }
   };
 }
+function normalizeGlobalConfig(config) {
+  const normalized = {
+    aiEnabled: config.aiEnabled !== false
+  };
+  if (normalized.aiEnabled) {
+    normalized.aiProvider = config.aiProvider ?? "copilot";
+    if (normalized.aiProvider === "ollama-cloud") {
+      normalized.aiModel = (config.aiModel?.trim() || DEFAULT_OLLAMA_CLOUD_MODEL).trim();
+    } else if (normalized.aiProvider === "openrouter") {
+      normalized.aiModel = (config.aiModel?.trim() || DEFAULT_OPENROUTER_MODEL).trim();
+    }
+  }
+  return normalized;
+}
+function buildGlobalConfigSnapshot(config) {
+  const normalized = normalizeGlobalConfig(config);
+  const aiProvider = normalized.aiProvider ?? "copilot";
+  const aiEnabled = normalized.aiEnabled !== false;
+  const providerLabel = aiProvider === "ollama-cloud" ? "Ollama Cloud" : aiProvider === "openrouter" ? "OpenRouter" : "GitHub Copilot";
+  return {
+    location: getGlobalConfigPath(),
+    exists: globalConfigExists(),
+    ai: {
+      enabled: aiEnabled,
+      provider: aiProvider,
+      providerLabel,
+      model: aiEnabled ? normalized.aiModel ?? null : null
+    }
+  };
+}
+async function promptForGlobalConfigEdits(current) {
+  const normalized = normalizeGlobalConfig(current);
+  const aiEnabled = await selectBooleanValue("Global AI default", normalized.aiEnabled !== false, "Enabled", "Disabled");
+  if (!aiEnabled) {
+    return {
+      config: {
+        aiEnabled: false
+      }
+    };
+  }
+  const currentProvider = normalized.aiProvider ?? "copilot";
+  const aiProvider = await selectCurrentValue("Global AI provider", AI_PROVIDER_OPTIONS, currentProvider);
+  let aiModel;
+  if (aiProvider === "ollama-cloud") {
+    aiModel = await inputPrompt("Global Ollama Cloud model", normalized.aiModel ?? DEFAULT_OLLAMA_CLOUD_MODEL);
+  } else if (aiProvider === "openrouter") {
+    aiModel = await inputPrompt("Global OpenRouter model", normalized.aiModel ?? DEFAULT_OPENROUTER_MODEL);
+  }
+  return {
+    config: {
+      aiEnabled: true,
+      aiProvider,
+      aiModel: aiModel?.trim() || undefined
+    }
+  };
+}
 function defaultDevBranchForWorkflow(workflow) {
   return workflow === "git-flow" ? "develop" : "dev";
 }
@@ -13003,12 +13248,26 @@ function printConfigSummary(snapshot) {
     }
   }
 }
+function printGlobalConfigSummary(snapshot) {
+  info(`Global config path: ${import_picocolors10.default.bold(snapshot.location)}`);
+  info(`Global defaults file: ${import_picocolors10.default.bold(snapshot.exists ? "present" : "missing (using built-ins)")}`);
+  info(`AI default: ${import_picocolors10.default.bold(snapshot.ai.enabled ? "enabled" : "disabled")}`);
+  info(`AI provider: ${import_picocolors10.default.bold(snapshot.ai.providerLabel)}`);
+  if (snapshot.ai.model) {
+    info(`AI model: ${import_picocolors10.default.bold(snapshot.ai.model)}`);
+  }
+}
 var config_default = defineCommand({
   meta: {
     name: "config",
     description: "Inspect or edit the repo config without rerunning setup"
   },
   args: {
+    global: {
+      type: "boolean",
+      description: "Read or edit global defaults instead of repo config",
+      default: false
+    },
     json: {
       type: "boolean",
       description: "Print the active repo config as JSON with metadata",
@@ -13021,15 +13280,44 @@ var config_default = defineCommand({
     }
   },
   async run({ args }) {
-    if (!await isGitRepo()) {
-      error("Not inside a git repository.");
-      process.exit(1);
-    }
     if (args.json && args.edit) {
       error("Use either --json or --edit, not both at the same time.");
       process.exit(1);
     }
     await projectHeading("config", "\u2699\uFE0F");
+    if (args.global) {
+      const currentGlobal = readGlobalConfig() ?? {};
+      if (args.edit) {
+        try {
+          const editResult = await promptForGlobalConfigEdits(currentGlobal);
+          writeGlobalConfig(normalizeGlobalConfig(editResult.config));
+          success("Updated global defaults.");
+          const snapshot3 = buildGlobalConfigSnapshot(readGlobalConfig() ?? {});
+          printGlobalConfigSummary(snapshot3);
+          if (args.json) {
+            console.log(JSON.stringify(snapshot3, null, 2));
+          }
+          return;
+        } catch (err) {
+          error(err instanceof Error ? err.message : String(err));
+          process.exit(1);
+        }
+      }
+      const snapshot2 = buildGlobalConfigSnapshot(currentGlobal);
+      if (args.json) {
+        console.log(JSON.stringify(snapshot2, null, 2));
+        return;
+      }
+      printGlobalConfigSummary(snapshot2);
+      console.log();
+      console.log(`  ${import_picocolors10.default.dim("Run `cn config --global --edit` to update global defaults.")}`);
+      console.log();
+      return;
+    }
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
     if (!configExists()) {
       error("No repo config found. Run `cn setup` first.");
       process.exit(1);
@@ -13195,7 +13483,7 @@ var import_picocolors12 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "contribute-now",
-  version: "0.8.0-dev.7eaa951",
+  version: "0.8.0-dev.a835394",
   description: "Developer CLI that automates git workflows \u2014 branching, syncing, committing, and PRs \u2014 with multi-workflow and commit convention support.",
   type: "module",
   bin: {
@@ -13253,6 +13541,9 @@ var package_default = {
   }
 };
 
+// src/commands/doctor.ts
+init_gh();
+
 // src/utils/remote.ts
 function parseRepoFromUrl(url) {
   const httpsMatch = url.match(/https?:\/\/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?$/);
@@ -13762,8 +14053,610 @@ async function uninstallHook() {
   success("commit-msg hook removed.");
 }
 
-// src/commands/log.ts
+// src/commands/label.ts
+init_gh();
 var import_picocolors14 = __toESM(require_picocolors(), 1);
+
+// src/utils/label.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5, join as join7, resolve as resolve5 } from "path";
+
+// src/data/clean-labels.ts
+var CLEAN_LABELS = [
+  {
+    name: "bug",
+    description: "[Type] Something isn't working [issues, PRs]",
+    color: "d73a4a"
+  },
+  {
+    name: "enhancement",
+    description: "[Type] New feature or improvement to existing functionality [issues, PRs]",
+    color: "1a7f37"
+  },
+  {
+    name: "documentation",
+    description: "[Type] Improvements or additions to docs, README, or guides [issues, PRs]",
+    color: "0075ca"
+  },
+  {
+    name: "refactor",
+    description: "[Type] Code improvement without changing functionality [PRs]",
+    color: "8957e5"
+  },
+  {
+    name: "performance",
+    description: "[Type] Optimization, speed, or resource usage improvements [issues, PRs]",
+    color: "e3795c"
+  },
+  {
+    name: "security",
+    description: "[Type] Security vulnerability or hardening [issues, PRs]",
+    color: "d4a72c"
+  },
+  {
+    name: "blocked",
+    description: "[Status] Waiting on another issue, decision, or external factor [issues]",
+    color: "cf222e"
+  },
+  {
+    name: "needs triage",
+    description: "[Status] New issue \u2014 needs review and categorization [issues]",
+    color: "e16f24"
+  },
+  {
+    name: "awaiting response",
+    description: "[Status] Waiting for more information from the reporter [issues]",
+    color: "1a7ec7"
+  },
+  {
+    name: "ready",
+    description: "[Status] Triaged and ready to be picked up [issues]",
+    color: "2da44e"
+  },
+  {
+    name: "good first issue",
+    description: "[Community] Good for newcomers \u2014 well-scoped and documented [issues]",
+    color: "7057ff"
+  },
+  {
+    name: "help wanted",
+    description: "[Community] Open for community contribution [issues]",
+    color: "0e8a16"
+  },
+  {
+    name: "maintainer only",
+    description: "[Community] Reserved for maintainers \u2014 not open for external contribution [issues, PRs]",
+    color: "b60205"
+  },
+  {
+    name: "duplicate",
+    description: "[Resolution] This issue or pull request already exists [issues, PRs]",
+    color: "cfd3d7"
+  },
+  {
+    name: "invalid",
+    description: "[Resolution] This doesn't seem right [issues, PRs]",
+    color: "cfd3d7"
+  },
+  {
+    name: "wontfix",
+    description: "[Resolution] This will not be worked on [issues]",
+    color: "cfd3d7"
+  },
+  {
+    name: "core",
+    description: "[Area] Core logic, business rules, and primary functionality [issues, PRs]",
+    color: "0052cc"
+  },
+  {
+    name: "interface",
+    description: "[Area] User-facing layer \u2014 UI, CLI, API endpoints, or SDK surface [issues, PRs]",
+    color: "5319e7"
+  },
+  {
+    name: "data",
+    description: "[Area] Database, storage, caching, or data models [issues, PRs]",
+    color: "006b75"
+  },
+  {
+    name: "infra",
+    description: "[Area] Build system, CI/CD, deployment, config, and DevOps [issues, PRs]",
+    color: "e16f24"
+  },
+  {
+    name: "testing",
+    description: "[Area] Unit tests, integration tests, E2E, and test tooling [issues, PRs]",
+    color: "1a7f37"
+  }
+];
+
+// src/utils/label.ts
+var LABEL_CACHE_DIRNAME = "contribute-now";
+var LABEL_CACHE_FILENAME = "labels.json";
+function findRepoRoot3(cwd = process.cwd()) {
+  let current = resolve5(cwd);
+  while (true) {
+    if (existsSync7(join7(current, ".git"))) {
+      return current;
+    }
+    const parent = dirname5(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveGitDir3(cwd = process.cwd()) {
+  const repoRoot = findRepoRoot3(cwd);
+  if (!repoRoot) {
+    return null;
+  }
+  const dotGitPath = join7(repoRoot, ".git");
+  try {
+    const stat = statSync4(dotGitPath);
+    if (stat.isDirectory()) {
+      return dotGitPath;
+    }
+    if (!stat.isFile()) {
+      return null;
+    }
+    const content = readFileSync6(dotGitPath, "utf-8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(content);
+    if (!match) {
+      return null;
+    }
+    return resolve5(repoRoot, match[1].trim());
+  } catch {
+    return null;
+  }
+}
+function getLabelCachePath(cwd = process.cwd()) {
+  const gitDir = resolveGitDir3(cwd);
+  if (!gitDir) {
+    return null;
+  }
+  return join7(gitDir, LABEL_CACHE_DIRNAME, LABEL_CACHE_FILENAME);
+}
+function readLabelCache(cwd = process.cwd()) {
+  const cachePath = getLabelCachePath(cwd);
+  if (!cachePath || !existsSync7(cachePath)) {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(readFileSync6(cachePath, "utf-8"));
+    if (!Array.isArray(raw.labels) || typeof raw.fetchedAt !== "string" || raw.source !== "clean-labels" && raw.source !== "repo") {
+      return null;
+    }
+    const validatedLabels = [];
+    for (const entry of raw.labels) {
+      if (typeof entry !== "object" || entry === null || typeof entry.name !== "string" || !entry.name) {
+        continue;
+      }
+      const e3 = entry;
+      validatedLabels.push({
+        name: e3.name.trim(),
+        description: typeof e3.description === "string" ? e3.description.trim() : "",
+        color: typeof e3.color === "string" ? e3.color.trim() : ""
+      });
+    }
+    if (validatedLabels.length === 0) {
+      return null;
+    }
+    return {
+      labels: validatedLabels,
+      source: raw.source,
+      fetchedAt: raw.fetchedAt
+    };
+  } catch {
+    return null;
+  }
+}
+function writeLabelCache(cache, cwd = process.cwd()) {
+  const cachePath = getLabelCachePath(cwd);
+  if (!cachePath) {
+    return;
+  }
+  mkdirSync6(dirname5(cachePath), { recursive: true });
+  writeFileSync6(cachePath, `${JSON.stringify(cache, null, 2)}
+`, "utf-8");
+}
+function normalizeLabelName(name) {
+  return name.toLowerCase().trim();
+}
+function isCleanLabelsMatch(repoLabels) {
+  const cleanNames = new Set(CLEAN_LABELS.map((l2) => normalizeLabelName(l2.name)));
+  const repoNames = new Set(repoLabels.map((l2) => normalizeLabelName(l2.name)));
+  if (cleanNames.size !== repoNames.size) {
+    return false;
+  }
+  for (const name of cleanNames) {
+    if (!repoNames.has(name)) {
+      return false;
+    }
+  }
+  return true;
+}
+function buildEffectiveLabelSource(repoLabels) {
+  if (isCleanLabelsMatch(repoLabels)) {
+    return {
+      labels: CLEAN_LABELS.map((cl) => ({
+        name: cl.name,
+        description: cl.description,
+        color: cl.color
+      })),
+      source: "clean-labels"
+    };
+  }
+  return { labels: repoLabels, source: "repo" };
+}
+async function syncLabelCache(cwd = process.cwd()) {
+  const { getRepoLabels: getRepoLabels2 } = await Promise.resolve().then(() => (init_gh(), exports_gh));
+  const repoLabels = await getRepoLabels2();
+  if (repoLabels.length === 0) {
+    return null;
+  }
+  const { labels, source } = buildEffectiveLabelSource(repoLabels);
+  const cache = {
+    labels,
+    source,
+    fetchedAt: new Date().toISOString()
+  };
+  writeLabelCache(cache, cwd);
+  return cache;
+}
+async function getActiveLabels(cwd = process.cwd(), force = false) {
+  if (!force) {
+    const cached = readLabelCache(cwd);
+    if (cached) {
+      return cached;
+    }
+  }
+  return syncLabelCache(cwd);
+}
+function parseLabelsCsv(csv) {
+  return csv.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function validateLabels(requested, available) {
+  const availableNormalized = new Map;
+  for (const label of available) {
+    availableNormalized.set(normalizeLabelName(label.name), label.name);
+  }
+  const valid = [];
+  const invalid = [];
+  for (const req of requested) {
+    const normalized = normalizeLabelName(req);
+    const canonical = availableNormalized.get(normalized);
+    if (canonical !== undefined) {
+      valid.push(canonical);
+    } else {
+      invalid.push(req);
+    }
+  }
+  return { valid, invalid };
+}
+function findCloseMatches(input, available, maxResults = 3) {
+  const needle = normalizeLabelName(input);
+  const scored = available.map((label) => {
+    const haystack = normalizeLabelName(label.name);
+    let score = 0;
+    if (haystack === needle) {
+      score = 100;
+    } else if (haystack.startsWith(needle) || needle.startsWith(haystack)) {
+      score = 60;
+    } else if (haystack.includes(needle) || needle.includes(haystack)) {
+      score = 40;
+    } else {
+      const needleBigrams = toBigrams(needle);
+      const haystackBigrams = toBigrams(haystack);
+      const overlap = [...needleBigrams].filter((b2) => haystackBigrams.has(b2)).length;
+      const union = new Set([...needleBigrams, ...haystackBigrams]).size;
+      score = union > 0 ? Math.round(overlap / union * 30) : 0;
+    }
+    return { name: label.name, score };
+  });
+  return scored.filter((item) => item.score > 0).sort((a2, b2) => b2.score - a2.score).slice(0, maxResults).map((item) => item.name);
+}
+function scoreLabelsForContent(content, labels) {
+  const contentTokens = tokenize(content.toLowerCase());
+  const scored = labels.map((label) => {
+    const nameTokens = tokenize(label.name.toLowerCase());
+    const descTokens = [...tokenize(stripDescriptionMeta(label.description).toLowerCase())].filter((t2) => t2.length > 3 && !STOP_WORDS.has(t2));
+    let score = 0;
+    for (const token of nameTokens) {
+      if (contentTokens.has(token))
+        score += 3;
+    }
+    const normalizedName = normalizeLabelName(label.name);
+    if (content.toLowerCase().includes(normalizedName)) {
+      score += 5;
+    }
+    for (const token of descTokens) {
+      if (contentTokens.has(token))
+        score += 1;
+    }
+    return { label, score };
+  });
+  return scored.filter((item) => item.score > 0).sort((a2, b2) => b2.score - a2.score);
+}
+var STOP_WORDS = new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "this",
+  "that",
+  "from",
+  "into",
+  "over",
+  "under",
+  "have",
+  "will",
+  "been",
+  "more",
+  "than",
+  "also",
+  "when",
+  "what",
+  "which",
+  "some",
+  "such",
+  "its",
+  "not",
+  "only",
+  "any",
+  "each",
+  "both"
+]);
+function stripDescriptionMeta(description) {
+  return description.replace(/^\[[\w\s]+\]\s*/u, "").replace(/\s*\[[\w,\s]+\]$/u, "").trim();
+}
+function tokenize(text) {
+  return new Set(text.split(/[\s\-_/,.:;!?()[\]{}"']+/).filter((t2) => t2.length > 0));
+}
+function toBigrams(text) {
+  const bigrams = new Set;
+  for (let i2 = 0;i2 < text.length - 1; i2++) {
+    bigrams.add(text.slice(i2, i2 + 2));
+  }
+  return bigrams;
+}
+
+// src/commands/label.ts
+async function requireGitRepository() {
+  if (!await isGitRepo()) {
+    error("Not inside a git repository.");
+    process.exit(1);
+  }
+}
+async function requireGhCli() {
+  if (!await checkGhInstalled()) {
+    error("GitHub CLI (gh) is required. Install it at https://cli.github.com");
+    process.exit(1);
+  }
+  if (!await checkGhAuth()) {
+    error("Not authenticated with GitHub CLI. Run `gh auth login` first.");
+    process.exit(1);
+  }
+}
+function extractLabelsCsv(rawArgs) {
+  const knownFlagsWithValues = new Set(["--issue", "--pr", "-i", "-p"]);
+  const parts = [];
+  let skipNext = false;
+  for (const arg of rawArgs) {
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    if (knownFlagsWithValues.has(arg)) {
+      skipNext = true;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      continue;
+    }
+    parts.push(arg);
+  }
+  return parts.join(" ");
+}
+function formatSourceNote(source) {
+  return source === "clean-labels" ? "(source: Clean Labels dataset)" : "(source: repo labels)";
+}
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Apply existing labels to an issue or pull request"
+  },
+  args: {
+    issue: {
+      type: "string",
+      alias: "i",
+      description: "Issue number to label"
+    },
+    pr: {
+      type: "string",
+      alias: "p",
+      description: "Pull request number to label"
+    },
+    labels: {
+      type: "positional",
+      description: "Comma-separated label names (spaces are part of label names)",
+      required: false
+    }
+  },
+  async run({ args, rawArgs }) {
+    await requireGitRepository();
+    await requireGhCli();
+    await projectHeading("label add", "\uD83C\uDFF7\uFE0F");
+    const hasIssue = Boolean(args.issue);
+    const hasPr = Boolean(args.pr);
+    if (!hasIssue && !hasPr) {
+      error("Provide a target: --issue <number> or --pr <number>");
+      process.exit(1);
+    }
+    if (hasIssue && hasPr) {
+      error("Use either --issue or --pr, not both.");
+      process.exit(1);
+    }
+    const targetNumber = Number(hasIssue ? args.issue : args.pr);
+    if (!Number.isInteger(targetNumber) || targetNumber <= 0) {
+      error(`Invalid ${hasIssue ? "issue" : "PR"} number: ${String(hasIssue ? args.issue : args.pr)}`);
+      process.exit(1);
+    }
+    const labelsCsv = extractLabelsCsv(rawArgs);
+    if (!labelsCsv) {
+      error("No labels provided. Pass a comma-separated list after the target flag.");
+      info("Example: cn label add --issue 42 bug,enhancement", "");
+      process.exit(1);
+    }
+    const requested = parseLabelsCsv(labelsCsv);
+    if (requested.length === 0) {
+      error("No valid label names found in input.");
+      process.exit(1);
+    }
+    let cache = await getActiveLabels();
+    if (!cache) {
+      error("Could not load repository labels. Make sure you are authenticated with `gh auth login`.");
+      process.exit(1);
+    }
+    let { valid, invalid } = validateLabels(requested, cache.labels);
+    if (invalid.length > 0) {
+      warn(`Unknown label(s) detected \u2014 resyncing label cache\u2026`);
+      const freshCache = await syncLabelCache();
+      if (freshCache) {
+        cache = freshCache;
+        const revalidated = validateLabels(requested, cache.labels);
+        valid = revalidated.valid;
+        invalid = revalidated.invalid;
+      }
+    }
+    if (invalid.length > 0) {
+      error(`Unknown label(s): ${invalid.map((l2) => import_picocolors14.default.bold(l2)).join(", ")}`);
+      console.log();
+      for (const label of invalid) {
+        const suggestions = findCloseMatches(label, cache.labels);
+        if (suggestions.length > 0) {
+          info(`  Did you mean for "${label}": ${suggestions.map((s2) => import_picocolors14.default.cyan(s2)).join(", ")}`, "");
+        }
+      }
+      console.log();
+      info(`Available labels: ${cache.labels.map((l2) => import_picocolors14.default.dim(l2.name)).join(", ")}`, "");
+      process.exit(1);
+    }
+    const targetLabel = hasIssue ? `issue #${targetNumber}` : `PR #${targetNumber}`;
+    info(`Applying ${valid.length} label(s) to ${import_picocolors14.default.bold(targetLabel)}\u2026`, "\uD83C\uDFF7\uFE0F");
+    const result = hasIssue ? await addLabelsToIssue(targetNumber, valid) : await addLabelsToPR(targetNumber, valid);
+    if (result.exitCode !== 0) {
+      const stderr = result.stderr.trim();
+      const isDrift = /not found|does not exist/i.test(stderr) || /not found|does not exist/i.test(result.stdout);
+      if (isDrift) {
+        warn("Label not found on remote \u2014 resyncing and retrying\u2026");
+        const freshCache = await syncLabelCache();
+        if (freshCache) {
+          const revalidated = validateLabels(requested, freshCache.labels);
+          if (revalidated.invalid.length === 0) {
+            const retry = hasIssue ? await addLabelsToIssue(targetNumber, revalidated.valid) : await addLabelsToPR(targetNumber, revalidated.valid);
+            if (retry.exitCode === 0) {
+              success(`Applied to ${import_picocolors14.default.bold(targetLabel)}: ${revalidated.valid.map((l2) => import_picocolors14.default.cyan(l2)).join(", ")}`);
+              return;
+            }
+            error(`Retry failed: ${retry.stderr.trim() || retry.stdout.trim()}`);
+            process.exit(1);
+          }
+        }
+      }
+      error(`Failed to apply labels: ${stderr || result.stdout.trim()}`);
+      info("Run `cn label add --help` for usage guidance.", "");
+      process.exit(1);
+    }
+    success(`Applied to ${import_picocolors14.default.bold(targetLabel)}: ${valid.map((l2) => import_picocolors14.default.cyan(l2)).join(", ")}`);
+    const sourceNote = formatSourceNote(cache.source);
+    info(sourceNote, "");
+  }
+});
+var suggestCommand = defineCommand({
+  meta: {
+    name: "suggest",
+    description: "Suggest labels for an issue or pull request based on its content"
+  },
+  args: {
+    issue: {
+      type: "string",
+      alias: "i",
+      description: "Issue number to suggest labels for"
+    },
+    pr: {
+      type: "string",
+      alias: "p",
+      description: "Pull request number to suggest labels for"
+    }
+  },
+  async run({ args }) {
+    await requireGitRepository();
+    await requireGhCli();
+    await projectHeading("label suggest", "\uD83C\uDFF7\uFE0F");
+    const hasIssue = Boolean(args.issue);
+    const hasPr = Boolean(args.pr);
+    if (!hasIssue && !hasPr) {
+      error("Provide a target: --issue <number> or --pr <number>");
+      process.exit(1);
+    }
+    if (hasIssue && hasPr) {
+      error("Use either --issue or --pr, not both.");
+      process.exit(1);
+    }
+    const targetNumber = Number(hasIssue ? args.issue : args.pr);
+    if (!Number.isInteger(targetNumber) || targetNumber <= 0) {
+      error(`Invalid ${hasIssue ? "issue" : "PR"} number: ${String(hasIssue ? args.issue : args.pr)}`);
+      process.exit(1);
+    }
+    const targetLabel = hasIssue ? `issue #${targetNumber}` : `PR #${targetNumber}`;
+    info(`Fetching ${import_picocolors14.default.bold(targetLabel)} content\u2026`, "");
+    const content = hasIssue ? await getIssueContent(targetNumber) : await getPRContent(targetNumber);
+    if (!content) {
+      error(`Could not fetch content for ${targetLabel}. Verify the number and your gh auth.`);
+      process.exit(1);
+    }
+    const fullText = `${content.title}
+
+${content.body}`;
+    const cache = await getActiveLabels();
+    if (!cache) {
+      error("Could not load repository labels. Run `cn label add --help` for setup guidance.");
+      process.exit(1);
+    }
+    const ranked = scoreLabelsForContent(fullText, cache.labels);
+    if (ranked.length === 0) {
+      info(`No label suggestions found for ${import_picocolors14.default.bold(targetLabel)}.`);
+      info(`Total labels available: ${cache.labels.length}`, "");
+      return;
+    }
+    const sourceNote = formatSourceNote(cache.source);
+    console.log();
+    console.log(`  ${import_picocolors14.default.bold(`Suggested labels for ${import_picocolors14.default.cyan(targetLabel)}:`)}  ${import_picocolors14.default.dim(sourceNote)}`);
+    console.log();
+    const topN = ranked.slice(0, 5);
+    for (const { label, score } of topN) {
+      const descPart = label.description ? import_picocolors14.default.dim(` \u2014 ${label.description}`) : "";
+      const scorePart = import_picocolors14.default.dim(` [score: ${score}]`);
+      console.log(`    ${import_picocolors14.default.cyan("\u2022")} ${import_picocolors14.default.bold(label.name)}${descPart}${scorePart}`);
+    }
+    console.log();
+    info(`Apply a label: cn label add --${hasIssue ? "issue" : "pr"} ${targetNumber} <label>`, "");
+  }
+});
+var label_default = defineCommand({
+  meta: {
+    name: "label",
+    description: "Manage labels on issues and pull requests"
+  },
+  subCommands: {
+    add: addCommand,
+    suggest: suggestCommand
+  }
+});
+
+// src/commands/log.ts
+var import_picocolors15 = __toESM(require_picocolors(), 1);
 function getDefaultOverviewRemoteCommitCount(hasLocalUnpushedCommits) {
   return hasLocalUnpushedCommits ? 10 : 20;
 }
@@ -13861,9 +14754,9 @@ var log_default = defineCommand({
     } else if (mode === "local") {
       if (!compareRef) {
         console.log();
-        console.log(import_picocolors14.default.yellow("  \u26A0 Could not determine a comparison branch."));
-        console.log(import_picocolors14.default.dim("    No upstream tracking set and no remote base branch found."));
-        console.log(import_picocolors14.default.dim(`    Use ${import_picocolors14.default.bold("cn log --full")} to see the full commit history instead.`));
+        console.log(import_picocolors15.default.yellow("  \u26A0 Could not determine a comparison branch."));
+        console.log(import_picocolors15.default.dim("    No upstream tracking set and no remote base branch found."));
+        console.log(import_picocolors15.default.dim(`    Use ${import_picocolors15.default.bold("cn log --full")} to see the full commit history instead.`));
         console.log();
         return;
       }
@@ -13882,8 +14775,8 @@ var log_default = defineCommand({
       const remoteBranch = compareRef ?? targetBranch;
       if (!remoteBranch) {
         console.log();
-        console.log(import_picocolors14.default.yellow("  \u26A0 Could not determine a remote branch to display."));
-        console.log(import_picocolors14.default.dim("    Set an upstream tracking branch or configure your base branch first."));
+        console.log(import_picocolors15.default.yellow("  \u26A0 Could not determine a remote branch to display."));
+        console.log(import_picocolors15.default.dim("    Set an upstream tracking branch or configure your base branch first."));
         console.log();
         return;
       }
@@ -13942,31 +14835,31 @@ async function getOverviewRemoteCommitCount(currentBranch, compareRef) {
 }
 function printModeHeader(mode, currentBranch, compareRef, usingFallback = false) {
   const branch = currentBranch ?? "HEAD";
-  const fallbackNote = usingFallback ? import_picocolors14.default.yellow(" (no upstream \u2014 comparing against base branch)") : "";
+  const fallbackNote = usingFallback ? import_picocolors15.default.yellow(" (no upstream \u2014 comparing against base branch)") : "";
   switch (mode) {
     case "overview":
-      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("overview")} \u2014 local unpushed commits and remote branch history for ${import_picocolors14.default.bold(branch)}`) + fallbackNote);
+      console.log(import_picocolors15.default.dim(`  mode: ${import_picocolors15.default.bold("overview")} \u2014 local unpushed commits and remote branch history for ${import_picocolors15.default.bold(branch)}`) + fallbackNote);
       if (compareRef) {
-        console.log(import_picocolors14.default.dim(`  remote source: ${import_picocolors14.default.bold(compareRef)}`));
+        console.log(import_picocolors15.default.dim(`  remote source: ${import_picocolors15.default.bold(compareRef)}`));
       }
       break;
     case "local":
-      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("local")} \u2014 unpushed commits on ${import_picocolors14.default.bold(branch)}`) + fallbackNote);
+      console.log(import_picocolors15.default.dim(`  mode: ${import_picocolors15.default.bold("local")} \u2014 unpushed commits on ${import_picocolors15.default.bold(branch)}`) + fallbackNote);
       if (compareRef) {
-        console.log(import_picocolors14.default.dim(`  comparing: ${import_picocolors14.default.bold(compareRef)} \u279C ${import_picocolors14.default.bold("HEAD")}`));
+        console.log(import_picocolors15.default.dim(`  comparing: ${import_picocolors15.default.bold(compareRef)} \u279C ${import_picocolors15.default.bold("HEAD")}`));
       }
       break;
     case "remote":
-      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("remote")} \u2014 remote branch history relevant to ${import_picocolors14.default.bold(branch)}`) + fallbackNote);
+      console.log(import_picocolors15.default.dim(`  mode: ${import_picocolors15.default.bold("remote")} \u2014 remote branch history relevant to ${import_picocolors15.default.bold(branch)}`) + fallbackNote);
       if (compareRef) {
-        console.log(import_picocolors14.default.dim(`  branch: ${import_picocolors14.default.bold(compareRef)}`));
+        console.log(import_picocolors15.default.dim(`  branch: ${import_picocolors15.default.bold(compareRef)}`));
       }
       break;
     case "full":
-      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("full")} \u2014 complete commit history for ${import_picocolors14.default.bold(branch)}`));
+      console.log(import_picocolors15.default.dim(`  mode: ${import_picocolors15.default.bold("full")} \u2014 complete commit history for ${import_picocolors15.default.bold(branch)}`));
       break;
     case "all":
-      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("all")} \u2014 commits across all branches`));
+      console.log(import_picocolors15.default.dim(`  mode: ${import_picocolors15.default.bold("all")} \u2014 commits across all branches`));
       break;
   }
 }
@@ -13990,7 +14883,7 @@ async function renderScopedLog(options) {
     }
     console.log();
     for (const entry of entries) {
-      const hashStr = import_picocolors14.default.yellow(entry.hash);
+      const hashStr = import_picocolors15.default.yellow(entry.hash);
       const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
       const subjectStr = colorizeSubject(entry.subject);
       console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
@@ -14009,10 +14902,10 @@ async function renderOverviewLog(options) {
     usingFallback
   } = options;
   console.log();
-  console.log(import_picocolors14.default.bold(import_picocolors14.default.cyan("  Local Unpushed Commits")));
+  console.log(import_picocolors15.default.bold(import_picocolors15.default.cyan("  Local Unpushed Commits")));
   if (!compareRef) {
-    console.log(import_picocolors14.default.dim("  No comparison branch detected for local commit status."));
-    console.log(import_picocolors14.default.dim("  Set an upstream tracking branch or run cn log --full to inspect the current branch history."));
+    console.log(import_picocolors15.default.dim("  No comparison branch detected for local commit status."));
+    console.log(import_picocolors15.default.dim("  Set an upstream tracking branch or run cn log --full to inspect the current branch history."));
   } else {
     await renderScopedLog({
       mode: "local",
@@ -14024,11 +14917,11 @@ async function renderOverviewLog(options) {
     });
   }
   console.log();
-  console.log(import_picocolors14.default.bold(import_picocolors14.default.cyan("  Remote Branch History")));
+  console.log(import_picocolors15.default.bold(import_picocolors15.default.cyan("  Remote Branch History")));
   if (!compareRef) {
-    console.log(import_picocolors14.default.dim("  No remote branch detected."));
+    console.log(import_picocolors15.default.dim("  No remote branch detected."));
     if (usingFallback) {
-      console.log(import_picocolors14.default.dim("  Configure your base branch or upstream tracking to enable the split view."));
+      console.log(import_picocolors15.default.dim("  Configure your base branch or upstream tracking to enable the split view."));
     }
     return;
   }
@@ -14041,15 +14934,15 @@ async function renderOverviewLog(options) {
     currentBranch
   });
   if (!hasRemoteHistory) {
-    console.log(import_picocolors14.default.dim("  No remote history found for the selected branch."));
+    console.log(import_picocolors15.default.dim("  No remote history found for the selected branch."));
   }
 }
 function printEmptyState(mode) {
   console.log();
   if (mode === "local") {
-    console.log(import_picocolors14.default.dim("  No local unpushed commits \u2014 you're up to date with remote!"));
+    console.log(import_picocolors15.default.dim("  No local unpushed commits \u2014 you're up to date with remote!"));
   } else {
-    console.log(import_picocolors14.default.dim("  No remote-only commits \u2014 your local branch is up to date!"));
+    console.log(import_picocolors15.default.dim("  No remote-only commits \u2014 your local branch is up to date!"));
   }
   console.log();
 }
@@ -14058,7 +14951,7 @@ async function renderFullLog(options) {
   if (showGraph) {
     const lines = await getLogGraph({ count, all, branch: targetBranch });
     if (lines.length === 0) {
-      console.log(import_picocolors14.default.dim("  No commits found."));
+      console.log(import_picocolors15.default.dim("  No commits found."));
       console.log();
       return false;
     }
@@ -14069,13 +14962,13 @@ async function renderFullLog(options) {
   } else {
     const entries = await getLogEntries({ count, all, branch: targetBranch });
     if (entries.length === 0) {
-      console.log(import_picocolors14.default.dim("  No commits found."));
+      console.log(import_picocolors15.default.dim("  No commits found."));
       console.log();
       return false;
     }
     console.log();
     for (const entry of entries) {
-      const hashStr = import_picocolors14.default.yellow(entry.hash);
+      const hashStr = import_picocolors15.default.yellow(entry.hash);
       const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
       const subjectStr = colorizeSubject(entry.subject);
       console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
@@ -14087,33 +14980,33 @@ function printFooter(mode, count, overviewRemoteCount, targetBranch) {
   console.log();
   switch (mode) {
     case "overview":
-      console.log(import_picocolors14.default.dim(`  Showing up to ${count} local commits and ${overviewRemoteCount} remote commits`));
+      console.log(import_picocolors15.default.dim(`  Showing up to ${count} local commits and ${overviewRemoteCount} remote commits`));
       break;
     case "local":
-      console.log(import_picocolors14.default.dim(`  Showing up to ${count} unpushed commits`));
+      console.log(import_picocolors15.default.dim(`  Showing up to ${count} unpushed commits`));
       break;
     case "remote":
-      console.log(import_picocolors14.default.dim(`  Showing ${count} most recent commits from the remote branch`));
+      console.log(import_picocolors15.default.dim(`  Showing ${count} most recent commits from the remote branch`));
       break;
     case "full":
-      console.log(import_picocolors14.default.dim(`  Showing ${count} most recent commits${targetBranch ? ` (${targetBranch})` : ""}`));
+      console.log(import_picocolors15.default.dim(`  Showing ${count} most recent commits${targetBranch ? ` (${targetBranch})` : ""}`));
       break;
     case "all":
-      console.log(import_picocolors14.default.dim(`  Showing ${count} most recent commits (all branches)`));
+      console.log(import_picocolors15.default.dim(`  Showing ${count} most recent commits (all branches)`));
       break;
   }
 }
 function colorizeGraphLine(line, protectedBranches, currentBranch) {
   const match = line.match(/^([|/\\*\s_.-]*)([a-f0-9]{7,12})(\s+\(([^)]+)\))?\s*(.*)/);
   if (!match) {
-    return import_picocolors14.default.cyan(line);
+    return import_picocolors15.default.cyan(line);
   }
   const [, graphPart = "", hash, , refs, subject = ""] = match;
   const parts = [];
   if (graphPart) {
     parts.push(colorizeGraphChars(graphPart));
   }
-  parts.push(import_picocolors14.default.yellow(hash));
+  parts.push(import_picocolors15.default.yellow(hash));
   if (refs) {
     parts.push(` (${colorizeRefs(refs, protectedBranches, currentBranch)})`);
   }
@@ -14124,15 +15017,15 @@ function colorizeGraphChars(graphPart) {
   return graphPart.split("").map((ch) => {
     switch (ch) {
       case "*":
-        return import_picocolors14.default.green(ch);
+        return import_picocolors15.default.green(ch);
       case "|":
-        return import_picocolors14.default.cyan(ch);
+        return import_picocolors15.default.cyan(ch);
       case "/":
       case "\\":
-        return import_picocolors14.default.cyan(ch);
+        return import_picocolors15.default.cyan(ch);
       case "-":
       case "_":
-        return import_picocolors14.default.cyan(ch);
+        return import_picocolors15.default.cyan(ch);
       default:
         return ch;
     }
@@ -14144,50 +15037,50 @@ function colorizeRefs(refs, protectedBranches, currentBranch) {
     if (trimmed.startsWith("HEAD ->") || trimmed === "HEAD") {
       const branchName = trimmed.replace("HEAD -> ", "");
       if (trimmed === "HEAD") {
-        return import_picocolors14.default.bold(import_picocolors14.default.cyan("HEAD"));
+        return import_picocolors15.default.bold(import_picocolors15.default.cyan("HEAD"));
       }
-      return `${import_picocolors14.default.bold(import_picocolors14.default.cyan("HEAD"))} ${import_picocolors14.default.dim("->")} ${colorizeRefName(branchName, protectedBranches, currentBranch)}`;
+      return `${import_picocolors15.default.bold(import_picocolors15.default.cyan("HEAD"))} ${import_picocolors15.default.dim("->")} ${colorizeRefName(branchName, protectedBranches, currentBranch)}`;
     }
     if (trimmed.startsWith("tag:")) {
-      return import_picocolors14.default.bold(import_picocolors14.default.magenta(trimmed));
+      return import_picocolors15.default.bold(import_picocolors15.default.magenta(trimmed));
     }
     return colorizeRefName(trimmed, protectedBranches, currentBranch);
-  }).join(import_picocolors14.default.dim(", "));
+  }).join(import_picocolors15.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_picocolors14.default.bold(import_picocolors14.default.red(name)) : import_picocolors14.default.bold(import_picocolors14.default.red(name));
+    return isRemote ? import_picocolors15.default.bold(import_picocolors15.default.red(name)) : import_picocolors15.default.bold(import_picocolors15.default.red(name));
   }
   if (localName === currentBranch) {
-    return import_picocolors14.default.bold(import_picocolors14.default.green(name));
+    return import_picocolors15.default.bold(import_picocolors15.default.green(name));
   }
   if (isRemote) {
-    return import_picocolors14.default.blue(name);
+    return import_picocolors15.default.blue(name);
   }
-  return import_picocolors14.default.green(name);
+  return import_picocolors15.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_picocolors14.default.white(rest)}`;
+    return `${emoji}${import_picocolors15.default.white(rest)}`;
   }
   if (subject.startsWith("Merge ")) {
-    return import_picocolors14.default.dim(subject);
+    return import_picocolors15.default.dim(subject);
   }
-  return import_picocolors14.default.white(subject);
+  return import_picocolors15.default.white(subject);
 }
 
 // src/commands/save.ts
 import { execFile as execFileCb4 } from "child_process";
-var import_picocolors15 = __toESM(require_picocolors(), 1);
+var import_picocolors16 = __toESM(require_picocolors(), 1);
 function gitRun(args) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     execFileCb4("git", args, (err, stdout2, stderr) => {
-      resolve5({
+      resolve6({
         exitCode: err ? err.code === "ENOENT" ? 127 : err.status ?? 1 : 0,
         stdout: stdout2 ?? "",
         stderr: stderr ?? ""
@@ -14257,8 +15150,8 @@ async function handleSave(message) {
     info("No uncommitted changes to save.");
     return;
   }
-  success(`Saved: ${import_picocolors15.default.dim(label)}`);
-  info(`Use ${import_picocolors15.default.bold("cn save --restore")} to bring them back.`, "");
+  success(`Saved: ${import_picocolors16.default.dim(label)}`);
+  info(`Use ${import_picocolors16.default.bold("cn save --restore")} to bring them back.`, "");
 }
 async function handleRestore() {
   await projectHeading("save --restore", "\uD83D\uDCBE");
@@ -14274,7 +15167,7 @@ async function handleRestore() {
       warn("You may have conflicts. Resolve them and run `git stash drop` when done.");
       process.exit(1);
     }
-    success(`Restored: ${import_picocolors15.default.dim(stashes[0].message)}`);
+    success(`Restored: ${import_picocolors16.default.dim(stashes[0].message)}`);
     return;
   }
   const choices = stashes.map((s2) => `${s2.index}  ${s2.message}`);
@@ -14287,7 +15180,7 @@ async function handleRestore() {
     process.exit(1);
   }
   const match = stashes.find((s2) => String(s2.index) === idx);
-  success(`Restored: ${import_picocolors15.default.dim(match?.message ?? "saved changes")}`);
+  success(`Restored: ${import_picocolors16.default.dim(match?.message ?? "saved changes")}`);
 }
 async function handleList() {
   await projectHeading("save --list", "\uD83D\uDCBE");
@@ -14298,13 +15191,13 @@ async function handleList() {
   }
   console.log();
   for (const s2 of stashes) {
-    const idx = import_picocolors15.default.dim(`[${s2.index}]`);
+    const idx = import_picocolors16.default.dim(`[${s2.index}]`);
     const msg = s2.message;
     console.log(`  ${idx}  ${msg}`);
   }
   console.log();
-  info(`Use ${import_picocolors15.default.bold("cn save --restore")} to bring changes back.`, "");
-  info(`Use ${import_picocolors15.default.bold("cn save --drop")} to discard saved changes.`, "");
+  info(`Use ${import_picocolors16.default.bold("cn save --restore")} to bring changes back.`, "");
+  info(`Use ${import_picocolors16.default.bold("cn save --drop")} to discard saved changes.`, "");
 }
 async function handleDrop() {
   await projectHeading("save --drop", "\uD83D\uDCBE");
@@ -14322,7 +15215,7 @@ async function handleDrop() {
     process.exit(1);
   }
   const match = stashes.find((s2) => String(s2.index) === idx);
-  success(`Dropped: ${import_picocolors15.default.dim(match?.message ?? "saved changes")}`);
+  success(`Dropped: ${import_picocolors16.default.dim(match?.message ?? "saved changes")}`);
 }
 async function getStashList() {
   const result = await gitRun(["stash", "list"]);
@@ -14339,7 +15232,8 @@ async function getStashList() {
 }
 
 // src/commands/setup.ts
-var import_picocolors16 = __toESM(require_picocolors(), 1);
+var import_picocolors17 = __toESM(require_picocolors(), 1);
+init_gh();
 async function shouldContinueSetupWithExistingConfig(options) {
   const { existingConfig, hasConfigFile, confirm, onInfo, onWarn, onSuccess, summary } = options;
   if (existingConfig) {
@@ -14362,6 +15256,43 @@ async function shouldContinueSetupWithExistingConfig(options) {
   }
   return true;
 }
+async function resolveApiKeyForSetup(options) {
+  const { providerLabel, hasStoredKey, getStoredKey, select, promptSecret } = options;
+  if (hasStoredKey) {
+    const choice = await select(`${providerLabel} API key`, [
+      "Keep existing stored key",
+      "Replace stored key"
+    ]);
+    if (choice === "Keep existing stored key") {
+      const existing = (await getStoredKey())?.trim() || "";
+      if (existing) {
+        return {
+          apiKey: existing,
+          shouldStore: false,
+          reusedStoredKey: true
+        };
+      }
+    }
+    const replacement = (await promptSecret(`Enter your ${providerLabel} API key`)).trim();
+    if (!replacement) {
+      throw new Error(`${providerLabel} API key is required when ${providerLabel} is selected.`);
+    }
+    return {
+      apiKey: replacement,
+      shouldStore: true,
+      reusedStoredKey: false
+    };
+  }
+  const initial = (await promptSecret(`Enter your ${providerLabel} API key`)).trim();
+  if (!initial) {
+    throw new Error(`${providerLabel} API key is required when ${providerLabel} is selected.`);
+  }
+  return {
+    apiKey: initial,
+    shouldStore: true,
+    reusedStoredKey: false
+  };
+}
 async function promptForOllamaCloudModel(apiKey, host = DEFAULT_OLLAMA_CLOUD_HOST) {
   try {
     info("Fetching available Ollama Cloud models...");
@@ -14448,7 +15379,7 @@ var setup_default = defineCommand({
       workflow = "github-flow";
     else if (workflowChoice.startsWith("Git Flow"))
       workflow = "git-flow";
-    info(`Workflow: ${import_picocolors16.default.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
+    info(`Workflow: ${import_picocolors17.default.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
     const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
       `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
       CONVENTION_DESCRIPTIONS.conventional,
@@ -14476,32 +15407,58 @@ var setup_default = defineCommand({
         aiProvider = "copilot";
       }
       if (aiProvider === "ollama-cloud") {
-        const apiKey = (await passwordPrompt("Enter your Ollama Cloud API key")).trim();
-        if (!apiKey) {
-          error("Ollama Cloud API key is required when Ollama Cloud is selected.");
+        let resolvedKey;
+        try {
+          resolvedKey = await resolveApiKeyForSetup({
+            providerLabel: "Ollama Cloud",
+            hasStoredKey: await hasOllamaCloudApiKey(),
+            getStoredKey: getOllamaCloudApiKey,
+            select: selectPrompt,
+            promptSecret: passwordPrompt
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          error(message);
           process.exit(1);
         }
-        aiModel = await promptForOllamaCloudModel(apiKey);
+        aiModel = await promptForOllamaCloudModel(resolvedKey.apiKey);
         try {
-          await setOllamaCloudApiKey(apiKey);
-          success("Stored Ollama Cloud API key in the local secrets store.");
-          info(`Secrets path: ${import_picocolors16.default.bold(getSecretsStorePath())}`);
+          if (resolvedKey.shouldStore) {
+            await setOllamaCloudApiKey(resolvedKey.apiKey);
+            success("Stored Ollama Cloud API key in the local secrets store.");
+            info(`Secrets path: ${import_picocolors17.default.bold(getSecretsStorePath())}`);
+          } else {
+            info("Using existing Ollama Cloud API key from the local secrets store.");
+          }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           error(`Failed to store Ollama Cloud API key: ${message}`);
           process.exit(1);
         }
       } else if (aiProvider === "openrouter") {
-        const apiKey = (await passwordPrompt("Enter your OpenRouter API key")).trim();
-        if (!apiKey) {
-          error("OpenRouter API key is required when OpenRouter is selected.");
+        let resolvedKey;
+        try {
+          resolvedKey = await resolveApiKeyForSetup({
+            providerLabel: "OpenRouter",
+            hasStoredKey: await hasOpenRouterApiKey(),
+            getStoredKey: getOpenRouterApiKey,
+            select: selectPrompt,
+            promptSecret: passwordPrompt
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          error(message);
           process.exit(1);
         }
-        aiModel = await promptForOpenRouterModel(apiKey);
+        aiModel = await promptForOpenRouterModel(resolvedKey.apiKey);
         try {
-          await setOpenRouterApiKey(apiKey);
-          success("Stored OpenRouter API key in the local secrets store.");
-          info(`Secrets path: ${import_picocolors16.default.bold(getSecretsStorePath())}`);
+          if (resolvedKey.shouldStore) {
+            await setOpenRouterApiKey(resolvedKey.apiKey);
+            success("Stored OpenRouter API key in the local secrets store.");
+            info(`Secrets path: ${import_picocolors17.default.bold(getSecretsStorePath())}`);
+          } else {
+            info("Using existing OpenRouter API key from the local secrets store.");
+          }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           error(`Failed to store OpenRouter API key: ${message}`);
@@ -14563,15 +15520,15 @@ var setup_default = defineCommand({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${import_picocolors16.default.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${import_picocolors16.default.bold(detectedRole)}. Is this correct?`);
+      info(`Detected role: ${import_picocolors17.default.bold(detectedRole)} (via ${detectionSource})`);
+      const confirmed = await confirmPrompt(`Role detected as ${import_picocolors17.default.bold(detectedRole)}. Is this correct?`);
       if (!confirmed) {
         const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
         detectedRole = roleChoice;
       }
     }
     const defaultConfig = getDefaultConfig();
-    info(import_picocolors16.default.dim("Tip: press Enter to keep the default branch name shown in each prompt."));
+    info(import_picocolors17.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} \u2014 press Enter to keep)`, mainBranchDefault);
     let devBranch;
@@ -14597,7 +15554,7 @@ var setup_default = defineCommand({
             error("Setup cannot continue without the upstream remote for contributors.");
             process.exit(1);
           }
-          success(`Added remote ${import_picocolors16.default.bold(upstreamRemote)} \u2192 ${upstreamUrl}`);
+          success(`Added remote ${import_picocolors17.default.bold(upstreamRemote)} \u2192 ${upstreamUrl}`);
         } else {
           error("An upstream remote URL is required for contributors.");
           info("Add it manually: git remote add upstream <url>", "");
@@ -14620,67 +15577,67 @@ var setup_default = defineCommand({
       showTips
     };
     writeConfig(config);
-    success(`Config written to ${import_picocolors16.default.bold(getConfigLocationLabel())}`);
+    success(`Config written to ${import_picocolors17.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_picocolors16.default.bold(syncRemote)} to verify branch configuration...`, "");
+    info(`Fetching ${import_picocolors17.default.bold(syncRemote)} to verify branch configuration...`, "");
     await fetchRemote(syncRemote);
     const mainRef = `${syncRemote}/${config.mainBranch}`;
     if (!await refExists(mainRef)) {
-      warn(`Main branch ref ${import_picocolors16.default.bold(mainRef)} not found on remote.`);
+      warn(`Main branch ref ${import_picocolors17.default.bold(mainRef)} not found on remote.`);
       warn("Config was saved \u2014 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_picocolors16.default.bold(devRef)} not found on remote.`);
+        warn(`Dev branch ref ${import_picocolors17.default.bold(devRef)} not found on remote.`);
         warn("Config was saved \u2014 verify the branch name and re-run setup if needed.");
       }
     }
     console.log();
     const resolvedAIConfig = resolveAIConfig(config);
-    info(`Workflow: ${import_picocolors16.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    info(`Convention: ${import_picocolors16.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-    info(`AI: ${import_picocolors16.default.bold(isAIEnabled(config) ? "enabled" : "disabled")}`);
+    info(`Workflow: ${import_picocolors17.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    info(`Convention: ${import_picocolors17.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+    info(`AI: ${import_picocolors17.default.bold(isAIEnabled(config) ? "enabled" : "disabled")}`);
     if (isAIEnabled(config)) {
-      info(`AI provider: ${import_picocolors16.default.bold(resolvedAIConfig.providerLabel)}`);
+      info(`AI provider: ${import_picocolors17.default.bold(resolvedAIConfig.providerLabel)}`);
       if (resolvedAIConfig.model) {
-        info(`AI model: ${import_picocolors16.default.bold(resolvedAIConfig.model)}`);
+        info(`AI model: ${import_picocolors17.default.bold(resolvedAIConfig.model)}`);
       }
     }
-    info(`Guides: ${import_picocolors16.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
-    info(`Role: ${import_picocolors16.default.bold(config.role)}`);
+    info(`Guides: ${import_picocolors17.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
+    info(`Role: ${import_picocolors17.default.bold(config.role)}`);
     if (config.devBranch) {
-      info(`Main: ${import_picocolors16.default.bold(config.mainBranch)} | Dev: ${import_picocolors16.default.bold(config.devBranch)}`);
+      info(`Main: ${import_picocolors17.default.bold(config.mainBranch)} | Dev: ${import_picocolors17.default.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${import_picocolors16.default.bold(config.mainBranch)}`);
+      info(`Main: ${import_picocolors17.default.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${import_picocolors16.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors16.default.bold(config.upstream)}` : ""}`);
+    info(`Origin: ${import_picocolors17.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors17.default.bold(config.upstream)}` : ""}`);
   }
 });
 function logConfigSummary(config) {
   const aiConfig = resolveAIConfig(config);
-  info(`Workflow: ${import_picocolors16.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-  info(`Convention: ${import_picocolors16.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-  info(`AI: ${import_picocolors16.default.bold(isAIEnabled(config) ? "enabled" : "disabled")}`);
+  info(`Workflow: ${import_picocolors17.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+  info(`Convention: ${import_picocolors17.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+  info(`AI: ${import_picocolors17.default.bold(isAIEnabled(config) ? "enabled" : "disabled")}`);
   if (isAIEnabled(config)) {
-    info(`AI provider: ${import_picocolors16.default.bold(aiConfig.providerLabel)}`);
+    info(`AI provider: ${import_picocolors17.default.bold(aiConfig.providerLabel)}`);
     if (aiConfig.model) {
-      info(`AI model: ${import_picocolors16.default.bold(aiConfig.model)}`);
+      info(`AI model: ${import_picocolors17.default.bold(aiConfig.model)}`);
     }
   }
-  info(`Guides: ${import_picocolors16.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
-  info(`Role: ${import_picocolors16.default.bold(config.role)}`);
+  info(`Guides: ${import_picocolors17.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
+  info(`Role: ${import_picocolors17.default.bold(config.role)}`);
   if (config.devBranch) {
-    info(`Main: ${import_picocolors16.default.bold(config.mainBranch)} | Dev: ${import_picocolors16.default.bold(config.devBranch)}`);
+    info(`Main: ${import_picocolors17.default.bold(config.mainBranch)} | Dev: ${import_picocolors17.default.bold(config.devBranch)}`);
   } else {
-    info(`Main: ${import_picocolors16.default.bold(config.mainBranch)}`);
+    info(`Main: ${import_picocolors17.default.bold(config.mainBranch)}`);
   }
-  info(`Origin: ${import_picocolors16.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors16.default.bold(config.upstream)}` : ""}`);
+  info(`Origin: ${import_picocolors17.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors17.default.bold(config.upstream)}` : ""}`);
 }
 
 // src/commands/start.ts
-var import_picocolors17 = __toESM(require_picocolors(), 1);
+var import_picocolors18 = __toESM(require_picocolors(), 1);
 var start_default = defineCommand({
   meta: {
     name: "start",
@@ -14732,16 +15689,16 @@ var start_default = defineCommand({
       warn("Start cancelled.");
       process.exit(0);
     }
-    info(`Creating branch: ${import_picocolors17.default.bold(branchName)}`);
+    info(`Creating branch: ${import_picocolors18.default.bold(branchName)}`);
     await fetchRemote(syncSource.remote);
     if (!await refExists(syncSource.ref)) {
-      warn(`Remote ref ${import_picocolors17.default.bold(syncSource.ref)} not found. Creating branch from local ${import_picocolors17.default.bold(baseBranch)}.`);
+      warn(`Remote ref ${import_picocolors18.default.bold(syncSource.ref)} not found. Creating branch from local ${import_picocolors18.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_picocolors17.default.bold(baseBranch)} with ${import_picocolors17.default.bold(String(ahead))} local commit${ahead > 1 ? "s" : ""} not in ${import_picocolors17.default.bold(syncSource.ref)}.`);
+        warn(`You are on ${import_picocolors18.default.bold(baseBranch)} with ${import_picocolors18.default.bold(String(ahead))} local commit${ahead > 1 ? "s" : ""} not in ${import_picocolors18.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) {
@@ -14758,10 +15715,10 @@ var start_default = defineCommand({
           error(`Failed to create branch: ${result2.stderr}`);
           process.exit(1);
         }
-        success(`Created ${import_picocolors17.default.bold(branchName)} from ${import_picocolors17.default.bold(syncSource.ref)}`);
+        success(`Created ${import_picocolors18.default.bold(branchName)} from ${import_picocolors18.default.bold(syncSource.ref)}`);
         return;
       }
-      error(`Failed to update ${import_picocolors17.default.bold(baseBranch)}: ${updateResult.stderr}`);
+      error(`Failed to update ${import_picocolors18.default.bold(baseBranch)}: ${updateResult.stderr}`);
       info("Make sure your base branch exists locally or the remote ref is available.", "");
       process.exit(1);
     }
@@ -14770,12 +15727,13 @@ var start_default = defineCommand({
       error(`Failed to create branch: ${result.stderr}`);
       process.exit(1);
     }
-    success(`Created ${import_picocolors17.default.bold(branchName)} from latest ${import_picocolors17.default.bold(baseBranch)}`);
+    success(`Created ${import_picocolors18.default.bold(branchName)} from latest ${import_picocolors18.default.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-var import_picocolors18 = __toESM(require_picocolors(), 1);
+var import_picocolors19 = __toESM(require_picocolors(), 1);
+init_gh();
 var status_default = defineCommand({
   meta: {
     name: "status",
@@ -14792,8 +15750,8 @@ var status_default = defineCommand({
       process.exit(1);
     }
     await projectHeading("status", "\uD83D\uDCCA");
-    console.log(`  ${import_picocolors18.default.dim("Workflow:")} ${import_picocolors18.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    console.log(`  ${import_picocolors18.default.dim("Role:")} ${import_picocolors18.default.bold(config.role)}`);
+    console.log(`  ${import_picocolors19.default.dim("Workflow:")} ${import_picocolors19.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+    console.log(`  ${import_picocolors19.default.dim("Role:")} ${import_picocolors19.default.bold(config.role)}`);
     console.log();
     await fetchAll();
     const currentBranch = await getCurrentBranch();
@@ -14802,7 +15760,7 @@ var status_default = defineCommand({
     const isContributor = config.role === "contributor";
     const [dirty, fileStatus] = await Promise.all([hasUncommittedChanges(), getFileStatus()]);
     if (dirty) {
-      console.log(`  ${import_picocolors18.default.yellow("\u26A0")}  ${import_picocolors18.default.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${import_picocolors19.default.yellow("\u26A0")}  ${import_picocolors19.default.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -14821,16 +15779,16 @@ 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_picocolors18.default.dim(` (current ${import_picocolors18.default.green("*")})`));
+      console.log(branchLine + import_picocolors19.default.dim(` (current ${import_picocolors19.default.green("*")})`));
       branchStatus = await detectBranchStatus(currentBranch, baseBranch);
       if (branchStatus.merged) {
-        console.log(`  ${import_picocolors18.default.green("\u2713")}  ${import_picocolors18.default.green("Branch merged")} \u2014 ${import_picocolors18.default.dim(branchStatus.mergedReason ?? "all commits reachable from base")}`);
+        console.log(`  ${import_picocolors19.default.green("\u2713")}  ${import_picocolors19.default.green("Branch merged")} \u2014 ${import_picocolors19.default.dim(branchStatus.mergedReason ?? "all commits reachable from base")}`);
       }
       if (branchStatus.stale) {
-        console.log(`  ${import_picocolors18.default.yellow("\u23F3")}  ${import_picocolors18.default.yellow("Branch is stale")} \u2014 ${import_picocolors18.default.dim(`last commit ${branchStatus.staleDaysAgo} days ago`)}`);
+        console.log(`  ${import_picocolors19.default.yellow("\u23F3")}  ${import_picocolors19.default.yellow("Branch is stale")} \u2014 ${import_picocolors19.default.dim(`last commit ${branchStatus.staleDaysAgo} days ago`)}`);
       }
     } else if (currentBranch) {
-      console.log(import_picocolors18.default.dim(`  (on ${import_picocolors18.default.bold(currentBranch)} branch)`));
+      console.log(import_picocolors19.default.dim(`  (on ${import_picocolors19.default.bold(currentBranch)} branch)`));
     }
     let branchesAligned = true;
     {
@@ -14867,20 +15825,20 @@ var status_default = defineCommand({
         }
         branchesAligned = groups.size === 1;
         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(" \xB7 "));
-          console.log(`     ${import_picocolors18.default.yellow(short)} ${import_picocolors18.default.dim("\u2500\u2500")} ${nameStr}`);
+          const nameStr = names.map((n2) => import_picocolors19.default.bold(n2)).join(import_picocolors19.default.dim(" \xB7 "));
+          console.log(`     ${import_picocolors19.default.yellow(short)} ${import_picocolors19.default.dim("\u2500\u2500")} ${nameStr}`);
           const subject = await getCommitSubject(hash);
           if (subject) {
-            console.log(`                ${import_picocolors18.default.dim(subject)}`);
+            console.log(`                ${import_picocolors19.default.dim(subject)}`);
           }
         }
         if (branchesAligned) {
-          console.log(`     ${import_picocolors18.default.green("\u2713")} ${import_picocolors18.default.green("All branches aligned")} ${import_picocolors18.default.dim("\u2014 ready to start")}`);
+          console.log(`     ${import_picocolors19.default.green("\u2713")} ${import_picocolors19.default.green("All branches aligned")} ${import_picocolors19.default.dim("\u2014 ready to start")}`);
         } else {
-          console.log(`     ${import_picocolors18.default.yellow("\u26A0")} ${import_picocolors18.default.yellow("Branches are not fully aligned")}`);
+          console.log(`     ${import_picocolors19.default.yellow("\u26A0")} ${import_picocolors19.default.yellow("Branches are not fully aligned")}`);
         }
       }
     }
@@ -14888,41 +15846,41 @@ var status_default = defineCommand({
     if (hasFiles) {
       console.log();
       if (fileStatus.staged.length > 0) {
-        console.log(`  ${import_picocolors18.default.green("Staged for commit:")}`);
+        console.log(`  ${import_picocolors19.default.green("Staged for commit:")}`);
         for (const { file, status } of fileStatus.staged) {
-          console.log(`    ${import_picocolors18.default.green("+")} ${import_picocolors18.default.dim(`${status}:`)} ${file}`);
+          console.log(`    ${import_picocolors19.default.green("+")} ${import_picocolors19.default.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.modified.length > 0) {
-        console.log(`  ${import_picocolors18.default.yellow("Unstaged changes:")}`);
+        console.log(`  ${import_picocolors19.default.yellow("Unstaged changes:")}`);
         for (const { file, status } of fileStatus.modified) {
-          console.log(`    ${import_picocolors18.default.yellow("~")} ${import_picocolors18.default.dim(`${status}:`)} ${file}`);
+          console.log(`    ${import_picocolors19.default.yellow("~")} ${import_picocolors19.default.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.untracked.length > 0) {
-        console.log(`  ${import_picocolors18.default.red("Untracked files:")}`);
+        console.log(`  ${import_picocolors19.default.red("Untracked files:")}`);
         for (const file of fileStatus.untracked) {
-          console.log(`    ${import_picocolors18.default.red("?")} ${file}`);
+          console.log(`    ${import_picocolors19.default.red("?")} ${file}`);
         }
       }
     } else if (!dirty) {
-      console.log(`  ${import_picocolors18.default.green("\u2713")}  ${import_picocolors18.default.dim("Working tree clean")}`);
+      console.log(`  ${import_picocolors19.default.green("\u2713")}  ${import_picocolors19.default.dim("Working tree clean")}`);
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = import_picocolors18.default.bold(branch.padEnd(20));
+  const label = import_picocolors19.default.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${import_picocolors18.default.green("\u2713")}  ${label} ${import_picocolors18.default.dim(`in sync with ${base}`)}`;
+    return `  ${import_picocolors19.default.green("\u2713")}  ${label} ${import_picocolors19.default.dim(`in sync with ${base}`)}`;
   }
   if (ahead > 0 && behind === 0) {
-    return `  ${import_picocolors18.default.yellow("\u2191")}  ${label} ${import_picocolors18.default.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+    return `  ${import_picocolors19.default.yellow("\u2191")}  ${label} ${import_picocolors19.default.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
   }
   if (behind > 0 && ahead === 0) {
-    return `  ${import_picocolors18.default.red("\u2193")}  ${label} ${import_picocolors18.default.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+    return `  ${import_picocolors19.default.red("\u2193")}  ${label} ${import_picocolors19.default.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
   }
-  return `  ${import_picocolors18.default.red("\u26A1")}  ${label} ${import_picocolors18.default.yellow(`${ahead} ahead`)}${import_picocolors18.default.dim(", ")}${import_picocolors18.default.red(`${behind} behind`)} ${import_picocolors18.default.dim(base)}`;
+  return `  ${import_picocolors19.default.red("\u26A1")}  ${label} ${import_picocolors19.default.yellow(`${ahead} ahead`)}${import_picocolors19.default.dim(", ")}${import_picocolors19.default.red(`${behind} behind`)} ${import_picocolors19.default.dim(base)}`;
 }
 var STALE_THRESHOLD_DAYS = 14;
 async function detectBranchStatus(branch, baseBranch) {
@@ -14973,15 +15931,16 @@ async function detectBranchStatus(branch, baseBranch) {
 }
 
 // src/commands/submit.ts
-var import_picocolors19 = __toESM(require_picocolors(), 1);
+var import_picocolors20 = __toESM(require_picocolors(), 1);
+init_gh();
 async function performSquashMerge(origin, baseBranch, featureBranch, options) {
-  info(`Checking out ${import_picocolors19.default.bold(baseBranch)}...`);
+  info(`Checking out ${import_picocolors20.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_picocolors19.default.bold(featureBranch)} into ${import_picocolors19.default.bold(baseBranch)}...`);
+  info(`Squash merging ${import_picocolors20.default.bold(featureBranch)} into ${import_picocolors20.default.bold(baseBranch)}...`);
   const mergeResult = await mergeSquash(featureBranch);
   if (mergeResult.exitCode !== 0) {
     error(`Squash merge failed: ${mergeResult.stderr}`);
@@ -15001,7 +15960,7 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
           message = aiMsg;
           spinner.success("AI commit message generated.");
           console.log(`
-  ${import_picocolors19.default.dim("AI suggestion:")} ${import_picocolors19.default.bold(import_picocolors19.default.cyan(message))}`);
+  ${import_picocolors20.default.dim("AI suggestion:")} ${import_picocolors20.default.bold(import_picocolors20.default.cyan(message))}`);
           break;
         }
         spinner.fail("AI did not return a commit message.");
@@ -15041,7 +16000,7 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
           message = regen;
           spinner.success("Commit message regenerated.");
           console.log(`
-  ${import_picocolors19.default.dim("AI suggestion:")} ${import_picocolors19.default.bold(import_picocolors19.default.cyan(regen))}`);
+  ${import_picocolors20.default.dim("AI suggestion:")} ${import_picocolors20.default.bold(import_picocolors20.default.cyan(regen))}`);
         } else {
           spinner.fail("Regeneration failed.");
         }
@@ -15057,13 +16016,13 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
     error(`Commit failed: ${commitResult.stderr}`);
     process.exit(1);
   }
-  info(`Pushing ${import_picocolors19.default.bold(baseBranch)} to ${origin}...`);
+  info(`Pushing ${import_picocolors20.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_picocolors19.default.bold(featureBranch)}...`);
+  info(`Deleting local branch ${import_picocolors20.default.bold(featureBranch)}...`);
   const delLocal = await forceDeleteBranch(featureBranch);
   if (delLocal.exitCode !== 0) {
     warn(`Could not delete local branch: ${delLocal.stderr.trim()}`);
@@ -15071,14 +16030,14 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
   const remoteBranchRef = `${origin}/${featureBranch}`;
   const remoteExists = await branchExists(remoteBranchRef);
   if (remoteExists) {
-    info(`Deleting remote branch ${import_picocolors19.default.bold(featureBranch)}...`);
+    info(`Deleting remote branch ${import_picocolors20.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_picocolors19.default.bold(featureBranch)} into ${import_picocolors19.default.bold(baseBranch)} and pushed.`);
-  info(`Run ${import_picocolors19.default.bold("cn start")} to begin a new feature.`, "");
+  success(`Squash merged ${import_picocolors20.default.bold(featureBranch)} into ${import_picocolors20.default.bold(baseBranch)} and pushed.`);
+  info(`Run ${import_picocolors20.default.bold("cn start")} to begin a new feature.`, "");
 }
 var submit_default = defineCommand({
   meta: {
@@ -15135,7 +16094,7 @@ var submit_default = defineCommand({
     }
     if (protectedBranches.includes(currentBranch)) {
       await projectHeading("submit", "\uD83D\uDE80");
-      warn(`You're on ${import_picocolors19.default.bold(currentBranch)}, which is a protected branch. PRs should come from feature branches.`);
+      warn(`You're on ${import_picocolors20.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);
@@ -15144,11 +16103,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_picocolors19.default.bold("cn start")} to create a new feature branch.`, "");
+        info(`  Run ${import_picocolors20.default.bold("cn start")} to create a new 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.");
@@ -15178,12 +16137,12 @@ var submit_default = defineCommand({
         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)} \u2014 no damage done.`, "");
+      info(`Reset ${import_picocolors20.default.bold(currentBranch)} back to ${import_picocolors20.default.bold(remoteRef)} \u2014 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("cn submit")} again to push and create your PR.`, "");
+      success(`You're now on ${import_picocolors20.default.bold(newBranchName)} with all your work intact.`);
+      info(`Run ${import_picocolors20.default.bold("cn submit")} again to push and create your PR.`, "");
       return;
     }
     await projectHeading("submit", "\uD83D\uDE80");
@@ -15192,7 +16151,7 @@ var submit_default = defineCommand({
     if (ghInstalled && ghAuthed) {
       const mergedPR = await getMergedPRForBranch(currentBranch);
       if (mergedPR) {
-        warn(`PR #${mergedPR.number} (${import_picocolors19.default.bold(mergedPR.title)}) was already merged.`);
+        warn(`PR #${mergedPR.number} (${import_picocolors20.default.bold(mergedPR.title)}) was already merged.`);
         const localWork = await hasLocalWork(origin, currentBranch);
         const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
         if (hasWork) {
@@ -15200,7 +16159,7 @@ var submit_default = defineCommand({
             warn("You have uncommitted changes in your working tree.");
           }
           if (localWork.unpushedCommits > 0) {
-            warn(`You have ${import_picocolors19.default.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not in the merged PR.`);
+            warn(`You have ${import_picocolors20.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";
@@ -15227,10 +16186,10 @@ var submit_default = defineCommand({
               error(`Failed to rename branch: ${renameResult.stderr}`);
               process.exit(1);
             }
-            success(`Renamed ${import_picocolors19.default.bold(currentBranch)} \u2192 ${import_picocolors19.default.bold(newBranchName)}`);
+            success(`Renamed ${import_picocolors20.default.bold(currentBranch)} \u2192 ${import_picocolors20.default.bold(newBranchName)}`);
             await unsetUpstream();
             const syncSource2 = getSyncSource(config);
-            info(`Syncing ${import_picocolors19.default.bold(newBranchName)} with latest ${import_picocolors19.default.bold(baseBranch)}...`);
+            info(`Syncing ${import_picocolors20.default.bold(newBranchName)} with latest ${import_picocolors20.default.bold(baseBranch)}...`);
             await fetchRemote(syncSource2.remote);
             let rebaseResult;
             if (staleUpstreamHash) {
@@ -15241,17 +16200,17 @@ var submit_default = defineCommand({
             }
             if (rebaseResult.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(syncSource2.ref)}.`);
+              success(`Rebased ${import_picocolors20.default.bold(newBranchName)} onto ${import_picocolors20.default.bold(syncSource2.ref)}.`);
             }
-            info(`All your changes are preserved. Run ${import_picocolors19.default.bold("cn submit")} when ready to create a new PR.`, "");
+            info(`All your changes are preserved. Run ${import_picocolors20.default.bold("cn submit")} when ready to create a new PR.`, "");
             return;
           }
           warn("Discarding local changes...");
         }
         const syncSource = getSyncSource(config);
-        info(`Switching to ${import_picocolors19.default.bold(baseBranch)} and syncing...`);
+        info(`Switching to ${import_picocolors20.default.bold(baseBranch)} and syncing...`);
         await fetchRemote(syncSource.remote);
         await resetHard("HEAD");
         const coResult = await checkoutBranch(baseBranch);
@@ -15260,23 +16219,23 @@ var submit_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)}...`);
         const delResult = await forceDeleteBranch(currentBranch);
         if (delResult.exitCode === 0) {
-          success(`Deleted ${import_picocolors19.default.bold(currentBranch)}.`);
+          success(`Deleted ${import_picocolors20.default.bold(currentBranch)}.`);
         } else {
           warn(`Could not delete branch: ${delResult.stderr.trim()}`);
         }
         console.log();
-        info(`You're now on ${import_picocolors19.default.bold(baseBranch)}. Run ${import_picocolors19.default.bold("cn start")} to begin a new feature.`);
+        info(`You're now on ${import_picocolors20.default.bold(baseBranch)}. Run ${import_picocolors20.default.bold("cn start")} to begin a new feature.`);
         return;
       }
     }
     if (ghInstalled && ghAuthed) {
       const existingPR = await getPRForBranch(currentBranch);
       if (existingPR) {
-        info(`Pushing ${import_picocolors19.default.bold(currentBranch)} to ${origin}...`);
+        info(`Pushing ${import_picocolors20.default.bold(currentBranch)} to ${origin}...`);
         const pushResult2 = await pushSetUpstream(origin, currentBranch);
         if (pushResult2.exitCode !== 0) {
           error(`Failed to push: ${pushResult2.stderr}`);
@@ -15287,8 +16246,8 @@ var submit_default = defineCommand({
           }
           process.exit(1);
         }
-        success(`Pushed changes to existing PR #${existingPR.number}: ${import_picocolors19.default.bold(existingPR.title)}`);
-        console.log(`  ${import_picocolors19.default.cyan(existingPR.url)}`);
+        success(`Pushed changes to existing PR #${existingPR.number}: ${import_picocolors20.default.bold(existingPR.title)}`);
+        console.log(`  ${import_picocolors20.default.cyan(existingPR.url)}`);
         return;
       }
     }
@@ -15310,10 +16269,10 @@ var submit_default = defineCommand({
           prBody = result.body;
           spinner.success("PR description generated.");
           console.log(`
-  ${import_picocolors19.default.dim("AI title:")} ${import_picocolors19.default.bold(import_picocolors19.default.cyan(prTitle))}`);
+  ${import_picocolors20.default.dim("AI title:")} ${import_picocolors20.default.bold(import_picocolors20.default.cyan(prTitle))}`);
           console.log(`
-${import_picocolors19.default.dim("AI body preview:")}`);
-          console.log(import_picocolors19.default.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+${import_picocolors20.default.dim("AI body preview:")}`);
+          console.log(import_picocolors20.default.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
         } else {
           spinner.fail("AI did not return a PR description.");
         }
@@ -15424,7 +16383,7 @@ ${import_picocolors19.default.dim("AI body preview:")}`);
       warn("Submit cancelled.");
       return;
     }
-    info(`Pushing ${import_picocolors19.default.bold(currentBranch)} to ${origin}...`);
+    info(`Pushing ${import_picocolors20.default.bold(currentBranch)} to ${origin}...`);
     const pushResult = await pushSetUpstream(origin, currentBranch);
     if (pushResult.exitCode !== 0) {
       error(`Failed to push: ${pushResult.stderr}`);
@@ -15443,7 +16402,7 @@ ${import_picocolors19.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_picocolors19.default.cyan(prUrl)}`);
+        console.log(`  ${import_picocolors20.default.cyan(prUrl)}`);
       } else {
         info("gh CLI not available. Create your PR manually on GitHub.", "");
       }
@@ -15477,7 +16436,7 @@ ${import_picocolors19.default.dim("AI body preview:")}`);
 });
 
 // src/commands/switch.ts
-var import_picocolors20 = __toESM(require_picocolors(), 1);
+var import_picocolors21 = __toESM(require_picocolors(), 1);
 var switch_default = defineCommand({
   meta: {
     name: "switch",
@@ -15509,11 +16468,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_picocolors20.default.red("protected"));
+          labels.push(import_picocolors21.default.red("protected"));
         if (b2.upstream)
-          labels.push(import_picocolors20.default.dim(`\u2192 ${b2.upstream}`));
+          labels.push(import_picocolors21.default.dim(`\u2192 ${b2.upstream}`));
         if (b2.gone)
-          labels.push(import_picocolors20.default.red("remote gone"));
+          labels.push(import_picocolors21.default.red("remote gone"));
         const suffix = labels.length > 0 ? `  ${labels.join(" \xB7 ")}` : "";
         return `${b2.name}${suffix}`;
       });
@@ -15525,7 +16484,7 @@ var switch_default = defineCommand({
       targetBranch = selected.split(/\s{2,}/)[0].trim();
     }
     if (targetBranch === currentBranch) {
-      info(`Already on ${import_picocolors20.default.bold(targetBranch)}.`);
+      info(`Already on ${import_picocolors21.default.bold(targetBranch)}.`);
       return;
     }
     if (await hasUncommittedChanges()) {
@@ -15544,7 +16503,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_picocolors20.default.dim(stashMsg)}`);
+        info(`Saved changes: ${import_picocolors21.default.dim(stashMsg)}`);
       } catch {
         error("Failed to save changes. Please commit or save manually.");
         process.exit(1);
@@ -15560,9 +16519,9 @@ var switch_default = defineCommand({
         }
         process.exit(1);
       }
-      success(`Switched to ${import_picocolors20.default.bold(targetBranch)}`);
-      info(`Your changes from ${import_picocolors20.default.bold(currentBranch ?? "previous branch")} are saved.`, "");
-      info(`Use ${import_picocolors20.default.bold("cn save --restore")} to bring them back.`, "");
+      success(`Switched to ${import_picocolors21.default.bold(targetBranch)}`);
+      info(`Your changes from ${import_picocolors21.default.bold(currentBranch ?? "previous branch")} are saved.`, "");
+      info(`Use ${import_picocolors21.default.bold("cn save --restore")} to bring them back.`, "");
       return;
     }
     const result = await checkoutBranch(targetBranch);
@@ -15570,12 +16529,12 @@ var switch_default = defineCommand({
       error(`Failed to switch to ${targetBranch}: ${result.stderr}`);
       process.exit(1);
     }
-    success(`Switched to ${import_picocolors20.default.bold(targetBranch)}`);
+    success(`Switched to ${import_picocolors21.default.bold(targetBranch)}`);
   }
 });
 
 // src/commands/sync.ts
-var import_picocolors21 = __toESM(require_picocolors(), 1);
+var import_picocolors22 = __toESM(require_picocolors(), 1);
 var sync_default = defineCommand({
   meta: {
     name: "sync",
@@ -15627,24 +16586,24 @@ var sync_default = defineCommand({
       await fetchRemote(origin);
     }
     if (!await refExists(syncSource.ref)) {
-      error(`Remote ref ${import_picocolors21.default.bold(syncSource.ref)} does not exist.`);
+      error(`Remote ref ${import_picocolors22.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_picocolors21.default.bold("cn setup")}.`, "");
+      info(`Check your config: the base branch may need updating via ${import_picocolors22.default.bold("cn setup")}.`, "");
       process.exit(1);
     }
     let allowMergeCommit = false;
     const div = await getDivergence(baseBranch, syncSource.ref);
     if (div.ahead > 0 || div.behind > 0) {
-      info(`${import_picocolors21.default.bold(baseBranch)} is ${import_picocolors21.default.yellow(`${div.ahead} ahead`)} and ${import_picocolors21.default.red(`${div.behind} behind`)} ${syncSource.ref}`);
+      info(`${import_picocolors22.default.bold(baseBranch)} is ${import_picocolors22.default.yellow(`${div.ahead} ahead`)} and ${import_picocolors22.default.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`${import_picocolors21.default.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+      info(`${import_picocolors22.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_picocolors21.default.bold(String(div.ahead))} local commit${div.ahead !== 1 ? "s" : ""} on ${import_picocolors21.default.bold(baseBranch)} that aren't on the remote.`);
+        warn(`You have ${import_picocolors22.default.bold(String(div.ahead))} local commit${div.ahead !== 1 ? "s" : ""} on ${import_picocolors22.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";
@@ -15674,7 +16633,7 @@ var sync_default = defineCommand({
             error(`Failed to create branch: ${branchResult.stderr}`);
             process.exit(1);
           }
-          success(`Created ${import_picocolors21.default.bold(newBranchName)} with your commits.`);
+          success(`Created ${import_picocolors22.default.bold(newBranchName)} with your commits.`);
           const coResult2 = await checkoutBranch(baseBranch);
           if (coResult2.exitCode !== 0) {
             error(`Failed to checkout ${baseBranch}: ${coResult2.stderr}`);
@@ -15682,11 +16641,11 @@ var sync_default = defineCommand({
           }
           const remoteRef = syncSource.ref;
           await updateLocalBranch(baseBranch, remoteRef);
-          success(`Reset ${import_picocolors21.default.bold(baseBranch)} to ${import_picocolors21.default.bold(remoteRef)}.`);
-          success(`${import_picocolors21.default.bold(baseBranch)} is now in sync with ${syncSource.ref}`);
+          success(`Reset ${import_picocolors22.default.bold(baseBranch)} to ${import_picocolors22.default.bold(remoteRef)}.`);
+          success(`${import_picocolors22.default.bold(baseBranch)} is now in sync with ${syncSource.ref}`);
           console.log();
-          info(`Your commits are safe on ${import_picocolors21.default.bold(newBranchName)}.`, "");
-          info(`Run ${import_picocolors21.default.bold(`git checkout ${newBranchName}`)} then ${import_picocolors21.default.bold("cn update")} to rebase onto the synced ${import_picocolors21.default.bold(baseBranch)}.`, "");
+          info(`Your commits are safe on ${import_picocolors22.default.bold(newBranchName)}.`, "");
+          info(`Run ${import_picocolors22.default.bold(`git checkout ${newBranchName}`)} then ${import_picocolors22.default.bold("cn update")} to rebase onto the synced ${import_picocolors22.default.bold(baseBranch)}.`, "");
           return;
         }
         allowMergeCommit = true;
@@ -15694,7 +16653,7 @@ var sync_default = defineCommand({
       }
     }
     if (!args.yes) {
-      const ok = await confirmPrompt(`This will pull ${import_picocolors21.default.bold(syncSource.ref)} into local ${import_picocolors21.default.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${import_picocolors22.default.bold(syncSource.ref)} into local ${import_picocolors22.default.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
@@ -15708,8 +16667,8 @@ var sync_default = defineCommand({
       if (allowMergeCommit) {
         error(`Pull failed: ${pullResult.stderr.trim()}`);
       } else {
-        error(`Fast-forward pull failed. Your local ${import_picocolors21.default.bold(baseBranch)} may have diverged.`);
-        info(`Use ${import_picocolors21.default.bold("cn sync")} again and choose "Move my commits to a new feature branch" to fix this.`, "");
+        error(`Fast-forward pull failed. Your local ${import_picocolors22.default.bold(baseBranch)} may have diverged.`);
+        info(`Use ${import_picocolors22.default.bold("cn sync")} again and choose "Move my commits to a new feature branch" to fix this.`, "");
       }
       process.exit(1);
     }
@@ -15717,7 +16676,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_picocolors21.default.bold(config.mainBranch)}...`);
+        info(`Also syncing ${import_picocolors22.default.bold(config.mainBranch)}...`);
         const mainCoResult = await checkoutBranch(config.mainBranch);
         if (mainCoResult.exitCode === 0) {
           const mainPullResult = await pullFastForwardOnly(origin, config.mainBranch);
@@ -15758,20 +16717,20 @@ var sync_default = defineCommand({
           }
         }
         console.log();
-        console.log(`  ${import_picocolors21.default.bold("\uD83D\uDD17 Branch Alignment")}`);
+        console.log(`  ${import_picocolors22.default.bold("\uD83D\uDD17 Branch Alignment")}`);
         for (const [hash, names] of groups) {
           const short = hash.slice(0, 7);
-          const nameStr = names.map((n2) => import_picocolors21.default.bold(n2)).join(import_picocolors21.default.dim(" \xB7 "));
-          console.log(`     ${import_picocolors21.default.yellow(short)} ${import_picocolors21.default.dim("\u2500\u2500")} ${nameStr}`);
+          const nameStr = names.map((n2) => import_picocolors22.default.bold(n2)).join(import_picocolors22.default.dim(" \xB7 "));
+          console.log(`     ${import_picocolors22.default.yellow(short)} ${import_picocolors22.default.dim("\u2500\u2500")} ${nameStr}`);
           const subject = await getCommitSubject(hash);
           if (subject) {
-            console.log(`                ${import_picocolors21.default.dim(subject)}`);
+            console.log(`                ${import_picocolors22.default.dim(subject)}`);
           }
         }
         if (groups.size === 1) {
-          console.log(`     ${import_picocolors21.default.green("\u2713")} ${import_picocolors21.default.green("All branches aligned")} ${import_picocolors21.default.dim("\u2014 ready to start")}`);
+          console.log(`     ${import_picocolors22.default.green("\u2713")} ${import_picocolors22.default.green("All branches aligned")} ${import_picocolors22.default.dim("\u2014 ready to start")}`);
         } else {
-          console.log(`     ${import_picocolors21.default.yellow("\u26A0")} ${import_picocolors21.default.yellow("Branches are not fully aligned")}`);
+          console.log(`     ${import_picocolors22.default.yellow("\u26A0")} ${import_picocolors22.default.yellow("Branches are not fully aligned")}`);
         }
       }
     }
@@ -15779,8 +16738,9 @@ var sync_default = defineCommand({
 });
 
 // src/commands/update.ts
-import { readFileSync as readFileSync6 } from "fs";
-var import_picocolors22 = __toESM(require_picocolors(), 1);
+import { readFileSync as readFileSync7 } from "fs";
+var import_picocolors23 = __toESM(require_picocolors(), 1);
+init_gh();
 function hasStaleBranchWorkToPreserve(uniqueCommitsAheadOfBase, hasUncommittedChanges2) {
   return hasUncommittedChanges2 || uniqueCommitsAheadOfBase > 0;
 }
@@ -15821,7 +16781,7 @@ var update_default = defineCommand({
     }
     if (protectedBranches.includes(currentBranch)) {
       await projectHeading("update", "\uD83D\uDD03");
-      warn(`You're on ${import_picocolors22.default.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
+      warn(`You're on ${import_picocolors23.default.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
       await fetchAll();
       const { origin } = config;
       const remoteRef = `${origin}/${currentBranch}`;
@@ -15830,12 +16790,12 @@ var update_default = defineCommand({
       const hasCommits = localWork.unpushedCommits > 0;
       const hasAnything = hasCommits || dirty;
       if (!hasAnything) {
-        info(`No local changes found on ${import_picocolors22.default.bold(currentBranch)}.`);
-        info(`Use ${import_picocolors22.default.bold("cn sync")} to sync protected branches, or ${import_picocolors22.default.bold("cn start")} to create a feature branch.`);
+        info(`No local changes found on ${import_picocolors23.default.bold(currentBranch)}.`);
+        info(`Use ${import_picocolors23.default.bold("cn sync")} to sync protected branches, or ${import_picocolors23.default.bold("cn start")} to create a feature branch.`);
         process.exit(1);
       }
       if (hasCommits) {
-        info(`Found ${import_picocolors22.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors22.default.bold(currentBranch)}.`);
+        info(`Found ${import_picocolors23.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors23.default.bold(currentBranch)}.`);
       }
       if (dirty) {
         info("You also have uncommitted changes in the working tree.");
@@ -15865,12 +16825,12 @@ var update_default = defineCommand({
         error(`Failed to create branch: ${branchResult.stderr}`);
         process.exit(1);
       }
-      success(`Created ${import_picocolors22.default.bold(newBranchName)} with your changes.`);
+      success(`Created ${import_picocolors23.default.bold(newBranchName)} with your changes.`);
       await updateLocalBranch(currentBranch, remoteRef);
-      info(`Reset ${import_picocolors22.default.bold(currentBranch)} back to ${import_picocolors22.default.bold(remoteRef)} \u2014 no damage done.`, "");
+      info(`Reset ${import_picocolors23.default.bold(currentBranch)} back to ${import_picocolors23.default.bold(remoteRef)} \u2014 no damage done.`, "");
       console.log();
-      success(`You're now on ${import_picocolors22.default.bold(newBranchName)} with all your work intact.`);
-      info(`Run ${import_picocolors22.default.bold("cn update")} again to rebase onto latest ${import_picocolors22.default.bold(baseBranch)}.`, "");
+      success(`You're now on ${import_picocolors23.default.bold(newBranchName)} with all your work intact.`);
+      info(`Run ${import_picocolors23.default.bold("cn update")} again to rebase onto latest ${import_picocolors23.default.bold(baseBranch)}.`, "");
       return;
     }
     if (await hasUncommittedChanges()) {
@@ -15880,8 +16840,8 @@ var update_default = defineCommand({
     await projectHeading("update", "\uD83D\uDD03");
     const mergedPR = await getMergedPRForBranch(currentBranch);
     if (mergedPR) {
-      warn(`PR #${mergedPR.number} (${import_picocolors22.default.bold(mergedPR.title)}) has already been merged.`);
-      info(`Link: ${import_picocolors22.default.underline(mergedPR.url)}`, "");
+      warn(`PR #${mergedPR.number} (${import_picocolors23.default.bold(mergedPR.title)}) has already been merged.`);
+      info(`Link: ${import_picocolors23.default.underline(mergedPR.url)}`, "");
       const uniqueCommitsAheadOfBase = await countCommitsAhead(currentBranch, syncSource.ref);
       const dirty = await hasUncommittedChanges();
       const hasWork = hasStaleBranchWorkToPreserve(uniqueCommitsAheadOfBase, dirty);
@@ -15890,12 +16850,12 @@ var update_default = defineCommand({
           info("You have uncommitted local changes.");
         }
         if (uniqueCommitsAheadOfBase > 0) {
-          info(`You have ${uniqueCommitsAheadOfBase} local commit(s) not in ${import_picocolors22.default.bold(syncSource.ref)}.`);
+          info(`You have ${uniqueCommitsAheadOfBase} local commit(s) not in ${import_picocolors23.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_picocolors22.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_picocolors23.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;
@@ -15917,7 +16877,7 @@ var update_default = defineCommand({
             error(`Failed to rename branch: ${renameResult.stderr}`);
             process.exit(1);
           }
-          success(`Renamed ${import_picocolors22.default.bold(currentBranch)} \u2192 ${import_picocolors22.default.bold(newBranchName)}`);
+          success(`Renamed ${import_picocolors23.default.bold(currentBranch)} \u2192 ${import_picocolors23.default.bold(newBranchName)}`);
           await unsetUpstream();
           await fetchRemote(syncSource.remote);
           let rebaseResult2;
@@ -15929,11 +16889,11 @@ var update_default = defineCommand({
           }
           if (rebaseResult2.exitCode !== 0) {
             warn("Rebase encountered conflicts. Resolve them manually, then run:");
-            info(`  ${import_picocolors22.default.bold("git rebase --continue")}`, "");
+            info(`  ${import_picocolors23.default.bold("git rebase --continue")}`, "");
           } else {
-            success(`Rebased ${import_picocolors22.default.bold(newBranchName)} onto ${import_picocolors22.default.bold(syncSource.ref)}.`);
+            success(`Rebased ${import_picocolors23.default.bold(newBranchName)} onto ${import_picocolors23.default.bold(syncSource.ref)}.`);
           }
-          info(`All your changes are preserved. Run ${import_picocolors22.default.bold("cn submit")} when ready to create a new PR.`, "");
+          info(`All your changes are preserved. Run ${import_picocolors23.default.bold("cn submit")} when ready to create a new PR.`, "");
           return;
         }
         warn("Discarding local changes...");
@@ -15952,24 +16912,24 @@ var update_default = defineCommand({
         process.exit(1);
       }
       await updateLocalBranch(baseBranch, syncSource.ref);
-      success(`Synced ${import_picocolors22.default.bold(baseBranch)} with ${import_picocolors22.default.bold(syncSource.ref)}.`);
-      info(`Deleting stale branch ${import_picocolors22.default.bold(currentBranch)}...`);
+      success(`Synced ${import_picocolors23.default.bold(baseBranch)} with ${import_picocolors23.default.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${import_picocolors23.default.bold(currentBranch)}...`);
       await forceDeleteBranch(currentBranch);
-      success(`Deleted ${import_picocolors22.default.bold(currentBranch)}.`);
-      info(`Run ${import_picocolors22.default.bold("cn start")} to begin a new feature branch.`, "");
+      success(`Deleted ${import_picocolors23.default.bold(currentBranch)}.`);
+      info(`Run ${import_picocolors23.default.bold("cn start")} to begin a new feature branch.`, "");
       return;
     }
-    info(`Updating ${import_picocolors22.default.bold(currentBranch)} with latest ${import_picocolors22.default.bold(baseBranch)}...`);
+    info(`Updating ${import_picocolors23.default.bold(currentBranch)} with latest ${import_picocolors23.default.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
     if (!await refExists(syncSource.ref)) {
-      error(`Remote ref ${import_picocolors22.default.bold(syncSource.ref)} does not exist.`);
+      error(`Remote ref ${import_picocolors23.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_picocolors22.default.dim(`Using --onto rebase (branch was based on a different ref)`));
+      info(import_picocolors23.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) {
@@ -15983,7 +16943,7 @@ var update_default = defineCommand({
           let conflictDiff = "";
           for (const file of conflictFiles.slice(0, 3)) {
             try {
-              const content = readFileSync6(file, "utf-8");
+              const content = readFileSync7(file, "utf-8");
               if (content.includes("<<<<<<<")) {
                 conflictDiff += `
 --- ${file} ---
@@ -16000,10 +16960,10 @@ ${content.slice(0, 2000)}
             if (suggestion) {
               spinner.success("AI conflict guidance ready.");
               console.log(`
-${import_picocolors22.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(import_picocolors22.default.dim("\u2500".repeat(60)));
+${import_picocolors23.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(import_picocolors23.default.dim("\u2500".repeat(60)));
               console.log(suggestion);
-              console.log(import_picocolors22.default.dim("\u2500".repeat(60)));
+              console.log(import_picocolors23.default.dim("\u2500".repeat(60)));
               console.log();
             } else {
               spinner.fail("AI could not analyze the conflicts.");
@@ -16011,21 +16971,21 @@ ${import_picocolors22.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance
           }
         }
       }
-      console.log(import_picocolors22.default.bold("To resolve:"));
+      console.log(import_picocolors23.default.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${import_picocolors22.default.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${import_picocolors22.default.cyan("git rebase --continue")}`);
+      console.log(`  2. ${import_picocolors23.default.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${import_picocolors23.default.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${import_picocolors22.default.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${import_picocolors23.default.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`${import_picocolors22.default.bold(currentBranch)} has been rebased onto latest ${import_picocolors22.default.bold(baseBranch)}`);
+    success(`${import_picocolors23.default.bold(currentBranch)} has been rebased onto latest ${import_picocolors23.default.bold(baseBranch)}`);
   }
 });
 
 // src/commands/validate.ts
-import { readFileSync as readFileSync7 } from "fs";
-var import_picocolors23 = __toESM(require_picocolors(), 1);
+import { readFileSync as readFileSync8 } from "fs";
+var import_picocolors24 = __toESM(require_picocolors(), 1);
 var validate_default = defineCommand({
   meta: {
     name: "validate",
@@ -16054,7 +17014,7 @@ var validate_default = defineCommand({
       info('Commit convention is set to "none". All messages are accepted.');
       process.exit(0);
     }
-    const message = args.file ? readFileSync7(args.file, "utf-8").split(/\r?\n/, 1)[0] ?? "" : args.message;
+    const message = args.file ? readFileSync8(args.file, "utf-8").split(/\r?\n/, 1)[0] ?? "" : args.message;
     if (!message) {
       error("No commit message provided. Pass a message or use --file <path>.");
       process.exit(1);
@@ -16065,14 +17025,14 @@ var validate_default = defineCommand({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(import_picocolors23.default.red(`  \u2717 ${line}`));
+      console.error(import_picocolors24.default.red(`  \u2717 ${line}`));
     }
     process.exit(1);
   }
 });
 
 // src/ui/banner.ts
-var import_picocolors24 = __toESM(require_picocolors(), 1);
+var import_picocolors25 = __toESM(require_picocolors(), 1);
 
 // src/data/announcements.json
 var announcements_default = [
@@ -16133,9 +17093,9 @@ function getAuthor() {
   return typeof package_default.author === "string" ? package_default.author : "unknown";
 }
 function showBanner(variant = "small") {
-  console.log(import_picocolors24.default.cyan(`
+  console.log(import_picocolors25.default.cyan(`
 ${LOGO}`));
-  console.log(`  ${import_picocolors24.default.dim(`v${getVersion()}`)} ${import_picocolors24.default.dim("\u2014")} ${import_picocolors24.default.dim(`Built by ${getAuthor()}`)}`);
+  console.log(`  ${import_picocolors25.default.dim(`v${getVersion()}`)} ${import_picocolors25.default.dim("\u2014")} ${import_picocolors25.default.dim(`Built by ${getAuthor()}`)}`);
   const announcements = getActiveAnnouncements();
   if (announcements.length > 0) {
     console.log();
@@ -16144,27 +17104,27 @@ ${LOGO}`));
   if (variant === "big") {
     const panelLines = [
       {
-        label: import_picocolors24.default.bold(import_picocolors24.default.cyan("Getting Started")),
+        label: import_picocolors25.default.bold(import_picocolors25.default.cyan("Getting Started")),
         rawLabel: "Getting Started",
         value: "",
         rawValue: ""
       },
       {
-        label: import_picocolors24.default.cyan("cn setup"),
+        label: import_picocolors25.default.cyan("cn setup"),
         rawLabel: "cn setup",
-        value: import_picocolors24.default.dim("configure workflow, remotes, and defaults"),
+        value: import_picocolors25.default.dim("configure workflow, remotes, and defaults"),
         rawValue: "configure workflow, remotes, and defaults"
       },
       {
-        label: import_picocolors24.default.cyan("cn doctor"),
+        label: import_picocolors25.default.cyan("cn doctor"),
         rawLabel: "cn doctor",
-        value: import_picocolors24.default.dim("verify your environment before doing any work"),
+        value: import_picocolors25.default.dim("verify your environment before doing any work"),
         rawValue: "verify your environment before doing any work"
       },
       {
-        label: import_picocolors24.default.cyan("cn start"),
+        label: import_picocolors25.default.cyan("cn start"),
         rawLabel: "cn start",
-        value: import_picocolors24.default.dim("create a branch and begin the next task"),
+        value: import_picocolors25.default.dim("create a branch and begin the next task"),
         rawValue: "create a branch and begin the next task"
       },
       {
@@ -16174,13 +17134,13 @@ ${LOGO}`));
         rawValue: ""
       },
       {
-        label: import_picocolors24.default.bold(import_picocolors24.default.cyan("Workflow")),
+        label: import_picocolors25.default.bold(import_picocolors25.default.cyan("Workflow")),
         rawLabel: "Workflow",
         value: "",
         rawValue: ""
       },
       {
-        label: import_picocolors24.default.dim("cn setup \u2192 cn commit \u2192 cn update \u2192 cn submit"),
+        label: import_picocolors25.default.dim("cn setup \u2192 cn commit \u2192 cn update \u2192 cn submit"),
         rawLabel: "cn setup \u2192 cn commit \u2192 cn update \u2192 cn submit",
         value: "",
         rawValue: ""
@@ -16205,22 +17165,22 @@ ${LOGO}`));
       return Math.max(max, lineLength);
     }, 0));
     console.log();
-    console.log(`  ${import_picocolors24.default.dim(`\u250C${"\u2500".repeat(contentWidth + 2)}\u2510`)}`);
+    console.log(`  ${import_picocolors25.default.dim(`\u250C${"\u2500".repeat(contentWidth + 2)}\u2510`)}`);
     for (const line of rows) {
       if (!line.rawLabel && !line.rawValue) {
-        console.log(`  ${import_picocolors24.default.dim("\u2502")} ${" ".repeat(contentWidth)} ${import_picocolors24.default.dim("\u2502")}`);
+        console.log(`  ${import_picocolors25.default.dim("\u2502")} ${" ".repeat(contentWidth)} ${import_picocolors25.default.dim("\u2502")}`);
         continue;
       }
       const left = line.rawValue ? `${line.label}${" ".repeat(Math.max(0, labelWidth - line.rawLabel.length + 2))}` : line.label;
-      const value = line.rawValue ? import_picocolors24.default.dim(line.rawValue) : "";
+      const value = line.rawValue ? import_picocolors25.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_picocolors24.default.dim("\u2502")} ${left}${value}${trailing} ${import_picocolors24.default.dim("\u2502")}`);
+      console.log(`  ${import_picocolors25.default.dim("\u2502")} ${left}${value}${trailing} ${import_picocolors25.default.dim("\u2502")}`);
     }
-    console.log(`  ${import_picocolors24.default.dim(`\u2514${"\u2500".repeat(contentWidth + 2)}\u2518`)}`);
+    console.log(`  ${import_picocolors25.default.dim(`\u2514${"\u2500".repeat(contentWidth + 2)}\u2518`)}`);
     console.log();
-    console.log(`  ${import_picocolors24.default.dim("Star or contribute:")} ${import_picocolors24.default.dim(linkify("gh.waren.build/contribute-now", "https://gh.waren.build/contribute-now"))}`);
-    console.log(`  ${import_picocolors24.default.dim("Sponsor:")} ${import_picocolors24.default.dim(linkify("warengonzaga.com/sponsor", "https://warengonzaga.com/sponsor"))}`);
+    console.log(`  ${import_picocolors25.default.dim("Star or contribute:")} ${import_picocolors25.default.dim(linkify("gh.waren.build/contribute-now", "https://gh.waren.build/contribute-now"))}`);
+    console.log(`  ${import_picocolors25.default.dim("Sponsor:")} ${import_picocolors25.default.dim(linkify("warengonzaga.com/sponsor", "https://warengonzaga.com/sponsor"))}`);
   }
   console.log();
 }
@@ -16252,7 +17212,7 @@ function renderAnnouncementBanner(announcement) {
   console.log(`  ${tone.border(`\u250C${"\u2500".repeat(rawWidth + 2)}\u2510`)}`);
   for (const line of lines) {
     const trailing = " ".repeat(Math.max(0, rawWidth - line.length));
-    const content = line === title ? tone.title(line) : import_picocolors24.default.dim(line);
+    const content = line === title ? tone.title(line) : import_picocolors25.default.dim(line);
     console.log(`  ${tone.border("\u2502")} ${content}${trailing} ${tone.border("\u2502")}`);
   }
   console.log(`  ${tone.border(`\u2514${"\u2500".repeat(rawWidth + 2)}\u2518`)}`);
@@ -16288,20 +17248,20 @@ function getAnnouncementTone(kind) {
     case "info":
       return {
         emoji: "\u2139",
-        border: import_picocolors24.default.blue,
-        title: (value) => import_picocolors24.default.bold(import_picocolors24.default.blue(value))
+        border: import_picocolors25.default.blue,
+        title: (value) => import_picocolors25.default.bold(import_picocolors25.default.blue(value))
       };
     case "warning":
       return {
         emoji: "\uD83D\uDEA8",
-        border: import_picocolors24.default.red,
-        title: (value) => import_picocolors24.default.bold(import_picocolors24.default.red(value))
+        border: import_picocolors25.default.red,
+        title: (value) => import_picocolors25.default.bold(import_picocolors25.default.red(value))
       };
     default:
       return {
         emoji: "\u26A0",
-        border: import_picocolors24.default.yellow,
-        title: (value) => import_picocolors24.default.bold(import_picocolors24.default.yellow(value))
+        border: import_picocolors25.default.yellow,
+        title: (value) => import_picocolors25.default.bold(import_picocolors25.default.yellow(value))
       };
   }
 }
@@ -16340,7 +17300,8 @@ if (!isVersion) {
     "branch",
     "hook",
     "validate",
-    "doctor"
+    "doctor",
+    "label"
   ];
   const isHelp = process.argv.includes("--help") || process.argv.includes("-h");
   const hasSubCommand = subCommands.some((cmd) => process.argv.includes(cmd));
@@ -16377,7 +17338,8 @@ var main = defineCommand({
     log: log_default,
     hook: hook_default,
     validate: validate_default,
-    doctor: doctor_default
+    doctor: doctor_default,
+    label: label_default
   },
   run({ args }) {
     if (args.version) {