@event4u/agent-config 16.3.0 → 16.4.0

package/dist/cli-delegate/cmd_git_convention.js

@@ -0,0 +1,1851 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  GIT_CONVENTION_KEYS,
+  checkoutSource,
+  conventionDefault,
+  conventionReading,
+  describeRefusal,
+  invalidReason,
+  isRefusal,
+  parseLayerText,
+  readGitConventionKey
+} from "./chunk-6V5FMA3P.js";
+import {
+  reportScanned
+} from "./chunk-I3EIN2YG.js";
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  find_project_root
+} from "./chunk-H76PHZBI.js";
+import "./chunk-T6BP34WI.js";
+import "./chunk-MCJYCQPF.js";
+import {
+  __toESM
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_git_convention.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import process2 from "node:process";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+
+// src/scripts/_lib/git_base_ref.ts
+var REMOTE_TRACKING = "refs/remotes/";
+var LOCAL_HEADS = "refs/heads/";
+function blankBaseError(value) {
+  return value.trim() === "" ? "--base was given an empty value \u2014 name the base branch (an unset variable expands to nothing); nothing was read or merged" : null;
+}
+function baseValueError(value, remotes = []) {
+  const blank = blankBaseError(value);
+  if (blank !== null) return blank;
+  const v = value.trim();
+  const branch = v.startsWith("-") ? v : parseBaseRef(v, remotes)?.branch ?? v;
+  return branch.startsWith("-") ? `--base ${JSON.stringify(v)} names a branch that starts with "-", which git reads as an option \u2014 no branch has that name; nothing was read or merged` : null;
+}
+function parseBaseRef(value, remotes = []) {
+  const v = value.trim();
+  if (v === "") return null;
+  if (v.startsWith(LOCAL_HEADS) && v.length > LOCAL_HEADS.length) {
+    const branch = v.slice(LOCAL_HEADS.length);
+    return { remote: "origin", branch, ref: `${REMOTE_TRACKING}origin/${branch}` };
+  }
+  if (v.startsWith("refs/")) return splitResolvedRef(v);
+  const slash = v.indexOf("/");
+  const known = /* @__PURE__ */ new Set(["origin", ...remotes]);
+  if (slash > 0 && slash < v.length - 1 && known.has(v.slice(0, slash))) {
+    return { remote: v.slice(0, slash), branch: v.slice(slash + 1), ref: v };
+  }
+  return { remote: "origin", branch: v, ref: `origin/${v}` };
+}
+function splitResolvedRef(ref) {
+  if (ref.startsWith(LOCAL_HEADS)) return { remote: "origin", branch: ref.slice(LOCAL_HEADS.length), ref };
+  if (ref.startsWith(REMOTE_TRACKING)) {
+    const rest = ref.slice(REMOTE_TRACKING.length);
+    const slash2 = rest.indexOf("/");
+    if (slash2 > 0) return { remote: rest.slice(0, slash2), branch: rest.slice(slash2 + 1), ref };
+  }
+  if (ref.startsWith("refs/")) return { remote: "origin", branch: ref, ref };
+  const slash = ref.indexOf("/");
+  return slash > 0 ? { remote: ref.slice(0, slash), branch: ref.slice(slash + 1), ref } : { remote: "origin", branch: ref, ref: `origin/${ref}` };
+}
+
+// src/scripts/_lib/git_convention_carrier.ts
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var CARRIER_PATH = ".git-convention.yml";
+var NETWORK_TIMEOUT_MS = 8e3;
+var CARRIER_FETCH_TIMEOUT_MS = 6e4;
+var runGit = (cmd, args, cwd, timeoutMs) => {
+  const r = spawnSync(cmd, [...args], { cwd, encoding: "utf-8", timeout: timeoutMs, maxBuffer: 32 * 1024 * 1024 });
+  const code = r.error?.code;
+  return { ok: r.status === 0, out: r.stdout ?? "", err: (r.stderr ?? "").trim(), timedOut: code === "ETIMEDOUT" };
+};
+function sh(cmd, args, cwd) {
+  return runGit(cmd, args, cwd, NETWORK_TIMEOUT_MS);
+}
+function resolveTarget(deps, override, defaultRef) {
+  const given = override === null ? null : parseBaseRef(override, deps.remotes?.() ?? []);
+  if (given !== null) return { ref: given.ref, reason: "explicit-base-override" };
+  const def = defaultRef === void 0 ? deps.defaultBranch() : defaultRef;
+  return def === null ? null : { ref: def, reason: "repository-default-branch" };
+}
+function parseSymrefDefault(lsRemoteOut) {
+  for (const line of lsRemoteOut.split("\n")) {
+    const t = line.trim();
+    if (!t.startsWith("ref:")) continue;
+    const name = t.slice("ref:".length).trim().split(/\s+/)[0] ?? "";
+    if (!name.startsWith("refs/heads/")) continue;
+    const short = name.slice("refs/heads/".length).trim();
+    if (short !== "") return `origin/${short}`;
+  }
+  return null;
+}
+function parseExactHeadSha(lsRemoteOut, branch) {
+  const want = `refs/heads/${branch}`;
+  for (const line of lsRemoteOut.split("\n")) {
+    const [sha, name] = line.trim().split(/\s+/);
+    if (name === want && sha !== void 0 && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(sha)) return sha;
+  }
+  return null;
+}
+function makeTargetDeps(repo, run = runGit) {
+  const ask = (cmd, args) => run(cmd, args, repo, NETWORK_TIMEOUT_MS);
+  return {
+    // The server first, the local ref second: `refs/remotes/origin/HEAD` is
+    // not set in every checkout (see `parseSymrefDefault`).
+    defaultBranch: () => {
+      const remote = ask("git", ["ls-remote", "--symref", "--", "origin", "HEAD"]);
+      const fromServer = remote.ok ? parseSymrefDefault(remote.out) : null;
+      if (fromServer !== null) return fromServer;
+      const head = ask("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+      return head.ok && head.out.trim() !== "" ? head.out.trim() : null;
+    },
+    remoteSha: (ref) => {
+      const { remote, branch } = splitResolvedRef(ref);
+      const out = ask("git", ["ls-remote", "--", remote, `refs/heads/${branch}`]);
+      return out.ok ? parseExactHeadSha(out.out, branch) : null;
+    },
+    remotes: () => {
+      const out = ask("git", ["remote"]);
+      return out.ok ? out.out.split("\n").map((r) => r.trim()).filter((r) => r !== "") : [];
+    },
+    defaultBranchOf: (remote) => {
+      const out = ask("git", ["ls-remote", "--symref", "--", remote, "HEAD"]);
+      const named = out.ok ? parseSymrefDefault(out.out) : null;
+      return named === null ? null : `${remote}/${named.slice("origin/".length)}`;
+    }
+  };
+}
+function memoTargetDeps(deps) {
+  const cache = /* @__PURE__ */ new Map();
+  const once = (key, ask) => {
+    if (!cache.has(key)) cache.set(key, ask());
+    return cache.get(key);
+  };
+  return {
+    ...deps,
+    defaultBranch: () => once("default", () => deps.defaultBranch()),
+    remoteSha: (ref) => once(`sha ${ref}`, () => deps.remoteSha(ref)),
+    ...deps.remotes === void 0 ? {} : { remotes: () => once("remotes", () => deps.remotes()) },
+    ...deps.defaultBranchOf === void 0 ? {} : { defaultBranchOf: (remote) => once(`default ${remote}`, () => deps.defaultBranchOf(remote)) }
+  };
+}
+function carrierBlobAt(repo, sha, fetchRef, run = runGit) {
+  const local = (args) => run("git", args, repo, NETWORK_TIMEOUT_MS);
+  const has = () => local(["cat-file", "-e", `${sha}^{commit}`]).ok;
+  if (!has()) {
+    const from = fetchRef === null ? null : splitResolvedRef(fetchRef);
+    const fetched = from === null ? null : run("git", ["fetch", "-q", "--", from.remote, from.branch], repo, CARRIER_FETCH_TIMEOUT_MS);
+    if (fetched?.timedOut === true) return { kind: "no-commit", timedOut: true };
+    if (!has()) return { kind: "no-commit" };
+  }
+  const listed = local(["ls-tree", "--name-only", sha, "--", CARRIER_PATH]);
+  if (!listed.ok) return { kind: "no-commit" };
+  if (listed.out.trim() === "") return { kind: "absent" };
+  const blob = local(["cat-file", "-p", `${sha}:${CARRIER_PATH}`]);
+  return blob.ok ? { kind: "present", text: blob.out } : { kind: "no-commit" };
+}
+var IGNORED_CARRIER_PATH = ".git-convention.yaml";
+function ignoredCarrierWarning(root) {
+  return fs.existsSync(path.join(root, IGNORED_CARRIER_PATH)) ? `${IGNORED_CARRIER_PATH} is ignored \u2014 the team declaration is read only from ${CARRIER_PATH}; rename it to ${CARRIER_PATH}` : null;
+}
+function _parseCarrier(text) {
+  const parsed = parseLayerText(text);
+  if (parsed.parsed !== "valid") return parsed;
+  const top = Object.keys(parsed.data).filter((k) => GIT_CONVENTION_KEYS.includes(k));
+  if (top.length === 0) return parsed;
+  const listed = top.map((k) => `\`${k}\``).join(", ");
+  return { ...parsed, shapeError: `${listed} set at the top level; the carrier reads its keys under \`git:\` (\`git:\` on one line, then \`  ${top[0]}: <value>\` indented)` };
+}
+function _carrierLayer(label, blob) {
+  if (blob.kind === "absent") return { path: label, carries: true, parsed: "absent", data: null };
+  return { path: label, carries: true, ..._parseCarrier(blob.text) };
+}
+function _workingTreeLayer(root) {
+  const p = path.join(root, CARRIER_PATH);
+  let text;
+  try {
+    if (!fs.statSync(p).isFile()) return { path: p, carries: true, parsed: "absent", data: null };
+    text = fs.readFileSync(p, "utf-8");
+  } catch (err) {
+    const parsed = err.code === "ENOENT" ? "absent" : "malformed";
+    return { path: p, carries: true, parsed, data: null };
+  }
+  return { path: p, carries: true, ..._parseCarrier(text) };
+}
+function conventionRoot(cwd) {
+  const top = sh("git", ["rev-parse", "--show-toplevel"], cwd);
+  if (top.ok && top.out.trim() !== "") return { root: top.out.trim(), git: true };
+  return { root: find_project_root(cwd) ?? cwd, git: false };
+}
+function _short(sha) {
+  return sha.slice(0, 12);
+}
+function readCommittedConvention(cwd, options = {}) {
+  const keys = options.keys ?? GIT_CONVENTION_KEYS;
+  const { root, git } = conventionRoot(cwd);
+  const developer = checkoutSource(root).layers();
+  const readings = {};
+  const readAt = {};
+  const candidates = {};
+  let target = null;
+  if (!git) {
+    for (const key of keys) {
+      readings[key] = readGitConventionKey(key, { layers: () => developer });
+      readAt[key] = null;
+    }
+    return { root, readings, readAt, target, candidates };
+  }
+  const headSha = sh("git", ["rev-parse", "--verify", "-q", "HEAD"], root).out.trim();
+  const headLabel = `${CARRIER_PATH} at ${headSha === "" ? "HEAD" : _short(headSha)}`;
+  let headBlob = null;
+  const atHead = () => {
+    if (headBlob === null) headBlob = headSha === "" ? { kind: "absent" } : carrierBlobAt(root, headSha, null, options.run);
+    return headBlob;
+  };
+  for (const key of keys) {
+    if (key !== "update_strategy") {
+      const blob2 = atHead();
+      readings[key] = blob2.kind === "no-commit" ? conventionReading(key, "unresolvable", null, headLabel, `the carrier at HEAD (${_short(headSha)}) could not be read`) : readGitConventionKey(key, { layers: () => [...developer, _carrierLayer(headLabel, blob2)] });
+      readAt[key] = headSha === "" ? null : headSha;
+      continue;
+    }
+    const deps = options.deps ?? makeTargetDeps(root);
+    const ref = resolveTarget(deps, options.override ?? null);
+    const sha = ref === null ? null : deps.remoteSha(ref.ref);
+    target = ref === null ? null : { ...ref, sha };
+    readAt[key] = sha;
+    if (ref === null || sha === null) {
+      readings[key] = conventionReading(
+        key,
+        "unresolvable",
+        null,
+        CARRIER_PATH,
+        ref === null ? "no --base was given and origin names no default branch, so the target commit is unknown" : `the server reports no commit for ${ref.ref} (no such branch on ${splitResolvedRef(ref.ref).remote}, no such remote, or it is unreachable)`
+      );
+      continue;
+    }
+    const blob = carrierBlobAt(root, sha, options.fetch === false ? null : ref.ref, options.run);
+    if (blob.kind === "no-commit") {
+      readings[key] = conventionReading(
+        key,
+        "unresolvable",
+        null,
+        `${CARRIER_PATH} at ${_short(sha)}`,
+        blob.timedOut === true ? `fetching commit ${_short(sha)} of ${ref.ref} timed out after ${CARRIER_FETCH_TIMEOUT_MS / 1e3} s` : `commit ${_short(sha)} of ${ref.ref} could not be fetched`
+      );
+      continue;
+    }
+    readings[key] = readGitConventionKey(key, { layers: () => [...developer, _carrierLayer(`${CARRIER_PATH} at ${_short(sha)}`, blob)] });
+  }
+  const tree = _workingTreeLayer(root);
+  for (const key of keys) {
+    const inForce = readings[key];
+    const local = readGitConventionKey(key, { layers: () => [...developer, tree] });
+    if (local.value !== inForce.value || local.state !== inForce.state) candidates[key] = local;
+  }
+  return { root, readings, readAt, target, candidates };
+}
+
+// src/scripts/_lib/git_convention_grammar.ts
+var TICKET_GRAMMAR = "[A-Z][A-Z0-9]+-[0-9]+";
+var TICKET_TOKEN = `(?<![A-Za-z0-9])${TICKET_GRAMMAR}(?![0-9])`;
+var TICKET_DENYLIST = ["UTF", "ISO", "SHA", "RFC", "CVE", "CWE", "GHSA"];
+var VERSION_LIKE_KEYS = ["HTTP", "HTTPS", "TLS", "SSL", "OAUTH", "PHP", "PYTHON", "JAVA", "JDK", "NODE", "ES", "HTML", "CSS"];
+var ANY_CASE_TOKEN = `(?<![A-Za-z0-9])[A-Za-z][A-Za-z0-9]+-[0-9]+(?![0-9])`;
+function ticketCandidates(text, keys) {
+  const card = keys !== void 0 && keys !== null && keys.length > 0 ? keys : null;
+  const out = [];
+  for (const m of text.matchAll(new RegExp(card === null ? TICKET_TOKEN : ANY_CASE_TOKEN, "g"))) {
+    const dash = m[0].indexOf("-");
+    const written = m[0].slice(0, dash);
+    const key = written.toUpperCase();
+    const number = m[0].slice(dash + 1);
+    if (written !== key && !card?.includes(key)) continue;
+    let status = "ticket";
+    if (TICKET_DENYLIST.includes(key)) status = "standard-name";
+    else if (card !== null) status = card.includes(key) ? "ticket" : "unknown-key";
+    else if (number.length === 1 && VERSION_LIKE_KEYS.includes(key)) status = "version-like";
+    out.push({ token: `${key}-${number}`, key, status });
+  }
+  return out;
+}
+var KEY = /^[A-Z][A-Z0-9]+$/;
+function parseTicketKeys(text) {
+  const line = /^\s*ticket_keys\s*:(.*)$/m.exec(text)?.[1];
+  const value = line ?? (text.includes(":") ? "" : text);
+  return value.replace(/[[\]"']/g, " ").split(/[\s,]+/).filter((k) => KEY.test(k));
+}
+function commitlintIssuePrefixes(configText) {
+  const list = /["']?issuePrefixes["']?\s*:\s*\[([^\]]*)\]/.exec(configText)?.[1] ?? "";
+  return [...list.matchAll(/["']([^"']*)["']/g)].map((m) => m[1].replace(/-$/, "")).filter((k) => KEY.test(k));
+}
+var COMMIT_TYPES = ["feat", "fix", "chore", "docs", "refactor", "test", "perf", "style", "build", "ci", "revert"];
+var TYPES = COMMIT_TYPES.join("|");
+var FORMAT_GRAMMAR = {
+  "ticket-scope": `^(${TYPES})(\\([^)]+\\))?!?: .+`,
+  "ticket-conventional": `^(${TICKET_GRAMMAR} )?(${TYPES})(\\([^)]+\\))?!?: .+`
+};
+var FAMILY_ERE = [
+  ["conventional", "^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\\([^)]+\\))?!?: "],
+  ["ticket-conventional", `^${TICKET_GRAMMAR} (build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\\([^)]+\\))?!?: `],
+  ["ticket-prefix", `^\\[${TICKET_GRAMMAR}\\][: ]|^${TICKET_GRAMMAR}[: ]`],
+  // `[:ascii:]` is not a POSIX class (GNU and BSD grep reject it); a leading
+  // character outside printable ASCII, the controls and the spaces is the same set.
+  ["gitmoji", "^:[a-z0-9_+-]+:[[:space:]]|^[^ -~[:cntrl:][:space:]]"],
+  ["imperative-plain", "^[A-Z][a-z]+[[:space:]].*[^.]$"]
+];
+function _js(ere) {
+  return new RegExp(ere.replaceAll("[^ -~[:cntrl:][:space:]]", "[^\\x00-\\x7F\\s]").replaceAll("[[:space:]]", "\\s"));
+}
+var FAMILY_JS = FAMILY_ERE.map(([f, ere]) => [f, _js(ere)]);
+function classifySubject(subject) {
+  return FAMILY_JS.find(([, re]) => re.test(subject))?.[0] ?? "other";
+}
+var SCOPE = /^[^(:]*\(([^)]*)\)/;
+function _ticketLeads(rule) {
+  return "format" in rule ? rule.format === "ticket-conventional" : rule.family === "ticket-conventional";
+}
+function ruleName(rule) {
+  return "format" in rule ? `git.commit_format: ${rule.format}` : `approved family ${rule.family}`;
+}
+var GIT_OWN_SUBJECT = '^((fixup|squash|amend)! .+|Revert ".+")$';
+var TICKETLESS_FORM = {
+  "ticket-prefix": "^\\S.*",
+  "ticket-conventional": FAMILY_ERE[0]?.[1] ?? ""
+};
+function checkSubject(subject, rule) {
+  if (new RegExp(GIT_OWN_SUBJECT).test(subject)) return { ok: true };
+  const grammar = "format" in rule ? new RegExp(FORMAT_GRAMMAR[rule.format]) : FAMILY_JS.find(([f]) => f === rule.family)?.[1];
+  const ticketless = "family" in rule ? TICKETLESS_FORM[rule.family] : void 0;
+  if (!grammar.test(subject) && ticketless !== void 0) {
+    const family = rule.family;
+    if (!_js(ticketless).test(subject)) {
+      return { ok: false, rule: `${ruleName(rule)} \u2014 does not match ${FAMILY_ERE.find(([f]) => f === family)?.[1] ?? ""}, nor its form without a ticket ${ticketless}` };
+    }
+    const stray = ticketCandidates(subject).find((c) => c.status === "ticket");
+    if (stray !== void 0) {
+      return { ok: false, rule: `${ruleName(rule)} \u2014 the ticket \`${stray.token}\` stands outside the leading position; it leads the subject or is left out` };
+    }
+    return { ok: true };
+  }
+  if (!grammar.test(subject)) {
+    return { ok: false, rule: `${ruleName(rule)} \u2014 does not match ${"format" in rule ? FORMAT_GRAMMAR[rule.format] : FAMILY_ERE.find(([f]) => f === rule.family)?.[1] ?? ""}` };
+  }
+  if (!_ticketLeads(rule)) return { ok: true };
+  const lead = /^(\S+) /.exec(subject)?.[1] ?? "";
+  const leading = ticketCandidates(lead).find((c) => c.token === lead);
+  if (leading !== void 0 && leading.status === "standard-name") {
+    return { ok: false, rule: `${ruleName(rule)} \u2014 \`${lead}\` is a standard name, not a ticket` };
+  }
+  const scope = SCOPE.exec(lead === "" || leading === void 0 ? subject : subject.slice(lead.length + 1))?.[1] ?? "";
+  const inScope = ticketCandidates(scope).find((c) => c.status === "ticket");
+  if (inScope !== void 0) {
+    return { ok: false, rule: `${ruleName(rule)} \u2014 the ticket \`${inScope.token}\` stands inside the scope; it leads the subject, never the scope` };
+  }
+  return { ok: true };
+}
+var VALUE = /^[A-Za-z0-9._-]+$/;
+var SEPARATORS = "-/_.";
+function renderBranch(pattern, input) {
+  const type = input.type ?? "";
+  const ticket = input.ticket ?? "";
+  let slug = input.slug;
+  if (slug === "" || !VALUE.test(slug)) return { ok: false, reason: `slug ${JSON.stringify(slug)} is empty or outside [A-Za-z0-9._-]` };
+  if (type !== "" && !VALUE.test(type)) return { ok: false, reason: `type ${JSON.stringify(type)} is outside [A-Za-z0-9._-]` };
+  if (ticket !== "" && !new RegExp(`^${TICKET_GRAMMAR}$`).test(ticket)) {
+    return { ok: false, reason: `ticket ${JSON.stringify(ticket)} does not match ${TICKET_GRAMMAR}` };
+  }
+  if (ticket !== "" && !pattern.includes("{ticket}") && slug !== ticket && !slug.startsWith(`${ticket}-`)) slug = `${ticket}-${slug}`;
+  const values = { type, ticket, slug };
+  const parts = pattern.split(/(\{(?:type|ticket|slug)\})/).filter((p) => p !== "");
+  const out = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const ph = /^\{(type|ticket|slug)\}$/.exec(part);
+    if (ph === null) {
+      out.push(part);
+      continue;
+    }
+    const value = values[ph[1]];
+    if (value !== "") {
+      out.push(value);
+      continue;
+    }
+    const next = parts[i + 1];
+    if (next !== void 0 && !next.startsWith("{") && SEPARATORS.includes(next[0])) {
+      parts[i + 1] = next.slice(1);
+    } else if (next === void 0 && out.length > 0) {
+      const prev = out[out.length - 1];
+      if (SEPARATORS.includes(prev.slice(-1))) out[out.length - 1] = prev.slice(0, -1);
+    }
+  }
+  const name = out.join("");
+  if (name === "" || name.startsWith("/") || name.endsWith("/") || name.includes("//") || name.includes("..")) {
+    return { ok: false, reason: `the rendered name ${JSON.stringify(name)} is not a branch name` };
+  }
+  return { ok: true, name };
+}
+
+// src/scripts/_lib/git_convention_measure.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+var MEASURE_LIMIT = 200;
+var MEASURE_SINCE = "24 months ago";
+var MIN_N = 30;
+var RECENT_WINDOW = MIN_N;
+var SHARE_BAR = 0.8;
+var SMALL_TEAM_SHARE_BAR = 0.9;
+var MIN_CAPPED_AUTHORS = 3;
+var AUTHOR_CAP_PER_HALF = 20;
+var BULK_IMPORT_FILES = 500;
+var MIN_BRANCHES = 10;
+var CLASSIFIER_VERSION = "2026-10-06";
+var BOT_AUTHOR = /\[bot\]|dependabot|renovate|github-actions|semantic-release|release-please/i;
+var AUTOMATION_SUBJECT = /^Revert |^Merge |^chore\(release\)|^Bump |^v?\d+\.\d+\.\d+$/;
+function _key(c) {
+  return (c.email || c.author).toLowerCase();
+}
+function _cap(commits) {
+  const seen = /* @__PURE__ */ new Map();
+  return commits.filter((c) => {
+    const k = _key(c);
+    const n = (seen.get(k) ?? 0) + 1;
+    seen.set(k, n);
+    return n <= AUTHOR_CAP_PER_HALF;
+  });
+}
+function _shares(commits) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of commits) {
+    const f = classifySubject(c.subject);
+    counts.set(f, (counts.get(f) ?? 0) + 1);
+  }
+  const total = commits.length;
+  return [...counts.entries()].map(([family, count]) => ({ family, count, share: total === 0 ? 0 : count / total })).sort((a, b) => b.count - a.count || a.family.localeCompare(b.family));
+}
+function _half(commits) {
+  const top = _shares(commits)[0];
+  return { n: commits.length, family: top?.family ?? null, share: top?.share ?? 0 };
+}
+function _clears(n, top, bar) {
+  return n >= MIN_N && top !== void 0 && top.family !== null && top.family !== "other" && top.share >= bar;
+}
+function measureSubjects(commits) {
+  const excluded = { bots: 0, automation: 0, bulk: 0 };
+  const eligible = commits.filter((c) => {
+    if (BOT_AUTHOR.test(c.author) || BOT_AUTHOR.test(c.email)) excluded.bots++;
+    else if (AUTOMATION_SUBJECT.test(c.subject)) excluded.automation++;
+    else if (c.files !== null && c.files > BULK_IMPORT_FILES) excluded.bulk++;
+    else return true;
+    return false;
+  });
+  const authors = new Set(eligible.map(_key)).size;
+  const capped = authors >= MIN_CAPPED_AUTHORS;
+  const bar = capped ? SHARE_BAR : SMALL_TEAM_SHARE_BAR;
+  const cut = Math.ceil(eligible.length / 2);
+  const newerRaw = eligible.slice(0, cut);
+  const olderRaw = eligible.slice(cut);
+  const newerSample = capped ? _cap(newerRaw) : newerRaw;
+  const olderSample = capped ? _cap(olderRaw) : olderRaw;
+  const sample = [...newerSample, ...olderSample];
+  const families = _shares(sample);
+  const newer = _half(newerSample);
+  const older = _half(olderSample);
+  const halvesAgree = newer.family !== null && newer.family === older.family;
+  const recent = _half((capped ? _cap(eligible) : eligible).slice(0, RECENT_WINDOW));
+  const top = families[0];
+  let established = null;
+  let migrating = false;
+  let migratedBy = null;
+  const reasons = [];
+  if (eligible.length < MIN_N) reasons.push(`n ${eligible.length} < ${MIN_N}`);
+  if (top === void 0 || top.family === "other") reasons.push("no family with a grammar leads");
+  else if (top.share < bar) reasons.push(`${top.family} at ${pct(top.share)} < ${pct(bar)}`);
+  if (!halvesAgree && eligible.length > 0) reasons.push(`the halves disagree (newer ${newer.family ?? "\u2014"}, older ${older.family ?? "\u2014"})`);
+  if (reasons.length === 0 && top !== void 0) established = top.family;
+  else if (!halvesAgree && _clears(newer.n, newer, bar)) {
+    established = newer.family;
+    migrating = true;
+    migratedBy = "newer-half";
+  }
+  if (!migrating && recent.n >= RECENT_WINDOW && recent.family !== top?.family && _clears(recent.n, recent, bar)) {
+    established = recent.family;
+    migrating = true;
+    migratedBy = "recent-window";
+    reasons.push(`the newest ${recent.n} read ${recent.family} at ${pct(recent.share)}, not ${top?.family ?? "\u2014"}`);
+  }
+  return {
+    eligible: eligible.length,
+    excluded,
+    authors,
+    capped,
+    cappedTotal: sample.length,
+    bar,
+    families,
+    newer,
+    older,
+    halvesAgree,
+    recent,
+    migratedBy,
+    established,
+    migrating,
+    reasons: established === null || migrating ? reasons : [],
+    strongest: families.filter((f) => f.family !== "other").slice(0, 2).map((f) => f.family)
+  };
+}
+var BRANCH_TYPES = [...COMMIT_TYPES, "feature", "bugfix", "hotfix"].join("|");
+var BRANCH_SHAPES = [
+  ["{type}/{ticket}-{slug}", new RegExp(`^(${BRANCH_TYPES})/${TICKET_GRAMMAR}-[^/]+$`)],
+  ["{type}/{ticket}/{slug}", new RegExp(`^(${BRANCH_TYPES})/${TICKET_GRAMMAR}/[^/]+$`)],
+  ["{ticket}-{slug}", new RegExp(`^${TICKET_GRAMMAR}-[^/]+$`)],
+  ["{ticket}/{slug}", new RegExp(`^${TICKET_GRAMMAR}/[^/]+$`)],
+  ["{type}/{slug}", new RegExp(`^(${BRANCH_TYPES})/[^/]+$`)]
+];
+var BOT_BRANCH = /^(dependabot|renovate|release-please)[/-]/;
+function classifyBranch(name) {
+  return BRANCH_SHAPES.find(([, re]) => re.test(name))?.[0] ?? "other";
+}
+function measureBranches(names) {
+  const sample = names.filter((n) => !BOT_BRANCH.test(n));
+  const counts = /* @__PURE__ */ new Map();
+  for (const n of sample) {
+    const s = classifyBranch(n);
+    counts.set(s, (counts.get(s) ?? 0) + 1);
+  }
+  const shapes = [...counts.entries()].map(([shape, count]) => ({ shape, count, share: count / sample.length })).sort((a, b) => b.count - a.count || a.shape.localeCompare(b.shape));
+  const top = shapes[0];
+  const clear = top !== void 0 && top.shape !== "other" && sample.length >= MIN_BRANCHES && top.share >= SHARE_BAR && invalidReason("branch_pattern", top.shape) === null;
+  return { sampled: sample.length, shapes, pattern: clear ? top.shape : null, share: top?.share ?? 0 };
+}
+function measureUpdateStyle(mergeSubjects, defaultBranch) {
+  const name = defaultBranch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const base = new RegExp(`^Merge (remote-tracking )?branch '(origin/)?${name}'`);
+  const baseMerges = mergeSubjects.filter((s) => base.test(s)).length;
+  return { merges: mergeSubjects.length, baseMerges, observed: baseMerges > 0 ? "merge" : "linear" };
+}
+function formatForFamily(family) {
+  if (family === "conventional") return "ticket-scope";
+  if (family === "ticket-conventional") return "ticket-conventional";
+  return null;
+}
+function teamFile(family, pattern) {
+  const format = family === null ? null : formatForFamily(family);
+  if (format === null && pattern === null) return null;
+  return ["git:", ...format === null ? [] : [`  commit_format: ${format}`], ...pattern === null ? [] : [`  branch_pattern: "${pattern}"`], ""].join("\n");
+}
+function pct(x) {
+  return `${Math.round(x * 100)} %`;
+}
+function _git(cwd, args) {
+  const r = spawnSync2("git", args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  return r.status === 0 ? r.stdout : null;
+}
+function _trunk(cwd) {
+  const ref = makeTargetDeps(cwd).defaultBranch();
+  if (ref === null) {
+    return { unresolved: "no default branch could be resolved \u2014 origin names none and refs/remotes/origin/HEAD is not set" };
+  }
+  if (_git(cwd, ["rev-parse", "-q", "--verify", `${ref}^{commit}`]) === null) {
+    return { unresolved: `the default branch ${ref} is not in this checkout \u2014 fetch it first` };
+  }
+  const slash = ref.indexOf("/");
+  return { trunk: ref, remote: ref.slice(0, slash), name: ref.slice(slash + 1) };
+}
+function readHistory(cwd, limit = MEASURE_LIMIT) {
+  if (_git(cwd, ["rev-parse", "--git-dir"]) === null) return null;
+  const t = _trunk(cwd);
+  if ("unresolved" in t) return t;
+  const read = (since) => (_git(cwd, ["log", t.trunk, "--no-merges", "-n", String(limit), ...since, "--pretty=format:%x1e%aN%x09%aE%x09%s", "--shortstat"]) ?? "").split("").filter((r) => r.trim() !== "").map((r) => {
+    const [head = "", ...rest] = r.split("\n");
+    const [author = "", email = "", ...subject] = head.split("	");
+    const stat = /(\d+) files? changed/.exec(rest.join("\n"));
+    return { author, email, subject: subject.join("	"), files: stat === null ? null : Number(stat[1]) };
+  });
+  let commits = read([`--since=${MEASURE_SINCE}`]);
+  let windowExtended = false;
+  if (commits.length < MIN_N) {
+    const all = read([]);
+    windowExtended = all.length > commits.length;
+    if (windowExtended) commits = all;
+  }
+  const refs = _git(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/remotes"]) ?? "";
+  const branches = refs.split("\n").map((r) => r.trim()).filter((r) => r !== "" && r.includes("/")).map((r) => ({ remote: r.slice(0, r.indexOf("/")), name: r.slice(r.indexOf("/") + 1) })).filter((b) => b.name !== "HEAD" && !(b.name === t.name && b.remote === t.remote)).map((b) => b.name);
+  const merges = _git(cwd, ["log", "--all", "--merges", "-n", String(limit), `--since=${MEASURE_SINCE}`, "--pretty=format:%s"]) ?? "";
+  return {
+    trunk: t.trunk,
+    defaultBranch: t.name,
+    commits,
+    branches,
+    mergeSubjects: merges.split("\n").filter((s) => s !== ""),
+    windowExtended
+  };
+}
+
+// src/scripts/sync_pr_branch.ts
+import * as path2 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// src/scripts/_lib/branch_convergence.ts
+var import_yaml = __toESM(require_dist(), 1);
+var POLICY_PATH = ".branch-convergence.yml";
+var MissingBranchConvergencePolicy = class extends Error {
+  target;
+  constructor(target) {
+    super(`MissingBranchConvergencePolicy(target="${target}")`);
+    this.name = "MissingBranchConvergencePolicy";
+    this.target = target;
+  }
+};
+var InvalidBranchConvergencePolicy = class extends Error {
+  constructor(detail) {
+    super(`InvalidBranchConvergencePolicy: ${detail}`);
+    this.name = "InvalidBranchConvergencePolicy";
+  }
+};
+var UnresolvableTargetSha = class extends Error {
+  target;
+  constructor(target) {
+    super(`UnresolvableTargetSha(target="${target}")`);
+    this.name = "UnresolvableTargetSha";
+    this.target = target;
+  }
+};
+var TARGET_KEYS = /* @__PURE__ */ new Set(["defaultBranch"]);
+var ROOT_KEYS = /* @__PURE__ */ new Set(["enabled", "targets"]);
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseBranchConvergencePolicy(text) {
+  let doc;
+  try {
+    doc = (0, import_yaml.parse)(text);
+  } catch (exc) {
+    throw new InvalidBranchConvergencePolicy(exc instanceof Error ? exc.message : String(exc));
+  }
+  if (!isPlainObject(doc)) {
+    return null;
+  }
+  const section = doc["branchConvergence"];
+  if (section === void 0) {
+    return null;
+  }
+  if (!isPlainObject(section)) {
+    throw new InvalidBranchConvergencePolicy("`branchConvergence` is not a mapping");
+  }
+  for (const k of Object.keys(section)) {
+    if (!ROOT_KEYS.has(k)) {
+      throw new InvalidBranchConvergencePolicy(`unknown field \`branchConvergence.${k}\``);
+    }
+  }
+  const enabled = section["enabled"];
+  if (typeof enabled !== "boolean") {
+    throw new InvalidBranchConvergencePolicy("`enabled` must be true or false");
+  }
+  const rawTargets = section["targets"] ?? {};
+  if (!isPlainObject(rawTargets)) {
+    throw new InvalidBranchConvergencePolicy("`targets` must be a mapping");
+  }
+  const targets = {};
+  for (const [name, entry] of Object.entries(rawTargets)) {
+    if (!isPlainObject(entry)) {
+      throw new InvalidBranchConvergencePolicy(`\`targets.${name}\` is not a mapping`);
+    }
+    for (const k of Object.keys(entry)) {
+      if (!TARGET_KEYS.has(k)) {
+        throw new InvalidBranchConvergencePolicy(`unknown field \`targets.${name}.${k}\``);
+      }
+    }
+    const v = entry["defaultBranch"];
+    if (v !== "include" && v !== "exclude") {
+      throw new InvalidBranchConvergencePolicy(
+        `\`targets.${name}.defaultBranch\` must be include or exclude, got ${JSON.stringify(v)}`
+      );
+    }
+    targets[name] = { defaultBranch: v };
+  }
+  return { enabled, targets };
+}
+function loadPolicyAtSha(targetSha, read) {
+  if (!/^[0-9a-f]{7,40}$/.test(targetSha)) {
+    throw new InvalidBranchConvergencePolicy(`\`targetSha\` is not a commit id: ${JSON.stringify(targetSha)}`);
+  }
+  const text = read(targetSha, POLICY_PATH);
+  if (text === null) {
+    return null;
+  }
+  return parseBranchConvergencePolicy(text);
+}
+
+// src/scripts/sync_pr_branch.ts
+var NETWORK_TIMEOUT_MS2 = 8e3;
+var MERGE_TIMEOUT_MS = 3e5;
+var GENERATED = [
+  // Untracked in THIS repository since 2026-08-21 (it was the #1 conflict
+  // path: 830 commits/60d, in the conflict set of every open CONFLICTING PR).
+  // The entry STAYS anyway, and the retirement criterion is a declared window
+  // rather than "one release" — the AI council flagged the release count as
+  // arbitrary and unverifiable. Remove this entry once no open branch predates
+  // the untrack commit, which is checkable:
+  //
+  //   git branch -r --contains <untrack-commit>   # must list every open branch
+  //
+  // Until then a straggler branch created before the untrack still carries the
+  // tracked file, and a conflict on it is still resolved by regeneration.
+  "agents/roadmaps-progress.md",
+  "agents/index.md",
+  "docs/catalog.md",
+  "dist/agent-src/",
+  // Written by `src/scripts/adr/regenerate_index.ts`, which takes the decisions
+  // directory as an ARGUMENT — so the path literal appears nowhere in the
+  // generator and every grep-based audit of this list missed it. Found instead
+  // by measurement: 4 of the last 50 sessions resolved a conflict here, and
+  // its only correct resolution is `task regenerate-adr-index`, never a hunk
+  // merge of two append-shaped indexes.
+  "docs/decisions/INDEX.md",
+  // Compiled by `compile_router.ts`. The `dist/agent-src/` prefix above does
+  // NOT match a sibling one level up under `dist/`, so this file was routed to
+  // a human decision despite being pure build output.
+  "dist/router.json",
+  ".augment/",
+  // Compiled from `hook_manifest.yaml` by `task build-ts`, never hand-written.
+  // It was classified AUTHORED until 2026-08-20, so this tool told the reader
+  // to "read both sides" on a file where mixing hunks yields a concern table
+  // matching NEITHER branch. One session resolved this same conflict three
+  // times and named it structural: main adds a concern and recompiles, so
+  // every open branch collides here. Regenerate; never merge.
+  "src/scripts/hook_manifest.json",
+  // Written together by one `build_archive_index.ts` call (`:409-410`) from the
+  // archived roadmap tree, so neither is ever hand-authored. They were
+  // classified AUTHORED until 2026-08-21, which made this tool ask for a human
+  // decision about a file whose only correct resolution is regeneration --
+  // the identical defect the hook_manifest.json comment above records, on two
+  // more paths at 47 commits/60d each. They conflict in 2 of the 7 open PRs
+  // measured for road-to-merge-hotspot-drawdown. Regenerate; never merge.
+  "agents/roadmaps/archive/INDEX.md",
+  "agents/roadmaps/archive/index.json",
+  // ── Added 2026-08-25 (road-to-merge-surface-zero 1.1). Each carries its
+  // write site, because this list tells a human to DISCARD one side, and an
+  // entry added on a conflict count alone would tell them to discard hand
+  // work. Counts are from `pr_conflict_census --limit 2000` over 60 days.
+  //
+  // Written by `build_proof.ts:500` from `docs/CLAIMS.md`. 26 resolutions, and
+  // it fails in pairs: a CLAIMS.md edit leaves it stale, which reds both the
+  // drift-guard test and `demo-commands-still-pass`.
+  "docs/proof.md",
+  // Both written by `generate_catalog.ts` (`:166` for llms.txt) from SKILL.md
+  // frontmatter. Neither has ever been hand-authored.
+  "docs/skills-catalog.md",
+  "llms.txt",
+  // Written by `lint_originality.ts:340`. Named by step 1.1 and included
+  // although the census found ZERO conflicts on it in either window — it is
+  // genuinely generated and classifying it costs nothing. Recorded rather than
+  // quietly dropped: the step named it on conflict frequency, and that premise
+  // does not hold.
+  "agents/reports/originality.json",
+  "agents/reports/originality.md"
+];
+var GENERATED_PATTERNS = [
+  {
+    // `generate_pack_manifests.ts:427`, and the file's own first line is
+    // the do-not-edit header that generator writes.
+    // 12 resolutions over 60 days across two packs.
+    re: /^src\/domains\/[^/]+\/pack\.yaml$/,
+    why: "per-pack manifest written by generate_pack_manifests.ts"
+  }
+];
+var REMEASURED = ["src/config/gate-violation-baselines.json"];
+function sh2(cmd, args, cwd, timeout = NETWORK_TIMEOUT_MS2) {
+  const r = spawnSync3(cmd, [...args], {
+    cwd,
+    encoding: "utf-8",
+    timeout,
+    maxBuffer: 32 * 1024 * 1024
+  });
+  return { ok: r.status === 0, out: r.stdout ?? "", err: (r.stderr ?? "").trim(), killed: r.signal !== null };
+}
+function mergeTimeoutMs() {
+  const n = Number(process.env["AGENT_CONFIG_SYNC_MERGE_TIMEOUT_MS"]);
+  return Number.isInteger(n) && n > 0 ? n : MERGE_TIMEOUT_MS;
+}
+var UNTRACKED_BY_DESIGN = [
+  "agents/roadmaps-progress.md",
+  "agents/roadmaps/archive/INDEX.md",
+  "agents/roadmaps/archive/index.json"
+];
+function isUntrackedByDesign(rel) {
+  return UNTRACKED_BY_DESIGN.includes(rel);
+}
+function isGenerated(rel) {
+  const norm = rel.replace(/\\/g, "/");
+  if (GENERATED.some((g) => g.endsWith("/") ? norm.startsWith(g) : norm === g)) return true;
+  return GENERATED_PATTERNS.some((p) => p.re.test(norm));
+}
+function isRemeasured(rel) {
+  const norm = rel.replace(/\\/g, "/");
+  return REMEASURED.some((g) => g.endsWith("/") ? norm.startsWith(g) : norm === g);
+}
+function behindRefusalMessage(plan, strategy) {
+  const t = plan.targetStale;
+  return `\u26A0\uFE0F  sync_pr_branch: refused \u2014 the branch is behind and git.update_strategy is \`${strategy}\`; this script only merges. Rebase on request instead (git-workflow references/branch-update.md). ${plan.summary ?? ""}. Behind: ${plan.behindDetail ?? "?"}.` + (t === void 0 ? "" : ` The target ${t.target} is itself ${String(t.behind)} commit(s) behind ${t.defaultRef}; once this branch is current with it, the target needs updating too.`);
+}
+function classifyConflicts(files) {
+  const generated = [];
+  const remeasured = [];
+  const authored = [];
+  for (const f of files) {
+    const rel = f.trim();
+    if (rel === "") continue;
+    if (isGenerated(rel)) generated.push(rel);
+    else if (isRemeasured(rel)) remeasured.push(rel);
+    else authored.push(rel);
+  }
+  return { generated, remeasured, authored };
+}
+function renderConflictReport(plan) {
+  const out = [`\u274C  ${plan.message}
+`];
+  const untracked = plan.generated.filter(isUntrackedByDesign);
+  const regenerable = plan.generated.filter((f) => !isUntrackedByDesign(f));
+  if (regenerable.length > 0) {
+    out.push(`
+  GENERATED (${String(regenerable.length)}) \u2014 resolve by REGENERATING, never by mixing hunks:
+`);
+    for (const f of regenerable) out.push(`    \xB7 ${f}
+`);
+    out.push("    \u2192 git checkout --ours <file> && task sync && task generate-tools\n");
+  }
+  if (untracked.length > 0) {
+    out.push(
+      `
+  UNTRACKED BY DESIGN (${String(untracked.length)}) \u2014 this repository does not commit these; TAKE THE DELETION:
+`
+    );
+    for (const f of untracked) out.push(`    \xB7 ${f}
+`);
+    out.push("    \u2192 git rm --cached -- <file>   (the working-tree copy stays; regenerate it locally)\n");
+  }
+  if (plan.remeasured.length > 0) {
+    out.push(
+      `
+  REMEASURED (${String(plan.remeasured.length)}) \u2014 RE-RUN THE MEASUREMENT on the merged tree; never merge, never pick a side:
+`
+    );
+    for (const f of plan.remeasured) out.push(`    \xB7 ${f}
+`);
+    out.push("    \u2192 resolve the tree, then re-run the gate that owns the baseline and record its number\n");
+  }
+  if (plan.authored.length > 0) {
+    out.push(`
+  AUTHORED (${String(plan.authored.length)}) \u2014 a human decision, read both sides:
+`);
+    for (const f of plan.authored) out.push(`    \xB7 ${f}
+`);
+  }
+  return out.join("");
+}
+var UnresolvableBase = class extends Error {
+  constructor(detail) {
+    super(`unresolvable \u2014 ${detail}`);
+    this.name = "UnresolvableBase";
+  }
+};
+function makeGitDeps(repo) {
+  return {
+    ...makeTargetDeps(repo),
+    // `git show <sha>:<path>` and nothing else. There is no filesystem read
+    // here by construction: a policy the PR head carries must not be able to
+    // change the criteria the PR is judged against.
+    readAtSha: (sha, rel) => {
+      const out = sh2("git", ["show", `${sha}:${rel}`], repo);
+      return out.ok ? out.out : null;
+    }
+  };
+}
+function bareName(ref) {
+  return splitResolvedRef(ref).branch;
+}
+function sameRemoteBranch(a, b) {
+  const x = splitResolvedRef(a);
+  const y = splitResolvedRef(b);
+  return x.remote === y.remote && x.branch === y.branch;
+}
+function resolveBase(repo, override, deps = makeGitDeps(repo)) {
+  const defaultRef = deps.defaultBranch();
+  const target = resolveTarget(deps, override, defaultRef);
+  if (target === null) {
+    throw new UnresolvableBase("no --base and no origin/HEAD");
+  }
+  const sameName = defaultRef !== null && sameRemoteBranch(target.ref, defaultRef);
+  const targetSha = deps.remoteSha(target.ref);
+  const defaultSha = defaultRef === null ? null : deps.remoteSha(defaultRef);
+  const sameSha = targetSha !== null && defaultSha !== null && targetSha === defaultSha;
+  const targetRemote = splitResolvedRef(target.ref).remote;
+  const ownDefault = sameName || sameSha || defaultRef !== null && splitResolvedRef(defaultRef).remote === targetRemote ? null : deps.defaultBranchOf?.(targetRemote) ?? null;
+  const ownName = ownDefault !== null && sameRemoteBranch(target.ref, ownDefault);
+  if (sameName || sameSha || ownName) {
+    return { entries: [target], policyStatus: "not-required" };
+  }
+  if (targetSha === null) {
+    throw new UnresolvableTargetSha(bareName(target.ref));
+  }
+  const policy = loadPolicyAtSha(targetSha, deps.readAtSha);
+  if (policy === null) {
+    throw new MissingBranchConvergencePolicy(bareName(target.ref));
+  }
+  if (!policy.enabled) {
+    return { entries: [target], policyStatus: "disabled" };
+  }
+  const entry = policy.targets[bareName(target.ref)];
+  if (entry === void 0) {
+    throw new MissingBranchConvergencePolicy(bareName(target.ref));
+  }
+  if (entry.defaultBranch === "exclude") {
+    return { entries: [target], policyStatus: "applied" };
+  }
+  if (defaultRef === null) {
+    throw new UnresolvableBase("policy says include the default branch, but origin/HEAD names none");
+  }
+  return {
+    entries: [target, { ref: defaultRef, reason: "branch-convergence-policy:include-default" }],
+    policyStatus: "applied"
+  };
+}
+function integrationOrder(r) {
+  const policyAdded = r.entries.filter((e) => e.reason === "branch-convergence-policy:include-default");
+  const rest = r.entries.filter((e) => e.reason !== "branch-convergence-policy:include-default");
+  return [...policyAdded, ...rest].map((e) => e.ref);
+}
+function describeReason(reason) {
+  switch (reason) {
+    case "explicit-base-override":
+      return "given by --base";
+    case "repository-default-branch":
+      return "the repo default branch";
+    case "branch-convergence-policy:include-default":
+      return "the default branch, added by the branch-convergence policy";
+  }
+}
+function renderBaseSummary(r) {
+  const byRef = new Map(r.entries.map((e) => [e.ref, e.reason]));
+  const parts = integrationOrder(r).map((ref) => `${ref} (${describeReason(byRef.get(ref))})`);
+  const head = r.policyStatus === "disabled" ? "BYPASSED \u2014 branch-convergence policy disabled at the target commit; the default branch was NOT considered" : r.policyStatus === "applied" ? "branch-convergence policy applied" : "no branch-convergence policy required (target is the default branch)";
+  return `${head}; integrating in order: ${parts.join(" \u2192 ")}`;
+}
+var MAX_BASE_ATTEMPTS = 3;
+function renderAttempts(attempts) {
+  return attempts.map((a) => `  attempt ${String(a.attempt)}: ${a.ref} ${a.before ?? "?"} \u2192 ${a.after ?? "?"}`).join("\n");
+}
+function integrateWithPinnedBase(refs, ops) {
+  const attempts = [];
+  for (let n = 1; n <= MAX_BASE_ATTEMPTS; n++) {
+    const pinned = refs.map((ref) => ({ ref, before: ops.remoteSha(ref) }));
+    const stop = n === 1 ? ops.checkPin?.(pinned) ?? null : null;
+    if (stop !== null) return { ok: false, stopped: true, attempts, conflicted: [], message: stop };
+    let conflicted = [];
+    let clean = true;
+    for (const q of pinned) {
+      const m = ops.merge(q.ref, q.before);
+      if (!m.ok && m.error !== void 0) return { ok: false, attempts, conflicted: [], message: m.error };
+      if (!m.ok) {
+        clean = false;
+        conflicted = m.conflicted;
+        break;
+      }
+    }
+    const moved = [];
+    for (const q of pinned) {
+      const after = ops.remoteSha(q.ref);
+      attempts.push({ attempt: n, ref: q.ref, before: q.before, after });
+      if (after !== q.before) moved.push(q.ref);
+    }
+    if (!clean) {
+      return {
+        ok: false,
+        attempts,
+        conflicted,
+        message: `merge hit ${String(conflicted.length)} conflict(s) on attempt ${String(n)}.`
+      };
+    }
+    if (moved.length === 0) {
+      return { ok: true, attempts, conflicted: [], message: `integrated ${refs.join(", ")} on attempt ${String(n)}.` };
+    }
+  }
+  return {
+    ok: false,
+    attempts,
+    conflicted: [],
+    message: `the base moved under every one of ${String(MAX_BASE_ATTEMPTS)} attempts \u2014 stopping rather than looping.
+${renderAttempts(attempts)}
+  \u2192 a base that moves this fast is a finding about landing speed, not a transient race.`
+  };
+}
+function mergePinned(repo, ref, sha) {
+  const tracking = () => sh2("git", ["rev-parse", "--verify", "-q", `${ref}^{commit}`], repo).out.trim();
+  let target = ref;
+  if (sha !== null && tracking() !== sha) {
+    const { remote, branch } = splitResolvedRef(ref);
+    sh2("git", ["fetch", "--", remote, `+refs/heads/${branch}:refs/remotes/${remote}/${branch}`], repo);
+    if (tracking() !== sha) {
+      if (!sh2("git", ["cat-file", "-e", `${sha}^{commit}`], repo).ok) {
+        return { ok: false, conflicted: [], error: `the pinned commit ${sha.slice(0, 12)} of ${ref} could not be fetched \u2014 nothing was merged for it.` };
+      }
+      target = sha;
+    }
+  }
+  const indexWasClean = sh2("git", ["diff", "--cached", "--quiet"], repo).ok;
+  const m = sh2("git", ["merge", "--no-edit", target], repo, mergeTimeoutMs());
+  if (!m.ok) {
+    const conflicted = sh2("git", ["diff", "--name-only", "--diff-filter=U"], repo).out.split("\n").filter((p) => p.trim() !== "");
+    if (conflicted.length > 0) return { ok: false, conflicted };
+    const how = m.killed ? `was stopped after ${String(mergeTimeoutMs() / 1e3)} s` : "did not complete";
+    if (sh2("git", ["rev-parse", "-q", "--verify", "MERGE_HEAD"], repo).ok) {
+      return {
+        ok: false,
+        conflicted: [],
+        error: `the merge of ${ref} ${how} and left a merge in progress (MERGE_HEAD is set) \u2014 finish it with \`git commit\` or discard it with \`git merge --abort\`.`
+      };
+    }
+    if (indexWasClean && !sh2("git", ["diff", "--cached", "--quiet"], repo).ok) {
+      return {
+        ok: false,
+        conflicted: [],
+        error: `the merge of ${ref} ${how} and left it half-applied in the index (no MERGE_HEAD) \u2014 discard it with \`git reset --merge\`.`
+      };
+    }
+    if (m.killed) {
+      return { ok: false, conflicted: [], error: `the merge of ${ref} was stopped after ${String(mergeTimeoutMs() / 1e3)} s before it changed anything \u2014 nothing was merged for it.` };
+    }
+    const why = (m.err || m.out).trim().split("\n").join(" ");
+    return { ok: false, conflicted: [], error: `git refused to merge ${ref}: ${why || "no reason given"} \u2014 nothing was merged for it.` };
+  }
+  if (sha !== null && !sh2("git", ["merge-base", "--is-ancestor", sha, "HEAD"], repo).ok) {
+    return { ok: false, conflicted: [], error: `the merge of ${ref} left HEAD without its pinned commit ${sha.slice(0, 12)}.` };
+  }
+  return { ok: true, conflicted: [] };
+}
+function autoResolveGenerated(split, ops) {
+  if (split.remeasured.length > 0 || split.authored.length > 0) {
+    return {
+      resolved: false,
+      message: `NOT auto-resolved: the conflict set contains ${String(split.remeasured.length)} remeasured and ${String(split.authored.length)} authored path(s), which have no single correct resolution.`
+    };
+  }
+  if (split.generated.length === 0) {
+    return { resolved: false, message: "nothing to auto-resolve." };
+  }
+  const first = ops.regenerate();
+  if (!first.ok) {
+    return { resolved: false, message: `NOT auto-resolved: regeneration failed \u2014 ${first.err.split("\n")[0] ?? "?"}` };
+  }
+  if (!ops.stage(split.generated)) {
+    return { resolved: false, message: "NOT auto-resolved: could not stage the regenerated paths." };
+  }
+  const second = ops.regenerate();
+  if (!second.ok) {
+    return { resolved: false, message: `NOT auto-resolved: the byte-identity re-run failed \u2014 ${second.err.split("\n")[0] ?? "?"}` };
+  }
+  const drift = ops.dirty(split.generated);
+  if (drift.length > 0) {
+    return {
+      resolved: false,
+      message: `NOT auto-resolved: these paths are not byte-identical to a clean regeneration, so at least one is partly hand-edited \u2014 ${drift.join(", ")}`
+    };
+  }
+  return {
+    resolved: true,
+    message: `auto-resolved ${String(split.generated.length)} generated conflict(s) by regeneration, byte-identity asserted.`
+  };
+}
+function gitRegenOps(repo) {
+  return {
+    // The repository's own consistency target — the exact CI mirror the
+    // pre-push hook already runs. Named here rather than open-coded so the
+    // generator this trusts is the one the gate trusts.
+    regenerate: () => {
+      const r = sh2("task", ["consistency"], repo);
+      return { ok: r.ok, err: r.err };
+    },
+    dirty: (paths) => {
+      const r = sh2("git", ["status", "--porcelain", "--", ...paths], repo);
+      if (!r.ok) return [...paths];
+      return r.out.split("\n").map((l) => l.slice(3).trim()).filter((l) => l !== "");
+    },
+    stage: (paths) => sh2("git", ["add", "--", ...paths], repo).ok
+  };
+}
+function sync(repo, baseOverride, dryRun, autoResolve = false, deps, opts = {}) {
+  let resolved;
+  try {
+    resolved = resolveBase(repo, baseOverride, deps ?? makeGitDeps(repo));
+  } catch (exc) {
+    return {
+      exit: 1,
+      message: `cannot resolve a base set to update against \u2014 ${exc instanceof Error ? exc.message : String(exc)}`,
+      generated: [],
+      remeasured: [],
+      authored: [],
+      scanned: 0
+    };
+  }
+  const summary = renderBaseSummary(resolved);
+  const order = integrationOrder(resolved);
+  const remotes = [.../* @__PURE__ */ new Set(["origin", ...order.map((ref) => splitResolvedRef(ref).remote)])];
+  const failed = remotes.map((remote) => ({ remote, ...sh2("git", ["fetch", "--prune", "--", remote], repo) })).find((f) => !f.ok);
+  if (failed !== void 0) {
+    return {
+      exit: 0,
+      message: `unverified \u2014 could not fetch ${failed.remote} (${failed.err.split("\n")[0] ?? "?"}). Base freshness NOT checked.`,
+      generated: [],
+      remeasured: [],
+      authored: [],
+      scanned: 0
+    };
+  }
+  for (const ref of order) {
+    const { remote, branch } = splitResolvedRef(ref);
+    const f = sh2("git", ["fetch", "-q", "--", remote, `+refs/heads/${branch}:refs/remotes/${remote}/${branch}`], repo);
+    if (!f.ok) {
+      return {
+        exit: 0,
+        message: `unverified \u2014 could not fetch ${ref} (${f.err.split("\n")[0] ?? "?"}). Base freshness NOT checked.`,
+        generated: [],
+        remeasured: [],
+        authored: [],
+        scanned: 0
+      };
+    }
+  }
+  const countBehind = (from, ref) => {
+    const r = sh2("git", ["rev-list", "--count", `${from}..${ref}`], repo);
+    const n = Number(r.out.trim());
+    return r.ok && r.out.trim() !== "" && Number.isInteger(n) ? n : null;
+  };
+  const uncountable = (ref) => ({
+    exit: 1,
+    message: `cannot count commits behind ${ref} \u2014 it is not in this checkout (a single-branch clone fetches only its own branch). Fetch it: git fetch -- ${splitResolvedRef(ref).remote} +refs/heads/${bareName(ref)}:refs/remotes/${splitResolvedRef(ref).remote}/${bareName(ref)}`,
+    generated: [],
+    remeasured: [],
+    authored: [],
+    scanned: 0
+  });
+  const behindEach = [];
+  for (const ref of order) {
+    const behind = countBehind("HEAD", ref);
+    if (behind === null) return uncountable(ref);
+    behindEach.push({ ref, behind });
+  }
+  const stale = behindEach.filter((b) => b.behind > 0);
+  if (stale.length === 0) {
+    return { exit: 0, message: `already current with every base ref \u2014 ${summary}.`, generated: [], remeasured: [], authored: [], scanned: order.length };
+  }
+  if (dryRun) {
+    const detail = stale.map((b) => `${b.ref} (${String(b.behind)} behind)`).join(", ");
+    const added = resolved.entries.find((e) => e.reason === "branch-convergence-policy:include-default");
+    const target = resolved.entries[0]?.ref ?? "";
+    const targetBehind = added === void 0 ? 0 : countBehind(target, added.ref);
+    if (targetBehind === null) return uncountable(added?.ref ?? target);
+    return {
+      ...targetBehind > 0 && added !== void 0 ? { targetStale: { target, defaultRef: added.ref, behind: targetBehind, branchBehind: behindEach.find((b) => b.ref === target)?.behind ?? 0 } } : {},
+      exit: 0,
+      message: `${summary}. Behind: ${detail} \u2014 would merge in that order. Dry run, nothing changed.`,
+      summary,
+      behindDetail: detail,
+      generated: [],
+      remeasured: [],
+      authored: [],
+      scanned: order.length,
+      behind: stale.length
+    };
+  }
+  const live = opts.live ?? makeGitDeps(repo);
+  const outcome = integrateWithPinnedBase(
+    stale.map((b) => b.ref),
+    {
+      remoteSha: (ref) => live.remoteSha(ref),
+      ...opts.checkPin === void 0 ? {} : { checkPin: opts.checkPin },
+      merge: (ref, sha) => mergePinned(repo, ref, sha)
+    }
+  );
+  if (outcome.ok) {
+    return {
+      exit: 0,
+      message: `${summary}. ${outcome.message} REGENERATE derived files now \u2014 a clean auto-merge of a generated file is still wrong.`,
+      generated: [],
+      remeasured: [],
+      authored: [],
+      scanned: order.length
+    };
+  }
+  if (outcome.conflicted.length === 0) {
+    return { exit: 1, message: `${summary}. ${outcome.message}`, generated: [], remeasured: [], authored: [], scanned: order.length };
+  }
+  const split = classifyConflicts(outcome.conflicted);
+  if (autoResolve) {
+    const attempt = autoResolveGenerated(split, gitRegenOps(repo));
+    if (attempt.resolved) {
+      return { exit: 0, message: `${summary}. ${attempt.message}`, generated: [], remeasured: [], authored: [], scanned: order.length };
+    }
+    return {
+      exit: 1,
+      message: `${summary}. ${outcome.message} ${attempt.message}`,
+      ...split,
+      scanned: order.length
+    };
+  }
+  return {
+    exit: 1,
+    message: `${summary}. ${outcome.message} NOT auto-resolved: a content conflict is where a parallel session's work disappears. (--auto-resolve-generated resolves a set that is GENERATED and nothing else.)`,
+    ...split,
+    scanned: order.length
+  };
+}
+function readStrategy(repo, base, deps) {
+  const read = readCommittedConvention(repo, { override: base, keys: ["update_strategy"], ...deps ? { deps } : {} });
+  return { reading: read.readings.update_strategy, baseResolved: read.target !== null && read.target.sha !== null, target: read.target };
+}
+function strategyExit(reading, baseResolved, developer) {
+  if (!isRefusal(reading.state)) return { exit: null, line: "", reading };
+  const refused = { exit: 4, line: `\u274C  sync_pr_branch: refused \u2014 ${describeRefusal(reading)}. Nothing was checked or merged.`, reading };
+  if (reading.state !== "unresolvable" || isRefusal(developer.state)) return refused;
+  const why = reading.detail ?? "the target commit is unknown";
+  if (!baseResolved) return { exit: 1, line: `\u274C  sync_pr_branch: base could not be resolved \u2014 ${why}. Nothing was checked or merged.`, reading };
+  return { exit: 0, line: `\u26A0\uFE0F  sync_pr_branch: unverified \u2014 ${why}. Base freshness NOT checked, nothing was merged.`, reading };
+}
+function strategyGate(repo, base, targetDeps) {
+  const { reading, baseResolved, target } = readStrategy(repo, base, targetDeps);
+  return { ...strategyExit(reading, baseResolved, readGitConventionKey("update_strategy", checkoutSource(conventionRoot(repo).root))), target };
+}
+function strategyInForce(r) {
+  return isRefusal(r.state) ? `unreadable (${r.state})` : r.value ?? "merge";
+}
+function policyMovedStop(from, to, planned, pinned) {
+  const was = strategyInForce(planned);
+  const now = strategyInForce(pinned);
+  if (was === now) return null;
+  const why = isRefusal(pinned.state) ? ` (${describeRefusal(pinned)})` : "";
+  return `the target moved from ${from.slice(0, 12)} to ${to.slice(0, 12)} and its git.update_strategy changed from ${was} to ${now}${why} \u2014 nothing was merged; run again so the plan is made under the strategy the new commit carries.`;
+}
+function main(argv, deps) {
+  const args = argv ?? process.argv.slice(2);
+  let repo = process.cwd();
+  let base = null;
+  let dryRun = false;
+  let quiet = false;
+  let autoResolve = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const val = () => {
+      const v = args[++i];
+      return v === void 0 || v.startsWith("--") ? null : v;
+    };
+    if (a === "--repo") {
+      const v = val();
+      if (v === null) {
+        process.stderr.write("\u274C  sync_pr_branch: --repo requires a value\n");
+        reportScanned({ gate: "sync_pr_branch", scanned: 0, units: "base ref(s)", roots: ["origin"], allowEmpty: "argument error" });
+        return 1;
+      }
+      repo = v;
+    } else if (a === "--base") {
+      const v = val();
+      if (v === null) {
+        process.stderr.write("\u274C  sync_pr_branch: --base requires a value\n");
+        reportScanned({ gate: "sync_pr_branch", scanned: 0, units: "base ref(s)", roots: ["origin"], allowEmpty: "argument error" });
+        return 1;
+      }
+      const blank = baseValueError(v);
+      if (blank !== null) {
+        process.stderr.write(`\u274C  sync_pr_branch: ${blank}
+`);
+        reportScanned({ gate: "sync_pr_branch", scanned: 0, units: "base ref(s)", roots: ["origin"], allowEmpty: "argument error" });
+        return 2;
+      }
+      base = v;
+    } else if (a === "--dry-run") {
+      dryRun = true;
+    } else if (a === "--auto-resolve-generated") {
+      autoResolve = true;
+    } else if (a === "--quiet") {
+      quiet = true;
+    } else if (a === "-h" || a === "--help") {
+      process.stdout.write(
+        "usage: sync_pr_branch [--repo PATH] [--base REF] [--dry-run] [--auto-resolve-generated] [--quiet]\n  Merges the PR base into the current branch so the PR does not go stale.\n  Under a git.update_strategy other than merge it only checks: a current\n  branch exits 0, a behind one exits 3 and is never merged (--dry-run and\n  --auto-resolve-generated have nothing to change there). A strategy that\n  cannot be read (unparsable file, typo, user-global-only) exits 4.\n  The base is --base; without it the default branch, so a PR into any other\n  base must pass --base <its base>; a branch name and refs/heads/<name> mean\n  origin/<name>, and <remote>/<name> is used as given. A blank --base\n  is a usage error, exit 2.\n  A base that cannot be resolved or counted exits 1; one whose commit\n  cannot be fetched is unverified, exit 0. A target that moves before the\n  merge is read again at the new commit; another strategy there exits 1,\n  nothing merged. A conflict is\n  reported and never auto-resolved; generated and authored conflicts are\n  listed separately because only the first has one correct resolution;\n  measured ratchet baselines are a third class, re-measured not merged.\n  The base is a SET: a non-default target may also carry the default branch,\n  per the branch-convergence policy read at the TARGET commit. Integration\n  runs the default first so the broad conflict surfaces first.\n  --auto-resolve-generated resolves a conflict set that is GENERATED and\n  nothing else, by regenerating and asserting byte-identity.\n"
+      );
+      reportScanned({ gate: "sync_pr_branch", scanned: 0, units: "base ref(s)", roots: ["origin"], allowEmpty: "help output" });
+      return 0;
+    } else {
+      process.stderr.write(`\u274C  sync_pr_branch: unknown argument \`${a}\`
+`);
+      reportScanned({ gate: "sync_pr_branch", scanned: 0, units: "base ref(s)", roots: ["origin"], allowEmpty: "argument error" });
+      return 1;
+    }
+  }
+  const ignored = ignoredCarrierWarning(conventionRoot(repo).root);
+  if (ignored !== null) process.stdout.write(`\u26A0\uFE0F  sync_pr_branch: ${ignored}
+`);
+  const live = deps ?? makeGitDeps(repo);
+  const targetDeps = memoTargetDeps(live);
+  let plan;
+  try {
+    const gate = strategyGate(repo, base, targetDeps);
+    if (gate.exit !== null) {
+      process.stdout.write(`${gate.line}
+`);
+      const why = gate.exit === 0 ? "target commit not fetched \u2014 stated above" : gate.exit === 1 ? "base unresolvable \u2014 stated above" : "git.update_strategy unreadable";
+      reportScanned({ gate: "sync_pr_branch", scanned: 0, units: "base ref(s)", roots: ["origin"], allowEmpty: why });
+      return gate.exit;
+    }
+    const strategy = gate.reading.value ?? "merge";
+    if (strategy !== "merge") {
+      plan = sync(repo, base, true, false, targetDeps);
+      const t = plan.targetStale;
+      if (plan.exit === 0 && t !== void 0 && t.branchBehind === 0) {
+        process.stdout.write(
+          `\u26A0\uFE0F  sync_pr_branch: refused \u2014 TARGET_POLICY_STALE: the target ${t.target} is itself ${String(t.behind)} commit(s) behind ${t.defaultRef}, which the branch-convergence policy requires; updating this branch onto the target cannot make it current. The target needs updating first; this branch has nothing to do until then.
+`
+        );
+        reportScanned({ gate: "sync_pr_branch", scanned: plan.scanned, units: "base ref(s)", roots: ["origin"] });
+        return 3;
+      }
+      if (plan.exit === 0 && (plan.behind ?? 0) > 0) {
+        process.stdout.write(`${behindRefusalMessage(plan, strategy)}
+`);
+        reportScanned({ gate: "sync_pr_branch", scanned: plan.scanned, units: "base ref(s)", roots: ["origin"] });
+        return 3;
+      }
+    } else {
+      const read = gate.target ?? null;
+      const checkPin = (pinned) => {
+        const now = read === null ? null : pinned.find((p) => p.ref === read.ref)?.before ?? null;
+        if (read === null || read.sha === null || now === null || now === read.sha) return null;
+        const again = strategyGate(repo, base, { ...targetDeps, remoteSha: () => now });
+        return policyMovedStop(read.sha, now, gate.reading, again.reading);
+      };
+      plan = sync(repo, base, dryRun, autoResolve, targetDeps, { live, checkPin });
+    }
+  } catch (exc) {
+    reportScanned({ gate: "sync_pr_branch", scanned: 0, units: "base ref(s)", roots: ["origin"], allowEmpty: "internal error" });
+    process.stderr.write(`\u274C  sync_pr_branch: internal error: ${exc instanceof Error ? exc.message : String(exc)}
+`);
+    return 2;
+  }
+  if (plan.exit === 1) {
+    process.stdout.write(renderConflictReport(plan));
+  } else if (plan.message.includes("BYPASSED")) {
+    process.stdout.write(`\u26A0\uFE0F  sync_pr_branch: ${plan.message}
+`);
+  } else if (plan.message.startsWith("unverified")) {
+    process.stdout.write(`\u26A0\uFE0F  sync_pr_branch: ${plan.message}
+`);
+  } else if (!quiet || plan.scanned > 0) {
+    process.stdout.write(`\u2705  ${plan.message}
+`);
+  }
+  reportScanned({
+    gate: "sync_pr_branch",
+    scanned: plan.scanned,
+    units: "base ref(s)",
+    roots: ["origin"],
+    ...plan.scanned === 0 ? { allowEmpty: "base unresolvable or remote unreachable \u2014 stated above" } : {}
+  });
+  return plan.exit;
+}
+var _HERE = fileURLToPath(import.meta.url);
+function _isCliEntry() {
+  if (process.argv[1] === void 0) return false;
+  if (true) return path2.basename(process.argv[1], ".js") === "sync_pr_branch";
+  return import.meta.url === pathToFileURL(path2.resolve(process.argv[1])).href || process.argv[1] === _HERE;
+}
+if (_isCliEntry()) {
+  process.exit(main());
+}
+
+// src/scripts/_cli/cmd_git_convention.ts
+var COMMITLINT_FILES = [
+  ".commitlintrc",
+  ".commitlintrc.json",
+  ".commitlintrc.yaml",
+  ".commitlintrc.yml",
+  ".commitlintrc.js",
+  ".commitlintrc.cjs",
+  ".commitlintrc.mjs",
+  ".commitlintrc.ts",
+  ".commitlintrc.cts",
+  ".commitlintrc.mts",
+  "commitlint.config.js",
+  "commitlint.config.cjs",
+  "commitlint.config.mjs",
+  "commitlint.config.ts",
+  "commitlint.config.cts",
+  "commitlint.config.mts"
+];
+function _git2(cwd, ...args) {
+  const r = spawnSync4("git", args, { cwd, encoding: "utf8" });
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+function _isExecutableFile(p) {
+  try {
+    const st = fs2.statSync(p);
+    return st.isFile() && (st.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+function commitMessageValidators(cwd) {
+  const found = [];
+  const top = _git2(cwd, "rev-parse", "--show-toplevel") ?? cwd;
+  const hook = _git2(cwd, "rev-parse", "--path-format=absolute", "--git-path", "hooks/commit-msg");
+  if (hook !== null && _isExecutableFile(hook)) found.push({ kind: "commit-msg hook", path: hook });
+  const config = COMMITLINT_FILES.map((name) => path3.join(top, name)).find((p) => fs2.existsSync(p));
+  if (config !== void 0) found.push({ kind: "commitlint config", path: config });
+  else {
+    try {
+      const pkg = JSON.parse(fs2.readFileSync(path3.join(top, "package.json"), "utf-8"));
+      if (pkg.commitlint !== void 0) found.push({ kind: "commitlint config", path: path3.join(top, "package.json") });
+    } catch {
+    }
+  }
+  return found;
+}
+function commitMessageValidator(cwd) {
+  return commitMessageValidators(cwd)[0] ?? null;
+}
+function _validatorNote(v) {
+  return `note: the ${v.kind} at ${v.path} also runs at commit time and may be stricter`;
+}
+function _short2(sha) {
+  return sha === null || sha === void 0 ? "?" : sha.slice(0, 12);
+}
+function showConvention(args, cwd, deps) {
+  let json = false;
+  let base = null;
+  const asked = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = args[i + 1];
+    if (a === "--json") json = true;
+    else if (a === "--base" && next !== void 0 && !next.startsWith("--")) {
+      const blank = baseValueError(next);
+      if (blank !== null) return { code: 2, out: [], err: [blank, USAGE] };
+      base = args[++i];
+    } else if (a === "--key" && next !== void 0 && GIT_CONVENTION_KEYS.includes(next)) {
+      if (!asked.includes(next)) asked.push(next);
+      i++;
+    } else return { code: 2, out: [], err: [a === "--key" ? `unknown key: ${next ?? "(none)"}` : `unknown argument: ${a}`, USAGE] };
+  }
+  const keys = asked.length === 0 ? GIT_CONVENTION_KEYS : GIT_CONVENTION_KEYS.filter((k) => asked.includes(k));
+  const read = readCommittedConvention(cwd, { override: base, keys, ...deps ? { deps } : {} });
+  const readings = read.readings;
+  const validators = commitMessageValidators(cwd);
+  const ok = !keys.some((k) => isRefusal(readings[k].state));
+  const code = ok ? 0 : 1;
+  const established = keys.includes("commit_format") ? _established(readings.commit_format, read.root) : null;
+  const ignored = ignoredCarrierWarning(read.root);
+  const warnings = ignored === null ? [] : [ignored];
+  if (json) {
+    const entries = {};
+    for (const k of keys) {
+      const { key: _key2, ...rest } = readings[k];
+      const cand = read.candidates[k];
+      entries[k] = {
+        ...rest,
+        read_at: read.readAt[k] ?? null,
+        candidate: cand === void 0 ? null : { value: cand.value, source: cand.source, state: cand.state, reason: cand.reason }
+      };
+    }
+    return {
+      code,
+      out: [JSON.stringify({ ok, keys: entries, target: read.target, warnings, convention_established: established, commit_message_validator: validators[0] ?? null, commit_message_validators: validators }, null, 2)],
+      err: []
+    };
+  }
+  const out = [];
+  for (const k of keys) {
+    const r = readings[k];
+    out.push(r.value === null ? `git.${k} \u2014 unknown` : `git.${k} = ${r.value}`);
+    out.push(`  state     ${r.state}`);
+    out.push(`  source    ${r.source ?? "(template default)"}`);
+    const at = read.readAt[k];
+    if (k === "update_strategy" && read.target !== null) {
+      out.push(`  read at   ${_short2(read.target.sha)} \u2014 ${read.target.ref}, the commit this branch is judged against`);
+    } else if (at !== null && at !== void 0) {
+      out.push(`  read at   ${_short2(at)} \u2014 HEAD`);
+    }
+    if (r.reason !== null) out.push(`  \u26A0\uFE0F  ${describeRefusal(r)}`);
+    const cand = read.candidates[k];
+    if (cand !== void 0) {
+      out.push(
+        `  candidate ${cand.value ?? "unknown"} (${cand.state}) from ${cand.source ?? "(template default)"} \u2014 this checkout's value; the value above is in force`
+      );
+      if (cand.reason !== null) out.push(`  \u26A0\uFE0F  candidate only, not in force: ${describeRefusal(cand)}`);
+    }
+  }
+  out.push(`team declaration: ${CARRIER_PATH} at the repository root (ADR-283)`);
+  if (established === false) out.push(NO_CONVENTION);
+  for (const w of warnings) out.push(`\u26A0\uFE0F  ${w}`);
+  if (validators.length === 0) out.push("commit-message validator: none in this repository");
+  for (const v of validators) out.push(`commit-message validator: ${v.kind} at ${v.path} \u2014 also runs at commit time and may be stricter than git.commit_format`);
+  return { code, out, err: [] };
+}
+var APPROVED_CARD = "agents/memory/curated/conventions/approved/commit-subject.md";
+function _flags(args, names) {
+  const values = {};
+  const positional = [];
+  let json = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--json") json = true;
+    else if (a.startsWith("--")) {
+      const v = args[i + 1];
+      if (!names.includes(a.slice(2)) || v === void 0 || v.startsWith("--")) return { values, json, positional, bad: a };
+      values[a.slice(2)] = v;
+      i++;
+    } else positional.push(a);
+  }
+  return { values, json, positional, bad: null };
+}
+function _cardFamily(root) {
+  let text;
+  try {
+    text = fs2.readFileSync(path3.join(root, APPROVED_CARD), "utf-8");
+  } catch {
+    return null;
+  }
+  return /^[ \t]*dominant_family:\s*["']?([a-z-]+)/m.exec(text)?.[1] ?? null;
+}
+function _declares(reading) {
+  if (reading.state !== "valid") return false;
+  return (reading.source ?? "").startsWith(CARRIER_PATH) || reading.value !== conventionDefault("commit_format");
+}
+function _commitlint(cwd) {
+  return commitMessageValidators(cwd).find((v) => v.kind === "commitlint config") ?? null;
+}
+function _established(reading, root) {
+  if (isRefusal(reading.state)) return null;
+  return _declares(reading) || _cardFamily(root) !== null || _commitlint(root) !== null;
+}
+var NO_CONVENTION = "no convention established \u2014 run git:convention measure";
+function _planSubject(values, cwd) {
+  if (values.format !== void 0) {
+    if (!["ticket-scope", "ticket-conventional"].includes(values.format)) return { kind: "stop", code: 1, lines: [`unknown format: ${values.format}`] };
+    return { kind: "rule", rule: { format: values.format }, tier: "passed by the caller", notes: [] };
+  }
+  if (values.family !== void 0) {
+    if (!FAMILY_ERE.some(([f]) => f === values.family)) return { kind: "stop", code: 1, lines: [`no grammar for family: ${values.family}`] };
+    return { kind: "rule", rule: { family: values.family }, tier: "passed by the caller", notes: [] };
+  }
+  const read = readCommittedConvention(cwd, { keys: ["commit_format"] });
+  const reading = read.readings.commit_format;
+  if (isRefusal(reading.state)) return { kind: "stop", code: 1, lines: [describeRefusal(reading)] };
+  const ignored = ignoredCarrierWarning(read.root);
+  const notes = [...ignored === null ? [] : [`\u26A0\uFE0F  ${ignored}`], ...commitMessageValidators(cwd).map(_validatorNote)];
+  if (_declares(reading)) return { kind: "rule", rule: { format: reading.value }, tier: `declared in ${reading.source}`, notes };
+  const family = _cardFamily(read.root);
+  if (family !== null) {
+    if (!FAMILY_ERE.some(([f]) => f === family)) return { kind: "stop", code: 1, lines: [`the approved family ${family} in ${APPROVED_CARD} has no grammar to validate against`] };
+    return { kind: "rule", rule: { family }, tier: `approved in ${APPROVED_CARD}`, notes };
+  }
+  const lint = _commitlint(cwd);
+  if (lint !== null) return { kind: "rule", rule: { format: reading.value ?? "ticket-scope" }, tier: `default (Conventional Commits); the commitlint config at ${lint.path} governs`, notes };
+  return { kind: "rule", rule: { format: reading.value ?? "ticket-scope" }, tier: "default (Conventional Commits)", notes, established: false };
+}
+function _subjectResult(json, code, lines, err = [], extra = {}) {
+  if (!json) return { code, out: lines, err };
+  return { code, out: [JSON.stringify({ ok: code === 0, code, lines, ...extra }, null, 2)], err };
+}
+var NO_SUBJECTS = "no subjects on stdin \u2014 the verb ran; pipe the subjects into it, one per line";
+function subjectCommand(args, cwd, stdin = "") {
+  const f = _flags(args, ["format", "family"]);
+  if (f.bad !== null || f.positional.length > 0) {
+    const why = `unknown argument: ${f.bad ?? f.positional[0]}`;
+    return _subjectResult(f.json, 2, f.json ? [why] : [], [why, USAGE]);
+  }
+  const subjects = stdin.split("\n").map((l) => l.trimEnd()).filter((l) => l !== "");
+  if (subjects.length === 0) return _subjectResult(f.json, 2, f.json ? [NO_SUBJECTS] : [], [NO_SUBJECTS, USAGE]);
+  const plan = _planSubject(f.values, cwd);
+  if (plan.kind === "stop") return _subjectResult(f.json, plan.code, plan.lines);
+  const failures = subjects.map((s) => ({ s, v: checkSubject(s, plan.rule) })).filter((x) => !x.v.ok);
+  const lines = failures.length === 0 ? [`${subjects.length} subject(s) valid under ${ruleName(plan.rule)} (${plan.tier})`, ...plan.notes] : [...failures.map((x) => `\u2717 ${x.s}
+  ${x.v.ok ? "" : x.v.rule}`), ...plan.notes];
+  if (plan.established === false) lines.push(NO_CONVENTION);
+  return _subjectResult(f.json, failures.length === 0 ? 0 : 1, lines, [], {
+    rule: ruleName(plan.rule),
+    tier: plan.tier,
+    notes: plan.notes,
+    convention_established: plan.established === false ? false : plan.tier === "passed by the caller" ? null : true,
+    failures: failures.map((x) => ({ subject: x.s, rule: x.v.ok ? null : x.v.rule }))
+  });
+}
+function _commitlintProposal(cwd) {
+  const v = commitMessageValidators(cwd).find((c) => c.kind === "commitlint config");
+  if (v === void 0) return null;
+  try {
+    const keys = commitlintIssuePrefixes(fs2.readFileSync(v.path, "utf-8"));
+    return keys.length === 0 ? null : { keys, from: v.path };
+  } catch {
+    return null;
+  }
+}
+function ticketCommand(args, cwd) {
+  const f = _flags(args, ["keys"]);
+  if (f.bad !== null || f.positional.length > 1) return { code: 2, out: [], err: [`unknown argument: ${f.bad ?? f.positional[1]}`, USAGE] };
+  const name = f.positional[0] ?? _git2(cwd, "rev-parse", "--abbrev-ref", "HEAD") ?? "";
+  const keys = f.values.keys === void 0 ? null : parseTicketKeys(f.values.keys);
+  const all = ticketCandidates(name, keys);
+  const ticket = all.find((c) => c.status === "ticket")?.token ?? null;
+  const proposal = keys === null ? _commitlintProposal(cwd) : null;
+  if (f.json) return { code: 0, out: [JSON.stringify({ branch: name, ticket, candidates: all, proposal }, null, 2)], err: [] };
+  const out = [`ticket ${ticket ?? "none"}`, ...all.map((c) => `  ${c.token.padEnd(14)} ${c.status}`)];
+  if (proposal !== null) {
+    out.push(`proposal ticket_keys: ${proposal.keys.join(", ")} (issuePrefixes in ${proposal.from}) \u2014 offer it for the convention card; this verb writes nothing`);
+  }
+  return { code: 0, out, err: [] };
+}
+var NO_BRANCH_PATTERN = "no branch_pattern declared \u2014 pass --pattern or declare one";
+function branchCommand(args, cwd) {
+  const f = _flags(args, ["type", "ticket", "slug", "pattern"]);
+  if (f.bad !== null || f.positional.length > 0 || f.values.slug === void 0) {
+    return { code: 2, out: [], err: [f.bad === null && f.positional.length === 0 ? "--slug is required" : `unknown argument: ${f.bad ?? f.positional[0]}`, USAGE] };
+  }
+  let pattern = f.values.pattern;
+  if (pattern === void 0) {
+    const reading = readCommittedConvention(cwd, { keys: ["branch_pattern"] }).readings.branch_pattern;
+    if (isRefusal(reading.state)) return { code: 1, out: [], err: [describeRefusal(reading)] };
+    if (reading.value === null) return { code: 1, out: [], err: [NO_BRANCH_PATTERN] };
+    pattern = reading.value;
+  } else {
+    const why = invalidReason("branch_pattern", pattern);
+    if (why !== null) return { code: 1, out: [], err: [`invalid pattern: ${why}`] };
+  }
+  const r = renderBranch(pattern, { type: f.values.type ?? null, ticket: f.values.ticket ?? null, slug: f.values.slug });
+  if (!r.ok) return { code: 1, out: [], err: [r.reason] };
+  const check = spawnSync4("git", ["check-ref-format", "--branch", r.name], { encoding: "utf8" });
+  if (check.error === void 0 && check.status !== 0) return { code: 1, out: [], err: [`\`${r.name}\` fails git check-ref-format --branch`] };
+  return { code: 0, out: f.json ? [JSON.stringify({ branch: r.name, pattern })] : [r.name], err: [] };
+}
+function cardText(m) {
+  return [
+    "---",
+    `dominant_family: ${m.family}`,
+    `observed_n: ${m.observedN}`,
+    `dominant_share: ${m.share.toFixed(2)}`,
+    `author_count: ${m.authors}`,
+    m.windowExtended === true ? `sample_window: "any age (fewer than ${MIN_N} since ${MEASURE_SINCE}), newest ${MEASURE_LIMIT} non-merge commits"` : `sample_window: "${MEASURE_SINCE}, newest ${MEASURE_LIMIT} non-merge commits"`,
+    `classifier_version: ${CLASSIFIER_VERSION}`,
+    `confirm_against: ${m.trunk}`,
+    "ticket_keys: []",
+    "---",
+    "",
+    `Approved by the user from \`agent-config git:convention measure\`. Re-measure when a tier-1 source appears or the newer half's family changes.`,
+    ""
+  ].join("\n");
+}
+function measureCommand(args, cwd) {
+  const f = _flags(args, ["limit", "family"]);
+  const limit = f.values.limit === void 0 ? MEASURE_LIMIT : Number(f.values.limit);
+  if (f.bad !== null || f.positional.length > 0 || !Number.isInteger(limit) || limit < 1) {
+    return { code: 2, out: [], err: [f.bad === null && f.positional.length === 0 ? `--limit must be a positive integer: ${f.values.limit}` : `unknown argument: ${f.bad ?? f.positional[0]}`, USAGE] };
+  }
+  const chosen = f.values.family;
+  if (chosen !== void 0 && !FAMILY_ERE.some(([fam]) => fam === chosen)) return { code: 2, out: [], err: [`no grammar for family: ${chosen}`, USAGE] };
+  const history = readHistory(cwd, limit);
+  if (history === null) return { code: 1, out: [], err: ["not a git repository"] };
+  if ("unresolved" in history) {
+    const line = `sample    none \u2014 ${history.unresolved}; nothing was sampled and nothing is proposed. Set it with: git remote set-head origin --auto`;
+    return f.json ? { code: 1, out: [JSON.stringify({ classifier_version: CLASSIFIER_VERSION, sample: { trunk: null, limit, since: MEASURE_SINCE, read: 0 }, trunk_unresolved: history.unresolved }, null, 2)], err: [] } : { code: 1, out: [line], err: [] };
+  }
+  const m = measureSubjects(history.commits);
+  const b = measureBranches(history.branches);
+  const u = measureUpdateStyle(history.mergeSubjects, history.defaultBranch);
+  const read = readCommittedConvention(cwd, { keys: ["commit_format"] });
+  const established = _established(read.readings.commit_format, read.root);
+  const lint = _commitlint(cwd);
+  const ignored = ignoredCarrierWarning(read.root);
+  const family = chosen ?? m.established;
+  const share = family === null ? 0 : m.families.find((x) => x.family === family)?.share ?? 0;
+  const team = teamFile(family, b.pattern);
+  const card = family === null ? null : cardText({ family, observedN: m.eligible, share, authors: m.authors, trunk: history.trunk, windowExtended: history.windowExtended });
+  if (f.json) {
+    return {
+      code: 0,
+      out: [JSON.stringify({
+        convention_established: established,
+        commitlint_config: lint?.path ?? null,
+        classifier_version: CLASSIFIER_VERSION,
+        sample: { trunk: history.trunk, limit, since: MEASURE_SINCE, window_extended: history.windowExtended, read: history.commits.length, eligible: m.eligible, excluded: m.excluded, authors: m.authors, capped: m.capped, capped_total: m.cappedTotal },
+        bar: { min_n: MIN_N, share: m.bar },
+        families: m.families,
+        halves: { newer: m.newer, older: m.older, agree: m.halvesAgree },
+        recent: m.recent,
+        verdict: { established: m.established, migrating: m.migrating, migrated_by: m.migratedBy, reasons: m.reasons, strongest: m.strongest },
+        branches: { sampled: b.sampled, pattern: b.pattern, share: b.share, shapes: b.shapes },
+        update_style: { observed: u.observed, base_merges: u.baseMerges, merges: u.merges, adopted: false },
+        chosen: family,
+        team_file: team,
+        card
+      }, null, 2)],
+      err: []
+    };
+  }
+  const out = [
+    ...ignored === null ? [] : [`\u26A0\uFE0F  ${ignored}`],
+    ...lint === null ? [] : [`commitlint: the repository has a commitlint config \u2014 the commitlint config at ${lint.path} governs the subject format; this measurement is advisory`],
+    established === true ? "convention: already established \u2014 a declaration or an approved card is in force; this measurement is advisory" : established === null ? "convention: git.commit_format cannot be read \u2014 see git:convention show" : "convention: none established \u2014 /commit offers the result below once",
+    history.windowExtended ? `sample    fewer than ${MIN_N} since ${MEASURE_SINCE} \u2014 sampled the newest ${history.commits.length} regardless of age on ${history.trunk} \xB7 classifier ${CLASSIFIER_VERSION}` : `sample    ${history.commits.length} commit(s) on ${history.trunk} since ${MEASURE_SINCE} \xB7 classifier ${CLASSIFIER_VERSION}`,
+    `          eligible ${m.eligible} (excluded: bots ${m.excluded.bots}, automation ${m.excluded.automation}, bulk ${m.excluded.bulk}) \xB7 authors ${m.authors}` + (m.capped ? ` \xB7 capped per author per half \u2192 ${m.cappedTotal}` : " \xB7 uncapped (fewer than three authors)"),
+    ...m.families.map((x) => `          ${x.family.padEnd(20)} ${String(x.count).padStart(4)}  ${pct(x.share)}`),
+    `halves    newer ${m.newer.family ?? "\u2014"} ${pct(m.newer.share)} \xB7 older ${m.older.family ?? "\u2014"} ${pct(m.older.share)} \u2014 ${m.halvesAgree ? "agree" : "disagree"}`,
+    m.established !== null ? `verdict   established: ${m.established}${m.migrating ? ` (migrating to ${m.established} \u2014 ${m.migratedBy === "recent-window" ? `the newest ${m.recent.n} commits` : "the newer half"} alone clear the bar)` : ""} \u2014 bar n \u2265 ${MIN_N}, share \u2265 ${pct(m.bar)}` : `verdict   below the bar (${m.reasons.join("; ")}) \u2014 strongest: ${m.strongest.join(", ") || "none with a grammar"}`,
+    b.pattern !== null ? `branches  ${b.sampled} sampled \u2014 proposed branch_pattern "${b.pattern}" (${pct(b.share)})` : `branches  ${b.sampled} sampled \u2014 no clear pattern`,
+    `update    observed ${u.observed} (${u.baseMerges} of ${u.merges} merge(s) bring the default branch into a topic branch) \u2014 shown, never adopted`
+  ];
+  if (team !== null) {
+    out.push(`team file ${chosen === void 0 ? "for the measured result" : `for --family ${chosen}`} \u2014 a human creates and commits ${CARRIER_PATH}, or init --yes creates it on the user's yes; this verb writes nothing:`);
+    out.push(...team.trimEnd().split("\n").map((l) => `  ${l}`));
+  }
+  if (chosen !== void 0 && card !== null) {
+    out.push(`card      for ${APPROVED_CARD}, save the lines below as they are:`);
+    out.push(...card.trimEnd().split("\n"));
+  }
+  return { code: 0, out, err: [] };
+}
+function initCommand(args, cwd) {
+  let yes = false;
+  const rest = [];
+  for (const a of args) {
+    if (a === "--yes") yes = true;
+    else rest.push(a);
+  }
+  const f = _flags(rest, ["commit-format", "branch-pattern"]);
+  if (f.bad !== null || f.positional.length > 0) return { code: 2, out: [], err: [`unknown argument: ${f.bad ?? f.positional[0]}`, USAGE] };
+  const { root, git } = conventionRoot(cwd);
+  if (!git) return { code: 1, out: [], err: ["not a git repository \u2014 the carrier lives at a repository root"] };
+  const existing = [CARRIER_PATH, IGNORED_CARRIER_PATH].find((name) => fs2.existsSync(path3.join(root, name)));
+  if (existing !== void 0) return { code: 1, out: [], err: [`${existing} already exists at ${root} \u2014 init creates the file once and never changes it; nothing was written`] };
+  if (!yes) return { code: 1, out: [], err: ["init writes only on the user's explicit yes this turn \u2014 pass --yes; nothing was written"] };
+  let format = f.values["commit-format"] ?? null;
+  let pattern = f.values["branch-pattern"] ?? null;
+  if (format === null || pattern === null) {
+    const history = readHistory(cwd);
+    if (history !== null && !("unresolved" in history)) {
+      const family = measureSubjects(history.commits).established;
+      if (format === null && family !== null) format = formatForFamily(family);
+      if (pattern === null) pattern = measureBranches(history.branches).pattern;
+    }
+  }
+  for (const [key, value] of [["commit_format", format], ["branch_pattern", pattern]]) {
+    const why = value === null ? null : invalidReason(key, value);
+    if (why !== null) return { code: 1, out: [], err: [`git.${key}: ${why}; nothing was written`] };
+  }
+  if (format === null && pattern === null) {
+    return { code: 1, out: [], err: ["nothing to write \u2014 measure proposes neither a commit_format nor a branch_pattern; pass --commit-format or --branch-pattern"] };
+  }
+  const content = ["git:", ...format === null ? [] : [`  commit_format: ${format}`], ...pattern === null ? [] : [`  branch_pattern: "${pattern}"`], ""].join("\n");
+  try {
+    fs2.writeFileSync(path3.join(root, CARRIER_PATH), content, { flag: "wx" });
+  } catch {
+    return { code: 1, out: [], err: [`${CARRIER_PATH} could not be created at ${root} (it may have appeared meanwhile); nothing was written`] };
+  }
+  return {
+    code: 0,
+    out: [`created ${CARRIER_PATH} at ${root} \u2014 NOT committed; review and commit it:`, ...content.trimEnd().split("\n")],
+    err: []
+  };
+}
+var SUBCOMMANDS = {
+  show: (args, cwd) => showConvention(args, cwd),
+  subject: (args, cwd, stdin) => subjectCommand(args, cwd, stdin),
+  ticket: (args, cwd) => ticketCommand(args, cwd),
+  branch: (args, cwd) => branchCommand(args, cwd),
+  measure: (args, cwd) => measureCommand(args, cwd),
+  init: (args, cwd) => initCommand(args, cwd),
+  // Prints as it runs; a later `--repo` in `args` overrides the directory.
+  sync: (args, cwd) => ({ code: main(["--repo", cwd, ...args]), out: [], err: [] })
+};
+var USAGE = [
+  "usage: agent-config git:convention show [--json] [--base REF] [--key KEY]...   (a pull request passes --base origin/<its base>)",
+  "       agent-config git:convention subject [--format F | --family F] [--json]   (subjects on stdin)",
+  '       agent-config git:convention ticket [BRANCH] [--keys "DEV, OPS"] [--json]',
+  "       agent-config git:convention branch --slug S [--type T] [--ticket K] [--pattern P] [--json]",
+  "       agent-config git:convention measure [--limit N] [--family F] [--json]   (proposes a convention from the history; writes nothing)",
+  "       agent-config git:convention init --yes [--commit-format F] [--branch-pattern P]   (creates .git-convention.yml once, on the user's yes; never overwrites, never commits)",
+  "       agent-config git:convention sync [--base REF] [--dry-run] [--auto-resolve-generated] [--quiet]   (without --base: the default branch)"
+].join("\n");
+function runGitConvention(argv, cwd, stdin) {
+  const [sub, ...rest] = argv;
+  if (sub === "-h" || sub === "--help") return { code: 0, out: [USAGE], err: [] };
+  const handler = sub === void 0 ? void 0 : SUBCOMMANDS[sub];
+  if (handler === void 0) {
+    return { code: 2, out: [], err: [sub === void 0 ? USAGE : `unknown subcommand: ${sub}`, ...sub === void 0 ? [] : [USAGE]] };
+  }
+  return handler(rest, cwd, stdin);
+}
+async function _stdin() {
+  if (process2.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process2.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function main2(argv = process2.argv.slice(2)) {
+  const result = runGitConvention(argv, process2.cwd(), argv[0] === "subject" ? await _stdin() : void 0);
+  for (const line of result.out) process2.stdout.write(`${line}
+`);
+  for (const line of result.err) process2.stderr.write(`${line}
+`);
+  return result.code;
+}
+function _isCliEntry2() {
+  if (process2.argv[1] === void 0) return false;
+  if (import.meta.url === pathToFileURL2(path3.resolve(process2.argv[1])).href) return true;
+  try {
+    return fs2.realpathSync(fileURLToPath2(import.meta.url)) === fs2.realpathSync(path3.resolve(process2.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry2()) {
+  process2.exitCode = await main2();
+}
+export {
+  APPROVED_CARD,
+  NO_BRANCH_PATTERN,
+  NO_CONVENTION,
+  NO_SUBJECTS,
+  SUBCOMMANDS,
+  branchCommand,
+  cardText,
+  commitMessageValidator,
+  commitMessageValidators,
+  initCommand,
+  main2 as main,
+  measureCommand,
+  runGitConvention,
+  showConvention,
+  subjectCommand,
+  ticketCommand
+};