@sideboard-ai/core 0.1.9

package/dist/chunk-LL7DTZ5B.js

@@ -0,0 +1,1282 @@
+import {
+  listThreads
+} from "./chunk-HYRHI3QU.js";
+import {
+  worktreesRoot
+} from "./chunk-M37RITA6.js";
+import {
+  gh,
+  git
+} from "./chunk-AJ6ROGD7.js";
+
+// src/git/worktree.ts
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+
+// src/git/teams.ts
+var FAMOUS_SOCCER_TEAMS = [
+  { name: "Aalborg", slug: "aalborg" },
+  { name: "Aalesund", slug: "aalesund" },
+  { name: "Aarhus", slug: "aarhus" },
+  { name: "Aberdeen", slug: "aberdeen" },
+  { name: "AC Milan", slug: "ac-milan" },
+  { name: "ADO Den Haag", slug: "ado-den-haag" },
+  { name: "AIK", slug: "aik" },
+  { name: "Ajaccio", slug: "ajaccio" },
+  { name: "Ajax", slug: "ajax" },
+  { name: "Al Ahly", slug: "al-ahly" },
+  { name: "Al Hilal", slug: "al-hilal" },
+  { name: "Alajuelense", slug: "alajuelense" },
+  { name: "Almere City", slug: "almere-city" },
+  { name: "Amiens", slug: "amiens" },
+  { name: "Angers", slug: "angers" },
+  { name: "Anyang", slug: "anyang" },
+  { name: "Argentinos Juniors", slug: "argentinos-juniors" },
+  { name: "Arsenal", slug: "arsenal" },
+  { name: "Aston Villa", slug: "aston-villa" },
+  { name: "Athletico Paranaense", slug: "athletico-paranaense" },
+  { name: "Atlanta United", slug: "atlanta-united" },
+  { name: "Atlas", slug: "atlas" },
+  { name: "Atl\xE9tico Madrid", slug: "atletico-madrid" },
+  { name: "Atl\xE9tico Mineiro", slug: "atletico-mineiro" },
+  { name: "Atl\xE9tico San Luis", slug: "atletico-san-luis" },
+  { name: "Augsburg", slug: "augsburg" },
+  { name: "Austin FC", slug: "austin-fc" },
+  { name: "Auxerre", slug: "auxerre" },
+  { name: "Avispa Fukuoka", slug: "avispa-fukuoka" },
+  { name: "AZ Alkmaar", slug: "az" },
+  { name: "Bahia", slug: "bahia" },
+  { name: "Banfield", slug: "banfield" },
+  { name: "Barcelona", slug: "barcelona" },
+  { name: "Bayer Leverkusen", slug: "bayer-leverkusen" },
+  { name: "Bayern Munich", slug: "bayern-munich" },
+  { name: "Belgrano", slug: "belgrano" },
+  { name: "Benfica", slug: "benfica" },
+  { name: "Birmingham Legion", slug: "birmingham-legion" },
+  { name: "Boca Juniors", slug: "boca-juniors" },
+  { name: "Bod\xF8/Glimt", slug: "bodo-glimt" },
+  { name: "Bordeaux", slug: "bordeaux" },
+  { name: "Borussia Dortmund", slug: "borussia-dortmund" },
+  { name: "Botafogo", slug: "botafogo" },
+  { name: "Bragantino", slug: "bragantino" },
+  { name: "Brann", slug: "brann" },
+  { name: "Brest", slug: "brest" },
+  { name: "Brommapojkarna", slug: "brommapojkarna" },
+  { name: "Br\xF8ndby", slug: "brondby" },
+  { name: "Brooklyn FC", slug: "brooklyn-fc" },
+  { name: "Bucheon", slug: "bucheon" },
+  { name: "Caen", slug: "caen" },
+  { name: "Cambuur", slug: "cambuur" },
+  { name: "Carmelita", slug: "carmelita" },
+  { name: "Cartagin\xE9s", slug: "cartagines" },
+  { name: "Cear\xE1", slug: "ceara" },
+  { name: "Celtic", slug: "celtic" },
+  { name: "Central C\xF3rdoba", slug: "central-cordoba" },
+  { name: "Cerezo Osaka", slug: "cerezo-osaka" },
+  { name: "CF Montr\xE9al", slug: "cf-montreal" },
+  { name: "Charleston Battery", slug: "charleston-battery" },
+  { name: "Charlotte FC", slug: "charlotte-fc" },
+  { name: "Chelsea", slug: "chelsea" },
+  { name: "Chicago Fire", slug: "chicago-fire" },
+  { name: "Chivas", slug: "chivas" },
+  { name: "Clermont", slug: "clermont" },
+  { name: "Club Am\xE9rica", slug: "club-america" },
+  { name: "Cologne", slug: "cologne" },
+  { name: "Colorado Rapids", slug: "colorado-rapids" },
+  { name: "Columbus Crew", slug: "columbus-crew" },
+  { name: "Corinthians", slug: "corinthians" },
+  { name: "Cruz Azul", slug: "cruz-azul" },
+  { name: "Cruzeiro", slug: "cruzeiro" },
+  { name: "Daejeon", slug: "daejeon" },
+  { name: "DC United", slug: "dc-united" },
+  { name: "Defensa y Justicia", slug: "defensa-y-justicia" },
+  { name: "Degerfors", slug: "degerfors" },
+  { name: "Detroit City", slug: "detroit-city" },
+  { name: "Dijon", slug: "dijon" },
+  { name: "Djurg\xE5rden", slug: "djurgarden" },
+  { name: "Dundee", slug: "dundee" },
+  { name: "Dundee United", slug: "dundee-united" },
+  { name: "Dynamo Kyiv", slug: "dynamo-kyiv" },
+  { name: "Eintracht Frankfurt", slug: "eintracht-frankfurt" },
+  { name: "El Paso Locomotive", slug: "el-paso-locomotive" },
+  { name: "Elfsborg", slug: "elfsborg" },
+  { name: "Emmen", slug: "emmen" },
+  { name: "Esbjerg", slug: "esbjerg" },
+  { name: "Estudiantes", slug: "estudiantes" },
+  { name: "Everton", slug: "everton" },
+  { name: "Excelsior", slug: "excelsior" },
+  { name: "Fagiano Okayama", slug: "fagiano-okayama" },
+  { name: "Falkirk", slug: "falkirk" },
+  { name: "FC Cincinnati", slug: "fc-cincinnati" },
+  { name: "FC Copenhagen", slug: "fc-copenhagen" },
+  { name: "FC Dallas", slug: "fc-dallas" },
+  { name: "FC Seoul", slug: "fc-seoul" },
+  { name: "FC Tokyo", slug: "fc-tokyo" },
+  { name: "FC Tulsa", slug: "fc-tulsa" },
+  { name: "Feyenoord", slug: "feyenoord" },
+  { name: "Flamengo", slug: "flamengo" },
+  { name: "Fluminense", slug: "fluminense" },
+  { name: "Fortaleza", slug: "fortaleza" },
+  { name: "Fortuna Sittard", slug: "fortuna-sittard" },
+  { name: "Fredrikstad", slug: "fredrikstad" },
+  { name: "Freiburg", slug: "freiburg" },
+  { name: "GAIS", slug: "gais" },
+  { name: "Galatasaray", slug: "galatasaray" },
+  { name: "Gamba Osaka", slug: "gamba-osaka" },
+  { name: "Gangwon", slug: "gangwon" },
+  { name: "Gimcheon Sangmu", slug: "gimcheon-sangmu" },
+  { name: "Gimnasia", slug: "gimnasia" },
+  { name: "Gladbach", slug: "gladbach" },
+  { name: "Go Ahead Eagles", slug: "go-ahead-eagles" },
+  { name: "Godoy Cruz", slug: "godoy-cruz" },
+  { name: "Gr\xEAmio", slug: "gremio" },
+  { name: "Groningen", slug: "groningen" },
+  { name: "Guadalupe", slug: "guadalupe" },
+  { name: "Guanacasteca", slug: "guanacasteca" },
+  { name: "Guingamp", slug: "guingamp" },
+  { name: "Gwangju", slug: "gwangju" },
+  { name: "H\xE4cken", slug: "hacken" },
+  { name: "Halmstad", slug: "halmstad" },
+  { name: "Hamburg", slug: "hamburg" },
+  { name: "Hammarby", slug: "hammarby" },
+  { name: "Hartford Athletic", slug: "hartford-athletic" },
+  { name: "Haugesund", slug: "haugesund" },
+  { name: "Hearts", slug: "hearts" },
+  { name: "Heerenveen", slug: "heerenveen" },
+  { name: "Heidenheim", slug: "heidenheim" },
+  { name: "Helsingborg", slug: "helsingborg" },
+  { name: "Heracles", slug: "heracles" },
+  { name: "Herediano", slug: "herediano" },
+  { name: "Hibernian", slug: "hibernian" },
+  { name: "Hoffenheim", slug: "hoffenheim" },
+  { name: "Horsens", slug: "horsens" },
+  { name: "Houston Dynamo", slug: "houston-dynamo" },
+  { name: "Hurac\xE1n", slug: "huracan" },
+  { name: "IFK G\xF6teborg", slug: "ifk-goteborg" },
+  { name: "IFK Norrk\xF6ping", slug: "norrkoping" },
+  { name: "Incheon United", slug: "incheon-united" },
+  { name: "Independiente", slug: "independiente" },
+  { name: "Indy Eleven", slug: "indy-eleven" },
+  { name: "Instituto", slug: "instituto" },
+  { name: "Inter Miami", slug: "inter-miami" },
+  { name: "Inter Milan", slug: "inter-milan" },
+  { name: "Internacional", slug: "internacional" },
+  { name: "JEF United", slug: "jef-united" },
+  { name: "Jeju SK", slug: "jeju-sk" },
+  { name: "Jeonbuk", slug: "jeonbuk" },
+  { name: "Ju\xE1rez", slug: "juarez" },
+  { name: "Juventude", slug: "juventude" },
+  { name: "Juventus", slug: "juventus" },
+  { name: "Kalmar FF", slug: "kalmar" },
+  { name: "Kashima Antlers", slug: "kashima-antlers" },
+  { name: "Kashiwa Reysol", slug: "kashiwa-reysol" },
+  { name: "Kawasaki Frontale", slug: "kawasaki-frontale" },
+  { name: "KFUM Oslo", slug: "kfum-oslo" },
+  { name: "Kilmarnock", slug: "kilmarnock" },
+  { name: "Kristiansund", slug: "kristiansund" },
+  { name: "Kyoto Sanga", slug: "kyoto-sanga" },
+  { name: "LA Galaxy", slug: "la-galaxy" },
+  { name: "LAFC", slug: "lafc" },
+  { name: "Lan\xFAs", slug: "lanus" },
+  { name: "Las Vegas Lights", slug: "las-vegas-lights" },
+  { name: "Lazio", slug: "lazio" },
+  { name: "Le Havre", slug: "le-havre" },
+  { name: "Le Mans", slug: "le-mans" },
+  { name: "Leeds United", slug: "leeds-united" },
+  { name: "Leicester City", slug: "leicester-city" },
+  { name: "Lens", slug: "lens" },
+  { name: "Le\xF3n", slug: "leon" },
+  { name: "Lexington SC", slug: "lexington-sc" },
+  { name: "Liberia", slug: "liberia" },
+  { name: "Lille", slug: "lille" },
+  { name: "Lillestr\xF8m", slug: "lillestrom" },
+  { name: "Lim\xF3n", slug: "limon" },
+  { name: "Liverpool", slug: "liverpool" },
+  { name: "Livingston", slug: "livingston" },
+  { name: "Lorient", slug: "lorient" },
+  { name: "Loudoun United", slug: "loudoun-united" },
+  { name: "Louisville City", slug: "louisville-city" },
+  { name: "Lyngby", slug: "lyngby" },
+  { name: "Lyon", slug: "lyon" },
+  { name: "Machida Zelvia", slug: "machida-zelvia" },
+  { name: "Mainz", slug: "mainz" },
+  { name: "Malm\xF6 FF", slug: "malmo" },
+  { name: "Manchester City", slug: "manchester-city" },
+  { name: "Manchester United", slug: "manchester-united" },
+  { name: "Marseille", slug: "marseille" },
+  { name: "Mazatl\xE1n", slug: "mazatlan" },
+  { name: "Metz", slug: "metz" },
+  { name: "Miami FC", slug: "miami-fc" },
+  { name: "Midtjylland", slug: "midtjylland" },
+  { name: "Minnesota United", slug: "minnesota-united" },
+  { name: "Mirassol", slug: "mirassol" },
+  { name: "Mito Hollyhock", slug: "mito-hollyhock" },
+  { name: "Mj\xE4llby", slug: "mjallby" },
+  { name: "Molde", slug: "molde" },
+  { name: "Monaco", slug: "monaco" },
+  { name: "Monterey Bay", slug: "monterey-bay" },
+  { name: "Monterrey", slug: "monterrey" },
+  { name: "Montpellier", slug: "montpellier" },
+  { name: "Motherwell", slug: "motherwell" },
+  { name: "Municipal Grecia", slug: "grecia" },
+  { name: "NAC Breda", slug: "nac-breda" },
+  { name: "Nagoya Grampus", slug: "nagoya-grampus" },
+  { name: "Nancy", slug: "nancy" },
+  { name: "Nantes", slug: "nantes" },
+  { name: "Napoli", slug: "napoli" },
+  { name: "Nashville SC", slug: "nashville-sc" },
+  { name: "NEC Nijmegen", slug: "nec" },
+  { name: "Necaxa", slug: "necaxa" },
+  { name: "New England", slug: "new-england" },
+  { name: "New Mexico United", slug: "new-mexico-united" },
+  { name: "Newcastle", slug: "newcastle" },
+  { name: "Newell's Old Boys", slug: "newells" },
+  { name: "Nice", slug: "nice" },
+  { name: "N\xEEmes", slug: "nimes" },
+  { name: "Nordsj\xE6lland", slug: "nordsjaelland" },
+  { name: "NY Red Bulls", slug: "ny-red-bulls" },
+  { name: "NYCFC", slug: "nycfc" },
+  { name: "Oakland Roots", slug: "oakland-roots" },
+  { name: "OB Odense", slug: "ob-odense" },
+  { name: "Odd", slug: "odd" },
+  { name: "Olympiacos", slug: "olympiacos" },
+  { name: "Orange County SC", slug: "orange-county-sc" },
+  { name: "\xD6rebro", slug: "orebro" },
+  { name: "Orlando City", slug: "orlando-city" },
+  { name: "Pachuca", slug: "pachuca" },
+  { name: "Palmeiras", slug: "palmeiras" },
+  { name: "Paris FC", slug: "paris-fc" },
+  { name: "Paris Saint-Germain", slug: "psg" },
+  { name: "PEC Zwolle", slug: "pec-zwolle" },
+  { name: "P\xE9rez Zeled\xF3n", slug: "perez-zeledon" },
+  { name: "Philadelphia Union", slug: "philadelphia-union" },
+  { name: "Phoenix Rising", slug: "phoenix-rising" },
+  { name: "Pittsburgh Riverhounds", slug: "pittsburgh-riverhounds" },
+  { name: "Platense", slug: "platense" },
+  { name: "Pohang Steelers", slug: "pohang-steelers" },
+  { name: "Portland Timbers", slug: "portland-timbers" },
+  { name: "Porto", slug: "porto" },
+  { name: "PSV", slug: "psv" },
+  { name: "Puebla", slug: "puebla" },
+  { name: "Pumas", slug: "pumas" },
+  { name: "Puntarenas", slug: "puntarenas" },
+  { name: "Quer\xE9taro", slug: "queretaro" },
+  { name: "Racing", slug: "racing" },
+  { name: "Randers", slug: "randers" },
+  { name: "Rangers", slug: "rangers" },
+  { name: "RB Leipzig", slug: "rb-leipzig" },
+  { name: "Real Madrid", slug: "real-madrid" },
+  { name: "Real Salt Lake", slug: "real-salt-lake" },
+  { name: "Red Star Belgrade", slug: "red-star" },
+  { name: "Reims", slug: "reims" },
+  { name: "Rennes", slug: "rennes" },
+  { name: "Rhode Island FC", slug: "rhode-island-fc" },
+  { name: "River Plate", slug: "river-plate" },
+  { name: "RKC Waalwijk", slug: "rkc" },
+  { name: "Roma", slug: "roma" },
+  { name: "Rosario Central", slug: "rosario-central" },
+  { name: "Rosenborg", slug: "rosenborg" },
+  { name: "Sacramento Republic", slug: "sacramento-republic" },
+  { name: "Saint-\xC9tienne", slug: "saint-etienne" },
+  { name: "San Antonio FC", slug: "san-antonio-fc" },
+  { name: "San Carlos", slug: "san-carlos" },
+  { name: "San Diego FC", slug: "san-diego-fc" },
+  { name: "San Jose Earthquakes", slug: "san-jose-earthquakes" },
+  { name: "San Lorenzo", slug: "san-lorenzo" },
+  { name: "Sanfrecce Hiroshima", slug: "sanfrecce-hiroshima" },
+  { name: "Santos", slug: "santos" },
+  { name: "Santos de Gu\xE1piles", slug: "santos-guapiles" },
+  { name: "Santos Laguna", slug: "santos-laguna" },
+  { name: "S\xE3o Paulo", slug: "sao-paulo" },
+  { name: "Saprissa", slug: "saprissa" },
+  { name: "Sarpsborg", slug: "sarpsborg" },
+  { name: "Schalke", slug: "schalke" },
+  { name: "Seattle Sounders", slug: "seattle-sounders" },
+  { name: "Sevilla", slug: "sevilla" },
+  { name: "Shakhtar", slug: "shakhtar" },
+  { name: "Shimizu S-Pulse", slug: "shimizu-s-pulse" },
+  { name: "Silkeborg", slug: "silkeborg" },
+  { name: "Sirius", slug: "sirius" },
+  { name: "Sochaux", slug: "sochaux" },
+  { name: "S\xF8nderjyske", slug: "sonderjyske" },
+  { name: "Sparta Rotterdam", slug: "sparta-rotterdam" },
+  { name: "Sport Recife", slug: "sport-recife" },
+  { name: "Sporting", slug: "sporting" },
+  { name: "Sporting Jax", slug: "sporting-jax" },
+  { name: "Sporting KC", slug: "sporting-kc" },
+  { name: "Sporting San Jos\xE9", slug: "sporting-san-jose" },
+  { name: "St Mirren", slug: "st-mirren" },
+  { name: "St. Louis City", slug: "st-louis-city" },
+  { name: "St. Pauli", slug: "st-pauli" },
+  { name: "Stab\xE6k", slug: "stabaek" },
+  { name: "Strasbourg", slug: "strasbourg" },
+  { name: "Str\xF8msgodset", slug: "stromsgodset" },
+  { name: "Stuttgart", slug: "stuttgart" },
+  { name: "Switchbacks", slug: "switchbacks" },
+  { name: "Talleres", slug: "talleres" },
+  { name: "Tampa Bay Rowdies", slug: "tampa-bay-rowdies" },
+  { name: "Tigre", slug: "tigre" },
+  { name: "Tigres", slug: "tigres" },
+  { name: "Tijuana", slug: "tijuana" },
+  { name: "Tokyo Verdy", slug: "tokyo-verdy" },
+  { name: "Toluca", slug: "toluca" },
+  { name: "Toronto FC", slug: "toronto-fc" },
+  { name: "Tottenham", slug: "tottenham" },
+  { name: "Toulouse", slug: "toulouse" },
+  { name: "Troms\xF8", slug: "tromso" },
+  { name: "Troyes", slug: "troyes" },
+  { name: "Twente", slug: "twente" },
+  { name: "Ulsan HD", slug: "ulsan-hd" },
+  { name: "Uni\xF3n", slug: "union" },
+  { name: "Union Berlin", slug: "union-berlin" },
+  { name: "Urawa Reds", slug: "urawa-reds" },
+  { name: "Utrecht", slug: "utrecht" },
+  { name: "V-Varen Nagasaki", slug: "v-varen-nagasaki" },
+  { name: "Valencia", slug: "valencia" },
+  { name: "V\xE5lerenga", slug: "valerenga" },
+  { name: "Vancouver Whitecaps", slug: "vancouver-whitecaps" },
+  { name: "V\xE4rnamo", slug: "varnamo" },
+  { name: "Vasco da Gama", slug: "vasco" },
+  { name: "Vejle", slug: "vejle" },
+  { name: "V\xE9lez Sarsfield", slug: "velez" },
+  { name: "Viborg", slug: "viborg" },
+  { name: "Viking", slug: "viking" },
+  { name: "Vissel Kobe", slug: "vissel-kobe" },
+  { name: "Vitesse", slug: "vitesse" },
+  { name: "Vit\xF3ria", slug: "vitoria" },
+  { name: "Volendam", slug: "volendam" },
+  { name: "Werder Bremen", slug: "werder-bremen" },
+  { name: "West Ham", slug: "west-ham" },
+  { name: "Willem II", slug: "willem-ii" },
+  { name: "Wolfsburg", slug: "wolfsburg" },
+  { name: "Yokohama Marinos", slug: "yokohama-marinos" }
+];
+function teamNameFromSlug(slug) {
+  const normalized = slug.toLowerCase().replace(/^thread\//, "");
+  const suffixMatch = normalized.match(/^(.+)-(\d+)$/);
+  const base = suffixMatch?.[1] ?? normalized;
+  const suffix = suffixMatch?.[2];
+  const team = FAMOUS_SOCCER_TEAMS.find((t) => t.slug === base);
+  if (team) return suffix ? `${team.name} ${suffix}` : team.name;
+  return normalized.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function teamSlugFromName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) return null;
+  const suffixMatch = trimmed.match(/^(.+?)\s+(\d+)$/);
+  const baseName = suffixMatch?.[1] ?? trimmed;
+  const suffix = suffixMatch?.[2];
+  const team = FAMOUS_SOCCER_TEAMS.find(
+    (t) => t.name.toLowerCase() === baseName.toLowerCase()
+  );
+  if (!team) return null;
+  return suffix ? `${team.slug}-${suffix}` : team.slug;
+}
+function normalizeTakenSlug(raw) {
+  return raw.toLowerCase().replace(/^thread\//, "").replace(/\/+$/, "");
+}
+function takenSlugsFromThread(thread) {
+  const out = /* @__PURE__ */ new Set();
+  const titleSlug = thread.title ? teamSlugFromName(thread.title) : null;
+  if (titleSlug) out.add(normalizeTakenSlug(titleSlug));
+  if (thread.branchName?.trim()) {
+    const branch = normalizeTakenSlug(thread.branchName.trim());
+    if (branch) out.add(branch);
+  }
+  if (thread.worktreePath) {
+    const parts = thread.worktreePath.replace(/\/+$/, "").split("/");
+    const dir = parts[parts.length - 1];
+    if (dir) out.add(normalizeTakenSlug(dir));
+  }
+  return [...out];
+}
+function allocateTeamName(taken, random = Math.random) {
+  const takenSet = new Set(
+    [...taken].map((s) => normalizeTakenSlug(s)).filter(Boolean)
+  );
+  const available = FAMOUS_SOCCER_TEAMS.filter((t) => !takenSet.has(t.slug));
+  if (available.length > 0) {
+    const idx = Math.floor(random() * available.length);
+    return available[idx];
+  }
+  for (let n = 2; n < 1e3; n++) {
+    for (const t of FAMOUS_SOCCER_TEAMS) {
+      const slug = `${t.slug}-${n}`;
+      if (!takenSet.has(slug)) {
+        return { name: `${t.name} ${n}`, slug };
+      }
+    }
+  }
+  throw new Error("No available soccer team names left");
+}
+
+// src/git/worktree-labels.ts
+function normalizeWorktreePath(worktreePath) {
+  const trimmed = worktreePath.replace(/\/+$/, "") || "/";
+  const absolute = trimmed.startsWith("/");
+  const parts = trimmed.split("/").filter((p) => p && p !== ".");
+  const out = [];
+  for (const p of parts) {
+    if (p === "..") {
+      out.pop();
+      continue;
+    }
+    out.push(p);
+  }
+  return (absolute ? "/" : "") + out.join("/");
+}
+function worktreeNameFromPath(worktreePath) {
+  const normalized = worktreePath.replace(/\/+$/, "");
+  const parts = normalized.split("/");
+  return parts[parts.length - 1] || worktreePath;
+}
+function isPlaceholderBranch(branchName, worktreePath) {
+  const branch = branchName.trim();
+  if (!branch || branch === "HEAD") return true;
+  if (branch.startsWith("thread/")) return true;
+  const dir = worktreeNameFromPath(worktreePath).toLowerCase();
+  return branch.toLowerCase() === dir;
+}
+function branchDisplayLabel(branchName, worktreePath) {
+  const dir = worktreeNameFromPath(worktreePath);
+  if (isPlaceholderBranch(branchName, worktreePath)) {
+    const slug = branchName.replace(/^thread\//, "") || dir;
+    return teamNameFromSlug(slug);
+  }
+  return branchName.trim();
+}
+function threadDisplayLabel(thread) {
+  if (thread.userSetTitle && thread.title?.trim()) return thread.title.trim();
+  if (thread.prTitle?.trim()) return thread.prTitle.trim();
+  return branchDisplayLabel(thread.branchName, thread.worktreePath);
+}
+function worktreeDisplayLabel(thread) {
+  return threadDisplayLabel(thread);
+}
+function worktreeDisplayLabelForGroup(threads) {
+  if (threads.length === 0) return "Worktree";
+  const canonical = [...threads].sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
+  return threadDisplayLabel(canonical);
+}
+
+// src/git/pr-gates.ts
+function buildMergeGateChecks(gate, opts = {}) {
+  const rows = [];
+  const base = gate.baseRefName?.trim() || "the base branch";
+  const link = gate.url?.trim() || null;
+  const mergeable = (gate.mergeable ?? "").toUpperCase();
+  const mergeState = (gate.mergeStateStatus ?? "").toUpperCase();
+  const review = (gate.reviewDecision ?? "").toUpperCase();
+  const suppressBlocked = opts.suppressGenericBlocked !== false;
+  const conflicting = mergeable === "CONFLICTING" || mergeState === "DIRTY";
+  if (conflicting) {
+    rows.push({
+      name: "Merge conflicts",
+      state: mergeable === "CONFLICTING" ? "CONFLICTING" : mergeState || "DIRTY",
+      bucket: "fail",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: `This branch has conflicts that must be resolved before it can merge into ${base}.`,
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  } else if (mergeState === "BEHIND") {
+    rows.push({
+      name: "Branch behind",
+      state: "BEHIND",
+      bucket: "fail",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: `Head is behind ${base}. Update this branch (merge or rebase) before merging.`,
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  } else if (mergeState === "BLOCKED" && !suppressBlocked) {
+    rows.push({
+      name: "Merge blocked",
+      state: "BLOCKED",
+      bucket: "fail",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: "GitHub reports this PR as blocked (branch protection \u2014 required reviews and/or status checks).",
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  } else if (mergeable === "UNKNOWN" || mergeState === "UNKNOWN") {
+    rows.push({
+      name: "Mergeability",
+      state: "UNKNOWN",
+      bucket: "pending",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: "GitHub is still computing whether this branch can merge.",
+      workflow: "mergeability",
+      kind: "mergeability"
+    });
+  }
+  if (review === "CHANGES_REQUESTED") {
+    rows.push({
+      name: "Code review",
+      state: "CHANGES_REQUESTED",
+      bucket: "fail",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: "A reviewer requested changes. Address their feedback before merging.",
+      workflow: "review",
+      kind: "review"
+    });
+  } else if (review === "REVIEW_REQUIRED") {
+    rows.push({
+      name: "Code review",
+      state: "REVIEW_REQUIRED",
+      bucket: "pending",
+      startedAt: null,
+      completedAt: null,
+      link,
+      description: "A required approving review is still outstanding.",
+      workflow: "review",
+      kind: "review"
+    });
+  }
+  return rows;
+}
+
+// src/git/worktree.ts
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+async function resolveRepoRoot(cwd) {
+  const { stdout } = await git(["rev-parse", "--show-toplevel"], cwd);
+  return stdout.trim();
+}
+function parseGithubSlugFromRemoteUrl(url) {
+  const trimmed = url.trim();
+  const match = trimmed.match(/github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/i) ?? trimmed.match(/github\.com[:/]([^/]+)\/([^/.]+)/i);
+  if (!match?.[1] || !match[2]) return null;
+  return `${match[1]}/${match[2]}`;
+}
+async function slugFromGitRemote(repoPath, remote) {
+  const result = await git(["remote", "get-url", remote], repoPath, {
+    reject: false
+  });
+  if (result.exitCode !== 0 || !result.stdout.trim()) return null;
+  return parseGithubSlugFromRemoteUrl(result.stdout);
+}
+async function resolveGithubRepoSlug(repoPath) {
+  const fromOrigin = await slugFromGitRemote(repoPath, "origin");
+  if (fromOrigin) return fromOrigin;
+  const viaGh = await gh(
+    ["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"],
+    repoPath,
+    { reject: false }
+  );
+  if (viaGh.exitCode === 0 && viaGh.stdout.trim()) {
+    return viaGh.stdout.trim();
+  }
+  for (const remote of ["upstream", "github"]) {
+    const slug = await slugFromGitRemote(repoPath, remote);
+    if (slug) return slug;
+  }
+  return null;
+}
+async function resolveDefaultBranch(repoPath) {
+  const viaGh = await gh(
+    ["repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"],
+    repoPath,
+    { reject: false }
+  );
+  if (viaGh.exitCode === 0 && viaGh.stdout.trim()) {
+    return viaGh.stdout.trim();
+  }
+  const viaOrigin = await git(
+    ["symbolic-ref", "refs/remotes/origin/HEAD"],
+    repoPath,
+    { reject: false }
+  );
+  if (viaOrigin.exitCode === 0 && viaOrigin.stdout.trim()) {
+    return viaOrigin.stdout.trim().replace(/^refs\/remotes\/origin\//, "");
+  }
+  for (const candidate of ["main", "master"]) {
+    const check = await git(
+      ["show-ref", "--verify", "--quiet", `refs/heads/${candidate}`],
+      repoPath,
+      { reject: false }
+    );
+    if (check.exitCode === 0) return candidate;
+  }
+  return "main";
+}
+async function resolveDiffBaseRef(cwd, branchOrRef, fallbackCwd) {
+  const ref = branchOrRef.trim();
+  if (!ref) return ref;
+  if (ref.startsWith("origin/") || ref.startsWith("refs/")) return ref;
+  if (ref.includes("/")) return ref;
+  const remote = `origin/${ref}`;
+  for (const dir of [cwd, fallbackCwd].filter(Boolean)) {
+    const ok = await git(["rev-parse", "--verify", remote], dir, { reject: false });
+    if (ok.exitCode === 0) return remote;
+  }
+  return ref;
+}
+async function listBranches(repoPath, opts) {
+  const { stdout } = await git(
+    ["for-each-ref", "--format=%(refname:short)|%(HEAD)|%(upstream:short)", "refs/heads", "refs/remotes"],
+    repoPath
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const branches = [];
+  for (const line of stdout.split("\n").filter(Boolean)) {
+    const [name, head] = line.split("|");
+    if (!name || name.endsWith("/HEAD")) continue;
+    const remote = name.startsWith("origin/");
+    const short = remote ? name.replace(/^origin\//, "") : name;
+    if (seen.has(short) && !remote) continue;
+    if (!seen.has(short)) {
+      seen.add(short);
+      branches.push({ name: short, remote, current: head === "*" });
+    }
+  }
+  const sorted = branches.sort((a, b) => a.name.localeCompare(b.name));
+  if (!opts?.unmergedOnly) return sorted;
+  const defaultBranch = await resolveDefaultBranch(repoPath);
+  const originDefault = `origin/${defaultBranch}`;
+  const originCheck = await git(
+    ["rev-parse", "--verify", "--quiet", originDefault],
+    repoPath,
+    { reject: false }
+  );
+  const mergeBase = originCheck.exitCode === 0 ? originDefault : defaultBranch;
+  const noMerged = await git(
+    [
+      "for-each-ref",
+      `--no-merged=${mergeBase}`,
+      "--format=%(refname:short)",
+      "refs/heads",
+      "refs/remotes/origin"
+    ],
+    repoPath,
+    { reject: false }
+  );
+  const keep = /* @__PURE__ */ new Set();
+  keep.add(defaultBranch);
+  for (const line of noMerged.stdout.split("\n").filter(Boolean)) {
+    const short = line.startsWith("origin/") ? line.replace(/^origin\//, "") : line;
+    if (short && short !== "HEAD") keep.add(short);
+  }
+  return sorted.filter((b) => keep.has(b.name));
+}
+async function listPrs(repoPath) {
+  const slug = await resolveGithubRepoSlug(repoPath);
+  const args = [
+    "pr",
+    "list",
+    "--json",
+    "number,title,headRefName,url,isCrossRepository",
+    "--limit",
+    "50"
+  ];
+  if (slug) args.push("--repo", slug);
+  const { stdout, exitCode } = await gh(args, repoPath, { reject: false });
+  if (exitCode !== 0 || !stdout.trim()) return [];
+  return JSON.parse(stdout);
+}
+async function getPr(repoPath, number) {
+  const slug = await resolveGithubRepoSlug(repoPath);
+  const args = [
+    "pr",
+    "view",
+    String(number),
+    "--json",
+    "number,title,headRefName,url,isCrossRepository"
+  ];
+  if (slug) args.push("--repo", slug);
+  const { stdout, exitCode } = await gh(args, repoPath, { reject: false });
+  if (exitCode !== 0 || !stdout.trim()) return null;
+  return JSON.parse(stdout);
+}
+function resolvePrSelector(thread) {
+  if (thread.prUrl?.trim()) return thread.prUrl.trim();
+  if (thread.sourceType === "pr" && thread.sourceRef?.trim()) {
+    return thread.sourceRef.replace(/^#/, "").trim();
+  }
+  if (thread.branchName?.trim()) return thread.branchName.trim();
+  return null;
+}
+function normalizeGhTime(value) {
+  if (typeof value !== "string" || !value.trim()) return null;
+  if (value.startsWith("0001-01-01")) return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? value : null;
+}
+function normalizeCheck(raw) {
+  return {
+    name: String(raw.name ?? "check"),
+    state: String(raw.state ?? ""),
+    bucket: String(raw.bucket ?? "pending"),
+    startedAt: normalizeGhTime(raw.startedAt),
+    completedAt: normalizeGhTime(raw.completedAt),
+    link: typeof raw.link === "string" && raw.link ? raw.link : null,
+    description: typeof raw.description === "string" && raw.description ? raw.description : null,
+    workflow: typeof raw.workflow === "string" && raw.workflow ? raw.workflow : null,
+    kind: "ci"
+  };
+}
+async function fetchPrMergeGate(cwd, selector, slug) {
+  const args = [
+    "pr",
+    "view",
+    selector,
+    "--json",
+    "mergeable,mergeStateStatus,reviewDecision,baseRefName,url"
+  ];
+  if (slug) args.push("--repo", slug);
+  const { stdout, exitCode, stderr } = await gh(args, cwd, { reject: false });
+  if (exitCode !== 0 || !stdout.trim()) {
+    if (/no pull requests found/i.test(stderr)) return null;
+    return null;
+  }
+  try {
+    const view = JSON.parse(stdout);
+    return {
+      mergeable: typeof view.mergeable === "string" && view.mergeable ? view.mergeable : null,
+      mergeStateStatus: typeof view.mergeStateStatus === "string" && view.mergeStateStatus ? view.mergeStateStatus : null,
+      reviewDecision: typeof view.reviewDecision === "string" && view.reviewDecision ? view.reviewDecision : null,
+      baseRefName: typeof view.baseRefName === "string" && view.baseRefName ? view.baseRefName : null,
+      url: typeof view.url === "string" && view.url ? view.url : null
+    };
+  } catch {
+    return null;
+  }
+}
+async function detectLocalMergeConflicts(cwd, baseRefName) {
+  const baseName = (baseRefName?.trim() || await resolveDefaultBranch(cwd)).replace(
+    /^origin\//,
+    ""
+  );
+  const baseRef = await resolveDiffBaseRef(cwd, baseName);
+  await git(["fetch", "origin", baseName], cwd, { reject: false });
+  const result = await git(
+    ["merge-tree", "--write-tree", "--name-only", baseRef, "HEAD"],
+    cwd,
+    { reject: false }
+  );
+  const out = `${result.stdout}
+${result.stderr}`;
+  const conflicting = result.exitCode !== 0 || /\bCONFLICT\b/i.test(out);
+  const files = conflicting ? [
+    ...new Set(
+      out.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("merge-tree:") && !/\bCONFLICT\b/i.test(l))
+    )
+  ].slice(0, 20) : [];
+  return { conflicting, base: baseName, files };
+}
+async function getPrChecks(cwd, selector) {
+  const slug = await resolveGithubRepoSlug(cwd);
+  const args = [
+    "pr",
+    "checks",
+    selector,
+    "--json",
+    "name,state,bucket,startedAt,completedAt,link,description,workflow"
+  ];
+  if (slug) args.push("--repo", slug);
+  const { stdout, exitCode, stderr } = await gh(args, cwd, { reject: false });
+  const errText = stderr.trim();
+  let ciChecks;
+  if (!stdout.trim()) {
+    if (/no pull requests found/i.test(errText)) return null;
+    if (/auth|login|HTTP\s*401|credentials|token/i.test(errText)) {
+      throw new Error(errText);
+    }
+    if (exitCode === 0 || exitCode === 1 || exitCode === 8) {
+      if (exitCode === 1 && errText && !/fail|check/i.test(errText)) {
+        throw new Error(errText);
+      }
+      ciChecks = [];
+    } else {
+      throw new Error(errText || `gh pr checks failed (${exitCode})`);
+    }
+  } else {
+    try {
+      const parsed = JSON.parse(stdout);
+      ciChecks = parsed.map(normalizeCheck);
+    } catch {
+      throw new Error(errText || "gh pr checks returned invalid JSON");
+    }
+  }
+  let gate = await fetchPrMergeGate(cwd, selector, slug);
+  const mergeable = (gate?.mergeable ?? "").toUpperCase();
+  const mergeState = (gate?.mergeStateStatus ?? "").toUpperCase();
+  const alreadyConflicting = mergeable === "CONFLICTING" || mergeState === "DIRTY";
+  const needsLocalProbe = !alreadyConflicting;
+  if (needsLocalProbe) {
+    try {
+      const local = await detectLocalMergeConflicts(cwd, gate?.baseRefName ?? null);
+      if (local.conflicting) {
+        const fileHint = local.files.length > 0 ? ` Conflicting paths: ${local.files.slice(0, 8).join(", ")}${local.files.length > 8 ? "\u2026" : ""}.` : "";
+        gate = {
+          mergeable: "CONFLICTING",
+          mergeStateStatus: "DIRTY",
+          reviewDecision: gate?.reviewDecision ?? null,
+          baseRefName: local.base,
+          url: gate?.url ?? null
+        };
+        const ciFailed2 = ciChecks.some((c) => c.bucket === "fail");
+        const review2 = (gate.reviewDecision ?? "").toUpperCase();
+        const hasReviewRow2 = review2 === "CHANGES_REQUESTED" || review2 === "REVIEW_REQUIRED";
+        const gateRows2 = buildMergeGateChecks(gate, {
+          suppressGenericBlocked: ciFailed2 || hasReviewRow2
+        }).map(
+          (row) => row.kind === "mergeability" && row.name === "Merge conflicts" ? {
+            ...row,
+            description: `${row.description ?? ""}${fileHint}`.trim()
+          } : row
+        );
+        return [...gateRows2, ...ciChecks];
+      }
+      if (gate && (mergeable === "UNKNOWN" || mergeState === "UNKNOWN")) {
+        gate = {
+          ...gate,
+          mergeable: gate.mergeable === "UNKNOWN" ? "MERGEABLE" : gate.mergeable,
+          mergeStateStatus: gate.mergeStateStatus === "UNKNOWN" ? "CLEAN" : gate.mergeStateStatus
+        };
+      }
+    } catch {
+    }
+  }
+  if (!gate) {
+    return ciChecks;
+  }
+  const ciFailed = ciChecks.some((c) => c.bucket === "fail");
+  const review = (gate.reviewDecision ?? "").toUpperCase();
+  const hasReviewRow = review === "CHANGES_REQUESTED" || review === "REVIEW_REQUIRED";
+  const gateRows = buildMergeGateChecks(gate, {
+    // Avoid duplicating "blocked" when CI failures or review rows already explain it.
+    suppressGenericBlocked: ciFailed || hasReviewRow
+  });
+  return [...gateRows, ...ciChecks];
+}
+async function getPrDetails(cwd, selector) {
+  const slug = await resolveGithubRepoSlug(cwd);
+  const viewArgs = [
+    "pr",
+    "view",
+    selector,
+    "--json",
+    [
+      "number",
+      "title",
+      "body",
+      "url",
+      "state",
+      "isDraft",
+      "reviewDecision",
+      "author",
+      "baseRefName",
+      "headRefName",
+      "additions",
+      "deletions",
+      "changedFiles",
+      "commits",
+      "comments",
+      "reviews"
+    ].join(",")
+  ];
+  if (slug) viewArgs.push("--repo", slug);
+  const { stdout, exitCode, stderr } = await gh(viewArgs, cwd, { reject: false });
+  if (exitCode !== 0 || !stdout.trim()) {
+    if (stderr.trim()) {
+      if (/no pull requests found/i.test(stderr)) return null;
+    }
+    return null;
+  }
+  let view;
+  try {
+    view = JSON.parse(stdout);
+  } catch {
+    throw new Error(stderr.trim() || "gh pr view returned invalid JSON");
+  }
+  let checks = [];
+  try {
+    checks = await getPrChecks(cwd, selector) ?? [];
+  } catch {
+    checks = [];
+  }
+  const author = view.author ?? {};
+  const commits = Array.isArray(view.commits) ? view.commits : [];
+  const comments = Array.isArray(view.comments) ? view.comments : [];
+  const reviews = Array.isArray(view.reviews) ? view.reviews : [];
+  return {
+    number: Number(view.number),
+    title: String(view.title ?? ""),
+    body: String(view.body ?? ""),
+    url: String(view.url ?? ""),
+    state: String(view.state ?? ""),
+    isDraft: Boolean(view.isDraft),
+    reviewDecision: typeof view.reviewDecision === "string" && view.reviewDecision ? view.reviewDecision : null,
+    author: { login: author.login ?? "unknown", name: author.name ?? null },
+    baseRefName: String(view.baseRefName ?? ""),
+    headRefName: String(view.headRefName ?? ""),
+    additions: Number(view.additions ?? 0),
+    deletions: Number(view.deletions ?? 0),
+    changedFiles: Number(view.changedFiles ?? 0),
+    commits: commits.map((c) => {
+      const row = c;
+      const authors = Array.isArray(row.authors) ? row.authors.map((a) => {
+        const actor = a;
+        return { login: actor.login ?? "unknown", name: actor.name ?? null };
+      }) : [];
+      return {
+        oid: String(row.oid ?? ""),
+        messageHeadline: String(row.messageHeadline ?? ""),
+        committedDate: String(row.committedDate ?? ""),
+        authors
+      };
+    }),
+    comments: comments.map((c) => {
+      const row = c;
+      const a = row.author ?? {};
+      return {
+        author: { login: a.login ?? "unknown" },
+        body: String(row.body ?? ""),
+        createdAt: String(row.createdAt ?? "")
+      };
+    }),
+    reviews: reviews.map((r) => {
+      const row = r;
+      const a = row.author ?? {};
+      return {
+        author: { login: a.login ?? "unknown" },
+        state: String(row.state ?? ""),
+        body: String(row.body ?? ""),
+        submittedAt: normalizeGhTime(row.submittedAt)
+      };
+    }),
+    checks
+  };
+}
+async function fetchPrHead(repoPath, number, localBranch) {
+  await git(
+    ["fetch", "origin", `pull/${number}/head:${localBranch}`],
+    repoPath,
+    { reject: false }
+  );
+}
+async function resolveWorktreeStartPoint(repoPath, sourceRef) {
+  const ref = sourceRef.trim();
+  if (!ref) throw new Error("sourceRef is required");
+  if (ref.startsWith("origin/") || ref.startsWith("refs/")) {
+    const ok = await git(["rev-parse", "--verify", ref], repoPath, {
+      reject: false
+    });
+    if (ok.exitCode === 0) return ref;
+  }
+  const remote = `origin/${ref}`;
+  const remoteOk = await git(["rev-parse", "--verify", remote], repoPath, {
+    reject: false
+  });
+  if (remoteOk.exitCode === 0) return remote;
+  const localOk = await git(["rev-parse", "--verify", ref], repoPath, {
+    reject: false
+  });
+  if (localOk.exitCode === 0) return ref;
+  return ref;
+}
+async function createThreadWorktree(opts) {
+  let branchName = `thread/${opts.slug}`;
+  const worktreePath = join(worktreesRoot(opts.repoPath), opts.slug);
+  if (existsSync(worktreePath)) {
+    throw new Error(`Worktree already exists at ${worktreePath}`);
+  }
+  await git(["fetch", "origin", "--prune"], opts.repoPath, { reject: false });
+  if (!opts.sourceRef.startsWith("origin/") && !opts.sourceRef.startsWith("refs/")) {
+    await git(["fetch", "origin", opts.sourceRef], opts.repoPath, {
+      reject: false
+    });
+  }
+  const startPoint = await resolveWorktreeStartPoint(
+    opts.repoPath,
+    opts.sourceRef
+  );
+  const add = await git(
+    ["worktree", "add", "-b", branchName, worktreePath, startPoint],
+    opts.repoPath,
+    { reject: false }
+  );
+  if (add.exitCode !== 0) {
+    const err = `${add.stderr}
+${add.stdout}`;
+    if (/already used by worktree|already exists|checked out/i.test(err)) {
+      for (let n = 2; n <= 20; n++) {
+        const alt = `${branchName}-${n}`;
+        const retry = await git(
+          ["worktree", "add", "-b", alt, worktreePath, startPoint],
+          opts.repoPath,
+          { reject: false }
+        );
+        if (retry.exitCode === 0) {
+          branchName = alt;
+          return { branchName, worktreePath };
+        }
+      }
+    }
+    throw new Error(
+      `Failed to create worktree: ${add.stderr.trim() || add.stdout.trim() || `exit ${add.exitCode}`}`
+    );
+  }
+  return { branchName, worktreePath };
+}
+async function removeWorktree(repoPath, worktreePath, opts) {
+  await git(["worktree", "remove", "--force", worktreePath], repoPath, {
+    reject: false
+  });
+  if (opts?.deleteBranch) {
+    await git(["branch", "-D", opts.deleteBranch], repoPath, { reject: false });
+  }
+}
+async function listWorktrees(repoPath) {
+  const { stdout } = await git(
+    ["worktree", "list", "--porcelain"],
+    repoPath,
+    { reject: false }
+  );
+  if (!stdout.trim()) return [];
+  const entries = [];
+  let current = null;
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current) entries.push(current);
+      current = { path: line.slice("worktree ".length), branch: null };
+    } else if (line.startsWith("branch ") && current) {
+      current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+    }
+  }
+  if (current) entries.push(current);
+  return entries;
+}
+async function isDirty(worktreePath) {
+  const { stdout } = await git(["status", "--porcelain"], worktreePath);
+  return stdout.trim().length > 0;
+}
+async function currentBranch(worktreePath) {
+  const { stdout } = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath);
+  return stdout.trim();
+}
+async function commitAll(worktreePath, message) {
+  const dirty = await isDirty(worktreePath);
+  if (!dirty) return false;
+  await git(["add", "-A"], worktreePath);
+  await git(["commit", "-m", message], worktreePath);
+  return true;
+}
+async function pushBranch(worktreePath, branchName) {
+  await git(["push", "-u", "origin", branchName], worktreePath);
+}
+async function mergePr(cwd, selector, opts) {
+  const slug = await resolveGithubRepoSlug(cwd);
+  const viewArgs = ["pr", "view", selector, "--json", "url,state,isDraft"];
+  if (slug) viewArgs.push("--repo", slug);
+  const before = await gh(viewArgs, cwd, { reject: false });
+  if (before.exitCode !== 0 || !before.stdout.trim()) {
+    throw new Error(before.stderr.trim() || "Could not load pull request");
+  }
+  let url = "";
+  let isDraft = false;
+  try {
+    const parsed = JSON.parse(before.stdout);
+    url = String(parsed.url ?? "");
+    isDraft = Boolean(parsed.isDraft);
+    if (String(parsed.state ?? "").toUpperCase() === "MERGED") {
+      return { url, state: "MERGED" };
+    }
+  } catch {
+    throw new Error("Could not parse pull request details");
+  }
+  if (isDraft) {
+    const readyArgs = ["pr", "ready", selector];
+    if (slug) readyArgs.push("--repo", slug);
+    const ready = await gh(readyArgs, cwd, { reject: false });
+    if (ready.exitCode !== 0) {
+      throw new Error(
+        ready.stderr.trim() || ready.stdout.trim() || "Could not mark draft pull request as ready"
+      );
+    }
+  }
+  const method = opts?.method ?? "squash";
+  const mergeFlag = method === "rebase" ? "--rebase" : method === "merge" ? "--merge" : "--squash";
+  const args = ["pr", "merge", selector, mergeFlag, "--delete-branch=false"];
+  if (slug) args.push("--repo", slug);
+  const { exitCode, stderr, stdout } = await gh(args, cwd, { reject: false });
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || "gh pr merge failed");
+  }
+  const after = await gh(viewArgs, cwd, { reject: false });
+  if (after.exitCode === 0 && after.stdout.trim()) {
+    try {
+      const parsed = JSON.parse(after.stdout);
+      return {
+        url: String(parsed.url ?? url),
+        state: String(parsed.state ?? "MERGED")
+      };
+    } catch {
+    }
+  }
+  return { url, state: "MERGED" };
+}
+async function createOrUpdatePr(worktreePath, opts) {
+  const existing = await gh(
+    ["pr", "view", opts.head, "--json", "url", "--jq", ".url"],
+    worktreePath,
+    { reject: false }
+  );
+  if (existing.exitCode === 0 && existing.stdout.trim() && !opts.web) {
+    const url2 = existing.stdout.trim();
+    await gh(
+      [
+        "pr",
+        "edit",
+        opts.head,
+        "--title",
+        opts.title,
+        "--body",
+        opts.body ?? opts.title
+      ],
+      worktreePath,
+      { reject: false }
+    );
+    return url2;
+  }
+  if (opts.web) {
+    const args2 = [
+      "pr",
+      "create",
+      "--web",
+      "--title",
+      opts.title,
+      "--body",
+      opts.body ?? opts.title,
+      "--base",
+      opts.base,
+      "--head",
+      opts.head
+    ];
+    if (opts.draft) args2.push("--draft");
+    await gh(args2, worktreePath, { reject: false });
+    const again = await gh(
+      ["pr", "view", opts.head, "--json", "url", "--jq", ".url"],
+      worktreePath,
+      { reject: false }
+    );
+    return again.stdout.trim() || "";
+  }
+  const args = [
+    "pr",
+    "create",
+    "--title",
+    opts.title,
+    "--body",
+    opts.body ?? opts.title,
+    "--base",
+    opts.base,
+    "--head",
+    opts.head
+  ];
+  if (opts.draft) args.push("--draft");
+  const { stdout } = await gh(args, worktreePath);
+  const url = stdout.trim().split("\n").find((l) => l.startsWith("http")) ?? stdout.trim();
+  return url;
+}
+function suggestSlug(source) {
+  const base = slugify(source || "thread");
+  const stamp = Date.now().toString(36).slice(-4);
+  return `${base || "thread"}-${stamp}`;
+}
+function sameRepoPath(a, b) {
+  return normalizeWorktreePath(a) === normalizeWorktreePath(b);
+}
+function listLocalThreadBranchSlugs(repoPath) {
+  const refsDir = join(repoPath, ".git", "refs", "heads", "thread");
+  if (!existsSync(refsDir)) return [];
+  try {
+    return readdirSync(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
+  } catch {
+    return [];
+  }
+}
+function collectTakenTeamSlugs(repoPath) {
+  const taken = /* @__PURE__ */ new Set();
+  const root = worktreesRoot(repoPath);
+  if (existsSync(root)) {
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name !== ".DS_Store") {
+        taken.add(normalizeTakenSlug(entry.name));
+      }
+    }
+  }
+  for (const slug of listLocalThreadBranchSlugs(repoPath)) {
+    taken.add(slug);
+  }
+  for (const thread of listThreads({ includeArchived: true })) {
+    if (!sameRepoPath(thread.repoPath, repoPath)) continue;
+    for (const slug of takenSlugsFromThread(thread)) {
+      taken.add(slug);
+    }
+  }
+  return taken;
+}
+function allocateTeamSlug(repoPath) {
+  const taken = collectTakenTeamSlugs(repoPath);
+  for (let attempt = 0; attempt < 32; attempt++) {
+    const team = allocateTeamName(taken);
+    const path = join(worktreesRoot(repoPath), team.slug);
+    if (!existsSync(path)) return team;
+    taken.add(team.slug);
+  }
+  throw new Error("No available soccer team worktree directories left");
+}
+
+export {
+  FAMOUS_SOCCER_TEAMS,
+  teamSlugFromName,
+  takenSlugsFromThread,
+  allocateTeamName,
+  normalizeWorktreePath,
+  worktreeNameFromPath,
+  isPlaceholderBranch,
+  branchDisplayLabel,
+  threadDisplayLabel,
+  worktreeDisplayLabel,
+  worktreeDisplayLabelForGroup,
+  slugify,
+  resolveRepoRoot,
+  parseGithubSlugFromRemoteUrl,
+  resolveGithubRepoSlug,
+  resolveDefaultBranch,
+  resolveDiffBaseRef,
+  listBranches,
+  listPrs,
+  getPr,
+  resolvePrSelector,
+  detectLocalMergeConflicts,
+  getPrChecks,
+  getPrDetails,
+  fetchPrHead,
+  resolveWorktreeStartPoint,
+  createThreadWorktree,
+  removeWorktree,
+  listWorktrees,
+  isDirty,
+  currentBranch,
+  commitAll,
+  pushBranch,
+  mergePr,
+  createOrUpdatePr,
+  suggestSlug,
+  collectTakenTeamSlugs,
+  allocateTeamSlug
+};