@quikcommit/cli 8.0.0 → 9.0.0

package/dist/index.js

@@ -72,6 +72,70 @@ var init_tokens = __esm({
   }
 });
 
+// ../shared/dist/branch.js
+function validateBranchName(name) {
+  if (typeof name !== "string")
+    return false;
+  if (name.length > MAX_BRANCH_NAME_LENGTH)
+    return false;
+  if (!BRANCH_NAME_RX.test(name))
+    return false;
+  if (PROTECTED_BRANCH_RX.test(name))
+    return false;
+  return true;
+}
+function slugifyFilename(path) {
+  const basename = path.split("/").pop() ?? path;
+  const noExt = basename.replace(/\.[^.]+$/, "");
+  return noExt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+function deterministicBranchName(opts) {
+  const files = opts.files ?? [];
+  const haystack = `${opts.description ?? ""} ${files.join(" ")}`;
+  let type = "chore";
+  for (const [rx, t] of TYPE_HINTS) {
+    if (rx.test(haystack)) {
+      type = t;
+      break;
+    }
+  }
+  let slug;
+  if (opts.description) {
+    slug = opts.description.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").split("-").slice(0, 5).join("-").slice(0, 40);
+  } else if (files.length > 0) {
+    slug = slugifyFilename(files[0] ?? "");
+  } else {
+    slug = "changes";
+  }
+  if (!slug)
+    slug = "changes";
+  if (slug.length === 1)
+    slug = `${slug}-changes`;
+  const name = `${type}/${slug}`;
+  if (!validateBranchName(name)) {
+    return { type: "chore", slug: "updates", name: "chore/updates" };
+  }
+  return { name, type, slug };
+}
+var BRANCH_NAME_RX, PROTECTED_BRANCH_RX, MAX_BRANCH_NAME_LENGTH, TYPE_HINTS;
+var init_branch = __esm({
+  "../shared/dist/branch.js"() {
+    "use strict";
+    BRANCH_NAME_RX = /^(feat|fix|refactor|perf|docs|test|chore|ci)\/[a-z0-9][a-z0-9-]{0,51}$/;
+    PROTECTED_BRANCH_RX = /(^|[/-])(main|master|develop|trunk|release)([/-]|$)/i;
+    MAX_BRANCH_NAME_LENGTH = 60;
+    TYPE_HINTS = [
+      [/\btest|spec\b/i, "test"],
+      [/\bdocs?\b|readme|\.md$/i, "docs"],
+      [/\bperf|benchmark/i, "perf"],
+      [/\brefactor\b/i, "refactor"],
+      [/\bci|workflow|github\/actions/i, "ci"],
+      [/\bfix|bug|issue/i, "fix"],
+      [/\bfeat|add|new\b/i, "feat"]
+    ];
+  }
+});
+
 // ../shared/dist/index.js
 var init_dist = __esm({
   "../shared/dist/index.js"() {
@@ -80,10 +144,19 @@ var init_dist = __esm({
     init_constants();
     init_rules();
     init_tokens();
+    init_branch();
   }
 });
 
 // src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearApiKey: () => clearApiKey,
+  getApiKey: () => getApiKey,
+  getConfig: () => getConfig,
+  saveApiKey: () => saveApiKey,
+  saveConfig: () => saveConfig
+});
 function getApiKey() {
   const envKey = process.env.QC_API_KEY;
   if (envKey?.trim()) return envKey.trim();
@@ -310,6 +383,13 @@ var init_api = __esm({
           body: JSON.stringify(body)
         });
         if (!res.ok) {
+          if (res.status === 413) {
+            const errBody = await res.json().catch(() => ({}));
+            const sizeHint = errBody.received_bytes ? ` (${Math.round(errBody.received_bytes / 1024)}KB > ${Math.round((errBody.limit_bytes ?? 0) / 1024)}KB limit)` : "";
+            throw new Error(
+              `Diff too large to send${sizeHint}. Try: qc --exclude '*.lock' --exclude 'dist/**' (or commit fewer files at a time).`
+            );
+          }
           const err = await res.json().catch(() => ({ error: res.statusText }));
           if (planRequiredMsg && err.code === "PLAN_REQUIRED") {
             throw new Error(planRequiredMsg);
@@ -356,6 +436,9 @@ var init_api = __esm({
           summary: data.summary ?? ""
         };
       }
+      async generateBranchName(req) {
+        return this.request("/v1/branch", req);
+      }
       async fetchJson(endpoint, options) {
         if (!this.apiKey) {
           throw new Error("Not authenticated. Run `qc login` first.");
@@ -7751,6 +7834,9 @@ var require_dist = __commonJS({
 
 // src/git.ts
 function validateRef(ref, name = "ref") {
+  if (ref.startsWith("-")) {
+    throw new Error(`Invalid git ref ${name}: starts with hyphen: "${ref}"`);
+  }
   if (!ref || !SAFE_GIT_REF.test(ref)) {
     throw new Error(`Invalid git ref ${name}: "${ref}"`);
   }
@@ -7893,6 +7979,23 @@ function getFullDiff(base = "main") {
     maxBuffer: 10 * 1024 * 1024
   });
 }
+function getStagedDiffShortstat() {
+  try {
+    const out = (0, import_child_process2.execFileSync)("git", ["diff", "--cached", "--shortstat"], {
+      encoding: "utf-8"
+    }).trim();
+    if (!out) return { additions: 0, deletions: 0 };
+    let additions = 0;
+    let deletions = 0;
+    const ins = /(\d+) insertion/.exec(out);
+    const del = /(\d+) deletion/.exec(out);
+    if (ins?.[1]) additions = parseInt(ins[1], 10);
+    if (del?.[1]) deletions = parseInt(del[1], 10);
+    return { additions, deletions };
+  } catch {
+    return { additions: 0, deletions: 0 };
+  }
+}
 function getShortStagedFiles(max = 3) {
   const output = (0, import_child_process2.execFileSync)("git", ["diff", "--cached", "--name-only"], {
     encoding: "utf-8"
@@ -7939,6 +8042,105 @@ function getRecentBranchCommits(count = 5) {
     return [];
   }
 }
+function getCommitsAheadOfUpstream(branch, upstream) {
+  validateRef(branch, "branch");
+  const target = upstream ?? `origin/${branch}`;
+  validateRef(target, "upstream");
+  try {
+    const out = (0, import_child_process2.execFileSync)(
+      "git",
+      ["rev-list", "--count", `${target}..HEAD`],
+      { encoding: "utf-8" }
+    ).trim();
+    const n = parseInt(out, 10);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+function getUpstreamRef(branch) {
+  validateRef(branch, "branch");
+  try {
+    return (0, import_child_process2.execFileSync)(
+      "git",
+      ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`],
+      { encoding: "utf-8" }
+    ).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getDefaultBranch() {
+  try {
+    const out = (0, import_child_process2.execFileSync)(
+      "git",
+      ["symbolic-ref", "refs/remotes/origin/HEAD"],
+      { encoding: "utf-8" }
+    ).trim();
+    const segments = out.split("/");
+    return segments[segments.length - 1] || null;
+  } catch {
+    return null;
+  }
+}
+function branchExists(name) {
+  validateRef(name, "branch");
+  try {
+    (0, import_child_process2.execFileSync)("git", ["show-ref", "--verify", "--quiet", `refs/heads/${name}`], {
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+  }
+  try {
+    (0, import_child_process2.execFileSync)("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${name}`], {
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stashPushIfDirty(message) {
+  const status = (0, import_child_process2.execFileSync)("git", ["status", "--porcelain"], { encoding: "utf-8" }).trim();
+  if (!status) return false;
+  (0, import_child_process2.execFileSync)("git", ["stash", "push", "--include-untracked", "--message", message], {
+    stdio: "pipe"
+  });
+  return true;
+}
+function stashPop() {
+  (0, import_child_process2.execFileSync)("git", ["stash", "pop"], { stdio: "pipe" });
+}
+function resetHard(ref) {
+  validateRef(ref, "ref");
+  (0, import_child_process2.execFileSync)("git", ["reset", "--hard", ref], { stdio: "pipe" });
+}
+function createBranch(name, base = "HEAD") {
+  validateRef(name, "name");
+  validateRef(base, "base");
+  (0, import_child_process2.execFileSync)("git", ["branch", name, base], { stdio: "pipe" });
+}
+function checkoutBranch(name) {
+  validateRef(name, "name");
+  (0, import_child_process2.execFileSync)("git", ["checkout", name], { stdio: "pipe" });
+}
+function createAndCheckoutBranch(name, base = "HEAD") {
+  validateRef(name, "name");
+  validateRef(base, "base");
+  (0, import_child_process2.execFileSync)("git", ["checkout", "-b", name, base], { stdio: "pipe" });
+}
+function getHeadSha() {
+  return (0, import_child_process2.execFileSync)("git", ["rev-parse", "HEAD"], { encoding: "utf-8" }).trim();
+}
+function gitPushSetUpstream(branch) {
+  validateRef(branch, "branch");
+  (0, import_child_process2.execFileSync)("git", ["push", "-u", "origin", branch], { stdio: "inherit" });
+}
+function deleteBranch(name) {
+  validateRef(name, "name");
+  (0, import_child_process2.execFileSync)("git", ["branch", "-D", name], { stdio: "pipe" });
+}
 var import_child_process2, import_fs2, import_path2, import_os3, SAFE_GIT_REF;
 var init_git = __esm({
   "src/git.ts"() {
@@ -7947,7 +8149,7 @@ var init_git = __esm({
     import_fs2 = require("fs");
     import_path2 = require("path");
     import_os3 = require("os");
-    SAFE_GIT_REF = /^[a-zA-Z0-9._\-/~:^@]+$/;
+    SAFE_GIT_REF = /^[a-zA-Z0-9][a-zA-Z0-9._\-/~:^@]*$/;
   }
 });
 
@@ -8762,1061 +8964,2053 @@ var init_changeset = __esm({
   }
 });
 
-// src/commands/init.ts
-var init_exports = {};
-__export(init_exports, {
-  init: () => init
-});
-function init(options) {
-  let hooksDir;
-  try {
-    hooksDir = (0, import_child_process6.execFileSync)("git", ["rev-parse", "--git-path", "hooks"], {
-      encoding: "utf-8"
-    }).trim();
-  } catch {
-    console.error("Error: Not a git repository");
-    process.exit(1);
+// src/branch-rescue.ts
+function rescueCommits(opts) {
+  const upstream = getUpstreamRef(opts.currentBranch);
+  if (!upstream) {
+    throw new Error(
+      `No upstream tracking branch for '${opts.currentBranch}'. Push it first or use \`qc branch\` manually.`
+    );
   }
-  const hookPath = (0, import_path8.join)(hooksDir, "prepare-commit-msg");
-  if (options.uninstall) {
-    if ((0, import_fs8.existsSync)(hookPath)) {
-      const content = (0, import_fs8.readFileSync)(hookPath, "utf-8");
-      if (content.includes("Quikcommit")) {
-        (0, import_fs8.unlinkSync)(hookPath);
-        console.log("Quikcommit hook removed.");
-      } else {
-        console.log("Hook exists but was not installed by Quikcommit. Skipping.");
+  const headSha = getHeadSha();
+  const stashed = stashPushIfDirty(`qc-rescue-${opts.newBranch}`);
+  try {
+    createBranch(opts.newBranch, headSha);
+  } catch (err) {
+    if (stashed) {
+      try {
+        stashPop();
+      } catch {
       }
-    } else {
-      console.log("No hook to remove.");
     }
-    return;
+    throw err;
   }
-  if ((0, import_fs8.existsSync)(hookPath)) {
-    const content = (0, import_fs8.readFileSync)(hookPath, "utf-8");
-    if (content.includes("Quikcommit")) {
-      console.log("Quikcommit hook is already installed.");
-      return;
+  try {
+    resetHard(upstream);
+  } catch (err) {
+    try {
+      deleteBranch(opts.newBranch);
+    } catch {
     }
-    console.error(
-      "A prepare-commit-msg hook already exists. Use --uninstall first or manually merge."
+    if (stashed) {
+      try {
+        stashPop();
+      } catch {
+      }
+    }
+    throw new Error(
+      `Rescue aborted: failed to reset ${opts.currentBranch} to upstream. Your repo state has been restored. Original error: ${err?.message ?? String(err)}`
     );
-    process.exit(1);
   }
-  (0, import_fs8.writeFileSync)(hookPath, HOOK_CONTENT);
-  (0, import_fs8.chmodSync)(hookPath, 493);
-  console.log("Quikcommit hook installed.");
-  console.log("Now just run `git commit` and a message will be generated automatically.");
+  try {
+    checkoutBranch(opts.newBranch);
+  } catch (err) {
+    try {
+      resetHard(headSha);
+    } catch {
+    }
+    if (stashed) {
+      try {
+        stashPop();
+      } catch {
+      }
+    }
+    throw err;
+  }
+  if (stashed) {
+    try {
+      stashPop();
+    } catch (err) {
+      throw new Error(
+        `Stash conflict during recovery. Your changes are preserved in the stash entry. Resolve manually with \`git stash pop\` then \`git stash drop\` after resolving conflicts.
+Original error: ${err?.message ?? err}`
+      );
+    }
+  }
+  return {
+    newBranch: opts.newBranch,
+    stashed,
+    upstreamRef: upstream,
+    movedFromSha: headSha
+  };
 }
-var import_fs8, import_path8, import_child_process6, HOOK_CONTENT;
-var init_init = __esm({
-  "src/commands/init.ts"() {
+var init_branch_rescue = __esm({
+  "src/branch-rescue.ts"() {
     "use strict";
-    import_fs8 = require("fs");
-    import_path8 = require("path");
-    import_child_process6 = require("child_process");
-    HOOK_CONTENT = `#!/bin/sh
-# Quikcommit - auto-generate commit messages
-# Installed by: qc init
-# Remove with: qc init --uninstall
-
-# Only generate if no message was provided (empty commit message file)
-COMMIT_MSG_FILE="$1"
-COMMIT_SOURCE="$2"
-
-# Skip if message was provided via -m, merge, squash, etc.
-if [ -n "$COMMIT_SOURCE" ]; then
-  exit 0
-fi
-
-# Skip if message file already has content (excluding comments)
-if grep -qv '^#' "$COMMIT_MSG_FILE" 2>/dev/null; then
-  if [ -n "$(grep -v '^#' "$COMMIT_MSG_FILE" | grep -v '^$')" ]; then
-    exit 0
-  fi
-fi
-
-# Generate commit message
-MSG=$(qc --message-only --hook-mode 2>/dev/null)
-if [ $? -eq 0 ] && [ -n "$MSG" ]; then
-  printf '%s
-' "$MSG" > "$COMMIT_MSG_FILE"
-fi
-`;
+    init_git();
   }
 });
 
-// src/commands/team.ts
-var team_exports = {};
-__export(team_exports, {
-  team: () => team
-});
-function createApiClient() {
-  return new ApiClient();
+// src/branch-detect.ts
+function matchGlob(name, pattern) {
+  const n = name.toLowerCase();
+  const p = pattern.toLowerCase();
+  if (!p.includes("*")) return n === p;
+  const escaped = p.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const withDoubleStar = escaped.replace(/\*\*/g, "\0DOUBLE_STAR\0");
+  const withSingleStar = withDoubleStar.replace(/\*/g, "[^/]*");
+  const final = withSingleStar.replace(/\x00DOUBLE_STAR\x00/g, ".*");
+  const rx = new RegExp("^" + final + "$");
+  return rx.test(n);
 }
-function mapCommitlintToRules(config2) {
-  if (!config2 || typeof config2 !== "object") return null;
-  const c = config2;
-  const rules = {};
-  const _ext = c.extends;
-  const rulesConfig = c.rules;
-  if (Array.isArray(rulesConfig?.["type-enum"]) && rulesConfig["type-enum"].length >= 3) {
-    const [, , value] = rulesConfig["type-enum"];
-    if (Array.isArray(value)) rules.types = value;
+function isProtectedBranch(branch, protectedList) {
+  if (!protectedList || protectedList.length === 0) return false;
+  return protectedList.some((p) => matchGlob(branch, p));
+}
+function resolveProtectedBranches(opts) {
+  const set = /* @__PURE__ */ new Set();
+  if (opts.configList && opts.configList.length > 0) {
+    for (const b of opts.configList) set.add(b);
+  } else {
+    for (const b of HARDCODED_PROTECTED) set.add(b);
   }
-  if (Array.isArray(rulesConfig?.["scope-enum"]) && rulesConfig["scope-enum"].length >= 3) {
-    const [, , value] = rulesConfig["scope-enum"];
-    if (Array.isArray(value)) rules.scopes = value;
+  if (opts.detectDefault && opts.defaultBranch) {
+    set.add(opts.defaultBranch);
   }
-  if (Array.isArray(rulesConfig?.["header-max-length"]) && rulesConfig["header-max-length"].length >= 3) {
-    const [, , maxLen] = rulesConfig["header-max-length"];
-    if (typeof maxLen === "number") rules.headerMaxLength = maxLen;
+  return Array.from(set);
+}
+var HARDCODED_PROTECTED;
+var init_branch_detect = __esm({
+  "src/branch-detect.ts"() {
+    "use strict";
+    HARDCODED_PROTECTED = ["main", "master", "develop", "trunk"];
   }
-  if (Array.isArray(rulesConfig?.["subject-case"]) && rulesConfig["subject-case"].length >= 3) {
-    const [, , val] = rulesConfig["subject-case"];
-    if (val != null) rules.subjectCase = Array.isArray(val) ? val : [val];
+});
+
+// src/protected-branch-guard.ts
+function shouldRunGuard(opts) {
+  if (opts.allowProtected) return false;
+  if (opts.hookMode) return false;
+  if (!opts.isTTY) return false;
+  return true;
+}
+function detectProtectedBranchState(opts) {
+  const branch = getCurrentBranch();
+  const protectedList = resolveProtectedBranches({
+    configList: opts.protectedBranches,
+    detectDefault: opts.detectDefault !== false,
+    defaultBranch: getDefaultBranch()
+  });
+  const protectedBranch = isProtectedBranch(branch, protectedList);
+  if (!protectedBranch) {
+    return { isProtected: false, branch, commitsAhead: 0, mode: "none" };
   }
-  return Object.keys(rules).length > 0 ? rules : null;
+  const commitsAhead = getCommitsAheadOfUpstream(branch);
+  const mode = commitsAhead > 0 ? "rescue" : "uncommitted";
+  return { isProtected: true, branch, commitsAhead, mode };
 }
-function detectLocalCommitlintRules() {
-  const cwd = process.cwd();
-  const files = [
-    ".commitlintrc.json",
-    ".commitlintrc",
-    "commitlint.config.js",
-    "commitlint.config.cjs",
-    "commitlint.config.mjs"
-  ];
-  for (const file of files) {
-    const path = (0, import_path9.join)(cwd, file);
-    if (!(0, import_fs9.existsSync)(path)) continue;
-    try {
-      const content = (0, import_fs9.readFileSync)(path, "utf-8");
-      let parsed;
-      if (file.endsWith(".json") || file === ".commitlintrc") {
-        parsed = JSON.parse(content);
-      } else {
-        continue;
-      }
-      const rules = mapCommitlintToRules(parsed);
-      if (rules) return rules;
-    } catch {
-    }
+var init_protected_branch_guard = __esm({
+  "src/protected-branch-guard.ts"() {
+    "use strict";
+    init_branch_detect();
+    init_git();
   }
-  const pkgPath = (0, import_path9.join)(cwd, "package.json");
-  if ((0, import_fs9.existsSync)(pkgPath)) {
-    try {
-      const content = (0, import_fs9.readFileSync)(pkgPath, "utf-8");
-      const pkg = JSON.parse(content);
-      if (pkg.commitlint) {
-        const rules = mapCommitlintToRules(pkg.commitlint);
-        if (rules) return rules;
-      }
-    } catch {
+});
+
+// src/branch-name.ts
+function sanitizeBranchName(input) {
+  if (!input) return null;
+  let s = input.toLowerCase().trim();
+  s = s.replace(/[\s_]+/g, "-");
+  s = s.replace(/[^a-z0-9/-]/g, "");
+  s = s.replace(/-+/g, "-").replace(/\/+/g, "/");
+  s = s.replace(/^[-/]+|[-/]+$/g, "");
+  if (!s.includes("/")) return null;
+  if (s.length > MAX_BRANCH_NAME_LENGTH) {
+    const parts = s.split("/");
+    const type = parts[0] ?? "";
+    const slugBudget = Math.min(MAX_BRANCH_NAME_LENGTH - type.length - 1, 52);
+    if (slugBudget < 2) return null;
+    s = `${type}/${parts.slice(1).join("/").slice(0, slugBudget).replace(/-+$/g, "")}`;
+  }
+  return validateBranchName(s) ? s : null;
+}
+function ensureUniqueName(name, exists) {
+  if (!exists(name)) return name;
+  for (let i = 2; i <= 100; i++) {
+    const candidate = `${name}-${i}`;
+    if (!exists(candidate)) return candidate;
+  }
+  throw new Error(`Could not find a unique name for ${name} after 100 attempts`);
+}
+function finalizeBranchName(raw, exists, options = {}) {
+  let candidate = raw;
+  if (!validateBranchName(candidate)) {
+    const s = sanitizeBranchName(candidate);
+    if (!s) {
+      throw new Error(`Generated invalid branch name and could not sanitize: ${raw}`);
     }
+    candidate = s;
   }
-  const config2 = getConfig();
-  if (config2.rules && Object.keys(config2.rules).length > 0) {
-    return config2.rules;
+  if (options.skipUniqueness) {
+    return candidate;
   }
-  return null;
+  return ensureUniqueName(candidate, exists);
 }
-async function team(subcommand, args) {
-  const api = createApiClient();
-  switch (subcommand) {
-    case void 0:
-    case "info": {
-      const info = await api.getTeam();
-      console.log(`
-  Team: ${info.name}`);
-      console.log(`  Plan: ${info.plan}`);
-      console.log(`  Members: ${info.member_count}`);
-      console.log("\n  Members:");
-      for (const m of info.members) {
-        console.log(`    ${m.name ?? m.email} <${m.email}> (${m.role})`);
+var init_branch_name = __esm({
+  "src/branch-name.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports2, module2) {
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module2.exports = createColors();
+    module2.exports.createColors = createColors;
+  }
+});
+
+// src/ui.ts
+function hasCliNoColor() {
+  try {
+    return process.argv.slice(2).includes("--no-color");
+  } catch {
+    return false;
+  }
+}
+function getTerminalWidth() {
+  return process.stderr.columns ?? process.stdout.columns ?? 80;
+}
+function createUI(options) {
+  const isColor = options.isTTY && !options.noColor;
+  const wrap = (fn) => (s) => isColor ? fn(s) : s;
+  const format = {
+    step: (msg) => `${isColor ? import_picocolors.default.dim("\u203A") : "\u203A"} ${isColor ? import_picocolors.default.dim(msg) : msg}`,
+    success: (msg) => `${isColor ? import_picocolors.default.green("\u2713") : "\u2713"} ${msg}`,
+    error: (msg) => `${isColor ? import_picocolors.default.red("\u2717") : "\u2717"} ${msg}`,
+    dim: wrap(import_picocolors.default.dim),
+    bold: wrap(import_picocolors.default.bold),
+    commitType: wrap(import_picocolors.default.cyan),
+    commitScope: wrap(import_picocolors.default.yellow),
+    accent: wrap(import_picocolors.default.magenta)
+  };
+  function createSpinner(message, write = (s) => process.stderr.write(s)) {
+    let frame = 0;
+    let interval = null;
+    return {
+      start() {
+        if (interval) return;
+        if (!options.isTTY) return;
+        interval = setInterval(() => {
+          const f = SPINNER_FRAMES2[frame++ % SPINNER_FRAMES2.length];
+          write(`\r${format.step(message)} ${isColor ? import_picocolors.default.cyan(f) : f}`);
+        }, 80);
+      },
+      stop(finalMessage) {
+        if (interval) {
+          clearInterval(interval);
+          interval = null;
+        }
+        if (options.isTTY) {
+          write("\r\x1B[2K");
+        }
+        if (finalMessage) {
+          write(finalMessage + "\n");
+        }
+      }
+    };
+  }
+  const log = {
+    step: (msg) => process.stderr.write(format.step(msg) + "\n"),
+    success: (msg) => process.stderr.write(format.success(msg) + "\n"),
+    error: (msg) => process.stderr.write(format.error(msg) + "\n"),
+    dim: (msg) => process.stderr.write(format.dim(msg) + "\n")
+  };
+  return { isColor, format, spinner: createSpinner, log };
+}
+function getUI() {
+  if (!_defaultUI) {
+    _defaultUI = createUI({
+      isTTY: !!process.stderr.isTTY,
+      noColor: !!process.env.NO_COLOR || hasCliNoColor()
+    });
+  }
+  return _defaultUI;
+}
+var import_picocolors, SPINNER_FRAMES2, _defaultUI, ui;
+var init_ui = __esm({
+  "src/ui.ts"() {
+    "use strict";
+    import_picocolors = __toESM(require_picocolors());
+    SPINNER_FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    ui = new Proxy({}, {
+      get(_target, prop) {
+        return getUI()[prop];
+      }
+    });
+  }
+});
+
+// src/ui-rich.ts
+function splitCommitForBox(message) {
+  const firstLine = message.split("\n")[0] ?? "";
+  const m = firstLine.match(HEADER_RX);
+  if (!m) return { type: null, scope: null, subject: firstLine, breaking: false };
+  return {
+    type: m[1] ?? null,
+    scope: m[2] ?? null,
+    breaking: m[3] === "!",
+    subject: m[4] ?? ""
+  };
+}
+function renderFileTree(files, maxFiles) {
+  if (files.length === 0) return "";
+  const lines = [];
+  const display = files.slice(0, maxFiles);
+  const overflow = Math.max(0, files.length - maxFiles);
+  for (let i = 0; i < display.length; i++) {
+    const isLast = i === display.length - 1 && overflow === 0;
+    const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
+    lines.push(`    ${connector} ${display[i]}`);
+  }
+  if (overflow > 0) {
+    lines.push(`    \u2514\u2500 +${overflow} more files`);
+  }
+  return lines.join("\n");
+}
+function wrapLine(text, width) {
+  if (text.length <= width) return [text];
+  const result = [];
+  let remaining = text;
+  while (remaining.length > width) {
+    let breakAt = remaining.lastIndexOf(" ", width);
+    if (breakAt < width / 2) breakAt = width;
+    result.push(remaining.slice(0, breakAt));
+    remaining = remaining.slice(breakAt).trimStart();
+  }
+  if (remaining) result.push(remaining);
+  return result;
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function boxedLine(content, innerWidth, isColor) {
+  const visibleLen = stripAnsi(content).length;
+  const padding = " ".repeat(Math.max(0, innerWidth - visibleLen));
+  const border = isColor ? import_picocolors2.default.dim("\u2502") : "\u2502";
+  return `  ${border}  ${content}${padding}  ${border}`;
+}
+function renderBoxedCommit(header, body, opts) {
+  if (opts.width < MIN_BOX_WIDTH) {
+    const lines2 = [header.split("\n")[0] ?? header];
+    if (body) lines2.push("", body);
+    return lines2.join("\n");
+  }
+  const innerWidth = opts.width - 8;
+  const horiz = opts.width - 2;
+  const top = "  " + (opts.isColor ? import_picocolors2.default.dim("\u256D" + "\u2500".repeat(horiz) + "\u256E") : "\u256D" + "\u2500".repeat(horiz) + "\u256E");
+  const bottom = "  " + (opts.isColor ? import_picocolors2.default.dim("\u2570" + "\u2500".repeat(horiz) + "\u256F") : "\u2570" + "\u2500".repeat(horiz) + "\u256F");
+  const parsed = splitCommitForBox(header);
+  let firstLineStyled;
+  if (parsed.type && parsed.scope) {
+    const bare = `${parsed.type}(${parsed.scope})${parsed.breaking ? "!" : ""}: ${parsed.subject}`;
+    firstLineStyled = opts.isColor ? `${import_picocolors2.default.bold(import_picocolors2.default.cyan(parsed.type))}(${import_picocolors2.default.bold(import_picocolors2.default.yellow(parsed.scope))})${parsed.breaking ? import_picocolors2.default.bold(import_picocolors2.default.red("!")) : ""}: ${parsed.subject}` : bare;
+  } else if (parsed.type) {
+    const bare = `${parsed.type}${parsed.breaking ? "!" : ""}: ${parsed.subject}`;
+    firstLineStyled = opts.isColor ? `${import_picocolors2.default.bold(import_picocolors2.default.cyan(parsed.type))}${parsed.breaking ? import_picocolors2.default.bold(import_picocolors2.default.red("!")) : ""}: ${parsed.subject}` : bare;
+  } else {
+    firstLineStyled = header.split("\n")[0] ?? header;
+  }
+  const lines = [];
+  const headerParts = wrapLine(firstLineStyled, innerWidth);
+  for (let i = 0; i < headerParts.length; i++) {
+    const indent = i === 0 ? "" : "    ";
+    lines.push(boxedLine(indent + (headerParts[i] ?? ""), innerWidth, opts.isColor));
+  }
+  if (body) {
+    lines.push(boxedLine("", innerWidth, opts.isColor));
+    for (const bline of body.split("\n")) {
+      const trimmed = bline.trim();
+      if (!trimmed) continue;
+      const rendered = trimmed.replace(/^[-*]\s+/, opts.isColor ? `${import_picocolors2.default.green("\u2022")} ` : "\u2022 ");
+      const wrapped = wrapLine(rendered, innerWidth);
+      for (let i = 0; i < wrapped.length; i++) {
+        lines.push(boxedLine((i === 0 ? "" : "  ") + (wrapped[i] ?? ""), innerWidth, opts.isColor));
+      }
+    }
+  }
+  return [top, ...lines, bottom].join("\n");
+}
+function renderStatsLine(stats, isColor) {
+  const parts = [];
+  parts.push(`${stats.files} files`);
+  parts.push(`+${stats.additions} \u2212${stats.deletions}`);
+  if (stats.tokens !== void 0) parts.push(`${stats.tokens} tokens`);
+  const text = parts.join(" \xB7 ");
+  return isColor ? `    ${import_picocolors2.default.dim(text)}` : `    ${text}`;
+}
+function shouldUseRichOutput(opts) {
+  if (!opts.isTTY) return false;
+  if (opts.noColor) return false;
+  if (opts.style !== "rich") return false;
+  if (opts.width < MIN_BOX_WIDTH) return false;
+  return true;
+}
+var import_picocolors2, HEADER_RX, MIN_BOX_WIDTH;
+var init_ui_rich = __esm({
+  "src/ui-rich.ts"() {
+    "use strict";
+    import_picocolors2 = __toESM(require_picocolors());
+    init_ui();
+    HEADER_RX = /^([a-z]+)(?:\(([^)]+)\))?(!)?:\s*(.*)$/;
+    MIN_BOX_WIDTH = 60;
+  }
+});
+
+// src/commit-helpers.ts
+function applyCliTypeScopeToRules(rules, type, scope) {
+  let next = { ...rules };
+  if (type) {
+    next = { ...next, types: [type] };
+  }
+  if (scope) {
+    next = { ...next, scopes: [scope] };
+  }
+  return next;
+}
+function generationHintsFromArgs(split, forceBody) {
+  const h = {};
+  if (split) h.split = true;
+  if (forceBody) h.force_body = true;
+  return Object.keys(h).length > 0 ? h : void 0;
+}
+function splitCommitMessageForDisplay(message) {
+  const t = message.replace(/\r\n/g, "\n").trimEnd();
+  const doubleNl = t.indexOf("\n\n");
+  if (doubleNl !== -1) {
+    const head = t.slice(0, doubleNl);
+    const subject = head.split("\n")[0]?.trim() ?? "";
+    return { subject, body: t.slice(doubleNl + 2).trimEnd() };
+  }
+  const firstNl = t.indexOf("\n");
+  if (firstNl === -1) {
+    return { subject: t.trim(), body: "" };
+  }
+  return {
+    subject: t.slice(0, firstNl).trim(),
+    body: t.slice(firstNl + 1).trimEnd()
+  };
+}
+function formatVerboseCommitDiagnostics(diagnostics, roundTripMs) {
+  const lines = [`api_round_trip_ms: ${roundTripMs}`];
+  if (diagnostics !== void 0) {
+    lines.push(JSON.stringify(diagnostics, null, 2));
+  }
+  return lines.join("\n");
+}
+async function interactiveRefineMessage(initial, opts) {
+  if (opts.skip) return { action: "accept", message: initial };
+  const rl = import_promises.default.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    process.stderr.write(`
+${initial}
+
+`);
+    const choice = (await rl.question("Keep? [Y/n/e]: ")).trim().toLowerCase();
+    if (choice === "n") {
+      return { action: "abort" };
+    }
+    if (choice === "e") {
+      process.stderr.write("Enter new message (end with a line containing only .):\n");
+      const lines = [];
+      while (true) {
+        const line = await rl.question("");
+        if (line === ".") break;
+        lines.push(line);
+      }
+      const edited = lines.join("\n").trim();
+      return { action: "edit", message: edited.length > 0 ? edited : initial };
+    }
+    return { action: "accept", message: initial };
+  } finally {
+    rl.close();
+  }
+}
+async function promptYesNo(question, defaultYes = true) {
+  const rl = import_promises.default.createInterface({ input: process.stdin, output: process.stderr });
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  try {
+    const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+    if (answer === "n" || answer === "no") return false;
+    if (answer === "y" || answer === "yes") return true;
+    return defaultYes;
+  } finally {
+    rl.close();
+  }
+}
+async function confirmCommit(prompt2, opts) {
+  if (opts.skip) return { action: "commit" };
+  const rl = import_promises.default.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const ans = (await rl.question(prompt2)).trim().toLowerCase();
+    if (ans !== "y" && ans !== "yes") {
+      return { action: "abort" };
+    }
+    return { action: "commit" };
+  } finally {
+    rl.close();
+  }
+}
+function shouldSkipTTYInteraction(hookMode) {
+  return hookMode === true || process.stdin.isTTY !== true;
+}
+function logVerboseDiagnostics(dim, verbose, quiet, diagnostics, roundTripMs) {
+  if (!verbose || quiet) return;
+  process.stderr.write(
+    `
+${formatVerboseCommitDiagnostics(diagnostics, roundTripMs)}
+`
+  );
+  dim("(verbose diagnostics on stderr)");
+}
+function isDisplayOpts(opts) {
+  return typeof opts === "object" && opts !== null && "log" in opts;
+}
+function createSilentLog() {
+  return {
+    step: () => {
+    },
+    success: () => {
+    },
+    error: (msg) => console.error(msg),
+    dim: () => {
+    }
+  };
+}
+function displayCommitMessage(message, opts) {
+  const display = isDisplayOpts(opts) ? opts : { log: opts };
+  const log = display.log;
+  const { subject, body } = splitCommitMessageForDisplay(message);
+  const tw = getTerminalWidth();
+  const useRich = shouldUseRichOutput({
+    isTTY: display.isTTY ?? !!process.stderr.isTTY,
+    noColor: display.isColor === false,
+    width: tw,
+    style: display.style ?? "rich"
+  });
+  if (useRich) {
+    const tree = display.stagedFiles && display.stagedFiles.length > 0 ? renderFileTree(display.stagedFiles, 8) : "";
+    if (tree) {
+      process.stderr.write(tree + "\n");
+    }
+    const boxed = renderBoxedCommit(subject, body, {
+      width: Math.min(Math.max(tw - 4, 60), 80),
+      isColor: !!display.isColor
+    });
+    process.stderr.write(boxed + "\n");
+    if (display.stats) {
+      process.stderr.write(renderStatsLine(display.stats, !!display.isColor) + "\n");
+    }
+    return;
+  }
+  log.success(subject);
+  if (body) {
+    for (const line of body.split("\n")) {
+      log.dim(`  ${line}`);
+    }
+    process.stderr.write("\n");
+  }
+}
+var import_promises;
+var init_commit_helpers = __esm({
+  "src/commit-helpers.ts"() {
+    "use strict";
+    import_promises = __toESM(require("node:readline/promises"));
+    init_ui_rich();
+  }
+});
+
+// src/smart-diff.ts
+function sanitizeFilepath(path) {
+  return path.replace(/[\x00-\x1F\x7F[\]`]/g, "_").slice(0, 200);
+}
+function classifyFile(filepath) {
+  const basename = filepath.split("/").pop() ?? filepath;
+  if (LOCK_FILES.has(basename)) return "lock";
+  if (filepath.endsWith(".map")) return "sourcemap";
+  if (VENDORED_PREFIXES.some((p) => filepath.startsWith(p))) return "vendored";
+  if (GENERATED_PATTERNS.some((p) => p.test(filepath))) return "generated";
+  return "code";
+}
+function parseDiffIntoFiles(diff) {
+  const files = [];
+  const parts = diff.split(/^(diff --git .+)$/m);
+  for (let i = 1; i < parts.length; i += 2) {
+    const header = parts[i];
+    const content = parts[i + 1] ?? "";
+    const match = header.match(/diff --git a\/(.+?) b\/(.+)/);
+    const filepath = match?.[2] ?? "unknown";
+    const lines = content.split("\n");
+    let additions = 0;
+    let deletions = 0;
+    for (const line of lines) {
+      if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+      else if (line.startsWith("-") && !line.startsWith("---")) deletions++;
+    }
+    files.push({ filepath, content: header + content, additions, deletions });
+  }
+  return files;
+}
+function isMinified(content) {
+  const lines = content.split("\n").filter(
+    (l) => (l.startsWith("+") || l.startsWith("-")) && !l.startsWith("+++") && !l.startsWith("---")
+  );
+  if (lines.length === 0) return false;
+  return lines.some((l) => l.length > 500);
+}
+function buildFileSummary(file) {
+  const sizeKB = Math.round(file.content.length / 1024);
+  return `[modified: ${sanitizeFilepath(file.filepath)} \u2014 +${file.additions} \u2212${file.deletions} lines, ~${sizeKB}KB]
+`;
+}
+function preprocessDiffWithSizeBudget(diff, maxBytes = 5 * 1024 * 1024) {
+  const files = parseDiffIntoFiles(diff);
+  if (files.length === 0) {
+    return { processedDiff: diff, summarized: [], aggressivelySummarized: [], tokensSaved: 0 };
+  }
+  const entries = [];
+  const summarized = [];
+  let tokensSaved = 0;
+  for (const file of files) {
+    const classification = classifyFile(file.filepath);
+    switch (classification) {
+      case "sourcemap":
+        tokensSaved += estimateTokens(file.content);
+        summarized.push(file.filepath);
+        entries.push({ file, isNoise: true, summaryLine: null });
+        break;
+      case "lock":
+        tokensSaved += estimateTokens(file.content);
+        summarized.push(file.filepath);
+        entries.push({
+          file,
+          isNoise: true,
+          summaryLine: `[lock file updated: ${sanitizeFilepath(file.filepath)} (+${file.additions} \u2212${file.deletions} lines)]
+`
+        });
+        break;
+      case "generated":
+        tokensSaved += estimateTokens(file.content);
+        summarized.push(file.filepath);
+        entries.push({
+          file,
+          isNoise: true,
+          summaryLine: `[generated: ${sanitizeFilepath(file.filepath)} (+${file.additions} \u2212${file.deletions})]
+`
+        });
+        break;
+      case "vendored":
+        tokensSaved += estimateTokens(file.content);
+        summarized.push(file.filepath);
+        entries.push({
+          file,
+          isNoise: true,
+          summaryLine: `[vendored: ${sanitizeFilepath(file.filepath)} updated]
+`
+        });
+        break;
+      case "code":
+        if (isMinified(file.content)) {
+          tokensSaved += estimateTokens(file.content);
+          const sizeKB = Math.round(file.content.length / 1024);
+          summarized.push(file.filepath);
+          entries.push({
+            file,
+            isNoise: true,
+            summaryLine: `[minified asset: ${sanitizeFilepath(file.filepath)} (${sizeKB} KB)]
+`
+          });
+        } else {
+          entries.push({ file, isNoise: false, summaryLine: null });
+        }
+        break;
+    }
+  }
+  const aggressiveMap = /* @__PURE__ */ new Map();
+  function buildOutput() {
+    const parts = [];
+    for (const entry of entries) {
+      if (entry.isNoise) {
+        if (entry.summaryLine !== null) parts.push(entry.summaryLine);
+      } else if (aggressiveMap.has(entry.file.filepath)) {
+        parts.push(aggressiveMap.get(entry.file.filepath));
+      } else {
+        parts.push(entry.file.content);
+      }
+    }
+    return parts.join("");
+  }
+  const codeEntries = entries.filter((e) => !e.isNoise);
+  let output = buildOutput();
+  if (output.length <= maxBytes) {
+    return {
+      processedDiff: output,
+      summarized,
+      aggressivelySummarized: [],
+      tokensSaved
+    };
+  }
+  const TIER1_THRESHOLD = 5 * 1024;
+  for (const entry of codeEntries) {
+    if (entry.file.content.length > TIER1_THRESHOLD && !aggressiveMap.has(entry.file.filepath)) {
+      tokensSaved += estimateTokens(entry.file.content);
+      aggressiveMap.set(entry.file.filepath, buildFileSummary(entry.file));
+    }
+  }
+  output = buildOutput();
+  if (output.length <= maxBytes) {
+    return {
+      processedDiff: output,
+      summarized,
+      aggressivelySummarized: [...aggressiveMap.keys()],
+      tokensSaved
+    };
+  }
+  const TIER2_THRESHOLD = 2 * 1024;
+  for (const entry of codeEntries) {
+    if (entry.file.content.length > TIER2_THRESHOLD && !aggressiveMap.has(entry.file.filepath)) {
+      tokensSaved += estimateTokens(entry.file.content);
+      aggressiveMap.set(entry.file.filepath, buildFileSummary(entry.file));
+    }
+  }
+  output = buildOutput();
+  if (output.length <= maxBytes) {
+    return {
+      processedDiff: output,
+      summarized,
+      aggressivelySummarized: [...aggressiveMap.keys()],
+      tokensSaved
+    };
+  }
+  for (const entry of codeEntries) {
+    if (!aggressiveMap.has(entry.file.filepath)) {
+      tokensSaved += estimateTokens(entry.file.content);
+      aggressiveMap.set(entry.file.filepath, buildFileSummary(entry.file));
+    }
+  }
+  return {
+    processedDiff: buildOutput(),
+    summarized,
+    aggressivelySummarized: [...aggressiveMap.keys()],
+    tokensSaved
+  };
+}
+var LOCK_FILES, GENERATED_PATTERNS, VENDORED_PREFIXES;
+var init_smart_diff = __esm({
+  "src/smart-diff.ts"() {
+    "use strict";
+    init_dist();
+    LOCK_FILES = /* @__PURE__ */ new Set([
+      "pnpm-lock.yaml",
+      "package-lock.json",
+      "yarn.lock",
+      "Cargo.lock",
+      "Gemfile.lock",
+      "poetry.lock",
+      "composer.lock",
+      "bun.lockb",
+      "shrinkwrap.json"
+    ]);
+    GENERATED_PATTERNS = [
+      /\.generated\.\w+$/,
+      /\.g\.dart$/,
+      /\.pb\.go$/,
+      /\.pb\.ts$/,
+      /(^|\/)\.prisma\/client\//,
+      /\/generated\//
+    ];
+    VENDORED_PREFIXES = ["vendor/", "third_party/", "node_modules/"];
+  }
+});
+
+// src/local.ts
+var local_exports = {};
+__export(local_exports, {
+  generateLocalBranchName: () => generateLocalBranchName,
+  getLocalProviderConfig: () => getLocalProviderConfig,
+  runLocalBranch: () => runLocalBranch,
+  runLocalCommit: () => runLocalCommit
+});
+function getLegacyProvider() {
+  try {
+    const p = (0, import_path8.join)(CONFIG_PATH2, "provider");
+    if ((0, import_fs8.existsSync)(p)) {
+      const v = (0, import_fs8.readFileSync)(p, "utf-8").trim().toLowerCase();
+      if (["ollama", "lmstudio", "openrouter", "custom", "cloudflare"].includes(v)) {
+        return v;
       }
-      break;
     }
-    case "rules": {
-      if (args?.[0] === "push") {
-        const rules = detectLocalCommitlintRules();
-        if (!rules) {
-          console.error("No local commitlint config found.");
-          process.exit(1);
-        }
-        await api.pushTeamRules(rules);
-        console.log("Team rules updated from local commitlint config.");
-      } else {
-        const rules = await api.getTeamRules();
-        console.log("\n  Team Commit Rules:");
-        console.log(JSON.stringify(rules, null, 2));
+  } catch {
+  }
+  return null;
+}
+function getLegacyBaseUrl(provider) {
+  try {
+    const p = (0, import_path8.join)(CONFIG_PATH2, "base_url");
+    if ((0, import_fs8.existsSync)(p)) {
+      return (0, import_fs8.readFileSync)(p, "utf-8").trim();
+    }
+  } catch {
+  }
+  return PROVIDER_URLS[provider] ?? "";
+}
+function getLegacyModel(provider) {
+  try {
+    const p = (0, import_path8.join)(CONFIG_PATH2, "model");
+    if ((0, import_fs8.existsSync)(p)) {
+      const v = (0, import_fs8.readFileSync)(p, "utf-8").trim();
+      if (v) return v;
+    }
+  } catch {
+  }
+  return DEFAULT_MODELS[provider] ?? "";
+}
+function getLocalProviderConfig() {
+  const config2 = getConfig();
+  const provider = config2.provider ?? getLegacyProvider();
+  if (!provider) return null;
+  const baseUrl = config2.apiUrl ?? getLegacyBaseUrl(provider) ?? PROVIDER_URLS[provider] ?? "";
+  if (!baseUrl) return null;
+  const model = config2.model ?? getLegacyModel(provider) ?? DEFAULT_MODELS[provider];
+  const apiKey = provider === "openrouter" || provider === "custom" ? getApiKey() : null;
+  if (provider === "openrouter" && !apiKey) return null;
+  return { provider, baseUrl, model, apiKey };
+}
+function buildUserPrompt(changes, diff, rules, recentCommits, hints) {
+  let prompt2 = `Generate a commit message for these changes:
+
+## File changes:
+<file_changes>
+${changes}
+</file_changes>
+
+## Diff:
+<diff>
+${diff}
+</diff>
+
+`;
+  if (recentCommits && recentCommits.length > 0) {
+    const history = recentCommits.slice(0, 10).join("\n");
+    prompt2 += `Recent commits on this branch (match style when appropriate):
+${history}
+
+`;
+  }
+  if (hints?.split) {
+    prompt2 += `MULTI-COMMIT MODE: If changes span multiple logical commits, focus the message on the primary change and mention other slices in the body.
+
+`;
+  }
+  if (hints?.force_body) {
+    prompt2 += `The user requires a BODY section after the subject line, even for small changes.
+
+`;
+  }
+  if (rules && Object.keys(rules).length > 0) {
+    prompt2 += `Rules: ${JSON.stringify(rules)}
+
+`;
+  }
+  prompt2 += `Important:
+- Follow conventional commit format: <type>(<scope>): <subject>
+- Response should be the commit message only, no explanations`;
+  return prompt2;
+}
+function buildRequest(provider, baseUrl, userContent, diff, changes, model, apiKey, rules, recentCommits, hints) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  if (provider === "openrouter") {
+    headers["HTTP-Referer"] = "https://github.com/Quikcommit-Internal/public";
+    headers["X-Title"] = "qc - AI Commit Message Generator";
+  }
+  let url;
+  let body;
+  switch (provider) {
+    case "ollama":
+      url = `${baseUrl}/api/generate`;
+      body = {
+        model,
+        prompt: userContent,
+        stream: false,
+        options: {}
+      };
+      return { url, body, headers: { "Content-Type": "application/json" } };
+    case "lmstudio":
+      url = `${baseUrl}/chat/completions`;
+      body = {
+        model,
+        stream: false,
+        messages: [
+          {
+            role: "system",
+            content: "You are a git commit message generator. Create conventional commit messages."
+          },
+          { role: "user", content: userContent }
+        ]
+      };
+      return { url, body, headers: { "Content-Type": "application/json" } };
+    case "openrouter":
+    case "custom":
+      url = `${baseUrl}/chat/completions`;
+      body = {
+        model,
+        stream: false,
+        messages: [
+          {
+            role: "system",
+            content: "You are a git commit message generator. Create conventional commit messages."
+          },
+          { role: "user", content: userContent }
+        ]
+      };
+      return { url, body, headers };
+    case "cloudflare": {
+      url = `${baseUrl.replace(/\/$/, "")}/commit`;
+      const payload = { diff, changes, rules };
+      if (recentCommits && recentCommits.length > 0) {
+        payload.recent_commits = recentCommits.slice(0, 10);
       }
-      break;
+      if (hints && Object.keys(hints).length > 0) {
+        payload.generation_hints = hints;
+      }
+      body = payload;
+      return { url, body, headers: { "Content-Type": "application/json" } };
     }
-    case "invite": {
-      const email = args?.[0];
-      if (!email) {
-        console.error("Usage: qc team invite <email>");
-        process.exit(1);
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+function parseResponse(provider, data) {
+  const r = data;
+  switch (provider) {
+    case "ollama":
+      return r.response ?? "";
+    case "lmstudio":
+    case "openrouter":
+    case "custom": {
+      const choices = r.choices;
+      return choices?.[0]?.message?.content ?? "";
+    }
+    case "cloudflare":
+      return r.commit?.response ?? "";
+    default:
+      return "";
+  }
+}
+async function runLocalCommit(args) {
+  const silent = !!(args.hookMode || args.quiet);
+  const ui2 = getUI();
+  const log = silent ? createSilentLog() : ui2.log;
+  if (!isGitRepo()) {
+    throw new Error("Not a git repository.");
+  }
+  if (!hasStagedChanges()) {
+    throw new Error("No staged changes. Stage files with `git add` first.");
+  }
+  const local = getLocalProviderConfig();
+  if (!local) {
+    throw new Error(
+      "No local provider configured. Set provider in ~/.config/qc/config.json or run with SaaS (qc login)."
+    );
+  }
+  const config2 = getConfig();
+  const excludes = [...config2.excludes ?? [], ...args.exclude];
+  let diff = getStagedDiff(excludes);
+  const changes = getStagedFiles();
+  if (!args.noSmartDiff) {
+    const smartResult = preprocessDiffWithSizeBudget(diff, 5 * 1024 * 1024);
+    diff = smartResult.processedDiff;
+    if (smartResult.summarized.length > 0 && !silent) {
+      log.step(
+        `smart-diff: ${smartResult.summarized.length} file(s) summarized (saved ~${Math.round(smartResult.tokensSaved / 1e3)}K tokens)`
+      );
+    }
+    if (smartResult.aggressivelySummarized.length > 0 && !silent) {
+      log.step(
+        `large-diff: ${smartResult.aggressivelySummarized.length} additional file(s) summarized to fit (commit message may be less specific)`
+      );
+    }
+  }
+  let rules = { ...await detectCommitlintRules(), ...config2.rules ?? {} };
+  const workspace = detectWorkspace();
+  if (workspace) {
+    const stagedFiles = changes.trim().split("\n").filter(Boolean);
+    const scope = autoDetectScope(stagedFiles, workspace);
+    if (scope) {
+      const scopes = scope.split(",").map((s) => s.trim());
+      rules = { ...rules, scopes };
+    }
+  }
+  rules = applyCliTypeScopeToRules(rules, args.type, args.scope);
+  const recentCommits = args.noContext ? void 0 : getRecentBranchCommits(5);
+  const generationHints = generationHintsFromArgs(args.split, args.forceBody);
+  const skipInteractive = silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
+  const skipConfirm = args.dryRun || args.messageOnly || silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
+  const model = args.model ?? local.model;
+  const modelDisplay = model ?? local.model ?? "default";
+  const userContent = buildUserPrompt(
+    changes,
+    diff,
+    Object.keys(rules).length > 0 ? rules : void 0,
+    recentCommits,
+    generationHints
+  );
+  const { url, body, headers } = buildRequest(
+    local.provider,
+    local.baseUrl,
+    userContent,
+    diff,
+    changes,
+    model,
+    local.apiKey,
+    rules,
+    recentCommits,
+    generationHints
+  );
+  if (!url || url.includes("YOUR-WORKER")) {
+    throw new Error(
+      "Cloudflare provider requires api_url. Run: qc config set api_url https://your-worker.workers.dev"
+    );
+  }
+  const spinner = ui2.spinner(`generating commit (${modelDisplay} via ${local.provider})...`);
+  if (!silent) spinner.start();
+  const t0 = Date.now();
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+  } finally {
+    spinner.stop();
+  }
+  const roundTripMs = Date.now() - t0;
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Provider error (${res.status}): ${text}`);
+  }
+  const data = await res.json();
+  let message = parseResponse(local.provider, data);
+  message = message.replace(/\\n/g, "\n").replace(/\\r/g, "").trim();
+  if (!message) {
+    throw new Error("Failed to generate commit message.");
+  }
+  const diagnostics = local.provider === "cloudflare" && typeof data === "object" && data !== null ? data.diagnostics : void 0;
+  logVerboseDiagnostics((msg) => log.dim(msg), args.verbose, args.quiet, diagnostics, roundTripMs);
+  if (args.interactive) {
+    if (shouldSkipTTYInteraction(args.hookMode)) {
+      if (!silent) log.dim("(--interactive ignored: not running in a TTY)");
+    } else {
+      const refineResult = await interactiveRefineMessage(message, { skip: skipInteractive });
+      if (refineResult.action === "abort") {
+        return;
       }
-      await api.inviteTeamMember(email);
-      console.log(`Invitation sent to ${email}`);
-      break;
+      message = refineResult.message;
     }
-    default:
-      console.error(`Unknown team command: ${subcommand}`);
-      console.log("Usage: qc team [info|rules|rules push|invite <email>]");
-      process.exit(1);
   }
-}
-var import_fs9, import_path9;
-var init_team = __esm({
-  "src/commands/team.ts"() {
-    "use strict";
-    import_fs9 = require("fs");
-    import_path9 = require("path");
-    init_api();
-    init_config();
+  if (args.messageOnly) {
+    console.log(message);
+    return;
   }
-});
-
-// src/commands/config.ts
-var config_exports = {};
-__export(config_exports, {
-  config: () => config
-});
-function config(args) {
-  if (args.length === 0) {
-    showConfig();
+  if (!silent) {
+    const stagedPaths = changes.trim().split("\n").filter(Boolean);
+    const short = getStagedDiffShortstat();
+    const tokenEst = diagnostics && typeof diagnostics === "object" && diagnostics !== null && "tokenUsage" in diagnostics ? diagnostics.tokenUsage?.totalEstimated : void 0;
+    displayCommitMessage(message, {
+      log,
+      isColor: ui2.isColor,
+      isTTY: !!process.stderr.isTTY,
+      style: "rich",
+      stagedFiles: stagedPaths,
+      stats: {
+        files: stagedPaths.length,
+        additions: short.additions,
+        deletions: short.deletions,
+        ...tokenEst !== void 0 ? { tokens: tokenEst } : {}
+      }
+    });
+  }
+  if (args.dryRun) {
     return;
   }
-  const sub = args[0];
-  if (sub === "set") {
-    const key = args[1];
-    const value = args[2];
-    if (!key || !value) {
-      console.error("Usage: qc config set <key> <value>");
-      console.error("  Keys: model, api_url, provider, auto_stage");
-      process.exit(1);
+  if (args.confirm) {
+    const confirmResult = await confirmCommit("Proceed with commit? [y/N]: ", { skip: skipConfirm });
+    if (confirmResult.action === "abort") {
+      return;
     }
-    setConfig(key, value);
-    return;
   }
-  if (sub === "reset") {
-    resetConfig();
-    return;
+  gitCommit(message);
+  if (args.push) {
+    gitPush();
   }
-  console.error(`Unknown subcommand: ${sub}`);
-  console.error("Usage: qc config [set <key> <value> | reset]");
-  process.exit(1);
 }
-function showConfig() {
-  const cfg = getConfig();
-  const apiKey = getApiKey();
-  console.log("Current configuration:");
-  console.log(`  model:    ${cfg.model ?? "(default for plan)"}`);
-  console.log(`  api_url:  ${cfg.apiUrl ?? DEFAULT_API_URL}`);
-  console.log(`  provider:   ${cfg.provider ?? "(default)"}`);
-  console.log(`  auto_stage: ${cfg.autoStage ? "true" : "false"}`);
-  console.log(`  auth:       ${apiKey ? "****" : "not set"}`);
-  if (cfg.excludes?.length) {
-    console.log(`  excludes: ${cfg.excludes.join(", ")}`);
+async function generateLocalBranchName(opts) {
+  const local = getLocalProviderConfig();
+  if (!local) {
+    throw new Error("No local provider configured. Set provider with `qc --use-ollama` etc.");
+  }
+  const sections = [];
+  sections.push("Generate a git branch name in the format <type>/<kebab-case-slug>.");
+  sections.push("Type must be one of: feat, fix, refactor, perf, docs, test, chore, ci.");
+  sections.push("Slug: 2-5 words, lowercase, hyphen-separated, max 55 chars.");
+  sections.push("Output ONLY the branch name on a single line. No explanation.");
+  sections.push("");
+  if (opts.description) {
+    sections.push("DESCRIPTION:");
+    sections.push(opts.description);
+  } else if (opts.recentCommits && opts.recentCommits.length > 0) {
+    sections.push("RECENT COMMITS:");
+    for (const c of opts.recentCommits) sections.push(`- ${c}`);
+  } else if (opts.diff) {
+    sections.push("DIFF:");
+    sections.push(opts.diff.slice(0, 3e4));
+  }
+  const userContent = sections.join("\n");
+  const model = opts.model ?? local.model;
+  const headers = { "Content-Type": "application/json" };
+  if (local.apiKey) headers.Authorization = `Bearer ${local.apiKey}`;
+  if (local.provider === "openrouter") {
+    headers["HTTP-Referer"] = "https://github.com/Quikcommit-Internal/public";
+    headers["X-Title"] = "qc - AI Commit Message Generator";
   }
-}
-function setConfig(key, value) {
-  const cfg = getConfig();
-  const updates = {};
-  if (key === "model") {
-    updates.model = value;
-  } else if (key === "provider") {
-    const valid = ["ollama", "lmstudio", "openrouter", "custom", "cloudflare"];
-    if (!valid.includes(value.toLowerCase())) {
-      console.error(`Invalid provider. Must be one of: ${valid.join(", ")}`);
-      process.exit(1);
-    }
-    updates.provider = value.toLowerCase();
-  } else if (key === "api_url") {
-    try {
-      new URL(value);
-      updates.apiUrl = value;
-    } catch {
-      console.error("Invalid URL:", value);
-      process.exit(1);
-    }
-  } else if (key === "auto_stage") {
-    updates.autoStage = value === "true" || value === "1";
-  } else {
-    console.error(`Unknown key: ${key}`);
-    console.error("  Keys: model, api_url, provider, auto_stage");
-    process.exit(1);
+  let url;
+  let body;
+  switch (local.provider) {
+    case "ollama":
+      url = `${local.baseUrl}/api/generate`;
+      body = { model, prompt: userContent, stream: false, options: {} };
+      break;
+    case "lmstudio":
+    case "openrouter":
+    case "custom":
+      url = `${local.baseUrl}/chat/completions`;
+      body = {
+        model,
+        stream: false,
+        messages: [
+          {
+            role: "system",
+            content: "You suggest concise git branch names. Reply with the branch name only."
+          },
+          { role: "user", content: userContent }
+        ]
+      };
+      break;
+    case "cloudflare":
+      url = `${local.baseUrl.replace(/\/$/, "")}/branch`;
+      body = {
+        diff: opts.diff,
+        changes: opts.changes,
+        recent_commits: opts.recentCommits,
+        description: opts.description,
+        model,
+        cf_model: model,
+        ...opts.rules ? { rules: opts.rules } : {}
+      };
+      break;
   }
-  saveConfig({ ...cfg, ...updates });
-  console.log(`Set ${key} = ${value}`);
-}
-function resetConfig() {
-  saveConfig({});
-  console.log("Config reset to defaults.");
-}
-var init_config2 = __esm({
-  "src/commands/config.ts"() {
-    "use strict";
-    init_config();
-    init_dist();
+  if (!url || url.includes("YOUR-WORKER")) {
+    throw new Error(
+      "Cloudflare provider requires api_url. Run: qc config set api_url https://your-worker.workers.dev"
+    );
   }
-});
-
-// src/commands/upgrade.ts
-var upgrade_exports = {};
-__export(upgrade_exports, {
-  upgrade: () => upgrade
-});
-async function upgrade() {
-  console.log(`
-Opening ${BILLING_URL}
-`);
+  let res;
   try {
-    const { execFileSync: execFileSync7 } = await import("child_process");
-    if (process.platform === "darwin") {
-      execFileSync7("open", [BILLING_URL]);
-    } else if (process.platform === "linux") {
-      execFileSync7("xdg-open", [BILLING_URL]);
-    } else if (process.platform === "win32") {
-      execFileSync7("cmd", ["/c", "start", "", BILLING_URL]);
-    }
+    res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
   } catch {
-    console.log(`Visit: ${BILLING_URL}`);
+    const fallback = deterministicBranchName({ files: opts.changes?.split("\n").filter(Boolean), description: opts.description });
+    return ensureUniqueName(fallback.name, branchExists);
   }
-}
-var BILLING_URL;
-var init_upgrade = __esm({
-  "src/commands/upgrade.ts"() {
-    "use strict";
-    BILLING_URL = "https://app.quikcommit.dev/billing";
+  if (!res.ok) {
+    const fallback = deterministicBranchName({ files: opts.changes?.split("\n").filter(Boolean), description: opts.description });
+    return ensureUniqueName(fallback.name, branchExists);
   }
-});
-
-// src/smart-diff.ts
-function sanitizeFilepath(path) {
-  return path.replace(/[\x00-\x1F\x7F[\]`]/g, "_").slice(0, 200);
-}
-function classifyFile(filepath) {
-  const basename = filepath.split("/").pop() ?? filepath;
-  if (LOCK_FILES.has(basename)) return "lock";
-  if (filepath.endsWith(".map")) return "sourcemap";
-  if (VENDORED_PREFIXES.some((p) => filepath.startsWith(p))) return "vendored";
-  if (GENERATED_PATTERNS.some((p) => p.test(filepath))) return "generated";
-  return "code";
-}
-function parseDiffIntoFiles(diff) {
-  const files = [];
-  const parts = diff.split(/^(diff --git .+)$/m);
-  for (let i = 1; i < parts.length; i += 2) {
-    const header = parts[i];
-    const content = parts[i + 1] ?? "";
-    const match = header.match(/diff --git a\/(.+?) b\/(.+)/);
-    const filepath = match?.[2] ?? "unknown";
-    const lines = content.split("\n");
-    let additions = 0;
-    let deletions = 0;
-    for (const line of lines) {
-      if (line.startsWith("+") && !line.startsWith("+++")) additions++;
-      else if (line.startsWith("-") && !line.startsWith("---")) deletions++;
-    }
-    files.push({ filepath, content: header + content, additions, deletions });
+  const data = await res.json();
+  let raw;
+  if (local.provider === "cloudflare") {
+    const r = data;
+    const br = r.branch;
+    raw = typeof br?.name === "string" ? br.name : "";
+  } else if (local.provider === "ollama") {
+    raw = data.response ?? "";
+  } else {
+    const choices = data.choices;
+    raw = choices?.[0]?.message?.content ?? "";
+  }
+  raw = raw.replace(/[\r\n].*$/s, "").trim();
+  const sanitized = sanitizeBranchName(raw);
+  if (!sanitized) {
+    const fallback = deterministicBranchName({ files: opts.changes?.split("\n").filter(Boolean), description: opts.description });
+    return ensureUniqueName(fallback.name, branchExists);
   }
-  return files;
-}
-function isMinified(content) {
-  const lines = content.split("\n").filter(
-    (l) => (l.startsWith("+") || l.startsWith("-")) && !l.startsWith("+++") && !l.startsWith("---")
-  );
-  if (lines.length === 0) return false;
-  return lines.some((l) => l.length > 500);
+  return ensureUniqueName(sanitized, branchExists);
 }
-function preprocessDiff(diff) {
-  const files = parseDiffIntoFiles(diff);
-  if (files.length === 0) return { processedDiff: diff, summarized: [], tokensSaved: 0 };
-  const kept = [];
-  const summarized = [];
-  let tokensSaved = 0;
-  for (const file of files) {
-    const classification = classifyFile(file.filepath);
-    switch (classification) {
-      case "sourcemap":
-        tokensSaved += estimateTokens(file.content);
-        summarized.push(file.filepath);
-        break;
-      case "lock":
-        tokensSaved += estimateTokens(file.content);
-        kept.push(`[lock file updated: ${sanitizeFilepath(file.filepath)} (+${file.additions} \u2212${file.deletions} lines)]
-`);
-        summarized.push(file.filepath);
-        break;
-      case "generated":
-        tokensSaved += estimateTokens(file.content);
-        kept.push(`[generated: ${sanitizeFilepath(file.filepath)} (+${file.additions} \u2212${file.deletions})]
-`);
-        summarized.push(file.filepath);
-        break;
-      case "vendored":
-        tokensSaved += estimateTokens(file.content);
-        kept.push(`[vendored: ${sanitizeFilepath(file.filepath)} updated]
-`);
-        summarized.push(file.filepath);
-        break;
-      case "code":
-        if (isMinified(file.content)) {
-          tokensSaved += estimateTokens(file.content);
-          const sizeKB = Math.round(file.content.length / 1024);
-          kept.push(`[minified asset: ${sanitizeFilepath(file.filepath)} (${sizeKB} KB)]
-`);
-          summarized.push(file.filepath);
-        } else {
-          kept.push(file.content);
-        }
-        break;
-    }
+async function runLocalBranch(opts) {
+  const local = getLocalProviderConfig();
+  if (!local) {
+    throw new Error("No local provider configured. Set provider with `qc --use-ollama` etc.");
+  }
+  const ui2 = getUI();
+  const log = ui2.log;
+  const spinner = ui2.spinner(`generating branch name (${opts.model ?? local.model} via ${local.provider})...`);
+  if (process.stderr.isTTY) spinner.start();
+  let final;
+  try {
+    final = await generateLocalBranchName({
+      description: opts.description,
+      diff: opts.diff,
+      changes: opts.changes,
+      recentCommits: opts.recentCommits,
+      model: opts.model,
+      rules: opts.rules
+    });
+  } catch {
+    const filesArr = opts.changes?.split("\n").filter(Boolean) ?? [];
+    const fallback = deterministicBranchName({ files: filesArr, description: opts.description });
+    final = ensureUniqueName(fallback.name, branchExists);
+    log.dim("(used local fallback name; AI generation failed)");
+  } finally {
+    spinner.stop();
+  }
+  log.success(`branch name: ${final}`);
+  const baseRef = opts.baseRef ?? "HEAD";
+  if (opts.noSwitch) {
+    createBranch(final, baseRef);
+    log.success(`created ${final} (not switched)`);
+  } else {
+    createAndCheckoutBranch(final, baseRef);
+    log.success(`switched to ${final}`);
+  }
+  if (opts.push) {
+    gitPushSetUpstream(final);
+    log.success(`pushed origin/${final}`);
   }
-  return {
-    processedDiff: kept.join(""),
-    summarized,
-    tokensSaved
-  };
 }
-var LOCK_FILES, GENERATED_PATTERNS, VENDORED_PREFIXES;
-var init_smart_diff = __esm({
-  "src/smart-diff.ts"() {
+var import_fs8, import_path8, import_os4, CONFIG_PATH2, PROVIDER_URLS, DEFAULT_MODELS;
+var init_local = __esm({
+  "src/local.ts"() {
     "use strict";
+    import_fs8 = require("fs");
+    import_path8 = require("path");
+    import_os4 = require("os");
+    init_config();
     init_dist();
-    LOCK_FILES = /* @__PURE__ */ new Set([
-      "pnpm-lock.yaml",
-      "package-lock.json",
-      "yarn.lock",
-      "Cargo.lock",
-      "Gemfile.lock",
-      "poetry.lock",
-      "composer.lock",
-      "bun.lockb",
-      "shrinkwrap.json"
-    ]);
-    GENERATED_PATTERNS = [
-      /\.generated\.\w+$/,
-      /\.g\.dart$/,
-      /\.pb\.go$/,
-      /\.pb\.ts$/,
-      /(^|\/)\.prisma\/client\//,
-      /\/generated\//
-    ];
-    VENDORED_PREFIXES = ["vendor/", "third_party/", "node_modules/"];
-  }
-});
-
-// ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS({
-  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports2, module2) {
-    var p = process || {};
-    var argv = p.argv || [];
-    var env = p.env || {};
-    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-    var formatter = (open, close, replace = open) => (input) => {
-      let string = "" + input, index = string.indexOf(close, open.length);
-      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-    };
-    var replaceClose = (string, close, replace, index) => {
-      let result = "", cursor = 0;
-      do {
-        result += string.substring(cursor, index) + replace;
-        cursor = index + close.length;
-        index = string.indexOf(close, cursor);
-      } while (~index);
-      return result + string.substring(cursor);
+    init_git();
+    init_monorepo();
+    init_commitlint();
+    init_smart_diff();
+    init_ui();
+    init_commit_helpers();
+    init_branch_name();
+    CONFIG_PATH2 = (0, import_path8.join)((0, import_os4.homedir)(), CONFIG_DIR);
+    PROVIDER_URLS = {
+      ollama: "http://localhost:11434",
+      lmstudio: "http://localhost:1234/v1",
+      openrouter: "https://openrouter.ai/api/v1",
+      custom: "",
+      cloudflare: ""
     };
-    var createColors = (enabled = isColorSupported) => {
-      let f = enabled ? formatter : () => String;
-      return {
-        isColorSupported: enabled,
-        reset: f("\x1B[0m", "\x1B[0m"),
-        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-        italic: f("\x1B[3m", "\x1B[23m"),
-        underline: f("\x1B[4m", "\x1B[24m"),
-        inverse: f("\x1B[7m", "\x1B[27m"),
-        hidden: f("\x1B[8m", "\x1B[28m"),
-        strikethrough: f("\x1B[9m", "\x1B[29m"),
-        black: f("\x1B[30m", "\x1B[39m"),
-        red: f("\x1B[31m", "\x1B[39m"),
-        green: f("\x1B[32m", "\x1B[39m"),
-        yellow: f("\x1B[33m", "\x1B[39m"),
-        blue: f("\x1B[34m", "\x1B[39m"),
-        magenta: f("\x1B[35m", "\x1B[39m"),
-        cyan: f("\x1B[36m", "\x1B[39m"),
-        white: f("\x1B[37m", "\x1B[39m"),
-        gray: f("\x1B[90m", "\x1B[39m"),
-        bgBlack: f("\x1B[40m", "\x1B[49m"),
-        bgRed: f("\x1B[41m", "\x1B[49m"),
-        bgGreen: f("\x1B[42m", "\x1B[49m"),
-        bgYellow: f("\x1B[43m", "\x1B[49m"),
-        bgBlue: f("\x1B[44m", "\x1B[49m"),
-        bgMagenta: f("\x1B[45m", "\x1B[49m"),
-        bgCyan: f("\x1B[46m", "\x1B[49m"),
-        bgWhite: f("\x1B[47m", "\x1B[49m"),
-        blackBright: f("\x1B[90m", "\x1B[39m"),
-        redBright: f("\x1B[91m", "\x1B[39m"),
-        greenBright: f("\x1B[92m", "\x1B[39m"),
-        yellowBright: f("\x1B[93m", "\x1B[39m"),
-        blueBright: f("\x1B[94m", "\x1B[39m"),
-        magentaBright: f("\x1B[95m", "\x1B[39m"),
-        cyanBright: f("\x1B[96m", "\x1B[39m"),
-        whiteBright: f("\x1B[97m", "\x1B[39m"),
-        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-        bgRedBright: f("\x1B[101m", "\x1B[49m"),
-        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-      };
+    DEFAULT_MODELS = {
+      ollama: "codellama",
+      lmstudio: "default",
+      openrouter: "google/gemini-flash-1.5-8b",
+      custom: "",
+      cloudflare: "@cf/qwen/qwen2.5-coder-32b-instruct"
     };
-    module2.exports = createColors();
-    module2.exports.createColors = createColors;
   }
 });
 
-// src/ui.ts
-function hasCliNoColor() {
-  try {
-    return process.argv.slice(2).includes("--no-color");
-  } catch {
-    return false;
-  }
+// src/commands/branch.ts
+var branch_exports = {};
+__export(branch_exports, {
+  runBranch: () => runBranch
+});
+function branchGenerationRules(cfg) {
+  const types = cfg.branch?.generation?.types;
+  if (types && types.length > 0) return { types: [...types] };
+  return void 0;
 }
-function createUI(options) {
-  const isColor = options.isTTY && !options.noColor;
-  const wrap = (fn) => (s) => isColor ? fn(s) : s;
-  const format = {
-    step: (msg) => `${isColor ? import_picocolors.default.dim("\u203A") : "\u203A"} ${isColor ? import_picocolors.default.dim(msg) : msg}`,
-    success: (msg) => `${isColor ? import_picocolors.default.green("\u2713") : "\u2713"} ${msg}`,
-    error: (msg) => `${isColor ? import_picocolors.default.red("\u2717") : "\u2717"} ${msg}`,
-    dim: wrap(import_picocolors.default.dim),
-    bold: wrap(import_picocolors.default.bold),
-    commitType: wrap(import_picocolors.default.cyan),
-    commitScope: wrap(import_picocolors.default.yellow)
-  };
-  function createSpinner(message, write = (s) => process.stderr.write(s)) {
-    let frame = 0;
-    let interval = null;
-    return {
-      start() {
-        if (interval) return;
-        if (!options.isTTY) return;
-        interval = setInterval(() => {
-          const f = SPINNER_FRAMES2[frame++ % SPINNER_FRAMES2.length];
-          write(`\r${format.step(message)} ${isColor ? import_picocolors.default.cyan(f) : f}`);
-        }, 80);
-      },
-      stop(finalMessage) {
-        if (interval) {
-          clearInterval(interval);
-          interval = null;
-        }
-        if (options.isTTY) {
-          write("\r\x1B[2K");
+function finalizeGeneratedBranchName(raw) {
+  return finalizeBranchName(raw, branchExists);
+}
+async function runBranch(opts) {
+  const ui2 = getUI();
+  const log = ui2.log;
+  if (!isGitRepo()) {
+    log.error("Not a git repository.");
+    process.exit(1);
+  }
+  const baseRef = opts.from ?? "HEAD";
+  const config2 = getConfig();
+  const model = opts.model ?? config2.model;
+  const genRules = branchGenerationRules(config2);
+  if (opts.rescue) {
+    const state = detectProtectedBranchState({
+      protectedBranches: config2.branch?.protectedBranches,
+      detectDefault: config2.branch?.detectDefault
+    });
+    if (!state.isProtected) {
+      throw new Error(
+        "`--rescue` only applies on a protected branch (e.g. main). The current branch is not protected."
+      );
+    }
+    if (state.commitsAhead === 0) {
+      throw new Error(
+        "No commits ahead of upstream to rescue. Push your branch or use `qc branch` without `--rescue`."
+      );
+    }
+    let final2;
+    if (opts.explicitName) {
+      const sanitized = sanitizeBranchName(opts.explicitName);
+      if (!sanitized) {
+        throw new Error(`invalid branch name: ${opts.explicitName}`);
+      }
+      final2 = finalizeBranchName(sanitized, branchExists);
+    } else {
+      const recent = getRecentBranchCommits(state.commitsAhead);
+      const apiKey2 = opts.apiKey ?? getApiKey();
+      if (apiKey2) {
+        const spinner2 = ui2.spinner(`generating branch name (${model ?? "default"})...`);
+        if (process.stderr.isTTY) spinner2.start();
+        try {
+          const client = new ApiClient({ apiKey: apiKey2 });
+          try {
+            const result2 = await client.generateBranchName({
+              recent_commits: recent,
+              model: opts.model,
+              description: opts.message,
+              rules: genRules
+            });
+            final2 = finalizeGeneratedBranchName(result2.name);
+          } catch {
+            const fallback = deterministicBranchName({
+              description: recent.join(" ") || opts.message
+            });
+            final2 = finalizeBranchName(fallback.name, branchExists);
+            log.dim("(used deterministic fallback name; API generation failed)");
+          }
+        } finally {
+          spinner2.stop();
         }
-        if (finalMessage) {
-          write(finalMessage + "\n");
+      } else {
+        const { getLocalProviderConfig: getLocalProviderConfig2, generateLocalBranchName: generateLocalBranchName2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+        if (!getLocalProviderConfig2()) {
+          throw new Error(
+            "Not authenticated. Run `qc login` first, or configure a local provider for `--rescue`."
+          );
+        }
+        const spinner2 = ui2.spinner(`generating branch name (${model ?? "default"} via local)...`);
+        if (process.stderr.isTTY) spinner2.start();
+        try {
+          try {
+            const name = await generateLocalBranchName2({
+              recentCommits: recent,
+              model: opts.model,
+              description: opts.message,
+              rules: genRules
+            });
+            final2 = finalizeBranchName(name, branchExists, { skipUniqueness: true });
+          } catch {
+            const fallback = deterministicBranchName({
+              description: recent.join(" ") || opts.message
+            });
+            final2 = finalizeBranchName(fallback.name, branchExists);
+            log.dim("(used deterministic fallback name; local provider failed)");
+          }
+        } finally {
+          spinner2.stop();
         }
       }
-    };
+    }
+    log.success(`branch name: ${final2}`);
+    if (opts.dryRun) {
+      log.dim("(dry-run; not running rescue)");
+      return;
+    }
+    if (!process.stdin.isTTY) {
+      throw new Error("`--rescue` requires an interactive terminal to confirm (or use `qc branch <name>` after arranging commits manually).");
+    }
+    log.dim(
+      `About to: 1) create ${final2} at HEAD, 2) reset ${state.branch} to upstream, 3) switch to ${final2}`
+    );
+    if (!await promptYesNo("Continue with rescue?")) {
+      log.dim("aborted.");
+      return;
+    }
+    rescueCommits({ currentBranch: state.branch, newBranch: final2 });
+    log.success(`moved ${state.commitsAhead} commit(s) to ${final2}`);
+    log.success(`${state.branch} reset to upstream`);
+    if (opts.push) {
+      gitPushSetUpstream(final2);
+      log.success(`pushed origin/${final2}`);
+    }
+    return;
+  }
+  if (opts.explicitName) {
+    const sanitized = sanitizeBranchName(opts.explicitName);
+    if (!sanitized) {
+      throw new Error(`invalid branch name: ${opts.explicitName}`);
+    }
+    const final2 = finalizeBranchName(sanitized, branchExists);
+    if (opts.dryRun) {
+      log.success(`would create branch: ${final2}`);
+      return;
+    }
+    if (opts.noSwitch) {
+      createBranch(final2, baseRef);
+      log.success(`created branch ${final2} (not switched)`);
+    } else {
+      createAndCheckoutBranch(final2, baseRef);
+      log.success(`switched to ${final2}`);
+    }
+    if (opts.push) {
+      gitPushSetUpstream(final2);
+      log.success(`pushed origin/${final2}`);
+    }
+    return;
   }
-  const log = {
-    step: (msg) => process.stderr.write(format.step(msg) + "\n"),
-    success: (msg) => process.stderr.write(format.success(msg) + "\n"),
-    error: (msg) => process.stderr.write(format.error(msg) + "\n"),
-    dim: (msg) => process.stderr.write(format.dim(msg) + "\n")
-  };
-  return { isColor, format, spinner: createSpinner, log };
-}
-function getUI() {
-  if (!_defaultUI) {
-    _defaultUI = createUI({
-      isTTY: !!process.stderr.isTTY,
-      noColor: !!process.env.NO_COLOR || hasCliNoColor()
-    });
+  const payload = { model, rules: genRules };
+  if (opts.message) {
+    payload.description = opts.message;
+  } else if (opts.fromCommits) {
+    payload.recent_commits = getRecentBranchCommits(10);
+  } else {
+    if (!hasStagedChanges()) {
+      throw new Error(
+        "No staged changes detected. Stage with `git add`, or provide -m '<description>'."
+      );
+    }
+    payload.diff = getStagedDiff(config2.excludes ?? []);
+    payload.changes = getStagedFiles();
   }
-  return _defaultUI;
-}
-var import_picocolors, SPINNER_FRAMES2, _defaultUI, ui;
-var init_ui = __esm({
-  "src/ui.ts"() {
-    "use strict";
-    import_picocolors = __toESM(require_picocolors());
-    SPINNER_FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-    ui = new Proxy({}, {
-      get(_target, prop) {
-        return getUI()[prop];
-      }
-    });
+  const apiKey = opts.apiKey ?? getApiKey();
+  if (!apiKey) {
+    const { getLocalProviderConfig: getLocalProviderConfig2, runLocalBranch: runLocalBranch2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+    if (getLocalProviderConfig2()) {
+      await runLocalBranch2({
+        description: opts.message,
+        diff: opts.message ? void 0 : payload.diff,
+        changes: opts.message ? void 0 : payload.changes,
+        recentCommits: payload.recent_commits,
+        model: opts.model,
+        noSwitch: opts.noSwitch,
+        push: opts.push,
+        baseRef,
+        rules: genRules
+      });
+      return;
+    }
+    throw new Error("Not authenticated. Run `qc login` first, or provide --message.");
   }
-});
-
-// src/commit-helpers.ts
-function applyCliTypeScopeToRules(rules, type, scope) {
-  let next = { ...rules };
-  if (type) {
-    next = { ...next, types: [type] };
+  const spinner = ui2.spinner(`generating branch name (${model ?? "default"})...`);
+  if (process.stderr.isTTY) spinner.start();
+  let result;
+  try {
+    const client = new ApiClient({ apiKey });
+    result = await client.generateBranchName(payload);
+  } finally {
+    spinner.stop();
   }
-  if (scope) {
-    next = { ...next, scopes: [scope] };
+  const final = finalizeGeneratedBranchName(result.name);
+  log.success(`branch name: ${final}`);
+  if (opts.dryRun) {
+    log.dim(`(dry-run; not creating)`);
+    return;
   }
-  return next;
-}
-function generationHintsFromArgs(split, forceBody) {
-  const h = {};
-  if (split) h.split = true;
-  if (forceBody) h.force_body = true;
-  return Object.keys(h).length > 0 ? h : void 0;
-}
-function splitCommitMessageForDisplay(message) {
-  const t = message.replace(/\r\n/g, "\n").trimEnd();
-  const doubleNl = t.indexOf("\n\n");
-  if (doubleNl !== -1) {
-    const head = t.slice(0, doubleNl);
-    const subject = head.split("\n")[0]?.trim() ?? "";
-    return { subject, body: t.slice(doubleNl + 2).trimEnd() };
+  if (opts.noSwitch) {
+    createBranch(final, baseRef);
+    log.success(`created ${final} (not switched)`);
+  } else {
+    createAndCheckoutBranch(final, baseRef);
+    log.success(`switched to ${final}`);
   }
-  const firstNl = t.indexOf("\n");
-  if (firstNl === -1) {
-    return { subject: t.trim(), body: "" };
+  if (opts.push) {
+    gitPushSetUpstream(final);
+    log.success(`pushed origin/${final}`);
   }
-  return {
-    subject: t.slice(0, firstNl).trim(),
-    body: t.slice(firstNl + 1).trimEnd()
-  };
 }
-function formatVerboseCommitDiagnostics(diagnostics, roundTripMs) {
-  const lines = [`api_round_trip_ms: ${roundTripMs}`];
-  if (diagnostics !== void 0) {
-    lines.push(JSON.stringify(diagnostics, null, 2));
+var init_branch2 = __esm({
+  "src/commands/branch.ts"() {
+    "use strict";
+    init_api();
+    init_config();
+    init_branch_rescue();
+    init_protected_branch_guard();
+    init_git();
+    init_branch_name();
+    init_commit_helpers();
+    init_ui();
   }
-  return lines.join("\n");
-}
-async function interactiveRefineMessage(initial, opts) {
-  if (opts.skip) return { action: "accept", message: initial };
-  const rl = import_promises.default.createInterface({ input: process.stdin, output: process.stderr });
-  try {
-    process.stderr.write(`
-${initial}
+});
 
-`);
-    const choice = (await rl.question("Keep? [Y/n/e]: ")).trim().toLowerCase();
-    if (choice === "n") {
-      return { action: "abort" };
-    }
-    if (choice === "e") {
-      process.stderr.write("Enter new message (end with a line containing only .):\n");
-      const lines = [];
-      while (true) {
-        const line = await rl.question("");
-        if (line === ".") break;
-        lines.push(line);
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  init: () => init
+});
+function init(options) {
+  let hooksDir;
+  try {
+    hooksDir = (0, import_child_process6.execFileSync)("git", ["rev-parse", "--git-path", "hooks"], {
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    console.error("Error: Not a git repository");
+    process.exit(1);
+  }
+  const hookPath = (0, import_path9.join)(hooksDir, "prepare-commit-msg");
+  if (options.uninstall) {
+    if ((0, import_fs9.existsSync)(hookPath)) {
+      const content = (0, import_fs9.readFileSync)(hookPath, "utf-8");
+      if (content.includes("Quikcommit")) {
+        (0, import_fs9.unlinkSync)(hookPath);
+        console.log("Quikcommit hook removed.");
+      } else {
+        console.log("Hook exists but was not installed by Quikcommit. Skipping.");
       }
-      const edited = lines.join("\n").trim();
-      return { action: "edit", message: edited.length > 0 ? edited : initial };
+    } else {
+      console.log("No hook to remove.");
     }
-    return { action: "accept", message: initial };
-  } finally {
-    rl.close();
+    return;
   }
-}
-async function confirmCommit(prompt2, opts) {
-  if (opts.skip) return { action: "commit" };
-  const rl = import_promises.default.createInterface({ input: process.stdin, output: process.stderr });
-  try {
-    const ans = (await rl.question(prompt2)).trim().toLowerCase();
-    if (ans !== "y" && ans !== "yes") {
-      return { action: "abort" };
+  if ((0, import_fs9.existsSync)(hookPath)) {
+    const content = (0, import_fs9.readFileSync)(hookPath, "utf-8");
+    if (content.includes("Quikcommit")) {
+      console.log("Quikcommit hook is already installed.");
+      return;
     }
-    return { action: "commit" };
-  } finally {
-    rl.close();
+    console.error(
+      "A prepare-commit-msg hook already exists. Use --uninstall first or manually merge."
+    );
+    process.exit(1);
   }
+  (0, import_fs9.writeFileSync)(hookPath, HOOK_CONTENT);
+  (0, import_fs9.chmodSync)(hookPath, 493);
+  console.log("Quikcommit hook installed.");
+  console.log("Now just run `git commit` and a message will be generated automatically.");
 }
-function shouldSkipTTYInteraction(hookMode) {
-  return hookMode === true || process.stdin.isTTY !== true;
-}
-function logVerboseDiagnostics(dim, verbose, quiet, diagnostics, roundTripMs) {
-  if (!verbose || quiet) return;
-  process.stderr.write(
-    `
-${formatVerboseCommitDiagnostics(diagnostics, roundTripMs)}
-`
-  );
-  dim("(verbose diagnostics on stderr)");
+var import_fs9, import_path9, import_child_process6, HOOK_CONTENT;
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    import_fs9 = require("fs");
+    import_path9 = require("path");
+    import_child_process6 = require("child_process");
+    HOOK_CONTENT = `#!/bin/sh
+# Quikcommit - auto-generate commit messages
+# Installed by: qc init
+# Remove with: qc init --uninstall
+
+# Only generate if no message was provided (empty commit message file)
+COMMIT_MSG_FILE="$1"
+COMMIT_SOURCE="$2"
+
+# Skip if message was provided via -m, merge, squash, etc.
+if [ -n "$COMMIT_SOURCE" ]; then
+  exit 0
+fi
+
+# Skip if message file already has content (excluding comments)
+if grep -qv '^#' "$COMMIT_MSG_FILE" 2>/dev/null; then
+  if [ -n "$(grep -v '^#' "$COMMIT_MSG_FILE" | grep -v '^$')" ]; then
+    exit 0
+  fi
+fi
+
+# Generate commit message
+MSG=$(qc --message-only --hook-mode 2>/dev/null)
+if [ $? -eq 0 ] && [ -n "$MSG" ]; then
+  printf '%s
+' "$MSG" > "$COMMIT_MSG_FILE"
+fi
+`;
+  }
+});
+
+// src/commands/team.ts
+var team_exports = {};
+__export(team_exports, {
+  team: () => team
+});
+function createApiClient() {
+  return new ApiClient();
 }
-function createSilentLog() {
-  return {
-    step: () => {
-    },
-    success: () => {
-    },
-    error: (msg) => console.error(msg),
-    dim: () => {
-    }
-  };
+function mapCommitlintToRules(config2) {
+  if (!config2 || typeof config2 !== "object") return null;
+  const c = config2;
+  const rules = {};
+  const _ext = c.extends;
+  const rulesConfig = c.rules;
+  if (Array.isArray(rulesConfig?.["type-enum"]) && rulesConfig["type-enum"].length >= 3) {
+    const [, , value] = rulesConfig["type-enum"];
+    if (Array.isArray(value)) rules.types = value;
+  }
+  if (Array.isArray(rulesConfig?.["scope-enum"]) && rulesConfig["scope-enum"].length >= 3) {
+    const [, , value] = rulesConfig["scope-enum"];
+    if (Array.isArray(value)) rules.scopes = value;
+  }
+  if (Array.isArray(rulesConfig?.["header-max-length"]) && rulesConfig["header-max-length"].length >= 3) {
+    const [, , maxLen] = rulesConfig["header-max-length"];
+    if (typeof maxLen === "number") rules.headerMaxLength = maxLen;
+  }
+  if (Array.isArray(rulesConfig?.["subject-case"]) && rulesConfig["subject-case"].length >= 3) {
+    const [, , val] = rulesConfig["subject-case"];
+    if (val != null) rules.subjectCase = Array.isArray(val) ? val : [val];
+  }
+  return Object.keys(rules).length > 0 ? rules : null;
 }
-function displayCommitMessage(message, log) {
-  const { subject, body } = splitCommitMessageForDisplay(message);
-  log.success(subject);
-  if (body) {
-    for (const line of body.split("\n")) {
-      log.dim(`  ${line}`);
+function detectLocalCommitlintRules() {
+  const cwd = process.cwd();
+  const files = [
+    ".commitlintrc.json",
+    ".commitlintrc",
+    "commitlint.config.js",
+    "commitlint.config.cjs",
+    "commitlint.config.mjs"
+  ];
+  for (const file of files) {
+    const path = (0, import_path10.join)(cwd, file);
+    if (!(0, import_fs10.existsSync)(path)) continue;
+    try {
+      const content = (0, import_fs10.readFileSync)(path, "utf-8");
+      let parsed;
+      if (file.endsWith(".json") || file === ".commitlintrc") {
+        parsed = JSON.parse(content);
+      } else {
+        continue;
+      }
+      const rules = mapCommitlintToRules(parsed);
+      if (rules) return rules;
+    } catch {
     }
-    process.stderr.write("\n");
-  }
-}
-var import_promises;
-var init_commit_helpers = __esm({
-  "src/commit-helpers.ts"() {
-    "use strict";
-    import_promises = __toESM(require("node:readline/promises"));
   }
-});
-
-// src/local.ts
-var local_exports = {};
-__export(local_exports, {
-  getLocalProviderConfig: () => getLocalProviderConfig,
-  runLocalCommit: () => runLocalCommit
-});
-function getLegacyProvider() {
-  try {
-    const p = (0, import_path10.join)(CONFIG_PATH2, "provider");
-    if ((0, import_fs10.existsSync)(p)) {
-      const v = (0, import_fs10.readFileSync)(p, "utf-8").trim().toLowerCase();
-      if (["ollama", "lmstudio", "openrouter", "custom", "cloudflare"].includes(v)) {
-        return v;
+  const pkgPath = (0, import_path10.join)(cwd, "package.json");
+  if ((0, import_fs10.existsSync)(pkgPath)) {
+    try {
+      const content = (0, import_fs10.readFileSync)(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.commitlint) {
+        const rules = mapCommitlintToRules(pkg.commitlint);
+        if (rules) return rules;
       }
+    } catch {
     }
-  } catch {
+  }
+  const config2 = getConfig();
+  if (config2.rules && Object.keys(config2.rules).length > 0) {
+    return config2.rules;
   }
   return null;
 }
-function getLegacyBaseUrl(provider) {
-  try {
-    const p = (0, import_path10.join)(CONFIG_PATH2, "base_url");
-    if ((0, import_fs10.existsSync)(p)) {
-      return (0, import_fs10.readFileSync)(p, "utf-8").trim();
+async function team(subcommand, args) {
+  const api = createApiClient();
+  switch (subcommand) {
+    case void 0:
+    case "info": {
+      const info = await api.getTeam();
+      console.log(`
+  Team: ${info.name}`);
+      console.log(`  Plan: ${info.plan}`);
+      console.log(`  Members: ${info.member_count}`);
+      console.log("\n  Members:");
+      for (const m of info.members) {
+        console.log(`    ${m.name ?? m.email} <${m.email}> (${m.role})`);
+      }
+      break;
     }
-  } catch {
-  }
-  return PROVIDER_URLS[provider] ?? "";
-}
-function getLegacyModel(provider) {
-  try {
-    const p = (0, import_path10.join)(CONFIG_PATH2, "model");
-    if ((0, import_fs10.existsSync)(p)) {
-      const v = (0, import_fs10.readFileSync)(p, "utf-8").trim();
-      if (v) return v;
+    case "rules": {
+      if (args?.[0] === "push") {
+        const rules = detectLocalCommitlintRules();
+        if (!rules) {
+          console.error("No local commitlint config found.");
+          process.exit(1);
+        }
+        await api.pushTeamRules(rules);
+        console.log("Team rules updated from local commitlint config.");
+      } else {
+        const rules = await api.getTeamRules();
+        console.log("\n  Team Commit Rules:");
+        console.log(JSON.stringify(rules, null, 2));
+      }
+      break;
     }
-  } catch {
+    case "invite": {
+      const email = args?.[0];
+      if (!email) {
+        console.error("Usage: qc team invite <email>");
+        process.exit(1);
+      }
+      await api.inviteTeamMember(email);
+      console.log(`Invitation sent to ${email}`);
+      break;
+    }
+    default:
+      console.error(`Unknown team command: ${subcommand}`);
+      console.log("Usage: qc team [info|rules|rules push|invite <email>]");
+      process.exit(1);
   }
-  return DEFAULT_MODELS[provider] ?? "";
-}
-function getLocalProviderConfig() {
-  const config2 = getConfig();
-  const provider = config2.provider ?? getLegacyProvider();
-  if (!provider) return null;
-  const baseUrl = config2.apiUrl ?? getLegacyBaseUrl(provider) ?? PROVIDER_URLS[provider] ?? "";
-  if (!baseUrl) return null;
-  const model = config2.model ?? getLegacyModel(provider) ?? DEFAULT_MODELS[provider];
-  const apiKey = provider === "openrouter" || provider === "custom" ? getApiKey() : null;
-  if (provider === "openrouter" && !apiKey) return null;
-  return { provider, baseUrl, model, apiKey };
 }
-function buildUserPrompt(changes, diff, rules, recentCommits, hints) {
-  let prompt2 = `Generate a commit message for these changes:
-
-## File changes:
-<file_changes>
-${changes}
-</file_changes>
-
-## Diff:
-<diff>
-${diff}
-</diff>
-
-`;
-  if (recentCommits && recentCommits.length > 0) {
-    const history = recentCommits.slice(0, 10).join("\n");
-    prompt2 += `Recent commits on this branch (match style when appropriate):
-${history}
-
-`;
+var import_fs10, import_path10;
+var init_team = __esm({
+  "src/commands/team.ts"() {
+    "use strict";
+    import_fs10 = require("fs");
+    import_path10 = require("path");
+    init_api();
+    init_config();
   }
-  if (hints?.split) {
-    prompt2 += `MULTI-COMMIT MODE: If changes span multiple logical commits, focus the message on the primary change and mention other slices in the body.
+});
 
-`;
+// src/commands/config.ts
+var config_exports2 = {};
+__export(config_exports2, {
+  config: () => config
+});
+function config(args) {
+  if (args.length === 0) {
+    showConfig();
+    return;
   }
-  if (hints?.force_body) {
-    prompt2 += `The user requires a BODY section after the subject line, even for small changes.
-
-`;
+  const sub = args[0];
+  if (sub === "set") {
+    const key = args[1];
+    const value = args[2];
+    if (!key || !value) {
+      console.error("Usage: qc config set <key> <value>");
+      console.error("  Keys: model, api_url, provider, auto_stage");
+      process.exit(1);
+    }
+    setConfig(key, value);
+    return;
   }
-  if (rules && Object.keys(rules).length > 0) {
-    prompt2 += `Rules: ${JSON.stringify(rules)}
-
-`;
+  if (sub === "reset") {
+    resetConfig();
+    return;
   }
-  prompt2 += `Important:
-- Follow conventional commit format: <type>(<scope>): <subject>
-- Response should be the commit message only, no explanations`;
-  return prompt2;
+  console.error(`Unknown subcommand: ${sub}`);
+  console.error("Usage: qc config [set <key> <value> | reset]");
+  process.exit(1);
 }
-function buildRequest(provider, baseUrl, userContent, diff, changes, model, apiKey, rules, recentCommits, hints) {
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["Authorization"] = `Bearer ${apiKey}`;
-  }
-  if (provider === "openrouter") {
-    headers["HTTP-Referer"] = "https://github.com/Quikcommit-Internal/public";
-    headers["X-Title"] = "qc - AI Commit Message Generator";
+function showConfig() {
+  const cfg = getConfig();
+  const apiKey = getApiKey();
+  console.log("Current configuration:");
+  console.log(`  model:    ${cfg.model ?? "(default for plan)"}`);
+  console.log(`  api_url:  ${cfg.apiUrl ?? DEFAULT_API_URL}`);
+  console.log(`  provider:   ${cfg.provider ?? "(default)"}`);
+  console.log(`  auto_stage: ${cfg.autoStage ? "true" : "false"}`);
+  console.log(`  auth:       ${apiKey ? "****" : "not set"}`);
+  if (cfg.excludes?.length) {
+    console.log(`  excludes: ${cfg.excludes.join(", ")}`);
   }
-  let url;
-  let body;
-  switch (provider) {
-    case "ollama":
-      url = `${baseUrl}/api/generate`;
-      body = {
-        model,
-        prompt: userContent,
-        stream: false,
-        options: {}
-      };
-      return { url, body, headers: { "Content-Type": "application/json" } };
-    case "lmstudio":
-      url = `${baseUrl}/chat/completions`;
-      body = {
-        model,
-        stream: false,
-        messages: [
-          {
-            role: "system",
-            content: "You are a git commit message generator. Create conventional commit messages."
-          },
-          { role: "user", content: userContent }
-        ]
-      };
-      return { url, body, headers: { "Content-Type": "application/json" } };
-    case "openrouter":
-    case "custom":
-      url = `${baseUrl}/chat/completions`;
-      body = {
-        model,
-        stream: false,
-        messages: [
-          {
-            role: "system",
-            content: "You are a git commit message generator. Create conventional commit messages."
-          },
-          { role: "user", content: userContent }
-        ]
-      };
-      return { url, body, headers };
-    case "cloudflare": {
-      url = `${baseUrl.replace(/\/$/, "")}/commit`;
-      const payload = { diff, changes, rules };
-      if (recentCommits && recentCommits.length > 0) {
-        payload.recent_commits = recentCommits.slice(0, 10);
-      }
-      if (hints && Object.keys(hints).length > 0) {
-        payload.generation_hints = hints;
-      }
-      body = payload;
-      return { url, body, headers: { "Content-Type": "application/json" } };
+}
+function setConfig(key, value) {
+  const cfg = getConfig();
+  const updates = {};
+  if (key === "model") {
+    updates.model = value;
+  } else if (key === "provider") {
+    const valid = ["ollama", "lmstudio", "openrouter", "custom", "cloudflare"];
+    if (!valid.includes(value.toLowerCase())) {
+      console.error(`Invalid provider. Must be one of: ${valid.join(", ")}`);
+      process.exit(1);
     }
-    default:
-      throw new Error(`Unknown provider: ${provider}`);
-  }
-}
-function parseResponse(provider, data) {
-  const r = data;
-  switch (provider) {
-    case "ollama":
-      return r.response ?? "";
-    case "lmstudio":
-    case "openrouter":
-    case "custom": {
-      const choices = r.choices;
-      return choices?.[0]?.message?.content ?? "";
+    updates.provider = value.toLowerCase();
+  } else if (key === "api_url") {
+    try {
+      new URL(value);
+      updates.apiUrl = value;
+    } catch {
+      console.error("Invalid URL:", value);
+      process.exit(1);
     }
-    case "cloudflare":
-      return r.commit?.response ?? "";
-    default:
-      return "";
+  } else if (key === "auto_stage") {
+    updates.autoStage = value === "true" || value === "1";
+  } else {
+    console.error(`Unknown key: ${key}`);
+    console.error("  Keys: model, api_url, provider, auto_stage");
+    process.exit(1);
   }
+  saveConfig({ ...cfg, ...updates });
+  console.log(`Set ${key} = ${value}`);
 }
-async function runLocalCommit(args) {
-  const silent = !!(args.hookMode || args.quiet);
-  const log = silent ? createSilentLog() : getUI().log;
-  if (!isGitRepo()) {
-    throw new Error("Not a git repository.");
-  }
-  if (!hasStagedChanges()) {
-    throw new Error("No staged changes. Stage files with `git add` first.");
-  }
-  const local = getLocalProviderConfig();
-  if (!local) {
-    throw new Error(
-      "No local provider configured. Set provider in ~/.config/qc/config.json or run with SaaS (qc login)."
-    );
+function resetConfig() {
+  saveConfig({});
+  console.log("Config reset to defaults.");
+}
+var init_config2 = __esm({
+  "src/commands/config.ts"() {
+    "use strict";
+    init_config();
+    init_dist();
   }
-  const config2 = getConfig();
-  const excludes = [...config2.excludes ?? [], ...args.exclude];
-  let diff = getStagedDiff(excludes);
-  const changes = getStagedFiles();
-  if (!args.noSmartDiff) {
-    const smartResult = preprocessDiff(diff);
-    diff = smartResult.processedDiff;
-    if (smartResult.summarized.length > 0 && !silent) {
-      log.step(
-        `smart-diff: ${smartResult.summarized.length} file(s) summarized (saved ~${Math.round(smartResult.tokensSaved / 1e3)}K tokens)`
-      );
+});
+
+// src/commands/upgrade.ts
+var upgrade_exports = {};
+__export(upgrade_exports, {
+  upgrade: () => upgrade
+});
+async function upgrade() {
+  console.log(`
+Opening ${BILLING_URL}
+`);
+  try {
+    const { execFileSync: execFileSync7 } = await import("child_process");
+    if (process.platform === "darwin") {
+      execFileSync7("open", [BILLING_URL]);
+    } else if (process.platform === "linux") {
+      execFileSync7("xdg-open", [BILLING_URL]);
+    } else if (process.platform === "win32") {
+      execFileSync7("cmd", ["/c", "start", "", BILLING_URL]);
     }
+  } catch {
+    console.log(`Visit: ${BILLING_URL}`);
   }
-  let rules = { ...await detectCommitlintRules(), ...config2.rules ?? {} };
-  const workspace = detectWorkspace();
-  if (workspace) {
-    const stagedFiles = changes.trim().split("\n").filter(Boolean);
-    const scope = autoDetectScope(stagedFiles, workspace);
-    if (scope) {
-      const scopes = scope.split(",").map((s) => s.trim());
-      rules = { ...rules, scopes };
-    }
+}
+var BILLING_URL;
+var init_upgrade = __esm({
+  "src/commands/upgrade.ts"() {
+    "use strict";
+    BILLING_URL = "https://app.quikcommit.dev/billing";
   }
-  rules = applyCliTypeScopeToRules(rules, args.type, args.scope);
-  const recentCommits = args.noContext ? void 0 : getRecentBranchCommits(5);
-  const generationHints = generationHintsFromArgs(args.split, args.forceBody);
-  const skipInteractive = silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
-  const skipConfirm = args.dryRun || args.messageOnly || silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
-  const model = args.model ?? local.model;
-  const modelDisplay = model ?? local.model ?? "default";
-  const userContent = buildUserPrompt(
-    changes,
-    diff,
-    Object.keys(rules).length > 0 ? rules : void 0,
-    recentCommits,
-    generationHints
-  );
-  const { url, body, headers } = buildRequest(
-    local.provider,
-    local.baseUrl,
-    userContent,
-    diff,
-    changes,
-    model,
-    local.apiKey,
-    rules,
-    recentCommits,
-    generationHints
+});
+
+// src/branch-guard.ts
+async function runBranchGuard(args, log) {
+  if (!shouldRunGuard({
+    allowProtected: !!args.allowProtected,
+    hookMode: !!args.hookMode,
+    isTTY: !!process.stdin.isTTY
+  })) {
+    return { action: "continue" };
+  }
+  const { getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const config2 = getConfig2();
+  const state = detectProtectedBranchState({
+    protectedBranches: config2.branch?.protectedBranches,
+    detectDefault: config2.branch?.detectDefault
+  });
+  if (!state.isProtected) {
+    return { action: "continue" };
+  }
+  log.error(
+    `You're on ${state.branch} (a protected branch).` + (state.commitsAhead > 0 ? ` ${state.commitsAhead} commit(s) ahead of upstream.` : "")
   );
-  if (!url || url.includes("YOUR-WORKER")) {
-    throw new Error(
-      "Cloudflare provider requires api_url. Run: qc config set api_url https://your-worker.workers.dev"
-    );
+  let action;
+  let usedConfigDefault = false;
+  if (args.autoBranch) {
+    action = "branch";
+  } else if (config2.branch?.defaultAction === "branch") {
+    action = "branch";
+    usedConfigDefault = true;
+  } else if (config2.branch?.defaultAction === "continue") {
+    action = "continue";
+    usedConfigDefault = true;
+  } else {
+    action = await promptProtectedAction(state.mode);
   }
-  const spinner = getUI().spinner(`generating commit (${modelDisplay} via ${local.provider})...`);
-  if (!silent) spinner.start();
-  const t0 = Date.now();
-  let res;
-  try {
-    res = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-  } finally {
-    spinner.stop();
+  if (action === "continue" && usedConfigDefault) {
+    log.dim("(continuing on protected branch per config `branch.defaultAction`)");
   }
-  const roundTripMs = Date.now() - t0;
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Provider error (${res.status}): ${text}`);
+  if (action === "abort") {
+    log.dim("aborted.");
+    return { action: "abort" };
   }
-  const data = await res.json();
-  let message = parseResponse(local.provider, data);
-  message = message.replace(/\\n/g, "\n").replace(/\\r/g, "").trim();
-  if (!message) {
-    throw new Error("Failed to generate commit message.");
+  if (action === "continue") {
+    return { action: "continue" };
   }
-  const diagnostics = local.provider === "cloudflare" && typeof data === "object" && data !== null ? data.diagnostics : void 0;
-  logVerboseDiagnostics((msg) => log.dim(msg), args.verbose, args.quiet, diagnostics, roundTripMs);
-  if (args.interactive) {
-    if (shouldSkipTTYInteraction(args.hookMode)) {
-      if (!silent) log.dim("(--interactive ignored: not running in a TTY)");
+  const stagedDiff = state.mode === "uncommitted" ? getStagedDiff(args.excludes ?? []) : "";
+  const stagedChanges = state.mode === "uncommitted" ? getStagedFiles() : "";
+  const recentCommits = state.mode === "rescue" ? getRecentBranchCommits(state.commitsAhead) : void 0;
+  const branchRules = args.branchRules ?? (config2.branch?.generation?.types && config2.branch.generation.types.length > 0 ? { types: [...config2.branch.generation.types] } : void 0);
+  const apiKey = args.apiKey;
+  const ui2 = getUI();
+  let generateLocalBranchNameFn;
+  if (!apiKey) {
+    const { getLocalProviderConfig: getLocalProviderConfig2, generateLocalBranchName: generateLocalBranchName2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+    if (!getLocalProviderConfig2()) {
+      log.error(
+        "Cannot generate branch name: not authenticated and no local provider configured. Run `qc login` or configure a local provider."
+      );
+      return { action: "abort" };
+    }
+    generateLocalBranchNameFn = generateLocalBranchName2;
+  }
+  const spinner = ui2.spinner(`generating branch name...`);
+  if (process.stderr.isTTY) spinner.start();
+  let rawName;
+  let usedFallback = false;
+  try {
+    if (apiKey) {
+      const client = new ApiClient({ apiKey });
+      try {
+        const branchResult = await client.generateBranchName({
+          diff: stagedDiff || void 0,
+          changes: stagedChanges || void 0,
+          recent_commits: recentCommits,
+          model: args.model,
+          rules: branchRules
+        });
+        rawName = branchResult.name;
+      } catch {
+        const fallbackInput = state.mode === "rescue" ? { files: [], description: recentCommits?.join(" ") ?? "" } : { files: stagedChanges ? stagedChanges.split("\n").filter(Boolean) : [] };
+        rawName = deterministicBranchName(fallbackInput).name;
+        usedFallback = true;
+      }
     } else {
-      const refineResult = await interactiveRefineMessage(message, { skip: skipInteractive });
-      if (refineResult.action === "abort") {
-        process.exit(0);
+      try {
+        rawName = await generateLocalBranchNameFn({
+          diff: stagedDiff || void 0,
+          changes: stagedChanges || void 0,
+          recentCommits,
+          model: args.model,
+          rules: branchRules
+        });
+      } catch {
+        const fallbackInput = state.mode === "rescue" ? { files: [], description: recentCommits?.join(" ") ?? "" } : { files: stagedChanges ? stagedChanges.split("\n").filter(Boolean) : [] };
+        rawName = deterministicBranchName(fallbackInput).name;
+        usedFallback = true;
       }
-      message = refineResult.message;
     }
+  } finally {
+    spinner.stop();
   }
-  if (args.messageOnly) {
-    console.log(message);
-    return;
-  }
-  if (!silent) {
-    displayCommitMessage(message, log);
-  }
-  if (args.dryRun) {
-    return;
+  if (usedFallback) {
+    log.dim("(used local fallback name; AI generation failed)");
   }
-  if (args.confirm) {
-    const confirmResult = await confirmCommit("Proceed with commit? [y/N]: ", { skip: skipConfirm });
-    if (confirmResult.action === "abort") {
-      process.exit(0);
+  let final;
+  try {
+    final = finalizeBranchName(rawName, branchExists);
+  } catch {
+    const generatorName = usedFallback ? "deterministic fallback" : apiKey ? "API generator" : "local provider";
+    log.error(`Invalid branch name from ${generatorName}: ${rawName}`);
+    return { action: "abort" };
+  }
+  log.success(`branch name: ${final}`);
+  if (state.mode === "rescue") {
+    log.dim(
+      `About to: 1) create ${final} at HEAD, 2) reset ${state.branch} to upstream, 3) switch to ${final}`
+    );
+    const confirmed = await promptYesNo("Continue with rescue?");
+    if (!confirmed) {
+      log.dim("aborted.");
+      return { action: "abort" };
+    }
+    try {
+      rescueCommits({ currentBranch: state.branch, newBranch: final });
+      log.success(`moved ${state.commitsAhead} commit(s) to ${final}`);
+      log.success(`${state.branch} reset to upstream`);
+    } catch (err) {
+      log.error(`Rescue failed: ${err instanceof Error ? err.message : String(err)}`);
+      return { action: "abort" };
     }
+    return { action: "done" };
   }
-  gitCommit(message);
-  if (args.push) {
-    gitPush();
+  createAndCheckoutBranch(final);
+  log.success(`switched to ${final}`);
+  return { action: "continue" };
+}
+async function promptProtectedAction(mode) {
+  const rl = import_promises2.default.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const question = mode === "rescue" ? "Move commits to a new branch? [B/c/a] " : "Create a new branch first? [B/c/a] ";
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    if (answer === "" || answer === "b" || answer === "y") return "branch";
+    if (answer === "c") return "continue";
+    return "abort";
+  } finally {
+    rl.close();
   }
 }
-var import_fs10, import_path10, import_os4, CONFIG_PATH2, PROVIDER_URLS, DEFAULT_MODELS;
-var init_local = __esm({
-  "src/local.ts"() {
+var import_promises2;
+var init_branch_guard = __esm({
+  "src/branch-guard.ts"() {
     "use strict";
-    import_fs10 = require("fs");
-    import_path10 = require("path");
-    import_os4 = require("os");
-    init_config();
-    init_dist();
+    import_promises2 = __toESM(require("node:readline/promises"));
+    init_api();
     init_git();
-    init_monorepo();
-    init_commitlint();
-    init_smart_diff();
+    init_protected_branch_guard();
+    init_branch_rescue();
+    init_branch_name();
     init_ui();
     init_commit_helpers();
-    CONFIG_PATH2 = (0, import_path10.join)((0, import_os4.homedir)(), CONFIG_DIR);
-    PROVIDER_URLS = {
-      ollama: "http://localhost:11434",
-      lmstudio: "http://localhost:1234/v1",
-      openrouter: "https://openrouter.ai/api/v1",
-      custom: "",
-      cloudflare: ""
-    };
-    DEFAULT_MODELS = {
-      ollama: "codellama",
-      lmstudio: "default",
-      openrouter: "google/gemini-flash-1.5-8b",
-      custom: "",
-      cloudflare: "@cf/qwen/qwen2.5-coder-32b-instruct"
-    };
   }
 });
 
@@ -9828,12 +11022,33 @@ __export(commit_exports, {
 async function runCommit(args) {
   const { messageOnly, push, apiKey: apiKeyFlag, hookMode, model: modelFlag, all } = args;
   const silent = !!(hookMode || args.quiet);
-  const log = silent ? createSilentLog() : getUI().log;
+  const ui2 = getUI();
+  const log = silent ? createSilentLog() : ui2.log;
   if (!isGitRepo()) {
     log.error("Not a git repository.");
     process.exit(1);
   }
   const config2 = getConfig();
+  const excludes = [...config2.excludes ?? [], ...args.exclude];
+  const guardResult = await runBranchGuard(
+    {
+      allowProtected: !!(args.allowProtected || config2.branch?.allowProtected),
+      autoBranch: !!args.autoBranch,
+      hookMode: !!args.hookMode,
+      apiKey: apiKeyFlag ?? getApiKey() ?? void 0,
+      model: args.model,
+      excludes
+    },
+    log
+  );
+  if (guardResult.action === "abort") {
+    return;
+  }
+  if (guardResult.action === "done") {
+    return;
+  }
+  const _exhaustive = guardResult.action;
+  void _exhaustive;
   if (all || config2.autoStage) {
     stageAll();
     const { files, total } = getShortStagedFiles();
@@ -9856,18 +11071,22 @@ async function runCommit(args) {
     process.exit(1);
   }
   const model = modelFlag ?? config2.model;
-  const excludes = [...config2.excludes ?? [], ...args.exclude];
   const diff = getStagedDiff(excludes);
   const changes = getStagedFiles();
   let processedDiff = diff;
   if (!args.noSmartDiff) {
-    const smartResult = preprocessDiff(diff);
+    const smartResult = preprocessDiffWithSizeBudget(diff, 5 * 1024 * 1024);
     processedDiff = smartResult.processedDiff;
     if (smartResult.summarized.length > 0) {
       log.step(
         `smart-diff: ${smartResult.summarized.length} file(s) summarized (saved ~${Math.round(smartResult.tokensSaved / 1e3)}K tokens)`
       );
     }
+    if (smartResult.aggressivelySummarized.length > 0) {
+      log.step(
+        `large-diff: ${smartResult.aggressivelySummarized.length} additional file(s) summarized to fit (commit message may be less specific \u2014 consider committing fewer files at a time)`
+      );
+    }
   }
   const commitlintRules = await detectCommitlintRules();
   let rules = { ...commitlintRules, ...config2.rules ?? {} };
@@ -9901,7 +11120,7 @@ async function runCommit(args) {
   const skipInteractive = silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
   const skipConfirm = args.dryRun || messageOnly || silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
   const modelDisplay = model ?? "default";
-  const spinner = getUI().spinner(`generating commit (${modelDisplay})...`);
+  const spinner = ui2.spinner(`generating commit (${modelDisplay})...`);
   if (!silent) spinner.start();
   const t0 = Date.now();
   let generatedMessage;
@@ -9927,7 +11146,7 @@ async function runCommit(args) {
     } else {
       const refineResult = await interactiveRefineMessage(message, { skip: skipInteractive });
       if (refineResult.action === "abort") {
-        process.exit(0);
+        return;
       }
       message = refineResult.message;
     }
@@ -9936,14 +11155,29 @@ async function runCommit(args) {
     console.log(message);
     return;
   }
-  displayCommitMessage(message, log);
+  const stagedPaths = changes.trim().split("\n").filter(Boolean);
+  const short = getStagedDiffShortstat();
+  const tokenEst = diagnostics && typeof diagnostics === "object" && diagnostics !== null && "tokenUsage" in diagnostics ? diagnostics.tokenUsage?.totalEstimated : void 0;
+  displayCommitMessage(message, {
+    log,
+    isColor: ui2.isColor,
+    isTTY: !!process.stderr.isTTY,
+    style: "rich",
+    stagedFiles: stagedPaths,
+    stats: {
+      files: stagedPaths.length,
+      additions: short.additions,
+      deletions: short.deletions,
+      ...tokenEst !== void 0 ? { tokens: tokenEst } : {}
+    }
+  });
   if (args.dryRun) {
     return;
   }
   if (args.confirm) {
     const confirmResult = await confirmCommit("Proceed with commit? [y/N]: ", { skip: skipConfirm });
     if (confirmResult.action === "abort") {
-      process.exit(0);
+      return;
     }
   }
   gitCommit(message);
@@ -9972,6 +11206,7 @@ var init_commit = __esm({
     init_ui();
     init_smart_diff();
     init_commit_helpers();
+    init_branch_guard();
   }
 });
 
@@ -9989,6 +11224,7 @@ Usage:
   qc pr                 Generate PR description from branch commits
   qc changelog          Generate changelog from commits since last tag
   qc changeset          Automate pnpm changeset with AI
+  qc branch             Generate branch name + create branch (use --message for description)
   qc init               Install prepare-commit-msg hook
   qc login              Sign in via browser
   qc logout             Clear local credentials
@@ -10018,11 +11254,22 @@ Flags:
   --model <id>          Use specific model
   --base <branch>       Base branch for pr/changeset (default: main)
   --create              Create PR with gh CLI (qc pr --create)
-  --from <ref>          Start ref for changelog
+  --from <ref>          Start ref for changelog / base ref for qc branch
   --to <ref>            End ref for changelog
   --write               Write changelog to CHANGELOG.md
   --hook-mode           Silent mode for git hooks
 
+Branch flags (qc branch):
+  --message <text>      Generate from a description (no diff needed)
+  --from-commits        Generate from recent commits instead of diff
+  --rescue              Move commits off current protected branch (see docs)
+  --no-switch           Create branch but don't checkout
+  --from <ref>          Create branch from this ref (default: HEAD)
+
+Commit guard flags:
+  --allow-protected     Bypass protected-branch guard for this run
+  --auto-branch         Auto-create branch with generated name (no prompt)
+
 Compose short flags: qc -ap (stage all + push), qc -apv (+ verbose)
 
 Examples:
@@ -10133,10 +11380,18 @@ function parseArgs(args) {
       result.command = "help";
     } else if (arg === "--all") {
       result.all = true;
+    } else if (arg === "--allow-protected") {
+      result.allowProtected = true;
+    } else if (arg === "--auto-branch") {
+      result.autoBranch = true;
     } else if (arg === "--message-only") {
       result.messageOnly = true;
+    } else if (arg === "--message" && i + 1 < args.length) {
+      result.message = args[++i];
     } else if (arg === "--push") {
       result.push = true;
+    } else if (arg === "--rescue") {
+      result.rescue = true;
     } else if (arg === "--verbose") {
       result.verbose = true;
     } else if (arg === "--quiet") {
@@ -10157,6 +11412,8 @@ function parseArgs(args) {
       result.noContext = true;
     } else if (arg === "--no-smart-diff") {
       result.noSmartDiff = true;
+    } else if (arg === "--no-switch") {
+      result.noSwitch = true;
     } else if (arg === "--local" || arg === "--use-ollama" || arg === "--use-lmstudio" || arg === "--use-openrouter" || arg === "--use-cloudflare") {
       result.local = true;
       if (arg === "--use-ollama") {
@@ -10176,6 +11433,8 @@ function parseArgs(args) {
       result.create = true;
     } else if (arg === "--from" && i + 1 < args.length) {
       result.from = args[++i];
+    } else if (arg === "--from-commits") {
+      result.fromCommits = true;
     } else if (arg === "--to" && i + 1 < args.length) {
       result.to = args[++i];
     } else if (arg === "--write") {
@@ -10211,6 +11470,9 @@ function parseArgs(args) {
     } else if (arg === "changelog") {
       result.command = "changelog";
       subcommandSeen = true;
+    } else if (arg === "branch") {
+      result.command = "branch";
+      subcommandSeen = true;
     } else if (arg === "init") {
       result.command = "init";
       subcommandSeen = true;
@@ -10325,6 +11587,23 @@ async function main() {
     });
     return;
   }
+  if (command === "branch") {
+    const { runBranch: runBranch2 } = await Promise.resolve().then(() => (init_branch2(), branch_exports));
+    const explicitName = values.positionals[0];
+    await runBranch2({
+      explicitName,
+      message: values.message,
+      fromCommits: values.fromCommits,
+      rescue: values.rescue,
+      dryRun: values.dryRun,
+      noSwitch: values.noSwitch,
+      push: values.push,
+      from: values.from,
+      model: values.model,
+      apiKey: values.apiKey
+    });
+    return;
+  }
   if (command === "init") {
     const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
     init2({ uninstall: values.uninstall });
@@ -10336,7 +11615,7 @@ async function main() {
     return;
   }
   if (command === "config") {
-    const { config: config2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+    const { config: config2 } = await Promise.resolve().then(() => (init_config2(), config_exports2));
     config2(values.positionals);
     return;
   }