contribute-now 0.7.2 → 0.7.3-dev.ed55e7b

package/dist/cli.js

@@ -7540,6 +7540,9 @@ async function hasLocalWork(remote, branch) {
 async function deleteRemoteBranch(remote, branch) {
   return run(["push", remote, "--delete", branch]);
 }
+async function stashChanges(message) {
+  return run(["stash", "push", "-m", `contrib-save: ${message}`]);
+}
 async function mergeSquash(branch) {
   return run(["merge", "--squash", branch]);
 }
@@ -10972,19 +10975,19 @@ async function checkCopilotAvailable2() {
   const aiConfig = resolveAIConfig();
   if (aiConfig.provider === "ollama-cloud") {
     if (!await hasOllamaCloudApiKey()) {
-      return "Ollama Cloud API key not found. Run `contrib setup` to save it.";
+      return "Ollama Cloud API key not found. Run `cn setup` to save it.";
     }
     try {
       const apiKey = await getOllamaCloudApiKey();
       if (!apiKey) {
-        return "Ollama Cloud API key not found. Run `contrib setup` to save it.";
+        return "Ollama Cloud API key not found. Run `cn setup` to save it.";
       }
       await fetchOllamaCloudModels(apiKey, aiConfig.host);
       return null;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       if (msg === "Ollama Cloud authentication failed") {
-        return "Ollama Cloud authentication failed. Update your saved API key with `contrib setup`.";
+        return "Ollama Cloud authentication failed. Update your saved API key with `cn setup`.";
       }
       if (msg.startsWith("Ollama Cloud model lookup failed")) {
         return msg.replace("model lookup", "health check");
@@ -11877,7 +11880,7 @@ var clean_default = defineCommand({
     await assertCleanGitState("cleaning");
     const config = readConfig();
     if (!config) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     const { origin } = config;
@@ -11983,13 +11986,121 @@ ${import_picocolors8.default.bold("Stale branches (remote deleted, likely squash
     const finalBranch = await getCurrentBranch();
     if (finalBranch && protectedBranches.has(finalBranch)) {
       console.log();
-      info(`You're on ${import_picocolors8.default.bold(finalBranch)}. Run ${import_picocolors8.default.bold("contrib start")} to begin a new feature.`);
+      info(`You're on ${import_picocolors8.default.bold(finalBranch)}. Run ${import_picocolors8.default.bold("cn start")} to begin a new feature.`);
     }
   }
 });
 
-// src/commands/commit.ts
+// src/commands/discard.ts
 var import_picocolors9 = __toESM(require_picocolors(), 1);
+var discard_default = defineCommand({
+  meta: {
+    name: "discard",
+    description: "Discard the current feature branch and return to the base branch"
+  },
+  args: {
+    force: {
+      type: "boolean",
+      alias: "f",
+      description: "Skip confirmation and discard immediately",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    await assertCleanGitState("discarding a branch");
+    const config = readConfig();
+    if (!config) {
+      error("No repo config found. Run `cn setup` first.");
+      process.exit(1);
+    }
+    const currentBranch = await getCurrentBranch();
+    const baseBranch = getBaseBranch(config);
+    await projectHeading("discard", "\uD83D\uDDD1\uFE0F");
+    if (isBranchProtected(currentBranch, config)) {
+      error(`${import_picocolors9.default.bold(currentBranch)} is a protected branch and cannot be discarded.`);
+      info(`Switch to a feature branch first, then run ${import_picocolors9.default.bold("cn discard")}.`);
+      process.exit(1);
+    }
+    if (currentBranch === baseBranch) {
+      info(`You are already on ${import_picocolors9.default.bold(baseBranch)}.`);
+      process.exit(0);
+    }
+    const { origin } = config;
+    const localWork = await hasLocalWork(origin, currentBranch);
+    const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
+    if (hasWork) {
+      if (localWork.uncommitted) {
+        warn("You have uncommitted changes in your working tree.");
+      }
+      if (localWork.unpushedCommits > 0) {
+        warn(`You have ${import_picocolors9.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on this branch.`);
+      }
+      warn("Discarding this branch will permanently lose that work.");
+      const SAVE_FIRST = "Save my changes first (cn save), then discard";
+      const DISCARD_ANYWAY = "Discard anyway \u2014 I do not need this work";
+      const CANCEL = "Keep the branch, take me back";
+      const action = await selectPrompt("This branch has unsaved work. What would you like to do?", [SAVE_FIRST, DISCARD_ANYWAY, CANCEL]);
+      if (action === CANCEL) {
+        info("Discard cancelled. Your branch is untouched.");
+        process.exit(0);
+      }
+      if (action === SAVE_FIRST) {
+        if (!localWork.uncommitted) {
+          info("No uncommitted changes to stash \u2014 unpushed commits will still be lost.");
+          const confirm = await confirmPrompt("Continue discarding the branch?");
+          if (!confirm) {
+            info("Discard cancelled.");
+            process.exit(0);
+          }
+        } else {
+          const stashResult = await stashChanges(`work-in-progress on ${currentBranch}`);
+          if (stashResult.exitCode !== 0) {
+            error(`Failed to save changes: ${stashResult.stderr}`);
+            process.exit(1);
+          }
+          success(`Changes saved. Use ${import_picocolors9.default.bold("cn save --restore")} to bring them back.`);
+        }
+      }
+    } else if (!args.force) {
+      const confirmed = await confirmPrompt(`Discard ${import_picocolors9.default.bold(currentBranch)} and return to ${import_picocolors9.default.bold(baseBranch)}?`);
+      if (!confirmed) {
+        info("Discard cancelled.");
+        process.exit(0);
+      }
+    }
+    const upstreamRef = await getUpstreamRef();
+    let deleteRemote = false;
+    if (upstreamRef) {
+      deleteRemote = await confirmPrompt(`Also delete the remote branch ${import_picocolors9.default.bold(upstreamRef)}?`);
+    }
+    const checkoutResult = await checkoutBranch(baseBranch);
+    if (checkoutResult.exitCode !== 0) {
+      error(`Failed to switch to ${import_picocolors9.default.bold(baseBranch)}: ${checkoutResult.stderr}`);
+      process.exit(1);
+    }
+    const deleteResult = await forceDeleteBranch(currentBranch);
+    if (deleteResult.exitCode !== 0) {
+      error(`Failed to delete branch ${import_picocolors9.default.bold(currentBranch)}: ${deleteResult.stderr}`);
+      process.exit(1);
+    }
+    success(`Discarded ${import_picocolors9.default.bold(currentBranch)} and switched back to ${import_picocolors9.default.bold(baseBranch)}`);
+    if (deleteRemote) {
+      const remoteDeleteResult = await deleteRemoteBranch(origin, currentBranch);
+      if (remoteDeleteResult.exitCode !== 0) {
+        warn(`Could not delete remote branch: ${remoteDeleteResult.stderr.trim()}`);
+      } else {
+        success(`Deleted remote branch ${import_picocolors9.default.bold(`${origin}/${currentBranch}`)}`);
+      }
+    }
+  }
+});
+
+// src/commands/commit.ts
+var import_picocolors10 = __toESM(require_picocolors(), 1);
 
 // src/utils/convention.ts
 var CLEAN_COMMIT_PATTERN = /^(\uD83D\uDCE6|\uD83D\uDD27|\uD83D\uDDD1\uFE0F?|\uD83D\uDD12|\u2699\uFE0F?|\u2615|\uD83E\uDDEA|\uD83D\uDCD6|\uD83D\uDE80) (new|update|remove|security|setup|chore|test|docs|release)(!?)( \([a-zA-Z0-9][a-zA-Z0-9-]*\))?: .{1,72}$/u;
@@ -12075,7 +12186,7 @@ var commit_default = defineCommand({
     await assertCleanGitState("committing");
     const config = readConfig();
     if (!config) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     await projectHeading("commit", "\uD83D\uDCBE");
@@ -12096,9 +12207,9 @@ var commit_default = defineCommand({
         process.exit(1);
       }
       console.log(`
-${import_picocolors9.default.bold("Changed files:")}`);
+${import_picocolors10.default.bold("Changed files:")}`);
       for (const f3 of changedFiles) {
-        console.log(`  ${import_picocolors9.default.dim("\u2022")} ${f3}`);
+        console.log(`  ${import_picocolors10.default.dim("\u2022")} ${f3}`);
       }
       const stageAction = await selectPrompt("No staged changes. How would you like to stage?", [
         "Stage all changes",
@@ -12140,8 +12251,8 @@ ${import_picocolors9.default.bold("Changed files:")}`);
       const dirs = new Set(stagedFiles.map((f3) => f3.split("/")[0]));
       if (dirs.size > 1) {
         console.log();
-        warn(`You're staging ${import_picocolors9.default.bold(String(stagedFiles.length))} files across ${import_picocolors9.default.bold(String(dirs.size))} directories in a single commit.`);
-        info(import_picocolors9.default.dim("Large commits mixing different topics make history harder to read and bisect. " + "For cleaner history, consider splitting into atomic commits."));
+        warn(`You're staging ${import_picocolors10.default.bold(String(stagedFiles.length))} files across ${import_picocolors10.default.bold(String(dirs.size))} directories in a single commit.`);
+        info(import_picocolors10.default.dim("Large commits mixing different topics make history harder to read and bisect. " + "For cleaner history, consider splitting into atomic commits."));
         const choice = await selectPrompt("How would you like to proceed?", [
           "Continue as single commit",
           "Switch to group mode (AI splits into atomic commits)",
@@ -12172,7 +12283,7 @@ ${import_picocolors9.default.bold("Changed files:")}`);
         if (commitMessage) {
           spinner.success("AI commit message generated.");
           console.log(`
-  ${import_picocolors9.default.dim("AI suggestion:")} ${import_picocolors9.default.bold(import_picocolors9.default.cyan(commitMessage))}`);
+  ${import_picocolors10.default.dim("AI suggestion:")} ${import_picocolors10.default.bold(import_picocolors10.default.cyan(commitMessage))}`);
         } else {
           spinner.fail("AI did not return a commit message.");
           warn("Falling back to manual entry.");
@@ -12200,7 +12311,7 @@ ${import_picocolors9.default.bold("Changed files:")}`);
         if (regen) {
           spinner.success("Commit message regenerated.");
           console.log(`
-  ${import_picocolors9.default.dim("AI suggestion:")} ${import_picocolors9.default.bold(import_picocolors9.default.cyan(regen))}`);
+  ${import_picocolors10.default.dim("AI suggestion:")} ${import_picocolors10.default.bold(import_picocolors10.default.cyan(regen))}`);
           const ok = await confirmPrompt("Use this message?");
           finalMessage = ok ? regen : await inputPrompt("Enter commit message manually");
         } else {
@@ -12215,7 +12326,7 @@ ${import_picocolors9.default.bold("Changed files:")}`);
       if (convention2 !== "none") {
         console.log();
         for (const hint of CONVENTION_FORMAT_HINTS[convention2]) {
-          console.log(import_picocolors9.default.dim(hint));
+          console.log(import_picocolors10.default.dim(hint));
         }
         console.log();
       }
@@ -12239,7 +12350,7 @@ ${import_picocolors9.default.bold("Changed files:")}`);
       error(`Failed to commit: ${result.stderr}`);
       process.exit(1);
     }
-    success(`Committed: ${import_picocolors9.default.bold(finalMessage)}`);
+    success(`Committed: ${import_picocolors10.default.bold(finalMessage)}`);
   }
 });
 async function runGroupCommit(model, config) {
@@ -12256,9 +12367,9 @@ async function runGroupCommit(model, config) {
     process.exit(1);
   }
   console.log(`
-${import_picocolors9.default.bold("Changed files:")}`);
+${import_picocolors10.default.bold("Changed files:")}`);
   for (const f3 of changedFiles) {
-    console.log(`  ${import_picocolors9.default.dim("\u2022")} ${f3}`);
+    console.log(`  ${import_picocolors10.default.dim("\u2022")} ${f3}`);
   }
   const spinner = createSpinner(changedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD ? `Asking AI to group ${changedFiles.length} file(s) into logical commits (using optimized batching)...` : `Asking AI to group ${changedFiles.length} file(s) into logical commits...`, {
     tips: LOADING_TIPS
@@ -12304,13 +12415,13 @@ ${import_picocolors9.default.bold("Changed files:")}`);
   let commitAll = false;
   while (!proceedToCommit) {
     console.log(`
-${import_picocolors9.default.bold(`AI suggested ${validGroups.length} commit group(s):`)}
+${import_picocolors10.default.bold(`AI suggested ${validGroups.length} commit group(s):`)}
 `);
     for (let i2 = 0;i2 < validGroups.length; i2++) {
       const g3 = validGroups[i2];
-      console.log(`  ${import_picocolors9.default.cyan(`Group ${i2 + 1}:`)} ${import_picocolors9.default.bold(g3.message)}`);
+      console.log(`  ${import_picocolors10.default.cyan(`Group ${i2 + 1}:`)} ${import_picocolors10.default.bold(g3.message)}`);
       for (const f3 of g3.files) {
-        console.log(`    ${import_picocolors9.default.dim("\u2022")} ${f3}`);
+        console.log(`    ${import_picocolors10.default.dim("\u2022")} ${f3}`);
       }
       console.log();
     }
@@ -12376,16 +12487,16 @@ ${import_picocolors9.default.bold(`AI suggested ${validGroups.length} commit gro
         continue;
       }
       committed++;
-      success(`Committed group ${i2 + 1}: ${import_picocolors9.default.bold(group.message)}`);
+      success(`Committed group ${i2 + 1}: ${import_picocolors10.default.bold(group.message)}`);
     }
   } else {
     for (let i2 = 0;i2 < validGroups.length; i2++) {
       const group = validGroups[i2];
-      console.log(import_picocolors9.default.bold(`
+      console.log(import_picocolors10.default.bold(`
 \u2500\u2500 Group ${i2 + 1}/${validGroups.length} \u2500\u2500`));
-      console.log(`  ${import_picocolors9.default.cyan(group.message)}`);
+      console.log(`  ${import_picocolors10.default.cyan(group.message)}`);
       for (const f3 of group.files) {
-        console.log(`  ${import_picocolors9.default.dim("\u2022")} ${f3}`);
+        console.log(`  ${import_picocolors10.default.dim("\u2022")} ${f3}`);
       }
       let message = group.message;
       let actionDone = false;
@@ -12409,7 +12520,7 @@ ${import_picocolors9.default.bold(`AI suggested ${validGroups.length} commit gro
           if (newMsg) {
             message = newMsg;
             group.message = newMsg;
-            regenSpinner.success(`New message: ${import_picocolors9.default.bold(message)}`);
+            regenSpinner.success(`New message: ${import_picocolors10.default.bold(message)}`);
           } else {
             regenSpinner.fail("AI could not generate a new message. Keeping current one.");
           }
@@ -12472,7 +12583,7 @@ ${import_picocolors9.default.bold(`AI suggested ${validGroups.length} commit gro
           continue;
         }
         committed++;
-        success(`Committed group ${i2 + 1}: ${import_picocolors9.default.bold(message)}`);
+        success(`Committed group ${i2 + 1}: ${import_picocolors10.default.bold(message)}`);
         actionDone = true;
       }
     }
@@ -12487,7 +12598,7 @@ ${import_picocolors9.default.bold(`AI suggested ${validGroups.length} commit gro
 }
 
 // src/commands/config.ts
-var import_picocolors10 = __toESM(require_picocolors(), 1);
+var import_picocolors11 = __toESM(require_picocolors(), 1);
 var WORKFLOW_OPTIONS = [
   { value: "clean-flow", label: WORKFLOW_DESCRIPTIONS["clean-flow"] },
   { value: "github-flow", label: WORKFLOW_DESCRIPTIONS["github-flow"] },
@@ -12703,7 +12814,7 @@ async function applyOllamaApiKeyEdit(result) {
   if (result.ollamaApiKeyAction === "set" && result.ollamaApiKey) {
     await setOllamaCloudApiKey(result.ollamaApiKey);
     success("Stored Ollama Cloud API key in the local secrets store.");
-    info(`Secrets path: ${import_picocolors10.default.bold(getSecretsStorePath())}`);
+    info(`Secrets path: ${import_picocolors11.default.bold(getSecretsStorePath())}`);
     return;
   }
   if (result.ollamaApiKeyAction === "delete") {
@@ -12716,29 +12827,29 @@ async function applyOllamaApiKeyEdit(result) {
   }
 }
 function printConfigSummary(snapshot) {
-  info(`Config source: ${import_picocolors10.default.bold(snapshot.source)}`);
-  info(`Config path: ${import_picocolors10.default.bold(snapshot.location)}`);
-  info(`Workflow: ${import_picocolors10.default.bold(snapshot.workflowLabel)}`);
-  info(`Convention: ${import_picocolors10.default.bold(snapshot.commitConventionLabel)}`);
-  info(`Role: ${import_picocolors10.default.bold(snapshot.role)}`);
+  info(`Config source: ${import_picocolors11.default.bold(snapshot.source)}`);
+  info(`Config path: ${import_picocolors11.default.bold(snapshot.location)}`);
+  info(`Workflow: ${import_picocolors11.default.bold(snapshot.workflowLabel)}`);
+  info(`Convention: ${import_picocolors11.default.bold(snapshot.commitConventionLabel)}`);
+  info(`Role: ${import_picocolors11.default.bold(snapshot.role)}`);
   if (snapshot.devBranch) {
-    info(`Main: ${import_picocolors10.default.bold(snapshot.mainBranch)} | Dev: ${import_picocolors10.default.bold(snapshot.devBranch)}`);
+    info(`Main: ${import_picocolors11.default.bold(snapshot.mainBranch)} | Dev: ${import_picocolors11.default.bold(snapshot.devBranch)}`);
   } else {
-    info(`Main: ${import_picocolors10.default.bold(snapshot.mainBranch)}`);
+    info(`Main: ${import_picocolors11.default.bold(snapshot.mainBranch)}`);
   }
-  info(`Origin: ${import_picocolors10.default.bold(snapshot.origin)} | Upstream: ${import_picocolors10.default.bold(snapshot.upstream)}`);
-  info(`Branch prefixes: ${import_picocolors10.default.bold(snapshot.branchPrefixes.join(", "))}`);
-  info(`Guides: ${import_picocolors10.default.bold(snapshot.showTips ? "shown" : "hidden")}`);
-  info(`AI: ${import_picocolors10.default.bold(snapshot.ai.enabled ? "enabled" : "disabled")}`);
+  info(`Origin: ${import_picocolors11.default.bold(snapshot.origin)} | Upstream: ${import_picocolors11.default.bold(snapshot.upstream)}`);
+  info(`Branch prefixes: ${import_picocolors11.default.bold(snapshot.branchPrefixes.join(", "))}`);
+  info(`Guides: ${import_picocolors11.default.bold(snapshot.showTips ? "shown" : "hidden")}`);
+  info(`AI: ${import_picocolors11.default.bold(snapshot.ai.enabled ? "enabled" : "disabled")}`);
   if (snapshot.ai.enabled && snapshot.ai.providerLabel) {
-    info(`AI provider: ${import_picocolors10.default.bold(snapshot.ai.providerLabel)}`);
+    info(`AI provider: ${import_picocolors11.default.bold(snapshot.ai.providerLabel)}`);
     if (snapshot.ai.model) {
-      info(`AI model: ${import_picocolors10.default.bold(snapshot.ai.model)}`);
+      info(`AI model: ${import_picocolors11.default.bold(snapshot.ai.model)}`);
     }
     if (snapshot.ai.provider === "ollama-cloud") {
-      info(`Ollama Cloud API key: ${import_picocolors10.default.bold(snapshot.ai.ollamaCloudApiKeyPresent ? "stored" : "missing")}`);
+      info(`Ollama Cloud API key: ${import_picocolors11.default.bold(snapshot.ai.ollamaCloudApiKeyPresent ? "stored" : "missing")}`);
       if (snapshot.ai.secretsPath) {
-        info(`Secrets path: ${import_picocolors10.default.bold(snapshot.ai.secretsPath)}`);
+        info(`Secrets path: ${import_picocolors11.default.bold(snapshot.ai.secretsPath)}`);
       }
     }
   }
@@ -12771,12 +12882,12 @@ var config_default = defineCommand({
     }
     await projectHeading("config", "\u2699\uFE0F");
     if (!configExists()) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     const config = readConfig();
     if (!config) {
-      error("Repo config exists but is invalid. Run `contrib setup` to repair it.");
+      error("Repo config exists but is invalid. Run `cn setup` to repair it.");
       process.exit(1);
     }
     const source = getConfigSource();
@@ -12814,18 +12925,18 @@ var config_default = defineCommand({
     }
     printConfigSummary(snapshot);
     console.log();
-    console.log(`  ${import_picocolors10.default.dim("Run `contrib config --edit` to update these settings.")}`);
+    console.log(`  ${import_picocolors11.default.dim("Run `cn config --edit` to update these settings.")}`);
     console.log();
   }
 });
 
 // src/commands/doctor.ts
 import { execFile as execFileCb3 } from "child_process";
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_picocolors12 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "contribute-now",
-  version: "0.7.2",
+  version: "0.7.3-dev.ed55e7b",
   description: "Developer CLI that automates git workflows \u2014 branching, syncing, committing, and PRs \u2014 with multi-workflow and commit convention support.",
   type: "module",
   bin: {
@@ -12874,13 +12985,11 @@ var package_default = {
     "@github/copilot-sdk": "^0.1.25",
     "@wgtechlabs/log-engine": "^2.3.1",
     citty: "^0.1.6",
-    figlet: "^1.10.0",
     picocolors: "^1.1.1"
   },
   devDependencies: {
     "@biomejs/biome": "^2.4.4",
     "@types/bun": "latest",
-    "@types/figlet": "^1.7.0",
     typescript: "^5.7.0"
   }
 };
@@ -12915,16 +13024,16 @@ async function getRepoInfoFromRemote(remote = "origin") {
 }
 
 // src/commands/doctor.ts
-var PASS = `  ${import_picocolors11.default.green("\u2714")} `;
-var FAIL = `  ${import_picocolors11.default.red("\u2717")} `;
-var WARN = `  ${import_picocolors11.default.yellow("\u26A0")} `;
+var PASS = `  ${import_picocolors12.default.green("\u2714")} `;
+var FAIL = `  ${import_picocolors12.default.red("\u2717")} `;
+var WARN = `  ${import_picocolors12.default.yellow("\u26A0")} `;
 function printReport(report) {
   for (const section of report.sections) {
     console.log(`
-  ${import_picocolors11.default.bold(import_picocolors11.default.underline(section.title))}`);
+  ${import_picocolors12.default.bold(import_picocolors12.default.underline(section.title))}`);
     for (const check of section.checks) {
       const prefix = check.ok ? check.warning ? WARN : PASS : FAIL;
-      const text = check.detail ? `${check.label} ${import_picocolors11.default.dim(`\u2014 ${check.detail}`)}` : check.label;
+      const text = check.detail ? `${check.label} ${import_picocolors12.default.dim(`\u2014 ${check.detail}`)}` : check.label;
       console.log(`${prefix}${text}`);
     }
   }
@@ -12954,7 +13063,7 @@ function runCmd(cmd, args) {
 async function toolSection() {
   const checks = [];
   checks.push({
-    label: `contrib v${package_default.version ?? "unknown"}`,
+    label: `cn v${package_default.version ?? "unknown"}`,
     ok: true
   });
   const runtime = typeof globalThis.Bun !== "undefined" ? `Bun ${globalThis.Bun.version ?? "?"}` : `Node ${process.version}`;
@@ -13009,7 +13118,7 @@ async function configSection() {
     checks.push({
       label: "Repo config not found",
       ok: false,
-      detail: "run `contrib setup` to create local config for this clone"
+      detail: "run `cn setup` to create local config for this clone"
     });
     if (localStateLabel) {
       checks.push({
@@ -13077,7 +13186,7 @@ async function configSection() {
         label: hasApiKey ? "Ollama Cloud API key present" : "Ollama Cloud API key missing",
         ok: true,
         warning: !hasApiKey,
-        detail: hasSecretsStore() ? "stored in the local secrets store" : "run `contrib setup` to save it"
+        detail: hasSecretsStore() ? "stored in the local secrets store" : "run `cn setup` to save it"
       });
     }
   }
@@ -13186,7 +13295,7 @@ async function workflowSection() {
     checks.push({
       label: "Cannot resolve workflow (no config)",
       ok: false,
-      detail: "run `contrib setup` first"
+      detail: "run `cn setup` first"
     });
     return { title: "Workflow Resolution", checks };
   }
@@ -13256,14 +13365,14 @@ var doctor_default = defineCommand({
     const failures = total.filter((c3) => !c3.ok);
     const warnings = total.filter((c3) => c3.ok && c3.warning);
     if (failures.length === 0 && warnings.length === 0) {
-      console.log(`  ${import_picocolors11.default.green("All checks passed!")} No issues detected.
+      console.log(`  ${import_picocolors12.default.green("All checks passed!")} No issues detected.
 `);
     } else {
       if (failures.length > 0) {
-        console.log(`  ${import_picocolors11.default.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
+        console.log(`  ${import_picocolors12.default.red(`${failures.length} issue${failures.length !== 1 ? "s" : ""} found.`)}`);
       }
       if (warnings.length > 0) {
-        console.log(`  ${import_picocolors11.default.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
+        console.log(`  ${import_picocolors12.default.yellow(`${warnings.length} warning${warnings.length !== 1 ? "s" : ""}.`)}`);
       }
       console.log();
     }
@@ -13273,7 +13382,7 @@ var doctor_default = defineCommand({
 // src/commands/hook.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
 import { join as join6 } from "path";
-var import_picocolors12 = __toESM(require_picocolors(), 1);
+var import_picocolors13 = __toESM(require_picocolors(), 1);
 var HOOK_MARKER = "# managed by contribute-now";
 function getHooksDir(cwd = process.cwd()) {
   return join6(cwd, ".git", "hooks");
@@ -13285,8 +13394,8 @@ function generateHookScript() {
   return `#!/bin/sh
 ${HOOK_MARKER}
 # Validates commit messages against your configured convention.
-# Install:   contrib hook install
-# Uninstall: contrib hook uninstall
+# Install:   cn hook install
+# Uninstall: cn hook uninstall
 
 commit_msg_file="$1"
 commit_msg=$(head -1 "$commit_msg_file")
@@ -13297,12 +13406,12 @@ case "$commit_msg" in
 esac
 
 # Detect available package runner
-if command -v contrib >/dev/null 2>&1; then
-  contrib validate --file "$commit_msg_file"
+if command -v cn >/dev/null 2>&1; then
+  cn validate --file "$commit_msg_file"
 elif command -v bunx >/dev/null 2>&1; then
-  bunx contrib validate --file "$commit_msg_file"
+  bunx cn validate --file "$commit_msg_file"
 else
-  echo "Warning: Neither contrib nor bunx is available. Skipping commit message validation."
+  echo "Warning: Neither cn nor bunx is available. Skipping commit message validation."
   exit 0
 fi
 `;
@@ -13340,12 +13449,12 @@ async function installHook() {
   await projectHeading("hook install", "\uD83E\uDE9D");
   const config = readConfig();
   if (!config) {
-    error("No repo config found. Run `contrib setup` first.");
+    error("No repo config found. Run `cn setup` first.");
     process.exit(1);
   }
   if (config.commitConvention === "none") {
     warn('Commit convention is set to "none". No hook to install.');
-    info("Change your convention with `contrib setup` first.", "");
+    info("Change your convention with `cn setup` first.", "");
     process.exit(0);
   }
   const hookPath = getHookPath();
@@ -13365,8 +13474,8 @@ async function installHook() {
   }
   writeFileSync5(hookPath, generateHookScript(), { mode: 493 });
   success(`commit-msg hook installed.`);
-  info(`Convention: ${import_picocolors12.default.bold(CONVENTION_LABELS[config.commitConvention])}`, "");
-  info(`Path: ${import_picocolors12.default.dim(hookPath)}`, "");
+  info(`Convention: ${import_picocolors13.default.bold(CONVENTION_LABELS[config.commitConvention])}`, "");
+  info(`Path: ${import_picocolors13.default.dim(hookPath)}`, "");
   warn("Note: hooks can be bypassed with `git commit --no-verify`.");
 }
 async function uninstallHook() {
@@ -13386,7 +13495,7 @@ async function uninstallHook() {
 }
 
 // src/commands/log.ts
-var import_picocolors13 = __toESM(require_picocolors(), 1);
+var import_picocolors14 = __toESM(require_picocolors(), 1);
 function getDefaultOverviewRemoteCommitCount(hasLocalUnpushedCommits) {
   return hasLocalUnpushedCommits ? 10 : 20;
 }
@@ -13484,9 +13593,9 @@ var log_default = defineCommand({
     } else if (mode === "local") {
       if (!compareRef) {
         console.log();
-        console.log(import_picocolors13.default.yellow("  \u26A0 Could not determine a comparison branch."));
-        console.log(import_picocolors13.default.dim("    No upstream tracking set and no remote base branch found."));
-        console.log(import_picocolors13.default.dim(`    Use ${import_picocolors13.default.bold("contrib log --full")} to see the full commit history instead.`));
+        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();
         return;
       }
@@ -13505,8 +13614,8 @@ var log_default = defineCommand({
       const remoteBranch = compareRef ?? targetBranch;
       if (!remoteBranch) {
         console.log();
-        console.log(import_picocolors13.default.yellow("  \u26A0 Could not determine a remote branch to display."));
-        console.log(import_picocolors13.default.dim("    Set an upstream tracking branch or configure your base branch first."));
+        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();
         return;
       }
@@ -13565,31 +13674,31 @@ async function getOverviewRemoteCommitCount(currentBranch, compareRef) {
 }
 function printModeHeader(mode, currentBranch, compareRef, usingFallback = false) {
   const branch = currentBranch ?? "HEAD";
-  const fallbackNote = usingFallback ? import_picocolors13.default.yellow(" (no upstream \u2014 comparing against base branch)") : "";
+  const fallbackNote = usingFallback ? import_picocolors14.default.yellow(" (no upstream \u2014 comparing against base branch)") : "";
   switch (mode) {
     case "overview":
-      console.log(import_picocolors13.default.dim(`  mode: ${import_picocolors13.default.bold("overview")} \u2014 local unpushed commits and remote branch history for ${import_picocolors13.default.bold(branch)}`) + fallbackNote);
+      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);
       if (compareRef) {
-        console.log(import_picocolors13.default.dim(`  remote source: ${import_picocolors13.default.bold(compareRef)}`));
+        console.log(import_picocolors14.default.dim(`  remote source: ${import_picocolors14.default.bold(compareRef)}`));
       }
       break;
     case "local":
-      console.log(import_picocolors13.default.dim(`  mode: ${import_picocolors13.default.bold("local")} \u2014 unpushed commits on ${import_picocolors13.default.bold(branch)}`) + fallbackNote);
+      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("local")} \u2014 unpushed commits on ${import_picocolors14.default.bold(branch)}`) + fallbackNote);
       if (compareRef) {
-        console.log(import_picocolors13.default.dim(`  comparing: ${import_picocolors13.default.bold(compareRef)} \u279C ${import_picocolors13.default.bold("HEAD")}`));
+        console.log(import_picocolors14.default.dim(`  comparing: ${import_picocolors14.default.bold(compareRef)} \u279C ${import_picocolors14.default.bold("HEAD")}`));
       }
       break;
     case "remote":
-      console.log(import_picocolors13.default.dim(`  mode: ${import_picocolors13.default.bold("remote")} \u2014 remote branch history relevant to ${import_picocolors13.default.bold(branch)}`) + fallbackNote);
+      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("remote")} \u2014 remote branch history relevant to ${import_picocolors14.default.bold(branch)}`) + fallbackNote);
       if (compareRef) {
-        console.log(import_picocolors13.default.dim(`  branch: ${import_picocolors13.default.bold(compareRef)}`));
+        console.log(import_picocolors14.default.dim(`  branch: ${import_picocolors14.default.bold(compareRef)}`));
       }
       break;
     case "full":
-      console.log(import_picocolors13.default.dim(`  mode: ${import_picocolors13.default.bold("full")} \u2014 complete commit history for ${import_picocolors13.default.bold(branch)}`));
+      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("full")} \u2014 complete commit history for ${import_picocolors14.default.bold(branch)}`));
       break;
     case "all":
-      console.log(import_picocolors13.default.dim(`  mode: ${import_picocolors13.default.bold("all")} \u2014 commits across all branches`));
+      console.log(import_picocolors14.default.dim(`  mode: ${import_picocolors14.default.bold("all")} \u2014 commits across all branches`));
       break;
   }
 }
@@ -13613,7 +13722,7 @@ async function renderScopedLog(options) {
     }
     console.log();
     for (const entry of entries) {
-      const hashStr = import_picocolors13.default.yellow(entry.hash);
+      const hashStr = import_picocolors14.default.yellow(entry.hash);
       const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
       const subjectStr = colorizeSubject(entry.subject);
       console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
@@ -13632,10 +13741,10 @@ async function renderOverviewLog(options) {
     usingFallback
   } = options;
   console.log();
-  console.log(import_picocolors13.default.bold(import_picocolors13.default.cyan("  Local Unpushed Commits")));
+  console.log(import_picocolors14.default.bold(import_picocolors14.default.cyan("  Local Unpushed Commits")));
   if (!compareRef) {
-    console.log(import_picocolors13.default.dim("  No comparison branch detected for local commit status."));
-    console.log(import_picocolors13.default.dim("  Set an upstream tracking branch or run cn log --full to inspect the current branch history."));
+    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."));
   } else {
     await renderScopedLog({
       mode: "local",
@@ -13647,11 +13756,11 @@ async function renderOverviewLog(options) {
     });
   }
   console.log();
-  console.log(import_picocolors13.default.bold(import_picocolors13.default.cyan("  Remote Branch History")));
+  console.log(import_picocolors14.default.bold(import_picocolors14.default.cyan("  Remote Branch History")));
   if (!compareRef) {
-    console.log(import_picocolors13.default.dim("  No remote branch detected."));
+    console.log(import_picocolors14.default.dim("  No remote branch detected."));
     if (usingFallback) {
-      console.log(import_picocolors13.default.dim("  Configure your base branch or upstream tracking to enable the split view."));
+      console.log(import_picocolors14.default.dim("  Configure your base branch or upstream tracking to enable the split view."));
     }
     return;
   }
@@ -13664,15 +13773,15 @@ async function renderOverviewLog(options) {
     currentBranch
   });
   if (!hasRemoteHistory) {
-    console.log(import_picocolors13.default.dim("  No remote history found for the selected branch."));
+    console.log(import_picocolors14.default.dim("  No remote history found for the selected branch."));
   }
 }
 function printEmptyState(mode) {
   console.log();
   if (mode === "local") {
-    console.log(import_picocolors13.default.dim("  No local unpushed commits \u2014 you're up to date with remote!"));
+    console.log(import_picocolors14.default.dim("  No local unpushed commits \u2014 you're up to date with remote!"));
   } else {
-    console.log(import_picocolors13.default.dim("  No remote-only commits \u2014 your local branch is up to date!"));
+    console.log(import_picocolors14.default.dim("  No remote-only commits \u2014 your local branch is up to date!"));
   }
   console.log();
 }
@@ -13681,7 +13790,7 @@ async function renderFullLog(options) {
   if (showGraph) {
     const lines = await getLogGraph({ count, all, branch: targetBranch });
     if (lines.length === 0) {
-      console.log(import_picocolors13.default.dim("  No commits found."));
+      console.log(import_picocolors14.default.dim("  No commits found."));
       console.log();
       return false;
     }
@@ -13692,13 +13801,13 @@ async function renderFullLog(options) {
   } else {
     const entries = await getLogEntries({ count, all, branch: targetBranch });
     if (entries.length === 0) {
-      console.log(import_picocolors13.default.dim("  No commits found."));
+      console.log(import_picocolors14.default.dim("  No commits found."));
       console.log();
       return false;
     }
     console.log();
     for (const entry of entries) {
-      const hashStr = import_picocolors13.default.yellow(entry.hash);
+      const hashStr = import_picocolors14.default.yellow(entry.hash);
       const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
       const subjectStr = colorizeSubject(entry.subject);
       console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
@@ -13710,33 +13819,33 @@ function printFooter(mode, count, overviewRemoteCount, targetBranch) {
   console.log();
   switch (mode) {
     case "overview":
-      console.log(import_picocolors13.default.dim(`  Showing up to ${count} local commits and ${overviewRemoteCount} remote commits`));
+      console.log(import_picocolors14.default.dim(`  Showing up to ${count} local commits and ${overviewRemoteCount} remote commits`));
       break;
     case "local":
-      console.log(import_picocolors13.default.dim(`  Showing up to ${count} unpushed commits`));
+      console.log(import_picocolors14.default.dim(`  Showing up to ${count} unpushed commits`));
       break;
     case "remote":
-      console.log(import_picocolors13.default.dim(`  Showing ${count} most recent commits from the remote branch`));
+      console.log(import_picocolors14.default.dim(`  Showing ${count} most recent commits from the remote branch`));
       break;
     case "full":
-      console.log(import_picocolors13.default.dim(`  Showing ${count} most recent commits${targetBranch ? ` (${targetBranch})` : ""}`));
+      console.log(import_picocolors14.default.dim(`  Showing ${count} most recent commits${targetBranch ? ` (${targetBranch})` : ""}`));
       break;
     case "all":
-      console.log(import_picocolors13.default.dim(`  Showing ${count} most recent commits (all branches)`));
+      console.log(import_picocolors14.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_picocolors13.default.cyan(line);
+    return import_picocolors14.default.cyan(line);
   }
   const [, graphPart = "", hash, , refs, subject = ""] = match;
   const parts = [];
   if (graphPart) {
     parts.push(colorizeGraphChars(graphPart));
   }
-  parts.push(import_picocolors13.default.yellow(hash));
+  parts.push(import_picocolors14.default.yellow(hash));
   if (refs) {
     parts.push(` (${colorizeRefs(refs, protectedBranches, currentBranch)})`);
   }
@@ -13747,15 +13856,15 @@ function colorizeGraphChars(graphPart) {
   return graphPart.split("").map((ch) => {
     switch (ch) {
       case "*":
-        return import_picocolors13.default.green(ch);
+        return import_picocolors14.default.green(ch);
       case "|":
-        return import_picocolors13.default.cyan(ch);
+        return import_picocolors14.default.cyan(ch);
       case "/":
       case "\\":
-        return import_picocolors13.default.cyan(ch);
+        return import_picocolors14.default.cyan(ch);
       case "-":
       case "_":
-        return import_picocolors13.default.cyan(ch);
+        return import_picocolors14.default.cyan(ch);
       default:
         return ch;
     }
@@ -13767,46 +13876,46 @@ function colorizeRefs(refs, protectedBranches, currentBranch) {
     if (trimmed.startsWith("HEAD ->") || trimmed === "HEAD") {
       const branchName = trimmed.replace("HEAD -> ", "");
       if (trimmed === "HEAD") {
-        return import_picocolors13.default.bold(import_picocolors13.default.cyan("HEAD"));
+        return import_picocolors14.default.bold(import_picocolors14.default.cyan("HEAD"));
       }
-      return `${import_picocolors13.default.bold(import_picocolors13.default.cyan("HEAD"))} ${import_picocolors13.default.dim("->")} ${colorizeRefName(branchName, protectedBranches, currentBranch)}`;
+      return `${import_picocolors14.default.bold(import_picocolors14.default.cyan("HEAD"))} ${import_picocolors14.default.dim("->")} ${colorizeRefName(branchName, protectedBranches, currentBranch)}`;
     }
     if (trimmed.startsWith("tag:")) {
-      return import_picocolors13.default.bold(import_picocolors13.default.magenta(trimmed));
+      return import_picocolors14.default.bold(import_picocolors14.default.magenta(trimmed));
     }
     return colorizeRefName(trimmed, protectedBranches, currentBranch);
-  }).join(import_picocolors13.default.dim(", "));
+  }).join(import_picocolors14.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_picocolors13.default.bold(import_picocolors13.default.red(name)) : import_picocolors13.default.bold(import_picocolors13.default.red(name));
+    return isRemote ? import_picocolors14.default.bold(import_picocolors14.default.red(name)) : import_picocolors14.default.bold(import_picocolors14.default.red(name));
   }
   if (localName === currentBranch) {
-    return import_picocolors13.default.bold(import_picocolors13.default.green(name));
+    return import_picocolors14.default.bold(import_picocolors14.default.green(name));
   }
   if (isRemote) {
-    return import_picocolors13.default.blue(name);
+    return import_picocolors14.default.blue(name);
   }
-  return import_picocolors13.default.green(name);
+  return import_picocolors14.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_picocolors13.default.white(rest)}`;
+    return `${emoji}${import_picocolors14.default.white(rest)}`;
   }
   if (subject.startsWith("Merge ")) {
-    return import_picocolors13.default.dim(subject);
+    return import_picocolors14.default.dim(subject);
   }
-  return import_picocolors13.default.white(subject);
+  return import_picocolors14.default.white(subject);
 }
 
 // src/commands/save.ts
 import { execFile as execFileCb4 } from "child_process";
-var import_picocolors14 = __toESM(require_picocolors(), 1);
+var import_picocolors15 = __toESM(require_picocolors(), 1);
 function gitRun(args) {
   return new Promise((resolve5) => {
     execFileCb4("git", args, (err, stdout2, stderr) => {
@@ -13880,8 +13989,8 @@ async function handleSave(message) {
     info("No uncommitted changes to save.");
     return;
   }
-  success(`Saved: ${import_picocolors14.default.dim(label)}`);
-  info(`Use ${import_picocolors14.default.bold("contrib save --restore")} to bring them back.`, "");
+  success(`Saved: ${import_picocolors15.default.dim(label)}`);
+  info(`Use ${import_picocolors15.default.bold("cn save --restore")} to bring them back.`, "");
 }
 async function handleRestore() {
   await projectHeading("save --restore", "\uD83D\uDCBE");
@@ -13897,7 +14006,7 @@ async function handleRestore() {
       warn("You may have conflicts. Resolve them and run `git stash drop` when done.");
       process.exit(1);
     }
-    success(`Restored: ${import_picocolors14.default.dim(stashes[0].message)}`);
+    success(`Restored: ${import_picocolors15.default.dim(stashes[0].message)}`);
     return;
   }
   const choices = stashes.map((s2) => `${s2.index}  ${s2.message}`);
@@ -13910,7 +14019,7 @@ async function handleRestore() {
     process.exit(1);
   }
   const match = stashes.find((s2) => String(s2.index) === idx);
-  success(`Restored: ${import_picocolors14.default.dim(match?.message ?? "saved changes")}`);
+  success(`Restored: ${import_picocolors15.default.dim(match?.message ?? "saved changes")}`);
 }
 async function handleList() {
   await projectHeading("save --list", "\uD83D\uDCBE");
@@ -13921,13 +14030,13 @@ async function handleList() {
   }
   console.log();
   for (const s2 of stashes) {
-    const idx = import_picocolors14.default.dim(`[${s2.index}]`);
+    const idx = import_picocolors15.default.dim(`[${s2.index}]`);
     const msg = s2.message;
     console.log(`  ${idx}  ${msg}`);
   }
   console.log();
-  info(`Use ${import_picocolors14.default.bold("contrib save --restore")} to bring changes back.`, "");
-  info(`Use ${import_picocolors14.default.bold("contrib save --drop")} to discard saved changes.`, "");
+  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.`, "");
 }
 async function handleDrop() {
   await projectHeading("save --drop", "\uD83D\uDCBE");
@@ -13945,7 +14054,7 @@ async function handleDrop() {
     process.exit(1);
   }
   const match = stashes.find((s2) => String(s2.index) === idx);
-  success(`Dropped: ${import_picocolors14.default.dim(match?.message ?? "saved changes")}`);
+  success(`Dropped: ${import_picocolors15.default.dim(match?.message ?? "saved changes")}`);
 }
 async function getStashList() {
   const result = await gitRun(["stash", "list"]);
@@ -13962,7 +14071,7 @@ async function getStashList() {
 }
 
 // src/commands/setup.ts
-var import_picocolors15 = __toESM(require_picocolors(), 1);
+var import_picocolors16 = __toESM(require_picocolors(), 1);
 async function shouldContinueSetupWithExistingConfig(options) {
   const { existingConfig, hasConfigFile, confirm, onInfo, onWarn, onSuccess, summary } = options;
   if (existingConfig) {
@@ -14045,7 +14154,7 @@ var setup_default = defineCommand({
       workflow = "github-flow";
     else if (workflowChoice.startsWith("Git Flow"))
       workflow = "git-flow";
-    info(`Workflow: ${import_picocolors15.default.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
+    info(`Workflow: ${import_picocolors16.default.bold(WORKFLOW_DESCRIPTIONS[workflow])}`);
     const conventionChoice = await selectPrompt("Which commit convention should this project use?", [
       `${CONVENTION_DESCRIPTIONS["clean-commit"]} (recommended)`,
       CONVENTION_DESCRIPTIONS.conventional,
@@ -14075,7 +14184,7 @@ var setup_default = defineCommand({
         try {
           await setOllamaCloudApiKey(apiKey);
           success("Stored Ollama Cloud API key in the local secrets store.");
-          info(`Secrets path: ${import_picocolors15.default.bold(getSecretsStorePath())}`);
+          info(`Secrets path: ${import_picocolors16.default.bold(getSecretsStorePath())}`);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           error(`Failed to store Ollama Cloud API key: ${message}`);
@@ -14137,15 +14246,15 @@ var setup_default = defineCommand({
       detectedRole = roleChoice;
       detectionSource = "user selection";
     } else {
-      info(`Detected role: ${import_picocolors15.default.bold(detectedRole)} (via ${detectionSource})`);
-      const confirmed = await confirmPrompt(`Role detected as ${import_picocolors15.default.bold(detectedRole)}. Is this correct?`);
+      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?`);
       if (!confirmed) {
         const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
         detectedRole = roleChoice;
       }
     }
     const defaultConfig = getDefaultConfig();
-    info(import_picocolors15.default.dim("Tip: press Enter to keep the default branch name shown in each prompt."));
+    info(import_picocolors16.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;
@@ -14171,7 +14280,7 @@ var setup_default = defineCommand({
             error("Setup cannot continue without the upstream remote for contributors.");
             process.exit(1);
           }
-          success(`Added remote ${import_picocolors15.default.bold(upstreamRemote)} \u2192 ${upstreamUrl}`);
+          success(`Added remote ${import_picocolors16.default.bold(upstreamRemote)} \u2192 ${upstreamUrl}`);
         } else {
           error("An upstream remote URL is required for contributors.");
           info("Add it manually: git remote add upstream <url>", "");
@@ -14194,67 +14303,67 @@ var setup_default = defineCommand({
       showTips
     };
     writeConfig(config);
-    success(`Config written to ${import_picocolors15.default.bold(getConfigLocationLabel())}`);
+    success(`Config written to ${import_picocolors16.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_picocolors15.default.bold(syncRemote)} to verify branch configuration...`, "");
+    info(`Fetching ${import_picocolors16.default.bold(syncRemote)} to verify branch configuration...`, "");
     await fetchRemote(syncRemote);
     const mainRef = `${syncRemote}/${config.mainBranch}`;
     if (!await refExists(mainRef)) {
-      warn(`Main branch ref ${import_picocolors15.default.bold(mainRef)} not found on remote.`);
+      warn(`Main branch ref ${import_picocolors16.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_picocolors15.default.bold(devRef)} not found on remote.`);
+        warn(`Dev branch ref ${import_picocolors16.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_picocolors15.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    info(`Convention: ${import_picocolors15.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-    info(`AI: ${import_picocolors15.default.bold(isAIEnabled(config) ? "enabled" : "disabled")}`);
+    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")}`);
     if (isAIEnabled(config)) {
-      info(`AI provider: ${import_picocolors15.default.bold(resolvedAIConfig.providerLabel)}`);
+      info(`AI provider: ${import_picocolors16.default.bold(resolvedAIConfig.providerLabel)}`);
       if (resolvedAIConfig.model) {
-        info(`AI model: ${import_picocolors15.default.bold(resolvedAIConfig.model)}`);
+        info(`AI model: ${import_picocolors16.default.bold(resolvedAIConfig.model)}`);
       }
     }
-    info(`Guides: ${import_picocolors15.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
-    info(`Role: ${import_picocolors15.default.bold(config.role)}`);
+    info(`Guides: ${import_picocolors16.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
+    info(`Role: ${import_picocolors16.default.bold(config.role)}`);
     if (config.devBranch) {
-      info(`Main: ${import_picocolors15.default.bold(config.mainBranch)} | Dev: ${import_picocolors15.default.bold(config.devBranch)}`);
+      info(`Main: ${import_picocolors16.default.bold(config.mainBranch)} | Dev: ${import_picocolors16.default.bold(config.devBranch)}`);
     } else {
-      info(`Main: ${import_picocolors15.default.bold(config.mainBranch)}`);
+      info(`Main: ${import_picocolors16.default.bold(config.mainBranch)}`);
     }
-    info(`Origin: ${import_picocolors15.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors15.default.bold(config.upstream)}` : ""}`);
+    info(`Origin: ${import_picocolors16.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors16.default.bold(config.upstream)}` : ""}`);
   }
 });
 function logConfigSummary(config) {
   const aiConfig = resolveAIConfig(config);
-  info(`Workflow: ${import_picocolors15.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-  info(`Convention: ${import_picocolors15.default.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
-  info(`AI: ${import_picocolors15.default.bold(isAIEnabled(config) ? "enabled" : "disabled")}`);
+  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")}`);
   if (isAIEnabled(config)) {
-    info(`AI provider: ${import_picocolors15.default.bold(aiConfig.providerLabel)}`);
+    info(`AI provider: ${import_picocolors16.default.bold(aiConfig.providerLabel)}`);
     if (aiConfig.model) {
-      info(`AI model: ${import_picocolors15.default.bold(aiConfig.model)}`);
+      info(`AI model: ${import_picocolors16.default.bold(aiConfig.model)}`);
     }
   }
-  info(`Guides: ${import_picocolors15.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
-  info(`Role: ${import_picocolors15.default.bold(config.role)}`);
+  info(`Guides: ${import_picocolors16.default.bold(shouldShowTips(config) ? "shown" : "hidden")}`);
+  info(`Role: ${import_picocolors16.default.bold(config.role)}`);
   if (config.devBranch) {
-    info(`Main: ${import_picocolors15.default.bold(config.mainBranch)} | Dev: ${import_picocolors15.default.bold(config.devBranch)}`);
+    info(`Main: ${import_picocolors16.default.bold(config.mainBranch)} | Dev: ${import_picocolors16.default.bold(config.devBranch)}`);
   } else {
-    info(`Main: ${import_picocolors15.default.bold(config.mainBranch)}`);
+    info(`Main: ${import_picocolors16.default.bold(config.mainBranch)}`);
   }
-  info(`Origin: ${import_picocolors15.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors15.default.bold(config.upstream)}` : ""}`);
+  info(`Origin: ${import_picocolors16.default.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${import_picocolors16.default.bold(config.upstream)}` : ""}`);
 }
 
 // src/commands/start.ts
-var import_picocolors16 = __toESM(require_picocolors(), 1);
+var import_picocolors17 = __toESM(require_picocolors(), 1);
 var start_default = defineCommand({
   meta: {
     name: "start",
@@ -14284,7 +14393,7 @@ var start_default = defineCommand({
     await assertCleanGitState("starting a new branch");
     const config = readConfig();
     if (!config) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     if (await hasUncommittedChanges()) {
@@ -14306,16 +14415,16 @@ var start_default = defineCommand({
       warn("Start cancelled.");
       process.exit(0);
     }
-    info(`Creating branch: ${import_picocolors16.default.bold(branchName)}`);
+    info(`Creating branch: ${import_picocolors17.default.bold(branchName)}`);
     await fetchRemote(syncSource.remote);
     if (!await refExists(syncSource.ref)) {
-      warn(`Remote ref ${import_picocolors16.default.bold(syncSource.ref)} not found. Creating branch from local ${import_picocolors16.default.bold(baseBranch)}.`);
+      warn(`Remote ref ${import_picocolors17.default.bold(syncSource.ref)} not found. Creating branch from local ${import_picocolors17.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_picocolors16.default.bold(baseBranch)} with ${import_picocolors16.default.bold(String(ahead))} local commit${ahead > 1 ? "s" : ""} not in ${import_picocolors16.default.bold(syncSource.ref)}.`);
+        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)}.`);
         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) {
@@ -14332,10 +14441,10 @@ var start_default = defineCommand({
           error(`Failed to create branch: ${result2.stderr}`);
           process.exit(1);
         }
-        success(`Created ${import_picocolors16.default.bold(branchName)} from ${import_picocolors16.default.bold(syncSource.ref)}`);
+        success(`Created ${import_picocolors17.default.bold(branchName)} from ${import_picocolors17.default.bold(syncSource.ref)}`);
         return;
       }
-      error(`Failed to update ${import_picocolors16.default.bold(baseBranch)}: ${updateResult.stderr}`);
+      error(`Failed to update ${import_picocolors17.default.bold(baseBranch)}: ${updateResult.stderr}`);
       info("Make sure your base branch exists locally or the remote ref is available.", "");
       process.exit(1);
     }
@@ -14344,12 +14453,12 @@ var start_default = defineCommand({
       error(`Failed to create branch: ${result.stderr}`);
       process.exit(1);
     }
-    success(`Created ${import_picocolors16.default.bold(branchName)} from latest ${import_picocolors16.default.bold(baseBranch)}`);
+    success(`Created ${import_picocolors17.default.bold(branchName)} from latest ${import_picocolors17.default.bold(baseBranch)}`);
   }
 });
 
 // src/commands/status.ts
-var import_picocolors17 = __toESM(require_picocolors(), 1);
+var import_picocolors18 = __toESM(require_picocolors(), 1);
 var status_default = defineCommand({
   meta: {
     name: "status",
@@ -14362,12 +14471,12 @@ var status_default = defineCommand({
     }
     const config = readConfig();
     if (!config) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     await projectHeading("status", "\uD83D\uDCCA");
-    console.log(`  ${import_picocolors17.default.dim("Workflow:")} ${import_picocolors17.default.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
-    console.log(`  ${import_picocolors17.default.dim("Role:")} ${import_picocolors17.default.bold(config.role)}`);
+    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();
     await fetchAll();
     const currentBranch = await getCurrentBranch();
@@ -14376,7 +14485,7 @@ var status_default = defineCommand({
     const isContributor = config.role === "contributor";
     const [dirty, fileStatus] = await Promise.all([hasUncommittedChanges(), getFileStatus()]);
     if (dirty) {
-      console.log(`  ${import_picocolors17.default.yellow("\u26A0")}  ${import_picocolors17.default.yellow("Uncommitted changes in working tree")}`);
+      console.log(`  ${import_picocolors18.default.yellow("\u26A0")}  ${import_picocolors18.default.yellow("Uncommitted changes in working tree")}`);
       console.log();
     }
     const mainRemote = `${origin}/${mainBranch}`;
@@ -14395,16 +14504,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_picocolors17.default.dim(` (current ${import_picocolors17.default.green("*")})`));
+      console.log(branchLine + import_picocolors18.default.dim(` (current ${import_picocolors18.default.green("*")})`));
       branchStatus = await detectBranchStatus(currentBranch, baseBranch);
       if (branchStatus.merged) {
-        console.log(`  ${import_picocolors17.default.green("\u2713")}  ${import_picocolors17.default.green("Branch merged")} \u2014 ${import_picocolors17.default.dim(branchStatus.mergedReason ?? "all commits reachable from base")}`);
+        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")}`);
       }
       if (branchStatus.stale) {
-        console.log(`  ${import_picocolors17.default.yellow("\u23F3")}  ${import_picocolors17.default.yellow("Branch is stale")} \u2014 ${import_picocolors17.default.dim(`last commit ${branchStatus.staleDaysAgo} days ago`)}`);
+        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`)}`);
       }
     } else if (currentBranch) {
-      console.log(import_picocolors17.default.dim(`  (on ${import_picocolors17.default.bold(currentBranch)} branch)`));
+      console.log(import_picocolors18.default.dim(`  (on ${import_picocolors18.default.bold(currentBranch)} branch)`));
     }
     let branchesAligned = true;
     {
@@ -14441,20 +14550,20 @@ var status_default = defineCommand({
         }
         branchesAligned = groups.size === 1;
         console.log();
-        console.log(`  ${import_picocolors17.default.bold("\uD83D\uDD17 Branch Alignment")}`);
+        console.log(`  ${import_picocolors18.default.bold("\uD83D\uDD17 Branch Alignment")}`);
         for (const [hash, names] of groups) {
           const short = hash.slice(0, 7);
-          const nameStr = names.map((n2) => import_picocolors17.default.bold(n2)).join(import_picocolors17.default.dim(" \xB7 "));
-          console.log(`     ${import_picocolors17.default.yellow(short)} ${import_picocolors17.default.dim("\u2500\u2500")} ${nameStr}`);
+          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 subject = await getCommitSubject(hash);
           if (subject) {
-            console.log(`                ${import_picocolors17.default.dim(subject)}`);
+            console.log(`                ${import_picocolors18.default.dim(subject)}`);
           }
         }
         if (branchesAligned) {
-          console.log(`     ${import_picocolors17.default.green("\u2713")} ${import_picocolors17.default.green("All branches aligned")} ${import_picocolors17.default.dim("\u2014 ready to start")}`);
+          console.log(`     ${import_picocolors18.default.green("\u2713")} ${import_picocolors18.default.green("All branches aligned")} ${import_picocolors18.default.dim("\u2014 ready to start")}`);
         } else {
-          console.log(`     ${import_picocolors17.default.yellow("\u26A0")} ${import_picocolors17.default.yellow("Branches are not fully aligned")}`);
+          console.log(`     ${import_picocolors18.default.yellow("\u26A0")} ${import_picocolors18.default.yellow("Branches are not fully aligned")}`);
         }
       }
     }
@@ -14462,41 +14571,41 @@ var status_default = defineCommand({
     if (hasFiles) {
       console.log();
       if (fileStatus.staged.length > 0) {
-        console.log(`  ${import_picocolors17.default.green("Staged for commit:")}`);
+        console.log(`  ${import_picocolors18.default.green("Staged for commit:")}`);
         for (const { file, status } of fileStatus.staged) {
-          console.log(`    ${import_picocolors17.default.green("+")} ${import_picocolors17.default.dim(`${status}:`)} ${file}`);
+          console.log(`    ${import_picocolors18.default.green("+")} ${import_picocolors18.default.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.modified.length > 0) {
-        console.log(`  ${import_picocolors17.default.yellow("Unstaged changes:")}`);
+        console.log(`  ${import_picocolors18.default.yellow("Unstaged changes:")}`);
         for (const { file, status } of fileStatus.modified) {
-          console.log(`    ${import_picocolors17.default.yellow("~")} ${import_picocolors17.default.dim(`${status}:`)} ${file}`);
+          console.log(`    ${import_picocolors18.default.yellow("~")} ${import_picocolors18.default.dim(`${status}:`)} ${file}`);
         }
       }
       if (fileStatus.untracked.length > 0) {
-        console.log(`  ${import_picocolors17.default.red("Untracked files:")}`);
+        console.log(`  ${import_picocolors18.default.red("Untracked files:")}`);
         for (const file of fileStatus.untracked) {
-          console.log(`    ${import_picocolors17.default.red("?")} ${file}`);
+          console.log(`    ${import_picocolors18.default.red("?")} ${file}`);
         }
       }
     } else if (!dirty) {
-      console.log(`  ${import_picocolors17.default.green("\u2713")}  ${import_picocolors17.default.dim("Working tree clean")}`);
+      console.log(`  ${import_picocolors18.default.green("\u2713")}  ${import_picocolors18.default.dim("Working tree clean")}`);
     }
     console.log();
   }
 });
 function formatStatus(branch, base, ahead, behind) {
-  const label = import_picocolors17.default.bold(branch.padEnd(20));
+  const label = import_picocolors18.default.bold(branch.padEnd(20));
   if (ahead === 0 && behind === 0) {
-    return `  ${import_picocolors17.default.green("\u2713")}  ${label} ${import_picocolors17.default.dim(`in sync with ${base}`)}`;
+    return `  ${import_picocolors18.default.green("\u2713")}  ${label} ${import_picocolors18.default.dim(`in sync with ${base}`)}`;
   }
   if (ahead > 0 && behind === 0) {
-    return `  ${import_picocolors17.default.yellow("\u2191")}  ${label} ${import_picocolors17.default.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+    return `  ${import_picocolors18.default.yellow("\u2191")}  ${label} ${import_picocolors18.default.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
   }
   if (behind > 0 && ahead === 0) {
-    return `  ${import_picocolors17.default.red("\u2193")}  ${label} ${import_picocolors17.default.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+    return `  ${import_picocolors18.default.red("\u2193")}  ${label} ${import_picocolors18.default.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
   }
-  return `  ${import_picocolors17.default.red("\u26A1")}  ${label} ${import_picocolors17.default.yellow(`${ahead} ahead`)}${import_picocolors17.default.dim(", ")}${import_picocolors17.default.red(`${behind} behind`)} ${import_picocolors17.default.dim(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)}`;
 }
 var STALE_THRESHOLD_DAYS = 14;
 async function detectBranchStatus(branch, baseBranch) {
@@ -14547,15 +14656,15 @@ async function detectBranchStatus(branch, baseBranch) {
 }
 
 // src/commands/submit.ts
-var import_picocolors18 = __toESM(require_picocolors(), 1);
+var import_picocolors19 = __toESM(require_picocolors(), 1);
 async function performSquashMerge(origin, baseBranch, featureBranch, options) {
-  info(`Checking out ${import_picocolors18.default.bold(baseBranch)}...`);
+  info(`Checking out ${import_picocolors19.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_picocolors18.default.bold(featureBranch)} into ${import_picocolors18.default.bold(baseBranch)}...`);
+  info(`Squash merging ${import_picocolors19.default.bold(featureBranch)} into ${import_picocolors19.default.bold(baseBranch)}...`);
   const mergeResult = await mergeSquash(featureBranch);
   if (mergeResult.exitCode !== 0) {
     error(`Squash merge failed: ${mergeResult.stderr}`);
@@ -14575,7 +14684,7 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
           message = aiMsg;
           spinner.success("AI commit message generated.");
           console.log(`
-  ${import_picocolors18.default.dim("AI suggestion:")} ${import_picocolors18.default.bold(import_picocolors18.default.cyan(message))}`);
+  ${import_picocolors19.default.dim("AI suggestion:")} ${import_picocolors19.default.bold(import_picocolors19.default.cyan(message))}`);
           break;
         }
         spinner.fail("AI did not return a commit message.");
@@ -14615,7 +14724,7 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
           message = regen;
           spinner.success("Commit message regenerated.");
           console.log(`
-  ${import_picocolors18.default.dim("AI suggestion:")} ${import_picocolors18.default.bold(import_picocolors18.default.cyan(regen))}`);
+  ${import_picocolors19.default.dim("AI suggestion:")} ${import_picocolors19.default.bold(import_picocolors19.default.cyan(regen))}`);
         } else {
           spinner.fail("Regeneration failed.");
         }
@@ -14631,13 +14740,13 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
     error(`Commit failed: ${commitResult.stderr}`);
     process.exit(1);
   }
-  info(`Pushing ${import_picocolors18.default.bold(baseBranch)} to ${origin}...`);
+  info(`Pushing ${import_picocolors19.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_picocolors18.default.bold(featureBranch)}...`);
+  info(`Deleting local branch ${import_picocolors19.default.bold(featureBranch)}...`);
   const delLocal = await forceDeleteBranch(featureBranch);
   if (delLocal.exitCode !== 0) {
     warn(`Could not delete local branch: ${delLocal.stderr.trim()}`);
@@ -14645,14 +14754,14 @@ async function performSquashMerge(origin, baseBranch, featureBranch, options) {
   const remoteBranchRef = `${origin}/${featureBranch}`;
   const remoteExists = await branchExists(remoteBranchRef);
   if (remoteExists) {
-    info(`Deleting remote branch ${import_picocolors18.default.bold(featureBranch)}...`);
+    info(`Deleting remote branch ${import_picocolors19.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_picocolors18.default.bold(featureBranch)} into ${import_picocolors18.default.bold(baseBranch)} and pushed.`);
-  info(`Run ${import_picocolors18.default.bold("contrib start")} to begin a new feature.`, "");
+  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.`, "");
 }
 var submit_default = defineCommand({
   meta: {
@@ -14695,7 +14804,7 @@ var submit_default = defineCommand({
     await assertCleanGitState("submitting");
     const config = readConfig();
     if (!config) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     const { origin } = config;
@@ -14709,7 +14818,7 @@ var submit_default = defineCommand({
     }
     if (protectedBranches.includes(currentBranch)) {
       await projectHeading("submit", "\uD83D\uDE80");
-      warn(`You're on ${import_picocolors18.default.bold(currentBranch)}, which is a protected branch. PRs should come from feature branches.`);
+      warn(`You're on ${import_picocolors19.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);
@@ -14718,11 +14827,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_picocolors18.default.bold("contrib start")} to create a new feature branch.`, "");
+        info(`  Run ${import_picocolors19.default.bold("cn start")} to create a new feature branch.`, "");
         process.exit(1);
       }
       if (hasCommits) {
-        info(`Found ${import_picocolors18.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors18.default.bold(currentBranch)}.`);
+        info(`Found ${import_picocolors19.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors19.default.bold(currentBranch)}.`);
       }
       if (dirty) {
         info("You also have uncommitted changes in the working tree.");
@@ -14752,12 +14861,12 @@ var submit_default = defineCommand({
         error(`Failed to create branch: ${branchResult.stderr}`);
         process.exit(1);
       }
-      success(`Created ${import_picocolors18.default.bold(newBranchName)} with your changes.`);
+      success(`Created ${import_picocolors19.default.bold(newBranchName)} with your changes.`);
       await updateLocalBranch(currentBranch, remoteRef);
-      info(`Reset ${import_picocolors18.default.bold(currentBranch)} back to ${import_picocolors18.default.bold(remoteRef)} \u2014 no damage done.`, "");
+      info(`Reset ${import_picocolors19.default.bold(currentBranch)} back to ${import_picocolors19.default.bold(remoteRef)} \u2014 no damage done.`, "");
       console.log();
-      success(`You're now on ${import_picocolors18.default.bold(newBranchName)} with all your work intact.`);
-      info(`Run ${import_picocolors18.default.bold("contrib submit")} again to push and create your PR.`, "");
+      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.`, "");
       return;
     }
     await projectHeading("submit", "\uD83D\uDE80");
@@ -14766,7 +14875,7 @@ var submit_default = defineCommand({
     if (ghInstalled && ghAuthed) {
       const mergedPR = await getMergedPRForBranch(currentBranch);
       if (mergedPR) {
-        warn(`PR #${mergedPR.number} (${import_picocolors18.default.bold(mergedPR.title)}) was already merged.`);
+        warn(`PR #${mergedPR.number} (${import_picocolors19.default.bold(mergedPR.title)}) was already merged.`);
         const localWork = await hasLocalWork(origin, currentBranch);
         const hasWork = localWork.uncommitted || localWork.unpushedCommits > 0;
         if (hasWork) {
@@ -14774,7 +14883,7 @@ var submit_default = defineCommand({
             warn("You have uncommitted changes in your working tree.");
           }
           if (localWork.unpushedCommits > 0) {
-            warn(`You have ${import_picocolors18.default.bold(String(localWork.unpushedCommits))} local commit${localWork.unpushedCommits !== 1 ? "s" : ""} not in the merged PR.`);
+            warn(`You have ${import_picocolors19.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";
@@ -14801,10 +14910,10 @@ var submit_default = defineCommand({
               error(`Failed to rename branch: ${renameResult.stderr}`);
               process.exit(1);
             }
-            success(`Renamed ${import_picocolors18.default.bold(currentBranch)} \u2192 ${import_picocolors18.default.bold(newBranchName)}`);
+            success(`Renamed ${import_picocolors19.default.bold(currentBranch)} \u2192 ${import_picocolors19.default.bold(newBranchName)}`);
             await unsetUpstream();
             const syncSource2 = getSyncSource(config);
-            info(`Syncing ${import_picocolors18.default.bold(newBranchName)} with latest ${import_picocolors18.default.bold(baseBranch)}...`);
+            info(`Syncing ${import_picocolors19.default.bold(newBranchName)} with latest ${import_picocolors19.default.bold(baseBranch)}...`);
             await fetchRemote(syncSource2.remote);
             let rebaseResult;
             if (staleUpstreamHash) {
@@ -14815,17 +14924,17 @@ var submit_default = defineCommand({
             }
             if (rebaseResult.exitCode !== 0) {
               warn("Rebase encountered conflicts. Resolve them manually, then run:");
-              info(`  ${import_picocolors18.default.bold("git rebase --continue")}`, "");
+              info(`  ${import_picocolors19.default.bold("git rebase --continue")}`, "");
             } else {
-              success(`Rebased ${import_picocolors18.default.bold(newBranchName)} onto ${import_picocolors18.default.bold(syncSource2.ref)}.`);
+              success(`Rebased ${import_picocolors19.default.bold(newBranchName)} onto ${import_picocolors19.default.bold(syncSource2.ref)}.`);
             }
-            info(`All your changes are preserved. Run ${import_picocolors18.default.bold("contrib submit")} when ready to create a new PR.`, "");
+            info(`All your changes are preserved. Run ${import_picocolors19.default.bold("cn submit")} when ready to create a new PR.`, "");
             return;
           }
           warn("Discarding local changes...");
         }
         const syncSource = getSyncSource(config);
-        info(`Switching to ${import_picocolors18.default.bold(baseBranch)} and syncing...`);
+        info(`Switching to ${import_picocolors19.default.bold(baseBranch)} and syncing...`);
         await fetchRemote(syncSource.remote);
         await resetHard("HEAD");
         const coResult = await checkoutBranch(baseBranch);
@@ -14834,35 +14943,35 @@ var submit_default = defineCommand({
           process.exit(1);
         }
         await updateLocalBranch(baseBranch, syncSource.ref);
-        success(`Synced ${import_picocolors18.default.bold(baseBranch)} with ${import_picocolors18.default.bold(syncSource.ref)}.`);
-        info(`Deleting stale branch ${import_picocolors18.default.bold(currentBranch)}...`);
+        success(`Synced ${import_picocolors19.default.bold(baseBranch)} with ${import_picocolors19.default.bold(syncSource.ref)}.`);
+        info(`Deleting stale branch ${import_picocolors19.default.bold(currentBranch)}...`);
         const delResult = await forceDeleteBranch(currentBranch);
         if (delResult.exitCode === 0) {
-          success(`Deleted ${import_picocolors18.default.bold(currentBranch)}.`);
+          success(`Deleted ${import_picocolors19.default.bold(currentBranch)}.`);
         } else {
           warn(`Could not delete branch: ${delResult.stderr.trim()}`);
         }
         console.log();
-        info(`You're now on ${import_picocolors18.default.bold(baseBranch)}. Run ${import_picocolors18.default.bold("contrib start")} to begin a new feature.`);
+        info(`You're now on ${import_picocolors19.default.bold(baseBranch)}. Run ${import_picocolors19.default.bold("cn start")} to begin a new feature.`);
         return;
       }
     }
     if (ghInstalled && ghAuthed) {
       const existingPR = await getPRForBranch(currentBranch);
       if (existingPR) {
-        info(`Pushing ${import_picocolors18.default.bold(currentBranch)} to ${origin}...`);
+        info(`Pushing ${import_picocolors19.default.bold(currentBranch)} to ${origin}...`);
         const pushResult2 = await pushSetUpstream(origin, currentBranch);
         if (pushResult2.exitCode !== 0) {
           error(`Failed to push: ${pushResult2.stderr}`);
           if (pushResult2.stderr.includes("rejected") || pushResult2.stderr.includes("non-fast-forward")) {
             warn("The remote branch has diverged. Try:");
             info(`  git pull --rebase ${origin} ${currentBranch}`, "");
-            info("  Then run `contrib submit` again.", "");
+            info("  Then run `cn submit` again.", "");
           }
           process.exit(1);
         }
-        success(`Pushed changes to existing PR #${existingPR.number}: ${import_picocolors18.default.bold(existingPR.title)}`);
-        console.log(`  ${import_picocolors18.default.cyan(existingPR.url)}`);
+        success(`Pushed changes to existing PR #${existingPR.number}: ${import_picocolors19.default.bold(existingPR.title)}`);
+        console.log(`  ${import_picocolors19.default.cyan(existingPR.url)}`);
         return;
       }
     }
@@ -14884,10 +14993,10 @@ var submit_default = defineCommand({
           prBody = result.body;
           spinner.success("PR description generated.");
           console.log(`
-  ${import_picocolors18.default.dim("AI title:")} ${import_picocolors18.default.bold(import_picocolors18.default.cyan(prTitle))}`);
+  ${import_picocolors19.default.dim("AI title:")} ${import_picocolors19.default.bold(import_picocolors19.default.cyan(prTitle))}`);
           console.log(`
-${import_picocolors18.default.dim("AI body preview:")}`);
-          console.log(import_picocolors18.default.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+${import_picocolors19.default.dim("AI body preview:")}`);
+          console.log(import_picocolors19.default.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
         } else {
           spinner.fail("AI did not return a PR description.");
         }
@@ -14998,14 +15107,14 @@ ${import_picocolors18.default.dim("AI body preview:")}`);
       warn("Submit cancelled.");
       return;
     }
-    info(`Pushing ${import_picocolors18.default.bold(currentBranch)} to ${origin}...`);
+    info(`Pushing ${import_picocolors19.default.bold(currentBranch)} to ${origin}...`);
     const pushResult = await pushSetUpstream(origin, currentBranch);
     if (pushResult.exitCode !== 0) {
       error(`Failed to push: ${pushResult.stderr}`);
       if (pushResult.stderr.includes("rejected") || pushResult.stderr.includes("non-fast-forward")) {
         warn("The remote branch has diverged. Try:");
         info(`  git pull --rebase ${origin} ${currentBranch}`, "");
-        info("  Then run `contrib submit` again.", "");
+        info("  Then run `cn submit` again.", "");
         info("If you need to force push (use with caution):", "");
         info(`  git push --force-with-lease ${origin} ${currentBranch}`, "");
       }
@@ -15017,7 +15126,7 @@ ${import_picocolors18.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_picocolors18.default.cyan(prUrl)}`);
+        console.log(`  ${import_picocolors19.default.cyan(prUrl)}`);
       } else {
         info("gh CLI not available. Create your PR manually on GitHub.", "");
       }
@@ -15051,7 +15160,7 @@ ${import_picocolors18.default.dim("AI body preview:")}`);
 });
 
 // src/commands/switch.ts
-var import_picocolors19 = __toESM(require_picocolors(), 1);
+var import_picocolors20 = __toESM(require_picocolors(), 1);
 var switch_default = defineCommand({
   meta: {
     name: "switch",
@@ -15083,11 +15192,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_picocolors19.default.red("protected"));
+          labels.push(import_picocolors20.default.red("protected"));
         if (b2.upstream)
-          labels.push(import_picocolors19.default.dim(`\u2192 ${b2.upstream}`));
+          labels.push(import_picocolors20.default.dim(`\u2192 ${b2.upstream}`));
         if (b2.gone)
-          labels.push(import_picocolors19.default.red("remote gone"));
+          labels.push(import_picocolors20.default.red("remote gone"));
         const suffix = labels.length > 0 ? `  ${labels.join(" \xB7 ")}` : "";
         return `${b2.name}${suffix}`;
       });
@@ -15099,7 +15208,7 @@ var switch_default = defineCommand({
       targetBranch = selected.split(/\s{2,}/)[0].trim();
     }
     if (targetBranch === currentBranch) {
-      info(`Already on ${import_picocolors19.default.bold(targetBranch)}.`);
+      info(`Already on ${import_picocolors20.default.bold(targetBranch)}.`);
       return;
     }
     if (await hasUncommittedChanges()) {
@@ -15118,7 +15227,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_picocolors19.default.dim(stashMsg)}`);
+        info(`Saved changes: ${import_picocolors20.default.dim(stashMsg)}`);
       } catch {
         error("Failed to save changes. Please commit or save manually.");
         process.exit(1);
@@ -15130,13 +15239,13 @@ var switch_default = defineCommand({
           await exec("git", ["stash", "pop"]);
           info("Restored saved changes.");
         } catch {
-          warn("Could not restore save automatically. Use `contrib save --restore` to recover.");
+          warn("Could not restore save automatically. Use `cn save --restore` to recover.");
         }
         process.exit(1);
       }
-      success(`Switched to ${import_picocolors19.default.bold(targetBranch)}`);
-      info(`Your changes from ${import_picocolors19.default.bold(currentBranch ?? "previous branch")} are saved.`, "");
-      info(`Use ${import_picocolors19.default.bold("contrib save --restore")} to bring them back.`, "");
+      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.`, "");
       return;
     }
     const result = await checkoutBranch(targetBranch);
@@ -15144,12 +15253,12 @@ var switch_default = defineCommand({
       error(`Failed to switch to ${targetBranch}: ${result.stderr}`);
       process.exit(1);
     }
-    success(`Switched to ${import_picocolors19.default.bold(targetBranch)}`);
+    success(`Switched to ${import_picocolors20.default.bold(targetBranch)}`);
   }
 });
 
 // src/commands/sync.ts
-var import_picocolors20 = __toESM(require_picocolors(), 1);
+var import_picocolors21 = __toESM(require_picocolors(), 1);
 var sync_default = defineCommand({
   meta: {
     name: "sync",
@@ -15180,7 +15289,7 @@ var sync_default = defineCommand({
     await assertCleanGitState("syncing");
     const config = readConfig();
     if (!config) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     const { workflow, role, origin } = config;
@@ -15201,24 +15310,24 @@ var sync_default = defineCommand({
       await fetchRemote(origin);
     }
     if (!await refExists(syncSource.ref)) {
-      error(`Remote ref ${import_picocolors20.default.bold(syncSource.ref)} does not exist.`);
+      error(`Remote ref ${import_picocolors21.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_picocolors20.default.bold("contrib setup")}.`, "");
+      info(`Check your config: the base branch may need updating via ${import_picocolors21.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_picocolors20.default.bold(baseBranch)} is ${import_picocolors20.default.yellow(`${div.ahead} ahead`)} and ${import_picocolors20.default.red(`${div.behind} behind`)} ${syncSource.ref}`);
+      info(`${import_picocolors21.default.bold(baseBranch)} is ${import_picocolors21.default.yellow(`${div.ahead} ahead`)} and ${import_picocolors21.default.red(`${div.behind} behind`)} ${syncSource.ref}`);
     } else {
-      info(`${import_picocolors20.default.bold(baseBranch)} is already in sync with ${syncSource.ref}`);
+      info(`${import_picocolors21.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_picocolors20.default.bold(String(div.ahead))} local commit${div.ahead !== 1 ? "s" : ""} on ${import_picocolors20.default.bold(baseBranch)} that aren't on the remote.`);
+        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.`);
         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";
@@ -15248,7 +15357,7 @@ var sync_default = defineCommand({
             error(`Failed to create branch: ${branchResult.stderr}`);
             process.exit(1);
           }
-          success(`Created ${import_picocolors20.default.bold(newBranchName)} with your commits.`);
+          success(`Created ${import_picocolors21.default.bold(newBranchName)} with your commits.`);
           const coResult2 = await checkoutBranch(baseBranch);
           if (coResult2.exitCode !== 0) {
             error(`Failed to checkout ${baseBranch}: ${coResult2.stderr}`);
@@ -15256,11 +15365,11 @@ var sync_default = defineCommand({
           }
           const remoteRef = syncSource.ref;
           await updateLocalBranch(baseBranch, remoteRef);
-          success(`Reset ${import_picocolors20.default.bold(baseBranch)} to ${import_picocolors20.default.bold(remoteRef)}.`);
-          success(`${import_picocolors20.default.bold(baseBranch)} is now in sync with ${syncSource.ref}`);
+          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}`);
           console.log();
-          info(`Your commits are safe on ${import_picocolors20.default.bold(newBranchName)}.`, "");
-          info(`Run ${import_picocolors20.default.bold(`git checkout ${newBranchName}`)} then ${import_picocolors20.default.bold("contrib update")} to rebase onto the synced ${import_picocolors20.default.bold(baseBranch)}.`, "");
+          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)}.`, "");
           return;
         }
         allowMergeCommit = true;
@@ -15268,7 +15377,7 @@ var sync_default = defineCommand({
       }
     }
     if (!args.yes) {
-      const ok = await confirmPrompt(`This will pull ${import_picocolors20.default.bold(syncSource.ref)} into local ${import_picocolors20.default.bold(baseBranch)}.`);
+      const ok = await confirmPrompt(`This will pull ${import_picocolors21.default.bold(syncSource.ref)} into local ${import_picocolors21.default.bold(baseBranch)}.`);
       if (!ok)
         process.exit(0);
     }
@@ -15282,8 +15391,8 @@ var sync_default = defineCommand({
       if (allowMergeCommit) {
         error(`Pull failed: ${pullResult.stderr.trim()}`);
       } else {
-        error(`Fast-forward pull failed. Your local ${import_picocolors20.default.bold(baseBranch)} may have diverged.`);
-        info(`Use ${import_picocolors20.default.bold("contrib sync")} again and choose "Move my commits to a new feature branch" to fix this.`, "");
+        error(`Fast-forward pull failed. Your local ${import_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.`, "");
       }
       process.exit(1);
     }
@@ -15291,7 +15400,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_picocolors20.default.bold(config.mainBranch)}...`);
+        info(`Also syncing ${import_picocolors21.default.bold(config.mainBranch)}...`);
         const mainCoResult = await checkoutBranch(config.mainBranch);
         if (mainCoResult.exitCode === 0) {
           const mainPullResult = await pullFastForwardOnly(origin, config.mainBranch);
@@ -15332,20 +15441,20 @@ var sync_default = defineCommand({
           }
         }
         console.log();
-        console.log(`  ${import_picocolors20.default.bold("\uD83D\uDD17 Branch Alignment")}`);
+        console.log(`  ${import_picocolors21.default.bold("\uD83D\uDD17 Branch Alignment")}`);
         for (const [hash, names] of groups) {
           const short = hash.slice(0, 7);
-          const nameStr = names.map((n2) => import_picocolors20.default.bold(n2)).join(import_picocolors20.default.dim(" \xB7 "));
-          console.log(`     ${import_picocolors20.default.yellow(short)} ${import_picocolors20.default.dim("\u2500\u2500")} ${nameStr}`);
+          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 subject = await getCommitSubject(hash);
           if (subject) {
-            console.log(`                ${import_picocolors20.default.dim(subject)}`);
+            console.log(`                ${import_picocolors21.default.dim(subject)}`);
           }
         }
         if (groups.size === 1) {
-          console.log(`     ${import_picocolors20.default.green("\u2713")} ${import_picocolors20.default.green("All branches aligned")} ${import_picocolors20.default.dim("\u2014 ready to start")}`);
+          console.log(`     ${import_picocolors21.default.green("\u2713")} ${import_picocolors21.default.green("All branches aligned")} ${import_picocolors21.default.dim("\u2014 ready to start")}`);
         } else {
-          console.log(`     ${import_picocolors20.default.yellow("\u26A0")} ${import_picocolors20.default.yellow("Branches are not fully aligned")}`);
+          console.log(`     ${import_picocolors21.default.yellow("\u26A0")} ${import_picocolors21.default.yellow("Branches are not fully aligned")}`);
         }
       }
     }
@@ -15354,7 +15463,7 @@ var sync_default = defineCommand({
 
 // src/commands/update.ts
 import { readFileSync as readFileSync6 } from "fs";
-var import_picocolors21 = __toESM(require_picocolors(), 1);
+var import_picocolors22 = __toESM(require_picocolors(), 1);
 function hasStaleBranchWorkToPreserve(uniqueCommitsAheadOfBase, hasUncommittedChanges2) {
   return hasUncommittedChanges2 || uniqueCommitsAheadOfBase > 0;
 }
@@ -15382,7 +15491,7 @@ var update_default = defineCommand({
     await assertCleanGitState("updating");
     const config = readConfig();
     if (!config) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     const baseBranch = getBaseBranch(config);
@@ -15395,7 +15504,7 @@ var update_default = defineCommand({
     }
     if (protectedBranches.includes(currentBranch)) {
       await projectHeading("update", "\uD83D\uDD03");
-      warn(`You're on ${import_picocolors21.default.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
+      warn(`You're on ${import_picocolors22.default.bold(currentBranch)}, which is a protected branch. Updates (rebase) apply to feature branches.`);
       await fetchAll();
       const { origin } = config;
       const remoteRef = `${origin}/${currentBranch}`;
@@ -15404,12 +15513,12 @@ var update_default = defineCommand({
       const hasCommits = localWork.unpushedCommits > 0;
       const hasAnything = hasCommits || dirty;
       if (!hasAnything) {
-        info(`No local changes found on ${import_picocolors21.default.bold(currentBranch)}.`);
-        info(`Use ${import_picocolors21.default.bold("contrib sync")} to sync protected branches, or ${import_picocolors21.default.bold("contrib start")} to create a feature branch.`);
+        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.`);
         process.exit(1);
       }
       if (hasCommits) {
-        info(`Found ${import_picocolors21.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors21.default.bold(currentBranch)}.`);
+        info(`Found ${import_picocolors22.default.bold(String(localWork.unpushedCommits))} unpushed commit${localWork.unpushedCommits !== 1 ? "s" : ""} on ${import_picocolors22.default.bold(currentBranch)}.`);
       }
       if (dirty) {
         info("You also have uncommitted changes in the working tree.");
@@ -15439,12 +15548,12 @@ var update_default = defineCommand({
         error(`Failed to create branch: ${branchResult.stderr}`);
         process.exit(1);
       }
-      success(`Created ${import_picocolors21.default.bold(newBranchName)} with your changes.`);
+      success(`Created ${import_picocolors22.default.bold(newBranchName)} with your changes.`);
       await updateLocalBranch(currentBranch, remoteRef);
-      info(`Reset ${import_picocolors21.default.bold(currentBranch)} back to ${import_picocolors21.default.bold(remoteRef)} \u2014 no damage done.`, "");
+      info(`Reset ${import_picocolors22.default.bold(currentBranch)} back to ${import_picocolors22.default.bold(remoteRef)} \u2014 no damage done.`, "");
       console.log();
-      success(`You're now on ${import_picocolors21.default.bold(newBranchName)} with all your work intact.`);
-      info(`Run ${import_picocolors21.default.bold("contrib update")} again to rebase onto latest ${import_picocolors21.default.bold(baseBranch)}.`, "");
+      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)}.`, "");
       return;
     }
     if (await hasUncommittedChanges()) {
@@ -15454,8 +15563,8 @@ var update_default = defineCommand({
     await projectHeading("update", "\uD83D\uDD03");
     const mergedPR = await getMergedPRForBranch(currentBranch);
     if (mergedPR) {
-      warn(`PR #${mergedPR.number} (${import_picocolors21.default.bold(mergedPR.title)}) has already been merged.`);
-      info(`Link: ${import_picocolors21.default.underline(mergedPR.url)}`, "");
+      warn(`PR #${mergedPR.number} (${import_picocolors22.default.bold(mergedPR.title)}) has already been merged.`);
+      info(`Link: ${import_picocolors22.default.underline(mergedPR.url)}`, "");
       const uniqueCommitsAheadOfBase = await countCommitsAhead(currentBranch, syncSource.ref);
       const dirty = await hasUncommittedChanges();
       const hasWork = hasStaleBranchWorkToPreserve(uniqueCommitsAheadOfBase, dirty);
@@ -15464,12 +15573,12 @@ var update_default = defineCommand({
           info("You have uncommitted local changes.");
         }
         if (uniqueCommitsAheadOfBase > 0) {
-          info(`You have ${uniqueCommitsAheadOfBase} local commit(s) not in ${import_picocolors21.default.bold(syncSource.ref)}.`);
+          info(`You have ${uniqueCommitsAheadOfBase} local commit(s) not in ${import_picocolors22.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_picocolors21.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_picocolors22.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;
@@ -15491,7 +15600,7 @@ var update_default = defineCommand({
             error(`Failed to rename branch: ${renameResult.stderr}`);
             process.exit(1);
           }
-          success(`Renamed ${import_picocolors21.default.bold(currentBranch)} \u2192 ${import_picocolors21.default.bold(newBranchName)}`);
+          success(`Renamed ${import_picocolors22.default.bold(currentBranch)} \u2192 ${import_picocolors22.default.bold(newBranchName)}`);
           await unsetUpstream();
           await fetchRemote(syncSource.remote);
           let rebaseResult2;
@@ -15503,11 +15612,11 @@ var update_default = defineCommand({
           }
           if (rebaseResult2.exitCode !== 0) {
             warn("Rebase encountered conflicts. Resolve them manually, then run:");
-            info(`  ${import_picocolors21.default.bold("git rebase --continue")}`, "");
+            info(`  ${import_picocolors22.default.bold("git rebase --continue")}`, "");
           } else {
-            success(`Rebased ${import_picocolors21.default.bold(newBranchName)} onto ${import_picocolors21.default.bold(syncSource.ref)}.`);
+            success(`Rebased ${import_picocolors22.default.bold(newBranchName)} onto ${import_picocolors22.default.bold(syncSource.ref)}.`);
           }
-          info(`All your changes are preserved. Run ${import_picocolors21.default.bold("contrib submit")} when ready to create a new PR.`, "");
+          info(`All your changes are preserved. Run ${import_picocolors22.default.bold("cn submit")} when ready to create a new PR.`, "");
           return;
         }
         warn("Discarding local changes...");
@@ -15526,24 +15635,24 @@ var update_default = defineCommand({
         process.exit(1);
       }
       await updateLocalBranch(baseBranch, syncSource.ref);
-      success(`Synced ${import_picocolors21.default.bold(baseBranch)} with ${import_picocolors21.default.bold(syncSource.ref)}.`);
-      info(`Deleting stale branch ${import_picocolors21.default.bold(currentBranch)}...`);
+      success(`Synced ${import_picocolors22.default.bold(baseBranch)} with ${import_picocolors22.default.bold(syncSource.ref)}.`);
+      info(`Deleting stale branch ${import_picocolors22.default.bold(currentBranch)}...`);
       await forceDeleteBranch(currentBranch);
-      success(`Deleted ${import_picocolors21.default.bold(currentBranch)}.`);
-      info(`Run ${import_picocolors21.default.bold("contrib start")} to begin a new feature branch.`, "");
+      success(`Deleted ${import_picocolors22.default.bold(currentBranch)}.`);
+      info(`Run ${import_picocolors22.default.bold("cn start")} to begin a new feature branch.`, "");
       return;
     }
-    info(`Updating ${import_picocolors21.default.bold(currentBranch)} with latest ${import_picocolors21.default.bold(baseBranch)}...`);
+    info(`Updating ${import_picocolors22.default.bold(currentBranch)} with latest ${import_picocolors22.default.bold(baseBranch)}...`);
     await fetchRemote(syncSource.remote);
     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.`);
       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_picocolors21.default.dim(`Using --onto rebase (branch was based on a different ref)`));
+      info(import_picocolors22.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) {
@@ -15574,10 +15683,10 @@ ${content.slice(0, 2000)}
             if (suggestion) {
               spinner.success("AI conflict guidance ready.");
               console.log(`
-${import_picocolors21.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
-              console.log(import_picocolors21.default.dim("\u2500".repeat(60)));
+${import_picocolors22.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(import_picocolors22.default.dim("\u2500".repeat(60)));
               console.log(suggestion);
-              console.log(import_picocolors21.default.dim("\u2500".repeat(60)));
+              console.log(import_picocolors22.default.dim("\u2500".repeat(60)));
               console.log();
             } else {
               spinner.fail("AI could not analyze the conflicts.");
@@ -15585,21 +15694,21 @@ ${import_picocolors21.default.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance
           }
         }
       }
-      console.log(import_picocolors21.default.bold("To resolve:"));
+      console.log(import_picocolors22.default.bold("To resolve:"));
       console.log(`  1. Fix conflicts in the affected files`);
-      console.log(`  2. ${import_picocolors21.default.cyan("git add <resolved-files>")}`);
-      console.log(`  3. ${import_picocolors21.default.cyan("git rebase --continue")}`);
+      console.log(`  2. ${import_picocolors22.default.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${import_picocolors22.default.cyan("git rebase --continue")}`);
       console.log();
-      console.log(`  Or abort: ${import_picocolors21.default.cyan("git rebase --abort")}`);
+      console.log(`  Or abort: ${import_picocolors22.default.cyan("git rebase --abort")}`);
       process.exit(1);
     }
-    success(`${import_picocolors21.default.bold(currentBranch)} has been rebased onto latest ${import_picocolors21.default.bold(baseBranch)}`);
+    success(`${import_picocolors22.default.bold(currentBranch)} has been rebased onto latest ${import_picocolors22.default.bold(baseBranch)}`);
   }
 });
 
 // src/commands/validate.ts
 import { readFileSync as readFileSync7 } from "fs";
-var import_picocolors22 = __toESM(require_picocolors(), 1);
+var import_picocolors23 = __toESM(require_picocolors(), 1);
 var validate_default = defineCommand({
   meta: {
     name: "validate",
@@ -15619,7 +15728,7 @@ var validate_default = defineCommand({
   async run({ args }) {
     const config = readConfig();
     if (!config) {
-      error("No repo config found. Run `contrib setup` first.");
+      error("No repo config found. Run `cn setup` first.");
       process.exit(1);
     }
     await projectHeading("validate", "\u2705");
@@ -15639,1402 +15748,14 @@ var validate_default = defineCommand({
     }
     const errors = getValidationError(convention);
     for (const line of errors) {
-      console.error(import_picocolors22.default.red(`  \u2717 ${line}`));
+      console.error(import_picocolors23.default.red(`  \u2717 ${line}`));
     }
     process.exit(1);
   }
 });
 
-// node_modules/figlet/dist/node-figlet.mjs
-import * as fs2 from "fs";
-import * as path2 from "path";
-
-// node_modules/figlet/dist/figlet-B0EdFl3_.js
-var LAYOUT = {
-  FULL_WIDTH: 0,
-  FITTING: 1,
-  SMUSHING: 2,
-  CONTROLLED_SMUSHING: 3
-};
-
-class FigletFont {
-  constructor() {
-    this.comment = "";
-    this.numChars = 0;
-    this.options = {};
-  }
-}
-var fontList = [
-  "1Row",
-  "3-D",
-  "3D Diagonal",
-  "3D-ASCII",
-  "3x5",
-  "4Max",
-  "5 Line Oblique",
-  "AMC 3 Line",
-  "AMC 3 Liv1",
-  "AMC AAA01",
-  "AMC Neko",
-  "AMC Razor",
-  "AMC Razor2",
-  "AMC Slash",
-  "AMC Slider",
-  "AMC Thin",
-  "AMC Tubes",
-  "AMC Untitled",
-  "ANSI Compact",
-  "ANSI Regular",
-  "ANSI Shadow",
-  "ASCII 12",
-  "ASCII 9",
-  "ASCII New Roman",
-  "Acrobatic",
-  "Alligator",
-  "Alligator2",
-  "Alpha",
-  "Alphabet",
-  "Arrows",
-  "Avatar",
-  "B1FF",
-  "Babyface Lame",
-  "Babyface Leet",
-  "Banner",
-  "Banner3-D",
-  "Banner3",
-  "Banner4",
-  "Barbwire",
-  "Basic",
-  "Bear",
-  "Bell",
-  "Benjamin",
-  "Big ASCII 12",
-  "Big ASCII 9",
-  "Big Chief",
-  "Big Money-ne",
-  "Big Money-nw",
-  "Big Money-se",
-  "Big Money-sw",
-  "Big Mono 12",
-  "Big Mono 9",
-  "Big",
-  "Bigfig",
-  "Binary",
-  "Block",
-  "Blocks",
-  "Bloody",
-  "BlurVision ASCII",
-  "Bolger",
-  "Braced",
-  "Bright",
-  "Broadway KB",
-  "Broadway",
-  "Bubble",
-  "Bulbhead",
-  "Caligraphy",
-  "Caligraphy2",
-  "Calvin S",
-  "Cards",
-  "Catwalk",
-  "Chiseled",
-  "Chunky",
-  "Circle",
-  "Classy",
-  "Coder Mini",
-  "Coinstak",
-  "Cola",
-  "Colossal",
-  "Computer",
-  "Contessa",
-  "Contrast",
-  "Cosmike",
-  "Cosmike2",
-  "Crawford",
-  "Crawford2",
-  "Crazy",
-  "Cricket",
-  "Cursive",
-  "Cyberlarge",
-  "Cybermedium",
-  "Cybersmall",
-  "Cygnet",
-  "DANC4",
-  "DOS Rebel",
-  "DWhistled",
-  "Dancing Font",
-  "Decimal",
-  "Def Leppard",
-  "Delta Corps Priest 1",
-  "DiamFont",
-  "Diamond",
-  "Diet Cola",
-  "Digital",
-  "Doh",
-  "Doom",
-  "Dot Matrix",
-  "Double Shorts",
-  "Double",
-  "Dr Pepper",
-  "Efti Chess",
-  "Efti Font",
-  "Efti Italic",
-  "Efti Piti",
-  "Efti Robot",
-  "Efti Wall",
-  "Efti Water",
-  "Electronic",
-  "Elite",
-  "Emboss 2",
-  "Emboss",
-  "Epic",
-  "Fender",
-  "Filter",
-  "Fire Font-k",
-  "Fire Font-s",
-  "Flipped",
-  "Flower Power",
-  "Font Font",
-  "Four Tops",
-  "Fraktur",
-  "Fun Face",
-  "Fun Faces",
-  "Future",
-  "Fuzzy",
-  "Georgi16",
-  "Georgia11",
-  "Ghost",
-  "Ghoulish",
-  "Glenyn",
-  "Goofy",
-  "Gothic",
-  "Graceful",
-  "Gradient",
-  "Graffiti",
-  "Greek",
-  "Heart Left",
-  "Heart Right",
-  "Henry 3D",
-  "Hex",
-  "Hieroglyphs",
-  "Hollywood",
-  "Horizontal Left",
-  "Horizontal Right",
-  "ICL-1900",
-  "Impossible",
-  "Invita",
-  "Isometric1",
-  "Isometric2",
-  "Isometric3",
-  "Isometric4",
-  "Italic",
-  "Ivrit",
-  "JS Block Letters",
-  "JS Bracket Letters",
-  "JS Capital Curves",
-  "JS Cursive",
-  "JS Stick Letters",
-  "Jacky",
-  "Jazmine",
-  "Jerusalem",
-  "Katakana",
-  "Kban",
-  "Keyboard",
-  "Knob",
-  "Konto Slant",
-  "Konto",
-  "LCD",
-  "Larry 3D 2",
-  "Larry 3D",
-  "Lean",
-  "Letter",
-  "Letters",
-  "Lil Devil",
-  "Line Blocks",
-  "Linux",
-  "Lockergnome",
-  "Madrid",
-  "Marquee",
-  "Maxfour",
-  "Merlin1",
-  "Merlin2",
-  "Mike",
-  "Mini",
-  "Mirror",
-  "Mnemonic",
-  "Modular",
-  "Mono 12",
-  "Mono 9",
-  "Morse",
-  "Morse2",
-  "Moscow",
-  "Mshebrew210",
-  "Muzzle",
-  "NScript",
-  "NT Greek",
-  "NV Script",
-  "Nancyj-Fancy",
-  "Nancyj-Improved",
-  "Nancyj-Underlined",
-  "Nancyj",
-  "Nipples",
-  "O8",
-  "OS2",
-  "Octal",
-  "Ogre",
-  "Old Banner",
-  "Pagga",
-  "Patorjk's Cheese",
-  "Patorjk-HeX",
-  "Pawp",
-  "Peaks Slant",
-  "Peaks",
-  "Pebbles",
-  "Pepper",
-  "Poison",
-  "Puffy",
-  "Puzzle",
-  "Pyramid",
-  "Rammstein",
-  "Rebel",
-  "Rectangles",
-  "Red Phoenix",
-  "Relief",
-  "Relief2",
-  "Reverse",
-  "Roman",
-  "Rot13",
-  "Rotated",
-  "Rounded",
-  "Rowan Cap",
-  "Rozzo",
-  "RubiFont",
-  "Runic",
-  "Runyc",
-  "S Blood",
-  "SL Script",
-  "Santa Clara",
-  "Script",
-  "Serifcap",
-  "Shaded Blocky",
-  "Shadow",
-  "Shimrod",
-  "Short",
-  "Slant Relief",
-  "Slant",
-  "Slide",
-  "Small ASCII 12",
-  "Small ASCII 9",
-  "Small Block",
-  "Small Braille",
-  "Small Caps",
-  "Small Isometric1",
-  "Small Keyboard",
-  "Small Mono 12",
-  "Small Mono 9",
-  "Small Poison",
-  "Small Script",
-  "Small Shadow",
-  "Small Slant",
-  "Small Tengwar",
-  "Small",
-  "Soft",
-  "Speed",
-  "Spliff",
-  "Stacey",
-  "Stampate",
-  "Stampatello",
-  "Standard",
-  "Star Strips",
-  "Star Wars",
-  "Stellar",
-  "Stforek",
-  "Stick Letters",
-  "Stop",
-  "Straight",
-  "Stronger Than All",
-  "Sub-Zero",
-  "Swamp Land",
-  "Swan",
-  "Sweet",
-  "THIS",
-  "Tanja",
-  "Tengwar",
-  "Term",
-  "Terrace",
-  "Test1",
-  "The Edge",
-  "Thick",
-  "Thin",
-  "Thorned",
-  "Three Point",
-  "Ticks Slant",
-  "Ticks",
-  "Tiles",
-  "Tinker-Toy",
-  "Tmplr",
-  "Tombstone",
-  "Train",
-  "Trek",
-  "Tsalagi",
-  "Tubular",
-  "Twisted",
-  "Two Point",
-  "USA Flag",
-  "Univers",
-  "Upside Down Text",
-  "Varsity",
-  "Wavescape",
-  "Wavy",
-  "Weird",
-  "Wet Letter",
-  "Whimsy",
-  "WideTerm",
-  "Wow",
-  "miniwi"
-];
-var renamedFonts = {
-  "ANSI-Compact": "ANSI Compact"
-};
-var getFontName = (name) => {
-  return renamedFonts[name] ? renamedFonts[name] : name;
-};
-function escapeRegExpChar(char) {
-  const specialChars = /[.*+?^${}()|[\]\\]/;
-  return specialChars.test(char) ? "\\" + char : char;
-}
-var figlet = (() => {
-  const { FULL_WIDTH = 0, FITTING, SMUSHING, CONTROLLED_SMUSHING } = LAYOUT;
-  const figFonts = {};
-  const figDefaults = {
-    font: "Standard",
-    fontPath: "./fonts",
-    fetchFontIfMissing: true
-  };
-  function removeEndChar(line, lineNum, fontHeight) {
-    const endChar = escapeRegExpChar(line.trim().slice(-1)) || "@";
-    const endCharRegEx = lineNum === fontHeight - 1 ? new RegExp(endChar + endChar + "?\\s*$") : new RegExp(endChar + "\\s*$");
-    return line.replace(endCharRegEx, "");
-  }
-  function getSmushingRules(oldLayout = -1, newLayout = null) {
-    let rules = {};
-    let val;
-    let codes = [
-      [16384, "vLayout", SMUSHING],
-      [8192, "vLayout", FITTING],
-      [4096, "vRule5", true],
-      [2048, "vRule4", true],
-      [1024, "vRule3", true],
-      [512, "vRule2", true],
-      [256, "vRule1", true],
-      [128, "hLayout", SMUSHING],
-      [64, "hLayout", FITTING],
-      [32, "hRule6", true],
-      [16, "hRule5", true],
-      [8, "hRule4", true],
-      [4, "hRule3", true],
-      [2, "hRule2", true],
-      [1, "hRule1", true]
-    ];
-    val = newLayout !== null ? newLayout : oldLayout;
-    for (const [code, rule, value] of codes) {
-      if (val >= code) {
-        val -= code;
-        if (rules[rule] === undefined) {
-          rules[rule] = value;
-        }
-      } else if (rule !== "vLayout" && rule !== "hLayout") {
-        rules[rule] = false;
-      }
-    }
-    if (typeof rules["hLayout"] === "undefined") {
-      if (oldLayout === 0) {
-        rules["hLayout"] = FITTING;
-      } else if (oldLayout === -1) {
-        rules["hLayout"] = FULL_WIDTH;
-      } else {
-        if (rules["hRule1"] || rules["hRule2"] || rules["hRule3"] || rules["hRule4"] || rules["hRule5"] || rules["hRule6"]) {
-          rules["hLayout"] = CONTROLLED_SMUSHING;
-        } else {
-          rules["hLayout"] = SMUSHING;
-        }
-      }
-    } else if (rules["hLayout"] === SMUSHING) {
-      if (rules["hRule1"] || rules["hRule2"] || rules["hRule3"] || rules["hRule4"] || rules["hRule5"] || rules["hRule6"]) {
-        rules["hLayout"] = CONTROLLED_SMUSHING;
-      }
-    }
-    if (typeof rules["vLayout"] === "undefined") {
-      if (rules["vRule1"] || rules["vRule2"] || rules["vRule3"] || rules["vRule4"] || rules["vRule5"]) {
-        rules["vLayout"] = CONTROLLED_SMUSHING;
-      } else {
-        rules["vLayout"] = FULL_WIDTH;
-      }
-    } else if (rules["vLayout"] === SMUSHING) {
-      if (rules["vRule1"] || rules["vRule2"] || rules["vRule3"] || rules["vRule4"] || rules["vRule5"]) {
-        rules["vLayout"] = CONTROLLED_SMUSHING;
-      }
-    }
-    return rules;
-  }
-  function hRule1_Smush(ch1, ch2, hardBlank = "") {
-    if (ch1 === ch2 && ch1 !== hardBlank) {
-      return ch1;
-    }
-    return false;
-  }
-  function hRule2_Smush(ch1, ch2) {
-    let rule2Str = "|/\\[]{}()<>";
-    if (ch1 === "_") {
-      if (rule2Str.indexOf(ch2) !== -1) {
-        return ch2;
-      }
-    } else if (ch2 === "_") {
-      if (rule2Str.indexOf(ch1) !== -1) {
-        return ch1;
-      }
-    }
-    return false;
-  }
-  function hRule3_Smush(ch1, ch2) {
-    let rule3Classes = "| /\\ [] {} () <>";
-    let r3_pos1 = rule3Classes.indexOf(ch1);
-    let r3_pos2 = rule3Classes.indexOf(ch2);
-    if (r3_pos1 !== -1 && r3_pos2 !== -1) {
-      if (r3_pos1 !== r3_pos2 && Math.abs(r3_pos1 - r3_pos2) !== 1) {
-        const startPos = Math.max(r3_pos1, r3_pos2);
-        const endPos = startPos + 1;
-        return rule3Classes.substring(startPos, endPos);
-      }
-    }
-    return false;
-  }
-  function hRule4_Smush(ch1, ch2) {
-    let rule4Str = "[] {} ()";
-    let r4_pos1 = rule4Str.indexOf(ch1);
-    let r4_pos2 = rule4Str.indexOf(ch2);
-    if (r4_pos1 !== -1 && r4_pos2 !== -1) {
-      if (Math.abs(r4_pos1 - r4_pos2) <= 1) {
-        return "|";
-      }
-    }
-    return false;
-  }
-  function hRule5_Smush(ch1, ch2) {
-    const patterns = {
-      "/\\": "|",
-      "\\/": "Y",
-      "><": "X"
-    };
-    return patterns[ch1 + ch2] || false;
-  }
-  function hRule6_Smush(ch1, ch2, hardBlank = "") {
-    if (ch1 === hardBlank && ch2 === hardBlank) {
-      return hardBlank;
-    }
-    return false;
-  }
-  function vRule1_Smush(ch1, ch2) {
-    if (ch1 === ch2) {
-      return ch1;
-    }
-    return false;
-  }
-  function vRule2_Smush(ch1, ch2) {
-    return hRule2_Smush(ch1, ch2);
-  }
-  function vRule3_Smush(ch1, ch2) {
-    return hRule3_Smush(ch1, ch2);
-  }
-  function vRule4_Smush(ch1, ch2) {
-    if (ch1 === "-" && ch2 === "_" || ch1 === "_" && ch2 === "-") {
-      return "=";
-    }
-    return false;
-  }
-  function vRule5_Smush(ch1, ch2) {
-    if (ch1 === "|" && ch2 === "|") {
-      return "|";
-    }
-    return false;
-  }
-  function uni_Smush(ch1, ch2, hardBlank) {
-    if (ch2 === " " || ch2 === "") {
-      return ch1;
-    } else if (ch2 === hardBlank && ch1 !== " ") {
-      return ch1;
-    } else {
-      return ch2;
-    }
-  }
-  function canVerticalSmush(txt1, txt2, opts) {
-    if (opts.fittingRules && opts.fittingRules.vLayout === FULL_WIDTH) {
-      return "invalid";
-    }
-    let ii, len = Math.min(txt1.length, txt2.length), ch1, ch2, endSmush = false, validSmush;
-    if (len === 0) {
-      return "invalid";
-    }
-    for (ii = 0;ii < len; ii++) {
-      ch1 = txt1.substring(ii, ii + 1);
-      ch2 = txt2.substring(ii, ii + 1);
-      if (ch1 !== " " && ch2 !== " ") {
-        if (opts.fittingRules && opts.fittingRules.vLayout === FITTING) {
-          return "invalid";
-        } else if (opts.fittingRules && opts.fittingRules.vLayout === SMUSHING) {
-          return "end";
-        } else {
-          if (vRule5_Smush(ch1, ch2)) {
-            endSmush = endSmush || false;
-            continue;
-          }
-          validSmush = false;
-          validSmush = opts.fittingRules && opts.fittingRules.vRule1 ? vRule1_Smush(ch1, ch2) : validSmush;
-          validSmush = !validSmush && opts.fittingRules && opts.fittingRules.vRule2 ? vRule2_Smush(ch1, ch2) : validSmush;
-          validSmush = !validSmush && opts.fittingRules && opts.fittingRules.vRule3 ? vRule3_Smush(ch1, ch2) : validSmush;
-          validSmush = !validSmush && opts.fittingRules && opts.fittingRules.vRule4 ? vRule4_Smush(ch1, ch2) : validSmush;
-          endSmush = true;
-          if (!validSmush) {
-            return "invalid";
-          }
-        }
-      }
-    }
-    if (endSmush) {
-      return "end";
-    } else {
-      return "valid";
-    }
-  }
-  function getVerticalSmushDist(lines1, lines2, opts) {
-    let maxDist = lines1.length;
-    let len1 = lines1.length;
-    let subLines1, subLines2, slen;
-    let curDist = 1;
-    let ii, ret, result;
-    while (curDist <= maxDist) {
-      subLines1 = lines1.slice(Math.max(0, len1 - curDist), len1);
-      subLines2 = lines2.slice(0, Math.min(maxDist, curDist));
-      slen = subLines2.length;
-      result = "";
-      for (ii = 0;ii < slen; ii++) {
-        ret = canVerticalSmush(subLines1[ii], subLines2[ii], opts);
-        if (ret === "end") {
-          result = ret;
-        } else if (ret === "invalid") {
-          result = ret;
-          break;
-        } else {
-          if (result === "") {
-            result = "valid";
-          }
-        }
-      }
-      if (result === "invalid") {
-        curDist--;
-        break;
-      }
-      if (result === "end") {
-        break;
-      }
-      if (result === "valid") {
-        curDist++;
-      }
-    }
-    return Math.min(maxDist, curDist);
-  }
-  function verticallySmushLines(line1, line2, opts) {
-    let ii, len = Math.min(line1.length, line2.length);
-    let ch1, ch2, result = "", validSmush;
-    const fittingRules = opts.fittingRules || {};
-    for (ii = 0;ii < len; ii++) {
-      ch1 = line1.substring(ii, ii + 1);
-      ch2 = line2.substring(ii, ii + 1);
-      if (ch1 !== " " && ch2 !== " ") {
-        if (fittingRules.vLayout === FITTING) {
-          result += uni_Smush(ch1, ch2);
-        } else if (fittingRules.vLayout === SMUSHING) {
-          result += uni_Smush(ch1, ch2);
-        } else {
-          validSmush = false;
-          validSmush = fittingRules.vRule5 ? vRule5_Smush(ch1, ch2) : validSmush;
-          validSmush = !validSmush && fittingRules.vRule1 ? vRule1_Smush(ch1, ch2) : validSmush;
-          validSmush = !validSmush && fittingRules.vRule2 ? vRule2_Smush(ch1, ch2) : validSmush;
-          validSmush = !validSmush && fittingRules.vRule3 ? vRule3_Smush(ch1, ch2) : validSmush;
-          validSmush = !validSmush && fittingRules.vRule4 ? vRule4_Smush(ch1, ch2) : validSmush;
-          result += validSmush;
-        }
-      } else {
-        result += uni_Smush(ch1, ch2);
-      }
-    }
-    return result;
-  }
-  function verticalSmush(lines1, lines2, overlap, opts) {
-    let len1 = lines1.length;
-    let len2 = lines2.length;
-    let piece1 = lines1.slice(0, Math.max(0, len1 - overlap));
-    let piece2_1 = lines1.slice(Math.max(0, len1 - overlap), len1);
-    let piece2_2 = lines2.slice(0, Math.min(overlap, len2));
-    let ii, len, line, piece2 = [], piece3;
-    len = piece2_1.length;
-    for (ii = 0;ii < len; ii++) {
-      if (ii >= len2) {
-        line = piece2_1[ii];
-      } else {
-        line = verticallySmushLines(piece2_1[ii], piece2_2[ii], opts);
-      }
-      piece2.push(line);
-    }
-    piece3 = lines2.slice(Math.min(overlap, len2), len2);
-    return [...piece1, ...piece2, ...piece3];
-  }
-  function padLines(lines, numSpaces) {
-    const padding = " ".repeat(numSpaces);
-    return lines.map((line) => line + padding);
-  }
-  function smushVerticalFigLines(output, lines, opts) {
-    let len1 = output[0].length;
-    let len2 = lines[0].length;
-    let overlap;
-    if (len1 > len2) {
-      lines = padLines(lines, len1 - len2);
-    } else if (len2 > len1) {
-      output = padLines(output, len2 - len1);
-    }
-    overlap = getVerticalSmushDist(output, lines, opts);
-    return verticalSmush(output, lines, overlap, opts);
-  }
-  function getHorizontalSmushLength(txt1, txt2, opts) {
-    const fittingRules = opts.fittingRules || {};
-    if (fittingRules.hLayout === FULL_WIDTH) {
-      return 0;
-    }
-    let ii, len1 = txt1.length, len2 = txt2.length;
-    let maxDist = len1;
-    let curDist = 1;
-    let breakAfter = false;
-    let seg1, seg2, ch1, ch2;
-    if (len1 === 0) {
-      return 0;
-    }
-    distCal:
-      while (curDist <= maxDist) {
-        const seg1StartPos = len1 - curDist;
-        seg1 = txt1.substring(seg1StartPos, seg1StartPos + curDist);
-        seg2 = txt2.substring(0, Math.min(curDist, len2));
-        for (ii = 0;ii < Math.min(curDist, len2); ii++) {
-          ch1 = seg1.substring(ii, ii + 1);
-          ch2 = seg2.substring(ii, ii + 1);
-          if (ch1 !== " " && ch2 !== " ") {
-            if (fittingRules.hLayout === FITTING) {
-              curDist = curDist - 1;
-              break distCal;
-            } else if (fittingRules.hLayout === SMUSHING) {
-              if (ch1 === opts.hardBlank || ch2 === opts.hardBlank) {
-                curDist = curDist - 1;
-              }
-              break distCal;
-            } else {
-              breakAfter = true;
-              const validSmush = fittingRules.hRule1 && hRule1_Smush(ch1, ch2, opts.hardBlank) || fittingRules.hRule2 && hRule2_Smush(ch1, ch2) || fittingRules.hRule3 && hRule3_Smush(ch1, ch2) || fittingRules.hRule4 && hRule4_Smush(ch1, ch2) || fittingRules.hRule5 && hRule5_Smush(ch1, ch2) || fittingRules.hRule6 && hRule6_Smush(ch1, ch2, opts.hardBlank);
-              if (!validSmush) {
-                curDist = curDist - 1;
-                break distCal;
-              }
-            }
-          }
-        }
-        if (breakAfter) {
-          break;
-        }
-        curDist++;
-      }
-    return Math.min(maxDist, curDist);
-  }
-  function horizontalSmush(textBlock1, textBlock2, overlap, opts) {
-    let ii, jj, outputFig = [], overlapStart, piece1, piece2, piece3, len1, len2, txt1, txt2;
-    const fittingRules = opts.fittingRules || {};
-    if (typeof opts.height !== "number") {
-      throw new Error("height is not defined.");
-    }
-    for (ii = 0;ii < opts.height; ii++) {
-      txt1 = textBlock1[ii];
-      txt2 = textBlock2[ii];
-      len1 = txt1.length;
-      len2 = txt2.length;
-      overlapStart = len1 - overlap;
-      piece1 = txt1.slice(0, Math.max(0, overlapStart));
-      piece2 = "";
-      const seg1StartPos = Math.max(0, len1 - overlap);
-      let seg1 = txt1.substring(seg1StartPos, seg1StartPos + overlap);
-      let seg2 = txt2.substring(0, Math.min(overlap, len2));
-      for (jj = 0;jj < overlap; jj++) {
-        let ch1 = jj < len1 ? seg1.substring(jj, jj + 1) : " ";
-        let ch2 = jj < len2 ? seg2.substring(jj, jj + 1) : " ";
-        if (ch1 !== " " && ch2 !== " ") {
-          if (fittingRules.hLayout === FITTING || fittingRules.hLayout === SMUSHING) {
-            piece2 += uni_Smush(ch1, ch2, opts.hardBlank);
-          } else {
-            const nextCh = fittingRules.hRule1 && hRule1_Smush(ch1, ch2, opts.hardBlank) || fittingRules.hRule2 && hRule2_Smush(ch1, ch2) || fittingRules.hRule3 && hRule3_Smush(ch1, ch2) || fittingRules.hRule4 && hRule4_Smush(ch1, ch2) || fittingRules.hRule5 && hRule5_Smush(ch1, ch2) || fittingRules.hRule6 && hRule6_Smush(ch1, ch2, opts.hardBlank) || uni_Smush(ch1, ch2, opts.hardBlank);
-            piece2 += nextCh;
-          }
-        } else {
-          piece2 += uni_Smush(ch1, ch2, opts.hardBlank);
-        }
-      }
-      if (overlap >= len2) {
-        piece3 = "";
-      } else {
-        piece3 = txt2.substring(overlap, overlap + Math.max(0, len2 - overlap));
-      }
-      outputFig[ii] = piece1 + piece2 + piece3;
-    }
-    return outputFig;
-  }
-  function newFigChar(len) {
-    return new Array(len).fill("");
-  }
-  const figLinesWidth = function(textLines) {
-    return Math.max(...textLines.map((line) => line.length));
-  };
-  function joinFigArray(array, len, opts) {
-    return array.reduce(function(acc, data) {
-      return horizontalSmush(acc, data.fig, data.overlap || 0, opts);
-    }, newFigChar(len));
-  }
-  function breakWord(figChars, len, opts) {
-    for (let i2 = figChars.length - 1;i2 > 0; i2--) {
-      const w2 = joinFigArray(figChars.slice(0, i2), len, opts);
-      if (figLinesWidth(w2) <= opts.width) {
-        return {
-          outputFigText: w2,
-          chars: figChars.slice(i2)
-        };
-      }
-    }
-    return { outputFigText: newFigChar(len), chars: figChars };
-  }
-  function generateFigTextLines(txt, figChars, opts) {
-    let charIndex, figChar, overlap = 0, row, outputFigText, len, height = opts.height, outputFigLines = [], maxWidth, nextFigChars = {
-      chars: [],
-      overlap
-    }, figWords = [], char, isSpace, textFigWord, textFigLine, tmpBreak;
-    if (typeof height !== "number") {
-      throw new Error("height is not defined.");
-    }
-    outputFigText = newFigChar(height);
-    const fittingRules = opts.fittingRules || {};
-    if (opts.printDirection === 1) {
-      txt = txt.split("").reverse().join("");
-    }
-    len = txt.length;
-    for (charIndex = 0;charIndex < len; charIndex++) {
-      char = txt.substring(charIndex, charIndex + 1);
-      isSpace = char.match(/\s/);
-      figChar = figChars[char.charCodeAt(0)];
-      textFigLine = null;
-      if (figChar) {
-        if (fittingRules.hLayout !== FULL_WIDTH) {
-          overlap = 1e4;
-          for (row = 0;row < height; row++) {
-            overlap = Math.min(overlap, getHorizontalSmushLength(outputFigText[row], figChar[row], opts));
-          }
-          overlap = overlap === 1e4 ? 0 : overlap;
-        }
-        if (opts.width > 0) {
-          if (opts.whitespaceBreak) {
-            textFigWord = joinFigArray(nextFigChars.chars.concat([
-              {
-                fig: figChar,
-                overlap
-              }
-            ]), height, opts);
-            textFigLine = joinFigArray(figWords.concat([
-              {
-                fig: textFigWord,
-                overlap: nextFigChars.overlap
-              }
-            ]), height, opts);
-            maxWidth = figLinesWidth(textFigLine);
-          } else {
-            textFigLine = horizontalSmush(outputFigText, figChar, overlap, opts);
-            maxWidth = figLinesWidth(textFigLine);
-          }
-          if (maxWidth >= opts.width && charIndex > 0) {
-            if (opts.whitespaceBreak) {
-              outputFigText = joinFigArray(figWords.slice(0, -1), height, opts);
-              if (figWords.length > 1) {
-                outputFigLines.push(outputFigText);
-                outputFigText = newFigChar(height);
-              }
-              figWords = [];
-            } else {
-              outputFigLines.push(outputFigText);
-              outputFigText = newFigChar(height);
-            }
-          }
-        }
-        if (opts.width > 0 && opts.whitespaceBreak) {
-          if (!isSpace || charIndex === len - 1) {
-            nextFigChars.chars.push({ fig: figChar, overlap });
-          }
-          if (isSpace || charIndex === len - 1) {
-            tmpBreak = null;
-            while (true) {
-              textFigLine = joinFigArray(nextFigChars.chars, height, opts);
-              maxWidth = figLinesWidth(textFigLine);
-              if (maxWidth >= opts.width) {
-                tmpBreak = breakWord(nextFigChars.chars, height, opts);
-                nextFigChars = { chars: tmpBreak.chars };
-                outputFigLines.push(tmpBreak.outputFigText);
-              } else {
-                break;
-              }
-            }
-            if (maxWidth > 0) {
-              if (tmpBreak) {
-                figWords.push({ fig: textFigLine, overlap: 1 });
-              } else {
-                figWords.push({
-                  fig: textFigLine,
-                  overlap: nextFigChars.overlap
-                });
-              }
-            }
-            if (isSpace) {
-              figWords.push({ fig: figChar, overlap });
-              outputFigText = newFigChar(height);
-            }
-            if (charIndex === len - 1) {
-              outputFigText = joinFigArray(figWords, height, opts);
-            }
-            nextFigChars = {
-              chars: [],
-              overlap
-            };
-            continue;
-          }
-        }
-        outputFigText = horizontalSmush(outputFigText, figChar, overlap, opts);
-      }
-    }
-    if (figLinesWidth(outputFigText) > 0) {
-      outputFigLines.push(outputFigText);
-    }
-    if (!opts.showHardBlanks) {
-      outputFigLines.forEach(function(outputFigText2) {
-        len = outputFigText2.length;
-        for (row = 0;row < len; row++) {
-          outputFigText2[row] = outputFigText2[row].replace(new RegExp("\\" + opts.hardBlank, "g"), " ");
-        }
-      });
-    }
-    if (txt === "" && outputFigLines.length === 0) {
-      outputFigLines.push(new Array(height).fill(""));
-    }
-    return outputFigLines;
-  }
-  const getHorizontalFittingRules = function(layout, options) {
-    let params;
-    const fittingRules = options.fittingRules || {};
-    if (layout === "default") {
-      params = {
-        hLayout: fittingRules.hLayout,
-        hRule1: fittingRules.hRule1,
-        hRule2: fittingRules.hRule2,
-        hRule3: fittingRules.hRule3,
-        hRule4: fittingRules.hRule4,
-        hRule5: fittingRules.hRule5,
-        hRule6: fittingRules.hRule6
-      };
-    } else if (layout === "full") {
-      params = {
-        hLayout: FULL_WIDTH,
-        hRule1: false,
-        hRule2: false,
-        hRule3: false,
-        hRule4: false,
-        hRule5: false,
-        hRule6: false
-      };
-    } else if (layout === "fitted") {
-      params = {
-        hLayout: FITTING,
-        hRule1: false,
-        hRule2: false,
-        hRule3: false,
-        hRule4: false,
-        hRule5: false,
-        hRule6: false
-      };
-    } else if (layout === "controlled smushing") {
-      params = {
-        hLayout: CONTROLLED_SMUSHING,
-        hRule1: true,
-        hRule2: true,
-        hRule3: true,
-        hRule4: true,
-        hRule5: true,
-        hRule6: true
-      };
-    } else if (layout === "universal smushing") {
-      params = {
-        hLayout: SMUSHING,
-        hRule1: false,
-        hRule2: false,
-        hRule3: false,
-        hRule4: false,
-        hRule5: false,
-        hRule6: false
-      };
-    } else {
-      return;
-    }
-    return params;
-  };
-  const getVerticalFittingRules = function(layout, options) {
-    let params = {};
-    const fittingRules = options.fittingRules || {};
-    if (layout === "default") {
-      params = {
-        vLayout: fittingRules.vLayout,
-        vRule1: fittingRules.vRule1,
-        vRule2: fittingRules.vRule2,
-        vRule3: fittingRules.vRule3,
-        vRule4: fittingRules.vRule4,
-        vRule5: fittingRules.vRule5
-      };
-    } else if (layout === "full") {
-      params = {
-        vLayout: FULL_WIDTH,
-        vRule1: false,
-        vRule2: false,
-        vRule3: false,
-        vRule4: false,
-        vRule5: false
-      };
-    } else if (layout === "fitted") {
-      params = {
-        vLayout: FITTING,
-        vRule1: false,
-        vRule2: false,
-        vRule3: false,
-        vRule4: false,
-        vRule5: false
-      };
-    } else if (layout === "controlled smushing") {
-      params = {
-        vLayout: CONTROLLED_SMUSHING,
-        vRule1: true,
-        vRule2: true,
-        vRule3: true,
-        vRule4: true,
-        vRule5: true
-      };
-    } else if (layout === "universal smushing") {
-      params = {
-        vLayout: SMUSHING,
-        vRule1: false,
-        vRule2: false,
-        vRule3: false,
-        vRule4: false,
-        vRule5: false
-      };
-    } else {
-      return;
-    }
-    return params;
-  };
-  const generateText = function(fontName, options, txt) {
-    txt = txt.replace(/\r\n/g, `
-`).replace(/\r/g, `
-`);
-    const actualFontName = getFontName(fontName);
-    let lines = txt.split(`
-`);
-    let figLines = [];
-    let ii, len, output;
-    len = lines.length;
-    for (ii = 0;ii < len; ii++) {
-      figLines = figLines.concat(generateFigTextLines(lines[ii], figFonts[actualFontName], options));
-    }
-    len = figLines.length;
-    output = figLines[0];
-    for (ii = 1;ii < len; ii++) {
-      output = smushVerticalFigLines(output, figLines[ii], options);
-    }
-    return output ? output.join(`
-`) : "";
-  };
-  function _reworkFontOpts(fontMeta, options) {
-    let myOpts;
-    if (typeof structuredClone !== "undefined") {
-      myOpts = structuredClone(fontMeta);
-    } else {
-      myOpts = JSON.parse(JSON.stringify(fontMeta));
-    }
-    myOpts.showHardBlanks = options.showHardBlanks || false;
-    myOpts.width = options.width || -1;
-    myOpts.whitespaceBreak = options.whitespaceBreak || false;
-    if (options.horizontalLayout) {
-      const params = getHorizontalFittingRules(options.horizontalLayout, fontMeta);
-      if (params) {
-        Object.assign(myOpts.fittingRules, params);
-      }
-    }
-    if (options.verticalLayout) {
-      const params = getVerticalFittingRules(options.verticalLayout, fontMeta);
-      if (params) {
-        Object.assign(myOpts.fittingRules, params);
-      }
-    }
-    myOpts.printDirection = options.printDirection !== null && options.printDirection !== undefined ? options.printDirection : fontMeta.printDirection;
-    return myOpts;
-  }
-  const me2 = async function(txt, optionsOrFontOrCallback, callback) {
-    return me2.text(txt, optionsOrFontOrCallback, callback);
-  };
-  me2.text = async function(txt, optionsOrFontOrCallback, callback) {
-    txt = txt + "";
-    let options, next;
-    if (typeof optionsOrFontOrCallback === "function") {
-      next = optionsOrFontOrCallback;
-      options = { font: figDefaults.font };
-    } else if (typeof optionsOrFontOrCallback === "string") {
-      options = { font: optionsOrFontOrCallback };
-      next = callback;
-    } else if (optionsOrFontOrCallback) {
-      options = optionsOrFontOrCallback;
-      next = callback;
-    } else {
-      options = { font: figDefaults.font };
-      next = callback;
-    }
-    const fontName = options.font || figDefaults.font;
-    try {
-      const fontOpts = await me2.loadFont(fontName);
-      const generatedTxt = fontOpts ? generateText(fontName, _reworkFontOpts(fontOpts, options), txt) : "";
-      if (next) {
-        next(null, generatedTxt);
-      }
-      return generatedTxt;
-    } catch (err) {
-      const error2 = err instanceof Error ? err : new Error(String(err));
-      if (next) {
-        next(error2);
-        return "";
-      }
-      throw error2;
-    }
-  };
-  me2.textSync = function(txt, options) {
-    txt = txt + "";
-    if (typeof options === "string") {
-      options = { font: options };
-    } else {
-      options = options || {};
-    }
-    const fontName = options.font || figDefaults.font;
-    let fontOpts = _reworkFontOpts(me2.loadFontSync(fontName), options);
-    return generateText(fontName, fontOpts, txt);
-  };
-  me2.metadata = async function(fontName, callback) {
-    fontName = fontName + "";
-    try {
-      const fontOpts = await me2.loadFont(fontName);
-      if (!fontOpts) {
-        throw new Error("Error loading font.");
-      }
-      const actualFontName = getFontName(fontName);
-      const font = figFonts[actualFontName] || {};
-      const result = [fontOpts, font.comment || ""];
-      if (callback) {
-        callback(null, fontOpts, font.comment);
-      }
-      return result;
-    } catch (err) {
-      const error2 = err instanceof Error ? err : new Error(String(err));
-      if (callback) {
-        callback(error2);
-        return null;
-      }
-      throw error2;
-    }
-  };
-  me2.defaults = function(opts) {
-    if (opts && typeof opts === "object") {
-      Object.assign(figDefaults, opts);
-    }
-    if (typeof structuredClone !== "undefined") {
-      return structuredClone(figDefaults);
-    } else {
-      return JSON.parse(JSON.stringify(figDefaults));
-    }
-  };
-  me2.parseFont = function(fontName, data, override = true) {
-    if (figFonts[fontName] && !override) {
-      return figFonts[fontName].options;
-    }
-    data = data.replace(/\r\n/g, `
-`).replace(/\r/g, `
-`);
-    const font = new FigletFont;
-    const lines = data.split(`
-`);
-    const headerLine = lines.shift();
-    if (!headerLine) {
-      throw new Error("Invalid font file: missing header");
-    }
-    const headerData = headerLine.split(" ");
-    const opts = {
-      hardBlank: headerData[0].substring(5, 6),
-      height: parseInt(headerData[1], 10),
-      baseline: parseInt(headerData[2], 10),
-      maxLength: parseInt(headerData[3], 10),
-      oldLayout: parseInt(headerData[4], 10),
-      numCommentLines: parseInt(headerData[5], 10),
-      printDirection: headerData[6] ? parseInt(headerData[6], 10) : 0,
-      fullLayout: headerData[7] ? parseInt(headerData[7], 10) : null,
-      codeTagCount: headerData[8] ? parseInt(headerData[8], 10) : null
-    };
-    const hardBlank = opts.hardBlank || "";
-    if (hardBlank.length !== 1 || [
-      opts.height,
-      opts.baseline,
-      opts.maxLength,
-      opts.oldLayout,
-      opts.numCommentLines
-    ].some((val) => val === null || val === undefined || isNaN(val))) {
-      throw new Error("FIGlet header contains invalid values.");
-    }
-    if (opts.height == null || opts.numCommentLines == null) {
-      throw new Error("FIGlet header contains invalid values.");
-    }
-    opts.fittingRules = getSmushingRules(opts.oldLayout, opts.fullLayout);
-    font.options = opts;
-    const charNums = [];
-    for (let i2 = 32;i2 <= 126; i2++) {
-      charNums.push(i2);
-    }
-    charNums.push(196, 214, 220, 228, 246, 252, 223);
-    if (lines.length < opts.numCommentLines + opts.height * charNums.length) {
-      throw new Error(`FIGlet file is missing data. Line length: ${lines.length}. Comment lines: ${opts.numCommentLines}. Height: ${opts.height}. Num chars: ${charNums.length}.`);
-    }
-    font.comment = lines.splice(0, opts.numCommentLines).join(`
-`);
-    font.numChars = 0;
-    while (lines.length > 0 && font.numChars < charNums.length) {
-      const cNum = charNums[font.numChars];
-      font[cNum] = lines.splice(0, opts.height);
-      for (let i2 = 0;i2 < opts.height; i2++) {
-        if (typeof font[cNum][i2] === "undefined") {
-          font[cNum][i2] = "";
-        } else {
-          font[cNum][i2] = removeEndChar(font[cNum][i2], i2, opts.height);
-        }
-      }
-      font.numChars++;
-    }
-    while (lines.length > 0) {
-      const cNumLine = lines.shift();
-      if (!cNumLine || cNumLine.trim() === "")
-        break;
-      let cNum = cNumLine.split(" ")[0];
-      let parsedNum;
-      if (/^-?0[xX][0-9a-fA-F]+$/.test(cNum)) {
-        parsedNum = parseInt(cNum, 16);
-      } else if (/^-?0[0-7]+$/.test(cNum)) {
-        parsedNum = parseInt(cNum, 8);
-      } else if (/^-?[0-9]+$/.test(cNum)) {
-        parsedNum = parseInt(cNum, 10);
-      } else {
-        throw new Error(`Error parsing data. Invalid data: ${cNum}`);
-      }
-      if (parsedNum === -1 || parsedNum < -2147483648 || parsedNum > 2147483647) {
-        const msg = parsedNum === -1 ? "The char code -1 is not permitted." : `The char code cannot be ${parsedNum < -2147483648 ? "less than -2147483648" : "greater than 2147483647"}.`;
-        throw new Error(`Error parsing data. ${msg}`);
-      }
-      font[parsedNum] = lines.splice(0, opts.height);
-      for (let i2 = 0;i2 < opts.height; i2++) {
-        if (typeof font[parsedNum][i2] === "undefined") {
-          font[parsedNum][i2] = "";
-        } else {
-          font[parsedNum][i2] = removeEndChar(font[parsedNum][i2], i2, opts.height);
-        }
-      }
-      font.numChars++;
-    }
-    figFonts[fontName] = font;
-    return opts;
-  };
-  me2.loadedFonts = () => {
-    return Object.keys(figFonts);
-  };
-  me2.clearLoadedFonts = () => {
-    Object.keys(figFonts).forEach((key) => {
-      delete figFonts[key];
-    });
-  };
-  me2.loadFont = async function(fontName, callback) {
-    const actualFontName = getFontName(fontName);
-    if (figFonts[actualFontName]) {
-      const result = figFonts[actualFontName].options;
-      if (callback) {
-        callback(null, result);
-      }
-      return Promise.resolve(result);
-    }
-    try {
-      if (!figDefaults.fetchFontIfMissing) {
-        throw new Error(`Font is not loaded: ${actualFontName}`);
-      }
-      const response = await fetch(`${figDefaults.fontPath}/${actualFontName}.flf`);
-      if (!response.ok) {
-        throw new Error(`Network response was not ok: ${response.status}`);
-      }
-      const text = await response.text();
-      const result = me2.parseFont(actualFontName, text);
-      if (callback) {
-        callback(null, result);
-      }
-      return result;
-    } catch (error2) {
-      const err = error2 instanceof Error ? error2 : new Error(String(error2));
-      if (callback) {
-        callback(err);
-        return null;
-      }
-      throw err;
-    }
-  };
-  me2.loadFontSync = function(name) {
-    const actualFontName = getFontName(name);
-    if (figFonts[actualFontName]) {
-      return figFonts[actualFontName].options;
-    }
-    throw new Error("Synchronous font loading is not implemented for the browser, it will only work for fonts already loaded.");
-  };
-  me2.preloadFonts = async function(fonts, callback) {
-    try {
-      for (const name of fonts) {
-        const actualFontName = getFontName(name);
-        const response = await fetch(`${figDefaults.fontPath}/${actualFontName}.flf`);
-        if (!response.ok) {
-          throw new Error(`Failed to preload fonts. Error fetching font: ${actualFontName}, status code: ${response.statusText}`);
-        }
-        const data = await response.text();
-        me2.parseFont(actualFontName, data);
-      }
-      if (callback) {
-        callback();
-      }
-    } catch (error2) {
-      const err = error2 instanceof Error ? error2 : new Error(String(error2));
-      if (callback) {
-        callback(err);
-        return;
-      }
-      throw error2;
-    }
-  };
-  me2.fonts = function(callback) {
-    return new Promise(function(resolve5, reject) {
-      resolve5(fontList);
-      if (callback) {
-        callback(null, fontList);
-      }
-    });
-  };
-  me2.fontsSync = function() {
-    return fontList;
-  };
-  me2.figFonts = figFonts;
-  return me2;
-})();
-
-// node_modules/figlet/dist/node-figlet.mjs
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var fontPath = path2.join(__dirname2, "/../fonts/");
-var nodeFiglet = figlet;
-nodeFiglet.defaults({ fontPath });
-nodeFiglet.loadFont = function(name, callback) {
-  const actualFontName = getFontName(name);
-  return new Promise((resolve5, reject) => {
-    if (nodeFiglet.figFonts[actualFontName]) {
-      if (callback) {
-        callback(null, nodeFiglet.figFonts[actualFontName].options);
-      }
-      resolve5(nodeFiglet.figFonts[actualFontName].options);
-      return;
-    }
-    fs2.readFile(path2.join(nodeFiglet.defaults().fontPath, actualFontName + ".flf"), { encoding: "utf-8" }, (err, fontData) => {
-      if (err) {
-        if (callback) {
-          callback(err);
-        }
-        reject(err);
-        return;
-      }
-      fontData = fontData + "";
-      try {
-        const font = nodeFiglet.parseFont(actualFontName, fontData);
-        if (callback) {
-          callback(null, font);
-        }
-        resolve5(font);
-      } catch (error2) {
-        const typedError = error2 instanceof Error ? error2 : new Error(String(error2));
-        if (callback) {
-          callback(typedError);
-        }
-        reject(typedError);
-      }
-    });
-  });
-};
-nodeFiglet.loadFontSync = function(font) {
-  const actualFontName = getFontName(font);
-  if (nodeFiglet.figFonts[actualFontName]) {
-    return nodeFiglet.figFonts[actualFontName].options;
-  }
-  const fontData = fs2.readFileSync(path2.join(nodeFiglet.defaults().fontPath, actualFontName + ".flf"), {
-    encoding: "utf-8"
-  }) + "";
-  return nodeFiglet.parseFont(actualFontName, fontData);
-};
-nodeFiglet.fonts = function(next) {
-  return new Promise((resolve5, reject) => {
-    const fontList2 = [];
-    fs2.readdir(nodeFiglet.defaults().fontPath, (err, files) => {
-      if (err) {
-        next && next(err);
-        reject(err);
-        return;
-      }
-      files.forEach((file) => {
-        if (/\.flf$/.test(file)) {
-          fontList2.push(file.replace(/\.flf$/, ""));
-        }
-      });
-      next && next(null, fontList2);
-      resolve5(fontList2);
-    });
-  });
-};
-nodeFiglet.fontsSync = function() {
-  const fontList2 = [];
-  fs2.readdirSync(nodeFiglet.defaults().fontPath).forEach((file) => {
-    if (/\.flf$/.test(file)) {
-      fontList2.push(file.replace(/\.flf$/, ""));
-    }
-  });
-  return fontList2;
-};
-
 // src/ui/banner.ts
-var import_picocolors23 = __toESM(require_picocolors(), 1);
+var import_picocolors24 = __toESM(require_picocolors(), 1);
 
 // src/data/announcements.json
 var announcements_default = [
@@ -17044,6 +15765,13 @@ var announcements_default = [
     title: "Legacy Config Detected",
     message: "Run cn setup to migrate this clone to local Git config, then delete .contributerc.json.",
     when: "legacy-config-present"
+  },
+  {
+    id: "contrib-command-deprecation",
+    kind: "info",
+    title: "Heads up: `contrib` will retire",
+    message: "The `contrib` command is being phased out. Please switch to `contribute` (primary) or the shorter `cn` shortcut \u2014 same features either way.",
+    when: "contrib-command-used"
   }
 ];
 
@@ -17059,25 +15787,28 @@ function shouldShowAnnouncement(announcement, cwd) {
   switch (announcement.when) {
     case "legacy-config-present":
       return hasLegacyConfig(cwd);
+    case "contrib-command-used":
+      return isLegacyCommandInvocation();
     default:
       return false;
   }
 }
+function isLegacyCommandInvocation() {
+  const entry = process.argv[1];
+  if (!entry)
+    return false;
+  const basename = entry.split(/[\\/]/).pop() ?? "";
+  const name = basename.replace(/\.(cmd|exe|ps1|bat|js|mjs|cjs)$/i, "").toLowerCase();
+  return name === "contrib";
+}
 
 // src/ui/banner.ts
-var LOGO_BIG;
-try {
-  LOGO_BIG = nodeFiglet.textSync(`Contribute
-Now`, { font: "ANSI Shadow" });
-} catch {
-  LOGO_BIG = "Contribute Now";
-}
-var LOGO_SMALL;
-try {
-  LOGO_SMALL = nodeFiglet.textSync("Contribute Now", { font: "Slant" });
-} catch {
-  LOGO_SMALL = "Contribute Now";
-}
+var LOGO = String.raw`   ______            __       _ __          __          _   __             
+  / ____/___  ____  / /______(_) /_  __  __/ /____     / | / /___ _      __
+ / /   / __ \/ __ \/ __/ ___/ / __ \/ / / / __/ _ \   /  |/ / __ \ | /| / /
+/ /___/ /_/ / / / / /_/ /  / / /_/ / /_/ / /_/  __/  / /|  / /_/ / |/ |/ / 
+\____/\____/_/ /_/\__/_/  /_/_.___/\__,_/\__/\___/  /_/ |_/\____/|__/|__/  
+                                                                           `;
 function getVersion() {
   return package_default.version ?? "unknown";
 }
@@ -17085,10 +15816,9 @@ function getAuthor() {
   return typeof package_default.author === "string" ? package_default.author : "unknown";
 }
 function showBanner(variant = "small") {
-  const logo = variant === "big" ? LOGO_BIG : LOGO_SMALL;
-  console.log(import_picocolors23.default.cyan(`
-${logo}`));
-  console.log(`  ${import_picocolors23.default.dim(`v${getVersion()}`)} ${import_picocolors23.default.dim("\u2014")} ${import_picocolors23.default.dim(`Built by ${getAuthor()}`)}`);
+  console.log(import_picocolors24.default.cyan(`
+${LOGO}`));
+  console.log(`  ${import_picocolors24.default.dim(`v${getVersion()}`)} ${import_picocolors24.default.dim("\u2014")} ${import_picocolors24.default.dim(`Built by ${getAuthor()}`)}`);
   const announcements = getActiveAnnouncements();
   if (announcements.length > 0) {
     console.log();
@@ -17097,27 +15827,27 @@ ${logo}`));
   if (variant === "big") {
     const panelLines = [
       {
-        label: import_picocolors23.default.bold(import_picocolors23.default.cyan("Getting Started")),
+        label: import_picocolors24.default.bold(import_picocolors24.default.cyan("Getting Started")),
         rawLabel: "Getting Started",
         value: "",
         rawValue: ""
       },
       {
-        label: import_picocolors23.default.cyan("cn setup"),
+        label: import_picocolors24.default.cyan("cn setup"),
         rawLabel: "cn setup",
-        value: import_picocolors23.default.dim("configure workflow, remotes, and defaults"),
+        value: import_picocolors24.default.dim("configure workflow, remotes, and defaults"),
         rawValue: "configure workflow, remotes, and defaults"
       },
       {
-        label: import_picocolors23.default.cyan("cn doctor"),
+        label: import_picocolors24.default.cyan("cn doctor"),
         rawLabel: "cn doctor",
-        value: import_picocolors23.default.dim("verify your environment before doing any work"),
+        value: import_picocolors24.default.dim("verify your environment before doing any work"),
         rawValue: "verify your environment before doing any work"
       },
       {
-        label: import_picocolors23.default.cyan("cn start"),
+        label: import_picocolors24.default.cyan("cn start"),
         rawLabel: "cn start",
-        value: import_picocolors23.default.dim("create a branch and begin the next task"),
+        value: import_picocolors24.default.dim("create a branch and begin the next task"),
         rawValue: "create a branch and begin the next task"
       },
       {
@@ -17127,13 +15857,13 @@ ${logo}`));
         rawValue: ""
       },
       {
-        label: import_picocolors23.default.bold(import_picocolors23.default.cyan("Workflow")),
+        label: import_picocolors24.default.bold(import_picocolors24.default.cyan("Workflow")),
         rawLabel: "Workflow",
         value: "",
         rawValue: ""
       },
       {
-        label: import_picocolors23.default.dim("cn setup \u2192 cn commit \u2192 cn update \u2192 cn submit"),
+        label: import_picocolors24.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: ""
@@ -17158,22 +15888,22 @@ ${logo}`));
       return Math.max(max, lineLength);
     }, 0));
     console.log();
-    console.log(`  ${import_picocolors23.default.dim(`\u250C${"\u2500".repeat(contentWidth + 2)}\u2510`)}`);
+    console.log(`  ${import_picocolors24.default.dim(`\u250C${"\u2500".repeat(contentWidth + 2)}\u2510`)}`);
     for (const line of rows) {
       if (!line.rawLabel && !line.rawValue) {
-        console.log(`  ${import_picocolors23.default.dim("\u2502")} ${" ".repeat(contentWidth)} ${import_picocolors23.default.dim("\u2502")}`);
+        console.log(`  ${import_picocolors24.default.dim("\u2502")} ${" ".repeat(contentWidth)} ${import_picocolors24.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_picocolors23.default.dim(line.rawValue) : "";
+      const value = line.rawValue ? import_picocolors24.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_picocolors23.default.dim("\u2502")} ${left}${value}${trailing} ${import_picocolors23.default.dim("\u2502")}`);
+      console.log(`  ${import_picocolors24.default.dim("\u2502")} ${left}${value}${trailing} ${import_picocolors24.default.dim("\u2502")}`);
     }
-    console.log(`  ${import_picocolors23.default.dim(`\u2514${"\u2500".repeat(contentWidth + 2)}\u2518`)}`);
+    console.log(`  ${import_picocolors24.default.dim(`\u2514${"\u2500".repeat(contentWidth + 2)}\u2518`)}`);
     console.log();
-    console.log(`  ${import_picocolors23.default.dim("Star or contribute:")} ${import_picocolors23.default.dim(linkify("gh.waren.build/contribute-now", "https://gh.waren.build/contribute-now"))}`);
-    console.log(`  ${import_picocolors23.default.dim("Sponsor:")} ${import_picocolors23.default.dim(linkify("warengonzaga.com/sponsor", "https://warengonzaga.com/sponsor"))}`);
+    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();
 }
@@ -17205,7 +15935,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_picocolors23.default.dim(line);
+    const content = line === title ? tone.title(line) : import_picocolors24.default.dim(line);
     console.log(`  ${tone.border("\u2502")} ${content}${trailing} ${tone.border("\u2502")}`);
   }
   console.log(`  ${tone.border(`\u2514${"\u2500".repeat(rawWidth + 2)}\u2518`)}`);
@@ -17241,20 +15971,20 @@ function getAnnouncementTone(kind) {
     case "info":
       return {
         emoji: "\u2139",
-        border: import_picocolors23.default.blue,
-        title: (value) => import_picocolors23.default.bold(import_picocolors23.default.blue(value))
+        border: import_picocolors24.default.blue,
+        title: (value) => import_picocolors24.default.bold(import_picocolors24.default.blue(value))
       };
     case "warning":
       return {
         emoji: "\uD83D\uDEA8",
-        border: import_picocolors23.default.red,
-        title: (value) => import_picocolors23.default.bold(import_picocolors23.default.red(value))
+        border: import_picocolors24.default.red,
+        title: (value) => import_picocolors24.default.bold(import_picocolors24.default.red(value))
       };
     default:
       return {
         emoji: "\u26A0",
-        border: import_picocolors23.default.yellow,
-        title: (value) => import_picocolors23.default.bold(import_picocolors23.default.yellow(value))
+        border: import_picocolors24.default.yellow,
+        title: (value) => import_picocolors24.default.bold(import_picocolors24.default.yellow(value))
       };
   }
 }
@@ -17285,6 +16015,7 @@ if (!isVersion) {
     "update",
     "submit",
     "switch",
+    "discard",
     "save",
     "clean",
     "status",
@@ -17301,7 +16032,7 @@ if (!isVersion) {
 }
 var main = defineCommand({
   meta: {
-    name: "contrib",
+    name: "cn",
     version: getVersion(),
     description: "Git workflow CLI that guides contributors through clean branching, commits, and PRs."
   },
@@ -17321,6 +16052,7 @@ var main = defineCommand({
     update: update_default,
     submit: submit_default,
     switch: switch_default,
+    discard: discard_default,
     save: save_default,
     branch: branch_default,
     clean: clean_default,
@@ -17332,8 +16064,11 @@ var main = defineCommand({
   },
   run({ args }) {
     if (args.version) {
-      console.log(`contrib v${getVersion()}`);
+      console.log(`cn v${getVersion()}`);
     }
   }
 });
-runMain(main);
+runMain(main).then(() => process.exit(process.exitCode ?? 0)).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});