@sideboard-ai/core 0.1.320 → 0.1.321

package/dist/{chunk-PNLGWAYE.js → chunk-YWBLQBSN.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-N2WW62LF.js";
 import {
   ensureWorktreeSideboardIgnored
-} from "./chunk-DD67JWTN.js";
+} from "./chunk-4YXZOXMT.js";
 import {
   gh,
   git,
@@ -14,8 +14,9 @@ import {
   githubCredentialHelperGitConfig,
   githubGhConfigEnv,
   materializeGithubAgentAuth,
+  originCli,
   resolveGhAuthToken
-} from "./chunk-2UG25RMK.js";
+} from "./chunk-YBTSZ2SW.js";
 import {
   getGithubGitAuthMode,
   getGithubPat
@@ -26,15 +27,13 @@ import {
   normalizeTakenSlug,
   normalizeWorktreePath,
   takenSlugsFromThread
-} from "./chunk-XMHMVEIY.js";
+} from "./chunk-B4CDSSRN.js";
 import {
   worktreesRoot
 } from "./chunk-WOU343SI.js";
 
 // src/git/worktree.ts
-import { randomBytes } from "crypto";
-import { existsSync as existsSync2, realpathSync, unlinkSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
+import { existsSync as existsSync2, realpathSync } from "fs";
 import { join as join2 } from "path";
 
 // src/git/gh-errors.ts
@@ -139,9 +138,9 @@ var HTTPS_REWRITE = [
   { key: "url.https://github.com/.insteadOf", value: "git@github.com:" },
   { key: "url.https://github.com/.insteadOf", value: "ssh://git@github.com/" }
 ];
-function githubHttpsInsteadOfEntries(remoteUrl) {
+function githubHttpsInsteadOfEntries(remoteUrl2) {
   const entries = [...HTTPS_REWRITE];
-  const url = remoteUrl?.trim() ?? "";
+  const url = remoteUrl2?.trim() ?? "";
   const scpAlias = url.match(/^(git@github\.com-[^:]+):/i);
   if (scpAlias?.[1]) {
     entries.push({
@@ -334,6 +333,53 @@ function formatGitAuthModeDirective(mode) {
   }
 }
 
+// src/git/remote-forge.ts
+function formatRemoteTag(remote) {
+  const name = remote.forge === "other" ? remote.host : remote.forge;
+  return `${name}:${remote.slug}`;
+}
+function forgeForHost(host) {
+  const h = host.toLowerCase();
+  if (h === "github.com" || h.startsWith("github.com-")) return "github";
+  if (h === "origin.cursor.com") return "cursor";
+  if (h === "entire.io" || h.endsWith(".entire.io") || h === "entire.com" || h.endsWith(".entire.com")) {
+    return "entire";
+  }
+  return "other";
+}
+function repoFromParts(host, owner, name) {
+  if (!host || !owner || !name || owner.includes("@")) return null;
+  const normalized = host.toLowerCase();
+  return {
+    forge: forgeForHost(normalized),
+    host: normalized,
+    slug: `${owner}/${name}`
+  };
+}
+function parseRemoteRepo(url) {
+  const trimmed = url.trim().replace(/\.git$/i, "");
+  if (!trimmed) return null;
+  if (trimmed.toLowerCase().startsWith("entire://")) {
+    const parts = trimmed.slice("entire://".length).replace(/^\/+/, "").split("/").filter(Boolean);
+    if (parts.length === 2) return { forge: "entire", host: "entire.io", slug: `${parts[0]}/${parts[1]}` };
+    if (parts.length >= 3) {
+      return repoFromParts(parts[0], parts[1], parts[2]);
+    }
+    return null;
+  }
+  const ssh = trimmed.match(/^git@([^:]+):([^/]+)\/([^/]+)$/i);
+  if (ssh?.[1] && ssh[2] && ssh[3]) return repoFromParts(ssh[1], ssh[2], ssh[3]);
+  try {
+    const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+    const parsed = new URL(withScheme);
+    const parts = parsed.pathname.split("/").filter(Boolean);
+    if (parts.length < 2) return null;
+    return repoFromParts(parsed.hostname, parts[parts.length - 2], parts[parts.length - 1]);
+  } catch {
+    return null;
+  }
+}
+
 // src/git/list-prs.ts
 var PR_LIST_JSON_FIELDS = [
   "number",
@@ -695,30 +741,6 @@ async function listGithubViewerTeamSlugs(repoPath) {
   return slugs;
 }
 
-// src/util/enqueue-by-key.ts
-var tails = /* @__PURE__ */ new Map();
-function enqueueByKey(key, fn) {
-  const prev = tails.get(key) ?? Promise.resolve();
-  const next = prev.then(fn, fn);
-  tails.set(
-    key,
-    next.then(
-      () => void 0,
-      () => void 0
-    )
-  );
-  return next;
-}
-
-// src/git/repo-git-lock.ts
-function repoLockKey(repoPath) {
-  const trimmed = repoPath.replace(/\/+$/, "");
-  return `git-worktree:${trimmed || "/"}`;
-}
-function withRepoGitLock(repoPath, fn) {
-  return enqueueByKey(repoLockKey(repoPath), fn);
-}
-
 // src/git/pr-gates.ts
 function prIsInMergeQueue(gate) {
   if (gate.isInMergeQueue) return true;
@@ -846,6 +868,359 @@ function buildMergeGateChecks(gate, opts = {}) {
   return rows;
 }
 
+// src/git/cursor-pr.ts
+var PLAIN_LIST_FIELDS = "number,title,headRefName,url,author,state,isDraft,reviewDecision";
+var SEARCH_LIST_FIELDS = `${PLAIN_LIST_FIELDS},labels,reviewRequests`;
+var VIEW_FIELDS = "number,title,body,url,state,isDraft,reviewDecision,author,createdAt,baseRefName,headRefName,additions,deletions,changedFiles,commits,comments,reviews,labels,mergeability";
+function repoArgs(slug) {
+  return ["-R", slug];
+}
+function cursorHeadBranch(head, slug) {
+  const branch = head.trim().replace(/^refs\/heads\//, "");
+  const owner = slug.split("/")[0];
+  if (owner && branch.startsWith(`${owner}:`)) return branch.slice(owner.length + 1);
+  return branch;
+}
+function cursorMergeFields(value) {
+  if (typeof value === "string" && value.trim()) {
+    const upper = value.trim().toUpperCase();
+    return { mergeable: upper, mergeStateStatus: upper };
+  }
+  if (value && typeof value === "object") {
+    const row = value;
+    const conflictState = String(row.mergeConflictState ?? "").trim().toUpperCase();
+    if ("hasMergeConflicts" in row || conflictState) {
+      if (conflictState.includes("PENDING")) {
+        return { mergeable: "UNKNOWN", mergeStateStatus: "UNKNOWN" };
+      }
+      const conflicting = row.hasMergeConflicts === true || conflictState.includes("CONFLICT") && !conflictState.includes("CLEAN");
+      if (conflicting) return { mergeable: "CONFLICTING", mergeStateStatus: "DIRTY" };
+      if (row.hasMergeConflicts === false || conflictState.includes("CLEAN")) {
+        return { mergeable: "MERGEABLE", mergeStateStatus: "CLEAN" };
+      }
+    }
+    const verdict = String(row.verdict ?? row.verdictKind ?? "").trim().toUpperCase();
+    if (verdict === "BLOCKED") return { mergeable: null, mergeStateStatus: "BLOCKED" };
+    if (verdict === "MERGEABLE") return { mergeable: "MERGEABLE", mergeStateStatus: "CLEAN" };
+    const status = String(row.status ?? row.state ?? row.mergeable ?? "").trim().toUpperCase();
+    return { mergeable: status || null, mergeStateStatus: status || null };
+  }
+  return { mergeable: null, mergeStateStatus: null };
+}
+function cursorReviewDecision(value) {
+  const raw = typeof value === "string" ? value.trim().toUpperCase().replace(/[\s-]+/g, "_") : "";
+  if (!raw) return null;
+  if (raw === "REQUIRED" || raw === "REVIEW_REQUIRED") return "REVIEW_REQUIRED";
+  if (raw === "CHANGES_REQUESTED") return "CHANGES_REQUESTED";
+  if (raw === "APPROVED") return "APPROVED";
+  return raw;
+}
+function cursorViewToPrMeta(view) {
+  const merge = cursorMergeFields(view.mergeability ?? view.mergeable);
+  const author = view.author ?? {};
+  return {
+    number: Number(view.number),
+    title: String(view.title ?? ""),
+    url: String(view.url ?? ""),
+    state: String(view.state ?? ""),
+    isDraft: Boolean(view.isDraft),
+    reviewDecision: cursorReviewDecision(view.reviewDecision),
+    baseRefName: String(view.baseRefName ?? ""),
+    headRefName: String(view.headRefName ?? ""),
+    isInMergeQueue: false,
+    mergeable: merge.mergeable,
+    mergeStateStatus: merge.mergeStateStatus,
+    authorLogin: author.login?.trim() || null,
+    reviewerLogins: [],
+    labels: labelNames(view.labels)
+  };
+}
+function loginOf(author) {
+  if (!author || typeof author !== "object") return "";
+  const row = author;
+  for (const key of ["login", "handle", "email", "displayName", "name", "id"]) {
+    const value = row[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+function upperState(value, isDraft) {
+  const raw = typeof value === "string" ? value.trim().toUpperCase() : "";
+  if (raw === "DRAFT") return "OPEN";
+  if (raw === "OPEN" || raw === "CLOSED" || raw === "MERGED") return raw;
+  return isDraft ? "OPEN" : raw;
+}
+function normalizeOriginPr(raw) {
+  const isDraft = raw.isDraft === true || String(raw.status ?? raw.state ?? "").toLowerCase() === "draft";
+  const login = loginOf(raw.author);
+  const author = raw.author && typeof raw.author === "object" ? { ...raw.author, login: login || "unknown" } : login ? { login } : { login: "unknown" };
+  return {
+    ...raw,
+    isDraft,
+    state: upperState(raw.state ?? raw.status, isDraft),
+    author,
+    body: raw.body ?? raw.description ?? "",
+    isCrossRepository: false,
+    reviewDecision: cursorReviewDecision(raw.reviewDecision),
+    reviewRequests: originReviewRequests(raw.reviewRequests)
+  };
+}
+function originReviewRequests(raw) {
+  if (!Array.isArray(raw)) return raw;
+  return raw.map(originReviewer).filter((row) => row != null);
+}
+function originReviewer(raw) {
+  if (typeof raw === "string" && raw.trim()) return { login: raw.trim() };
+  if (!raw || typeof raw !== "object") return null;
+  const row = raw;
+  if (typeof row.login === "string" && row.login.trim()) return row;
+  const kind = String(row.kind ?? row.__typename ?? "").toLowerCase();
+  const slug = typeof row.slug === "string" ? row.slug.trim() : "";
+  const name = typeof row.name === "string" ? row.name.trim() : "";
+  const id = typeof row.id === "string" ? row.id.trim() : "";
+  if (kind.includes("team") || kind.includes("group") || slug.includes("/") && !row.login) {
+    return { __typename: "Team", slug: slug || name, name };
+  }
+  if (kind.includes("service") || kind.includes("bot")) {
+    const login2 = name || id || "cursor-bot";
+    return { __typename: "Bot", login: login2.toLowerCase().endsWith("[bot]") ? login2 : `${login2}[bot]` };
+  }
+  const login = name || id;
+  return login ? { login } : null;
+}
+function originChecksToRuns(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return [];
+  }
+  const rows = Array.isArray(parsed) ? parsed : [];
+  return rows.map((row) => {
+    const item = row ?? {};
+    const conclusion = typeof item.conclusion === "string" ? item.conclusion.toLowerCase() : "";
+    const status = typeof item.status === "string" ? item.status.toLowerCase() : "";
+    const bucket = conclusion === "success" || conclusion === "neutral" ? "pass" : conclusion === "failure" || conclusion === "timed_out" || conclusion === "action_required" ? "fail" : conclusion === "cancelled" ? "cancel" : conclusion === "skipped" ? "skipping" : "pending";
+    const state = conclusion || status || "pending";
+    const link = typeof item.link === "string" ? item.link : typeof item.detailsUrl === "string" ? item.detailsUrl : null;
+    const description = typeof item.summary === "string" ? item.summary : typeof item.description === "string" ? item.description : null;
+    return {
+      name: String(item.name ?? "check"),
+      state,
+      bucket,
+      startedAt: typeof item.startedAt === "string" ? item.startedAt : null,
+      completedAt: typeof item.completedAt === "string" ? item.completedAt : null,
+      link,
+      description,
+      workflow: typeof item.group === "string" ? item.group : null,
+      kind: "ci"
+    };
+  });
+}
+function listedHasLabels(pr, labels) {
+  if (labels.length === 0) return true;
+  const have = new Set((pr.labels ?? []).map((name) => name.toLowerCase()));
+  return labels.every((label) => have.has(label.toLowerCase()));
+}
+async function listCursorPrs(repoPath, slug, opts, head) {
+  const resolved = resolveListPrsOptions(opts);
+  const limit = Math.max(1, Math.min(250, resolved.limit ?? 200));
+  const fetchLimit = prListFetchLimit(limit, resolved.reviewer);
+  const useSearch = resolved.labels.length > 0 || Boolean(resolved.reviewer) || Boolean(resolved.query);
+  const state = resolved.draft === true ? "draft" : resolved.state;
+  const args = [
+    "pr",
+    "list",
+    ...repoArgs(slug),
+    "--state",
+    state,
+    "--limit",
+    String(fetchLimit),
+    "--json",
+    useSearch ? SEARCH_LIST_FIELDS : PLAIN_LIST_FIELDS
+  ];
+  if (head?.trim()) args.push("--head", head.trim());
+  if (useSearch) {
+    for (const label of resolved.labels) args.push("--label", label);
+    if (resolved.query) args.push("--search", resolved.query);
+    else if (resolved.labels.length === 0) {
+      const token = state === "all" ? "is:open OR is:closed OR is:merged" : `is:${state}`;
+      args.push("--search", token);
+    }
+  }
+  const { stdout, exitCode } = await originCli(args, repoPath, { reject: false, timeoutMs: 2e4 });
+  if (exitCode !== 0 || !stdout.trim()) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const normalized = parsed.filter((row) => row && typeof row === "object").map((row) => normalizeOriginPr(row));
+  const listed = applyPrListResponse(JSON.stringify(normalized), { ...opts, limit: void 0 });
+  return listed.filter((pr) => listedHasLabels(pr, resolved.labels)).slice(0, limit);
+}
+async function viewCursorPr(repoPath, slug, selector, fields) {
+  const { stdout, exitCode } = await originCli(
+    ["pr", "view", selector, ...repoArgs(slug), "--json", fields],
+    repoPath,
+    { reject: false, timeoutMs: 2e4 }
+  );
+  if (exitCode !== 0 || !stdout.trim()) return null;
+  try {
+    const parsed = JSON.parse(stdout);
+    return normalizeOriginPr(parsed);
+  } catch {
+    return null;
+  }
+}
+var CURSOR_PR_VIEW_FIELDS = VIEW_FIELDS;
+async function createOrUpdateCursorPr(repoPath, slug, opts) {
+  const branch = cursorHeadBranch(opts.head, slug);
+  const existing = await originCli(
+    ["pr", "view", branch, ...repoArgs(slug), "--json", "url"],
+    repoPath,
+    { reject: false, timeoutMs: 2e4 }
+  );
+  if (existing.exitCode === 0 && existing.stdout.trim()) {
+    let url2 = "";
+    try {
+      url2 = String(JSON.parse(existing.stdout).url ?? "");
+    } catch {
+      url2 = "";
+    }
+    if (url2) {
+      await originCli(
+        ["pr", "edit", branch, ...repoArgs(slug), "--title", opts.title, "-F", opts.bodyFile],
+        repoPath,
+        { reject: false, timeoutMs: 2e4 }
+      );
+      return url2;
+    }
+  }
+  const args = [
+    "pr",
+    "create",
+    ...repoArgs(slug),
+    "--title",
+    opts.title,
+    "-F",
+    opts.bodyFile,
+    "--base",
+    opts.base,
+    "--head",
+    branch,
+    "--push"
+  ];
+  if (opts.draft) args.push("--draft");
+  const created = await originCli(args, repoPath, { reject: false, timeoutMs: 6e4 });
+  if (created.exitCode !== 0) {
+    throw new Error(created.stderr.trim() || created.stdout.trim() || "origin pr create failed");
+  }
+  const printed = created.stdout.trim().split("\n").find((line) => line.startsWith("http"));
+  if (printed) return printed;
+  const viewed = await viewCursorPr(repoPath, slug, branch, "url");
+  const url = typeof viewed?.url === "string" ? viewed.url.trim() : "";
+  return url || created.stdout.trim();
+}
+async function readyCursorPr(repoPath, slug, selector) {
+  const ready = await originCli(["pr", "ready", selector, ...repoArgs(slug)], repoPath, {
+    reject: false,
+    timeoutMs: 2e4
+  });
+  if (ready.exitCode !== 0) {
+    throw new Error(ready.stderr.trim() || ready.stdout.trim() || "Could not mark the Cursor pull request ready");
+  }
+}
+async function mergeCursorPr(repoPath, slug, selector, method) {
+  const args = ["pr", "merge", selector, ...repoArgs(slug)];
+  if (method === "merge") args.push("--merge");
+  else if (method === "squash") args.push("--squash");
+  const merged = await originCli(args, repoPath, {
+    reject: false,
+    timeoutMs: 6e4
+  });
+  if (merged.exitCode !== 0) {
+    throw new Error(merged.stderr.trim() || merged.stdout.trim() || "origin pr merge failed");
+  }
+}
+async function fetchCursorPrHead(repoPath, slug, number, localBranch) {
+  const view = await viewCursorPr(repoPath, slug, String(number), "headRefName");
+  const head = typeof view?.headRefName === "string" ? view.headRefName.trim() : "";
+  if (!head) {
+    throw new Error(`Could not resolve the head branch for Cursor pull request #${number}`);
+  }
+  const result = await git(["fetch", "origin", `${head}:${localBranch}`], repoPath, { reject: false });
+  if (result.exitCode !== 0) {
+    throw new Error((result.stderr || result.stdout).trim() || `git fetch origin ${head} failed`);
+  }
+}
+async function cursorPrChecks(repoPath, slug, selector) {
+  const { stdout, exitCode, stderr } = await originCli(
+    ["pr", "checks", selector, ...repoArgs(slug), "--json", "name,status,conclusion,detailsUrl,startedAt,completedAt,summary,group,link"],
+    repoPath,
+    { reject: false, timeoutMs: 2e4 }
+  );
+  const err = stderr.trim();
+  let ci;
+  if (!stdout.trim()) {
+    if (/no pull request|not found|no change/i.test(err)) return null;
+    if (exitCode !== 0 && err) throw new Error(err);
+    ci = [];
+  } else {
+    ci = originChecksToRuns(stdout);
+  }
+  const view = await viewCursorPr(
+    repoPath,
+    slug,
+    selector,
+    "url,baseRefName,reviewDecision,mergeability"
+  );
+  if (!view) return ci;
+  return cursorChecksWithGate(ci, cursorViewToPrMeta(view));
+}
+function cursorChecksWithGate(ci, meta) {
+  const gate = {
+    mergeable: meta.mergeable,
+    mergeStateStatus: meta.mergeStateStatus,
+    reviewDecision: meta.reviewDecision,
+    baseRefName: meta.baseRefName,
+    url: meta.url,
+    isInMergeQueue: meta.isInMergeQueue
+  };
+  const review = (gate.reviewDecision ?? "").toUpperCase();
+  const hasReviewRow = review === "CHANGES_REQUESTED" || review === "REVIEW_REQUIRED";
+  const gateRows = buildMergeGateChecks(gate, {
+    suppressGenericBlocked: ci.some((check) => check.bucket === "fail") || hasReviewRow
+  });
+  return [...gateRows, ...ci];
+}
+
+// src/util/enqueue-by-key.ts
+var tails = /* @__PURE__ */ new Map();
+function enqueueByKey(key, fn) {
+  const prev = tails.get(key) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  tails.set(
+    key,
+    next.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return next;
+}
+
+// src/git/repo-git-lock.ts
+function repoLockKey(repoPath) {
+  const trimmed = repoPath.replace(/\/+$/, "");
+  return `git-worktree:${trimmed || "/"}`;
+}
+function withRepoGitLock(repoPath, fn) {
+  return enqueueByKey(repoLockKey(repoPath), fn);
+}
+
 // src/git/stack.ts
 var cachedStatus = null;
 var STATUS_TTL_MS = 6e4;
@@ -1083,31 +1458,6 @@ function allocateTeamSlug(repoPath) {
 }
 
 // src/git/worktree.ts
-async function lookupGithubGraphqlReset(cwd) {
-  const result = await gh(["api", "rate_limit"], cwd, { reject: false });
-  if (result.exitCode !== 0 || !result.stdout.trim()) return void 0;
-  try {
-    const data = JSON.parse(result.stdout);
-    const reset = data.resources?.graphql?.reset;
-    return typeof reset === "number" ? reset : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function formatPrCreateFailure(raw, cwd, ctx) {
-  if (!isGhRateLimitError(raw)) {
-    return formatGhLandError(raw, {
-      targetedRepo: ctx?.slug,
-      headRef: ctx?.head
-    });
-  }
-  const resetAt = await lookupGithubGraphqlReset(cwd);
-  return formatGhLandError(raw, {
-    resetAt,
-    targetedRepo: ctx?.slug,
-    headRef: ctx?.head
-  });
-}
 function slugify(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
 }
@@ -1130,25 +1480,39 @@ function canonicalizeRepoPath(path) {
   }
 }
 function parseGithubSlugFromRemoteUrl(url) {
-  const trimmed = url.trim().replace(/\.git$/i, "");
-  if (!trimmed) return null;
-  const github = trimmed.match(/github\.com[:/]([^/]+)\/([^/]+)$/i);
-  if (github?.[1] && github[2]) return `${github[1]}/${github[2]}`;
-  const sshAlias = trimmed.match(/^git@[^:]+:([^/]+)\/([^/]+)$/i);
-  if (sshAlias?.[1] && sshAlias[2]) return `${sshAlias[1]}/${sshAlias[2]}`;
-  return null;
+  const parsed = parseRemoteRepo(url);
+  return parsed?.forge === "github" ? parsed.slug : null;
 }
-async function slugFromGitRemote(repoPath, remote) {
+async function remoteUrl(repoPath, remote) {
   const result = await git(["remote", "get-url", remote], repoPath, {
     reject: false,
     timeoutMs: 5e3
   });
   if (result.exitCode !== 0 || !result.stdout.trim()) return null;
-  return parseGithubSlugFromRemoteUrl(result.stdout);
+  return result.stdout.trim();
+}
+async function slugFromGitRemote(repoPath, remote) {
+  const url = await remoteUrl(repoPath, remote);
+  if (!url) return null;
+  return parseGithubSlugFromRemoteUrl(url);
+}
+async function resolveOriginRemote(repoPath) {
+  const url = await remoteUrl(repoPath, "origin");
+  if (!url) return null;
+  return parseRemoteRepo(url);
+}
+async function resolveProjectRemoteTag(repoPath) {
+  const origin = await resolveOriginRemote(repoPath);
+  if (origin) return formatRemoteTag(origin);
+  const slug = await resolveGithubRepoSlug(repoPath);
+  return slug ? `github:${slug}` : null;
 }
 async function resolveGithubRepoSlug(repoPath) {
-  const fromOrigin = await slugFromGitRemote(repoPath, "origin");
-  if (fromOrigin) return fromOrigin;
+  const originUrl = await remoteUrl(repoPath, "origin");
+  if (originUrl) {
+    const parsed = parseRemoteRepo(originUrl);
+    return parsed?.forge === "github" ? parsed.slug : null;
+  }
   const hasAlt = Boolean(await slugFromGitRemote(repoPath, "upstream")) || Boolean(await slugFromGitRemote(repoPath, "github"));
   if (!hasAlt) {
     const viaGh = await gh(
@@ -1194,6 +1558,8 @@ ${view.stderr}`;
   });
 }
 async function originGhRepoEnv(cwd, opts) {
+  const origin = await resolveOriginRemote(cwd);
+  if (origin?.forge === "cursor") return { ORIGIN_REPO: origin.slug };
   await ensureGhPreferOrigin(cwd);
   const slug = await resolveGithubRepoSlug(cwd);
   const mode = opts?.mode ?? getGithubGitAuthMode();
@@ -1308,7 +1674,16 @@ async function listBranches(repoPath, opts) {
   }
   return sorted.filter((b) => keep.has(b.name));
 }
+function entireUsesTrails() {
+  return new Error(
+    "This checkout is on Entire. Trails replace pull requests \u2014 use `entire trail` (Settings \u2192 Git \u2192 Entire), not `gh`."
+  );
+}
 async function listPrs(repoPath, opts) {
+  const origin = await resolveOriginRemote(repoPath);
+  if (origin?.forge === "entire") return [];
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) return listCursorPrs(repoPath, cursorSlug, opts);
   const slug = await resolveGithubRepoSlug(repoPath);
   const resolved = resolveListPrsOptions(opts);
   const limit = resolved.limit ?? 200;
@@ -1346,6 +1721,18 @@ function prInfoFromGhView(view) {
   };
 }
 async function getPr(repoPath, number) {
+  const origin = await resolveOriginRemote(repoPath);
+  if (origin?.forge === "entire") return null;
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) {
+    const view = await viewCursorPr(
+      repoPath,
+      cursorSlug,
+      String(number),
+      "number,title,headRefName,url,author,isDraft,state"
+    );
+    return view ? prInfoFromGhView(view) : null;
+  }
   const slug = await resolveGithubRepoSlug(repoPath);
   const args = [
     "pr",
@@ -1407,6 +1794,13 @@ function connectedPrSelectors(thread, currentHeadPrUrl) {
 async function getPrForHeadBranch(repoPath, branch) {
   const head = normalizeGitBranchName(branch);
   if (!head || isDefaultishSourceRef(head)) return null;
+  const origin = await resolveOriginRemote(repoPath);
+  if (origin?.forge === "entire") return null;
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) {
+    const rows = await listCursorPrs(repoPath, cursorSlug, { state: "open", limit: 5 }, head);
+    return rows[0] ?? null;
+  }
   const slug = await resolveGithubRepoSlug(repoPath);
   const listHead = slug ? ghHeadRef(slug, head) : head;
   const listArgs = [
@@ -1571,6 +1965,10 @@ async function probeLocalMergeGate(cwd, gate) {
   return { gate, files: [] };
 }
 async function getPrChecks(cwd, selector) {
+  const origin = await resolveOriginRemote(cwd);
+  if (origin?.forge === "entire") return null;
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) return cursorPrChecks(cwd, cursorSlug, selector);
   const slug = await resolveGithubRepoSlug(cwd);
   const args = [
     "pr",
@@ -1626,6 +2024,18 @@ async function getPrChecks(cwd, selector) {
   return [...gateRows, ...ciChecks];
 }
 async function getPrMeta(cwd, selector) {
+  const origin = await resolveOriginRemote(cwd);
+  if (origin?.forge === "entire") return null;
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) {
+    const view = await viewCursorPr(
+      cwd,
+      cursorSlug,
+      selector,
+      "number,title,url,state,isDraft,reviewDecision,baseRefName,headRefName,author,labels,mergeability"
+    );
+    return view ? cursorViewToPrMeta(view) : null;
+  }
   const slug = await resolveGithubRepoSlug(cwd);
   const viewArgs = [
     "pr",
@@ -1776,6 +2186,13 @@ function parsePrDetailsView(view) {
   };
 }
 async function getPrDetails(cwd, selector) {
+  const origin = await resolveOriginRemote(cwd);
+  if (origin?.forge === "entire") return null;
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) {
+    const view2 = await viewCursorPr(cwd, cursorSlug, selector, CURSOR_PR_VIEW_FIELDS);
+    return view2 ? parsePrDetailsView(view2) : null;
+  }
   const slug = await resolveGithubRepoSlug(cwd);
   const viewArgs = ["pr", "view", selector, "--json", PR_DETAILS_JSON_FIELDS];
   if (slug) viewArgs.push("--repo", slug);
@@ -1795,6 +2212,13 @@ async function getPrDetails(cwd, selector) {
   return parsePrDetailsView(view);
 }
 async function fetchPrHead(repoPath, number, localBranch) {
+  const origin = await resolveOriginRemote(repoPath);
+  if (origin?.forge === "entire") throw entireUsesTrails();
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) {
+    await fetchCursorPrHead(repoPath, cursorSlug, number, localBranch);
+    return;
+  }
   const slug = await resolveGithubRepoSlug(repoPath);
   const refspec = `+pull/${number}/head:${localBranch}`;
   const errors = [];
@@ -1937,10 +2361,10 @@ async function originRemoteUrl(cwd) {
   const result = await git(["remote", "get-url", "origin"], cwd, { reject: false });
   return result.exitCode === 0 ? result.stdout.trim() : "";
 }
-function githubHttpsRetryEnv(remoteUrl) {
+function githubHttpsRetryEnv(remoteUrl2) {
   return {
     GIT_TERMINAL_PROMPT: "0",
-    ...githubAgentGitEnv(void 0, { remoteUrl })
+    ...githubAgentGitEnv(void 0, { remoteUrl: remoteUrl2 })
   };
 }
 async function fetchOriginWithAuth(repoPath, args, timeoutMs) {
@@ -1954,11 +2378,11 @@ async function fetchOriginWithAuth(repoPath, args, timeoutMs) {
   }
   const token = await resolveGithubAgentToken(mode, repoPath);
   if (!token) return false;
-  const remoteUrl = await originRemoteUrl(repoPath);
+  const remoteUrl2 = await originRemoteUrl(repoPath);
   const tryHttps = async (header) => git(args, repoPath, {
     reject: false,
     timeoutMs,
-    env: githubHttpsRetryEnv(remoteUrl),
+    env: githubHttpsRetryEnv(remoteUrl2),
     config: {
       "http.extraHeader": header
     }
@@ -2307,10 +2731,10 @@ async function pushBranch(worktreePath, branchName) {
       sshErr || `git push origin ${branchName} failed` + (!token ? " (SSH remote and gh auth token unavailable \u2014 unlock ssh-agent or run: gh auth login)" : "")
     );
   }
-  const remoteUrl = await originRemoteUrl(worktreePath);
+  const remoteUrl2 = await originRemoteUrl(worktreePath);
   const tryHttps = async (header) => git(["push", "-u", "origin", branchName], worktreePath, {
     reject: false,
-    env: githubHttpsRetryEnv(remoteUrl),
+    env: githubHttpsRetryEnv(remoteUrl2),
     config: {
       "http.extraHeader": header
     }
@@ -2323,6 +2747,40 @@ async function pushBranch(worktreePath, branchName) {
   const httpsErr = (basicPush.stderr || bearer.stderr || bearer.stdout).trim();
   throw new Error(httpsErr || sshErr || `git push origin ${branchName} failed`);
 }
+async function markCursorPrReady(cwd, slug, selector) {
+  const view = await viewCursorPr(cwd, slug, selector, "url,state,isDraft");
+  if (!view) throw new Error("Could not load the Cursor pull request");
+  const url = String(view.url ?? "");
+  const state = String(view.state ?? "").toUpperCase();
+  const isDraft = Boolean(view.isDraft);
+  if (state === "MERGED" || state === "CLOSED") {
+    return { url, state, isDraft: false };
+  }
+  if (isDraft) {
+    if (await isDirty(cwd)) {
+      throw new Error(
+        "Commit and push local work before marking the pull request ready for review."
+      );
+    }
+    const unpushed = await countUnpushedVsOrigin(cwd);
+    if (unpushed > 0) {
+      throw new Error(
+        "Push this branch to origin before marking the pull request ready for review."
+      );
+    }
+    await readyCursorPr(cwd, slug, selector);
+  }
+  return { url, state: state || "OPEN", isDraft: false };
+}
+async function mergeCursorPullRequest(cwd, slug, selector, method) {
+  const view = await viewCursorPr(cwd, slug, selector, "url,state,isDraft");
+  if (!view) throw new Error("Could not load the Cursor pull request");
+  const url = String(view.url ?? "");
+  if (String(view.state ?? "").toUpperCase() === "MERGED") return { url, state: "MERGED" };
+  if (view.isDraft) await readyCursorPr(cwd, slug, selector);
+  await mergeCursorPr(cwd, slug, selector, method);
+  return { url, state: "MERGED" };
+}
 async function runPrReady(cwd, selector, slug) {
   const readyArgs = ["pr", "ready", selector];
   if (slug) readyArgs.push("--repo", slug);
@@ -2334,6 +2792,10 @@ async function runPrReady(cwd, selector, slug) {
   }
 }
 async function markPrReady(cwd, selector) {
+  const origin = await resolveOriginRemote(cwd);
+  if (origin?.forge === "entire") throw entireUsesTrails();
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) return markCursorPrReady(cwd, cursorSlug, selector);
   const slug = await resolveGithubRepoSlug(cwd);
   const viewArgs = ["pr", "view", selector, "--json", "url,state,isDraft"];
   if (slug) viewArgs.push("--repo", slug);
@@ -2372,6 +2834,10 @@ async function markPrReady(cwd, selector) {
   return { url, state: state || "OPEN", isDraft: false };
 }
 async function mergePr(cwd, selector, opts) {
+  const origin = await resolveOriginRemote(cwd);
+  if (origin?.forge === "entire") throw entireUsesTrails();
+  const cursorSlug = origin?.forge === "cursor" ? origin.slug : null;
+  if (cursorSlug) return mergeCursorPullRequest(cwd, cursorSlug, selector, opts?.method ?? "squash");
   const slug = await resolveGithubRepoSlug(cwd);
   const viewArgs = ["pr", "view", selector, "--json", "url,state,isDraft,number"];
   if (slug) viewArgs.push("--repo", slug);
@@ -2430,116 +2896,6 @@ async function mergePr(cwd, selector, opts) {
   }
   return { url, state: "MERGED" };
 }
-function ghPrCreateAssigneeArgs(assignee) {
-  const raw = assignee?.trim();
-  if (raw && /^(none|unassigned)$/i.test(raw)) return [];
-  return ["--assignee", raw || "@me"];
-}
-async function createOrUpdatePr(worktreePath, opts) {
-  await ensureGhPreferOrigin(worktreePath);
-  const slug = await resolveGithubRepoSlug(worktreePath);
-  if (!slug) {
-    throw new Error(
-      "Could not resolve the origin GitHub repo (owner/name) for this worktree. Check that `git remote get-url origin` points at github.com."
-    );
-  }
-  const repoArgs = ghRepoSelectArgs(slug);
-  const headRef = ghHeadRef(slug, opts.head);
-  const branchOnly = opts.head.trim().replace(/^refs\/heads\//, "");
-  const bodyText = clampGithubPrBody(opts.body ?? opts.title);
-  const bodyFile = join2(
-    tmpdir(),
-    `sideboard-pr-body-${process.pid}-${randomBytes(6).toString("hex")}.md`
-  );
-  writeFileSync(bodyFile, bodyText.endsWith("\n") ? bodyText : `${bodyText}
-`, "utf8");
-  const bodyArgs = ["--body-file", bodyFile];
-  try {
-    return await createOrUpdatePrWithBodyFile(worktreePath, {
-      ...opts,
-      slug,
-      repoArgs,
-      headRef,
-      branchOnly,
-      bodyArgs
-    });
-  } finally {
-    try {
-      unlinkSync(bodyFile);
-    } catch {
-    }
-  }
-}
-async function createOrUpdatePrWithBodyFile(worktreePath, opts) {
-  const { slug, repoArgs, headRef, branchOnly, bodyArgs } = opts;
-  const existing = await gh(
-    [...repoArgs, "pr", "view", branchOnly, "--json", "url", "--jq", ".url"],
-    worktreePath,
-    { reject: false }
-  );
-  if (existing.exitCode === 0 && existing.stdout.trim() && !opts.web) {
-    const url2 = existing.stdout.trim();
-    await gh(
-      [
-        ...repoArgs,
-        "pr",
-        "edit",
-        branchOnly,
-        "--title",
-        opts.title,
-        ...bodyArgs
-      ],
-      worktreePath,
-      { reject: false }
-    );
-    return url2;
-  }
-  if (opts.web) {
-    const args2 = [
-      ...repoArgs,
-      "pr",
-      "create",
-      "--web",
-      "--title",
-      opts.title,
-      ...bodyArgs,
-      "--base",
-      opts.base,
-      "--head",
-      headRef
-    ];
-    if (opts.draft) args2.push("--draft");
-    args2.push(...ghPrCreateAssigneeArgs(opts.assignee));
-    await gh(args2, worktreePath, { reject: false });
-    const again = await gh(
-      [...repoArgs, "pr", "view", branchOnly, "--json", "url", "--jq", ".url"],
-      worktreePath,
-      { reject: false }
-    );
-    return again.stdout.trim() || "";
-  }
-  const args = [
-    ...repoArgs,
-    "pr",
-    "create",
-    "--title",
-    opts.title,
-    ...bodyArgs,
-    "--base",
-    opts.base,
-    "--head",
-    headRef
-  ];
-  if (opts.draft) args.push("--draft");
-  args.push(...ghPrCreateAssigneeArgs(opts.assignee));
-  const created = await gh(args, worktreePath, { reject: false });
-  if (created.exitCode !== 0) {
-    const raw = created.stderr.trim() || created.stdout.trim() || "gh pr create failed";
-    throw new Error(await formatPrCreateFailure(raw, worktreePath, { slug, head: headRef }));
-  }
-  const url = created.stdout.trim().split("\n").find((l) => l.startsWith("http")) ?? created.stdout.trim();
-  return url;
-}
 function suggestSlug(source) {
   const base = slugify(source || "thread");
   const stamp = Date.now().toString(36).slice(-4);
@@ -2547,6 +2903,8 @@ function suggestSlug(source) {
 }
 
 export {
+  isGhRateLimitError,
+  clampGithubPrBody,
   formatGhLandError,
   githubAgentGitEnv,
   mergeAgentGitAuthEnv,
@@ -2555,10 +2913,12 @@ export {
   resolveCodexGitWritableRoots,
   codexUnattendedGitConfigArgs,
   formatGitAuthModeDirective,
+  formatRemoteTag,
   resolveListPrsOptions,
+  ciChecksFailed,
+  createOrUpdateCursorPr,
   enqueueByKey,
   withRepoGitLock,
-  ciChecksFailed,
   detectGhStack,
   getPrStack,
   initPrStack,
@@ -2569,6 +2929,8 @@ export {
   resolveRepoRoot,
   canonicalizeRepoPath,
   parseGithubSlugFromRemoteUrl,
+  resolveOriginRemote,
+  resolveProjectRemoteTag,
   resolveGithubRepoSlug,
   ghRepoSelectArgs,
   ghHeadRef,
@@ -2577,6 +2939,7 @@ export {
   resolveDefaultBranch,
   resolveDiffBaseRef,
   listBranches,
+  entireUsesTrails,
   listPrs,
   getPr,
   isDefaultishSourceRef,
@@ -2608,7 +2971,5 @@ export {
   pushBranch,
   markPrReady,
   mergePr,
-  ghPrCreateAssigneeArgs,
-  createOrUpdatePr,
   suggestSlug
 };