@sideboard-ai/core 0.1.10 → 0.1.19

package/dist/index.cjs

@@ -1357,6 +1357,69 @@ var init_worktree_labels = __esm({
   }
 });
 
+// src/git/gh-errors.ts
+function isGhRateLimitError(text) {
+  return /API rate limit (already )?exceeded/i.test(text) || /rate limit exceeded/i.test(text);
+}
+function formatRateLimitResetHint(resetEpochSec, nowMs = Date.now()) {
+  const ms = resetEpochSec * 1e3 - nowMs;
+  if (ms <= 0) return "soon";
+  const mins = Math.max(1, Math.ceil(ms / 6e4));
+  if (mins < 60) {
+    return `in about ${mins} minute${mins === 1 ? "" : "s"}`;
+  }
+  const hours = Math.ceil(mins / 60);
+  return `in about ${hours} hour${hours === 1 ? "" : "s"}`;
+}
+function extractGhErrorDetail(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  const graphql = trimmed.match(/\bGraphQL:\s*(.+)$/im);
+  if (graphql?.[1]) return `GraphQL: ${graphql[1].trim()}`;
+  const http = trimmed.match(/\bHTTP\s+\d{3}:\s*(.+)$/im);
+  if (http?.[1]) return `HTTP: ${http[1].trim()}`;
+  const lines = trimmed.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  if (lines.length > 1 && /^Command failed with exit code/i.test(lines[0])) {
+    return lines.slice(1).join(" ").trim() || lines[0];
+  }
+  return trimmed;
+}
+function formatGhLandError(raw, opts) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("GitHub API rate limit exceeded.")) {
+    return trimmed;
+  }
+  const detail = extractGhErrorDetail(raw);
+  if (/Head ref must be a branch|No commits between|Head sha can't be blank/i.test(
+    raw
+  ) || /Head ref must be a branch|No commits between|Head sha can't be blank/i.test(
+    detail
+  )) {
+    const target = opts?.targetedRepo ? ` Targeted ${opts.targetedRepo}` : "";
+    const head = opts?.headRef ? ` with head ${opts.headRef}` : "";
+    const hint = opts?.targetedRepo ? ` Branch was pushed to origin \u2014 confirm it exists on GitHub and differs from the base branch.${target}${head}.` : " Often `gh` targeted upstream instead of origin. Branch was pushed \u2014 retry in the latest Sideboard, or run: gh pr create -R <owner/name> --base main --head <branch>.";
+    return `Could not create the pull request.${hint}`;
+  }
+  if (isGhRateLimitError(raw) || isGhRateLimitError(detail)) {
+    const when = opts?.resetAt ? ` Try again ${formatRateLimitResetHint(opts.resetAt, opts.nowMs)}.` : " Wait a few minutes and try again.";
+    const pushNote = opts?.pushed === false ? "" : " Your branch was already pushed.";
+    return `GitHub API rate limit exceeded.${pushNote}${when} Or create the pull request in the browser (Push & open on GitHub).`;
+  }
+  return detail || "Failed to create or update pull request";
+}
+function formatIpcInvokeError(err) {
+  let msg = err instanceof Error ? err.message : String(err);
+  msg = msg.replace(/^Error invoking remote method '[^']+':\s*/i, "");
+  msg = msg.replace(/^ExecaError:\s*/i, "");
+  msg = msg.replace(/^Error:\s*/i, "");
+  return formatGhLandError(msg);
+}
+var init_gh_errors = __esm({
+  "src/git/gh-errors.ts"() {
+    "use strict";
+  }
+});
+
 // src/agents/path.ts
 function ensureAgentPath(env = process.env) {
   const home = env.HOME || env.USERPROFILE || (0, import_node_os4.homedir)();
@@ -1547,10 +1610,14 @@ __export(worktree_exports, {
   createThreadWorktree: () => createThreadWorktree,
   currentBranch: () => currentBranch,
   detectLocalMergeConflicts: () => detectLocalMergeConflicts,
+  ensureGhPreferOrigin: () => ensureGhPreferOrigin,
   fetchPrHead: () => fetchPrHead,
   getPr: () => getPr,
   getPrChecks: () => getPrChecks,
   getPrDetails: () => getPrDetails,
+  getPrMeta: () => getPrMeta,
+  ghHeadRef: () => ghHeadRef,
+  ghRepoSelectArgs: () => ghRepoSelectArgs,
   isDirty: () => isDirty,
   isPlaceholderBranch: () => isPlaceholderBranch,
   listBranches: () => listBranches,
@@ -1558,6 +1625,7 @@ __export(worktree_exports, {
   listWorktrees: () => listWorktrees,
   mergePr: () => mergePr,
   normalizeWorktreePath: () => normalizeWorktreePath,
+  originGhRepoEnv: () => originGhRepoEnv,
   parseGithubSlugFromRemoteUrl: () => parseGithubSlugFromRemoteUrl,
   pushBranch: () => pushBranch,
   removeWorktree: () => removeWorktree,
@@ -1574,6 +1642,31 @@ __export(worktree_exports, {
   worktreeDisplayLabelForGroup: () => worktreeDisplayLabelForGroup,
   worktreeNameFromPath: () => worktreeNameFromPath
 });
+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);
 }
@@ -1582,10 +1675,13 @@ async function resolveRepoRoot(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]}`;
+  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;
 }
 async function slugFromGitRemote(repoPath, remote) {
   const result = await git(["remote", "get-url", remote], repoPath, {
@@ -1597,13 +1693,16 @@ async function slugFromGitRemote(repoPath, remote) {
 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();
+  const hasAlt = Boolean(await slugFromGitRemote(repoPath, "upstream")) || Boolean(await slugFromGitRemote(repoPath, "github"));
+  if (!hasAlt) {
+    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);
@@ -1611,15 +1710,35 @@ async function resolveGithubRepoSlug(repoPath) {
   }
   return null;
 }
+function ghRepoSelectArgs(slug) {
+  return ["-R", slug];
+}
+function ghHeadRef(slug, branch) {
+  const owner = slug.split("/")[0];
+  const head = branch.trim().replace(/^refs\/heads\//, "");
+  if (!owner || !head) return head || branch;
+  if (head.includes(":")) return head;
+  return `${owner}:${head}`;
+}
+async function ensureGhPreferOrigin(cwd) {
+  const originSlug = await slugFromGitRemote(cwd, "origin");
+  if (!originSlug) return;
+  const hasAlt = Boolean(await slugFromGitRemote(cwd, "upstream")) || Boolean(await slugFromGitRemote(cwd, "github"));
+  if (!hasAlt) return;
+  const view = await gh(["repo", "set-default", "--view"], cwd, {
+    reject: false
+  });
+  const current = `${view.stdout}
+${view.stderr}`;
+  if (view.exitCode === 0 && current.includes(originSlug)) return;
+  await gh(["repo", "set-default", "origin"], cwd, { reject: false });
+}
+async function originGhRepoEnv(cwd) {
+  await ensureGhPreferOrigin(cwd);
+  const slug = await resolveGithubRepoSlug(cwd);
+  return slug ? { GH_REPO: slug } : {};
+}
 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,
@@ -1628,6 +1747,31 @@ async function resolveDefaultBranch(repoPath) {
   if (viaOrigin.exitCode === 0 && viaOrigin.stdout.trim()) {
     return viaOrigin.stdout.trim().replace(/^refs\/remotes\/origin\//, "");
   }
+  const slug = await resolveGithubRepoSlug(repoPath);
+  const viaGh = await gh(
+    [
+      "repo",
+      "view",
+      ...slug ? ["--repo", slug] : [],
+      "--json",
+      "defaultBranchRef",
+      "--jq",
+      ".defaultBranchRef.name"
+    ],
+    repoPath,
+    { reject: false }
+  );
+  if (viaGh.exitCode === 0 && viaGh.stdout.trim()) {
+    return viaGh.stdout.trim();
+  }
+  for (const candidate of ["main", "master"]) {
+    const check = await git(
+      ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${candidate}`],
+      repoPath,
+      { reject: false }
+    );
+    if (check.exitCode === 0) return candidate;
+  }
   for (const candidate of ["main", "master"]) {
     const check = await git(
       ["show-ref", "--verify", "--quiet", `refs/heads/${candidate}`],
@@ -1888,6 +2032,37 @@ async function getPrChecks(cwd, selector) {
   });
   return [...gateRows, ...ciChecks];
 }
+async function getPrMeta(cwd, selector) {
+  const slug = await resolveGithubRepoSlug(cwd);
+  const viewArgs = [
+    "pr",
+    "view",
+    selector,
+    "--json",
+    "number,title,url,state,isDraft,reviewDecision,baseRefName,headRefName"
+  ];
+  if (slug) viewArgs.push("--repo", slug);
+  const { stdout, exitCode, stderr } = await gh(viewArgs, 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 {
+      number: Number(view.number),
+      title: String(view.title ?? ""),
+      url: String(view.url ?? ""),
+      state: String(view.state ?? ""),
+      isDraft: Boolean(view.isDraft),
+      reviewDecision: typeof view.reviewDecision === "string" && view.reviewDecision ? view.reviewDecision : null,
+      baseRefName: String(view.baseRefName ?? ""),
+      headRefName: String(view.headRefName ?? "")
+    };
+  } catch {
+    return null;
+  }
+}
 async function getPrDetails(cwd, selector) {
   const slug = await resolveGithubRepoSlug(cwd);
   const viewArgs = [
@@ -1909,7 +2084,6 @@ async function getPrDetails(cwd, selector) {
       "additions",
       "deletions",
       "changedFiles",
-      "commits",
       "comments",
       "reviews"
     ].join(",")
@@ -1928,14 +2102,7 @@ async function getPrDetails(cwd, selector) {
   } 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 {
@@ -1952,19 +2119,8 @@ async function getPrDetails(cwd, selector) {
     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
-      };
-    }),
+    // Commits live in Changes; omit from GraphQL to save rate-limit points.
+    commits: [],
     comments: comments.map((c) => {
       const row = c;
       const a = row.author ?? {};
@@ -1984,7 +2140,8 @@ async function getPrDetails(cwd, selector) {
         submittedAt: normalizeGhTime(row.submittedAt)
       };
     }),
-    checks
+    // CI lives in Checks tab via getPrChecks — nesting burned GraphQL points.
+    checks: []
   };
 }
 async function fetchPrHead(repoPath, number, localBranch) {
@@ -2020,6 +2177,7 @@ async function createThreadWorktree(opts) {
   if ((0, import_node_fs5.existsSync)(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
+  await ensureGhPreferOrigin(opts.repoPath);
   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, {
@@ -2048,6 +2206,7 @@ ${add.stdout}`;
         );
         if (retry.exitCode === 0) {
           branchName = alt;
+          await ensureGhPreferOrigin(worktreePath);
           return { branchName, worktreePath };
         }
       }
@@ -2056,6 +2215,7 @@ ${add.stdout}`;
       `Failed to create worktree: ${add.stderr.trim() || add.stdout.trim() || `exit ${add.exitCode}`}`
     );
   }
+  await ensureGhPreferOrigin(worktreePath);
   return { branchName, worktreePath };
 }
 async function removeWorktree(repoPath, worktreePath, opts) {
@@ -2156,8 +2316,18 @@ async function mergePr(cwd, selector, opts) {
   return { url, state: "MERGED" };
 }
 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 existing = await gh(
-    ["pr", "view", opts.head, "--json", "url", "--jq", ".url"],
+    [...repoArgs, "pr", "view", branchOnly, "--json", "url", "--jq", ".url"],
     worktreePath,
     { reject: false }
   );
@@ -2165,9 +2335,10 @@ async function createOrUpdatePr(worktreePath, opts) {
     const url2 = existing.stdout.trim();
     await gh(
       [
+        ...repoArgs,
         "pr",
         "edit",
-        opts.head,
+        branchOnly,
         "--title",
         opts.title,
         "--body",
@@ -2180,6 +2351,7 @@ async function createOrUpdatePr(worktreePath, opts) {
   }
   if (opts.web) {
     const args2 = [
+      ...repoArgs,
       "pr",
       "create",
       "--web",
@@ -2190,18 +2362,19 @@ async function createOrUpdatePr(worktreePath, opts) {
       "--base",
       opts.base,
       "--head",
-      opts.head
+      headRef
     ];
     if (opts.draft) args2.push("--draft");
     await gh(args2, worktreePath, { reject: false });
     const again = await gh(
-      ["pr", "view", opts.head, "--json", "url", "--jq", ".url"],
+      [...repoArgs, "pr", "view", branchOnly, "--json", "url", "--jq", ".url"],
       worktreePath,
       { reject: false }
     );
     return again.stdout.trim() || "";
   }
   const args = [
+    ...repoArgs,
     "pr",
     "create",
     "--title",
@@ -2211,11 +2384,15 @@ async function createOrUpdatePr(worktreePath, opts) {
     "--base",
     opts.base,
     "--head",
-    opts.head
+    headRef
   ];
   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();
+  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) {
@@ -2276,6 +2453,7 @@ var init_worktree = __esm({
     init_thread_store();
     init_teams();
     init_worktree_labels();
+    init_gh_errors();
     init_run();
     init_pr_gates();
     init_teams();
@@ -2316,7 +2494,8 @@ function coordinatorGreenfieldPlaybook(reposDir) {
     "- Examples:",
     `  - Clone: \`git clone <url> ${reposDir}/<name>\``,
     `  - New GitHub repo: \`gh repo create <owner>/<name> --private --clone -- ${reposDir}/<name>\` (or mkdir + git init + gh repo create + remote add + push)`,
-    "- Then: add_workspace with that absolute path \u2192 create_thread (repoPath + parentThreadId) \u2192 send_to_thread (build) \u2192 wait_for_turn \u2192 send_to_thread (`gh pr create --draft`) or create_draft_pr.",
+    "- Then: add_workspace with that absolute path \u2192 create_thread (repoPath + parentThreadId) \u2192 send_to_thread (build) \u2192 wait_for_turn \u2192 send_to_thread (`gh pr create --draft -R <origin-owner/name>`) or create_draft_pr.",
+    "- Always target the child worktree's **origin** (`github:` slug from list_workspaces / `git remote get-url origin` in that worktree). Never open PRs against `upstream`.",
     "- Do coding work in the child worktree thread, not by editing files in this home cwd."
   ].join("\n");
 }
@@ -2381,7 +2560,7 @@ function coordinatorSystemPrompt(opts) {
     COORDINATOR_TOOL_PLAYBOOK,
     coordinatorGreenfieldPlaybook(reposDir),
     "When creating threads, pass the correct repoPath for the target workspace and parentThreadId for children.",
-    "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 send_to_thread (ask for `gh pr create --draft`) \u2192 wait_for_turn. Use create_draft_pr only if the child cannot open the PR.",
+    "Typical flow (existing): list_workspaces \u2192 list_branches|list_prs|list_issues \u2192 create_thread \u2192 send_to_thread (implement) \u2192 wait_for_turn \u2192 send_to_thread (ask for `gh pr create --draft -R <origin-owner/name>` using the workspace github slug) \u2192 wait_for_turn. Use create_draft_pr only if the child cannot open the PR. Never target upstream.",
     "Typical flow (new app): Bash under repos dir (clone or gh repo create) \u2192 add_workspace \u2192 create_thread \u2192 send_to_thread \u2192 wait_for_turn \u2192 draft PR.",
     `Goal: ${opts.goal}`,
     `Parent thread id (pass as parentThreadId when creating children): ${opts.parentId}`,
@@ -2418,8 +2597,8 @@ var init_coordinator_prompt = __esm({
       "Inspect / PRs:",
       "- get_diff \u2014 compact diff summary",
       "- preview_land \u2014 preview push+PR (does not push)",
-      "- Prefer asking the worktree agent via send_to_thread to open a draft PR (`gh pr create --draft`) so it owns title/body from the diff.",
-      "- create_draft_pr \u2014 fallback: commit (if dirty), push, open/update a DRAFT PR from the orchestrator",
+      "- Prefer asking the worktree agent via send_to_thread to open a draft PR with `gh pr create --draft -R <origin-owner/name>` (use the workspace `github:` slug / that worktree's origin \u2014 never upstream) so it owns title/body from the diff.",
+      "- create_draft_pr \u2014 fallback: commit (if dirty), push to origin, open/update a DRAFT PR from the orchestrator (always against origin)",
       "Human-only (do not attempt): ready-for-review confirm_land, purge_thread.",
       "Thread links in replies: when mentioning a chat/thread for the user, include a markdown link `[Title](sideboard://thread/<id>)` using the full id (or the link field from create_thread / list_threads). Sideboard renders these as clickable opens.",
       "Bash / Read / etc: allowed for (1) inspecting target worktrees / registered repo paths from MCP, and (2) greenfield setup under ~/sideboard/repos (git clone, gh repo create, git init+remote). Never git init/clone *inside* this synthetic home cwd \u2014 emptiness here is expected, not a bug."
@@ -2596,6 +2775,9 @@ __export(workspaces_exports, {
 function workspacesFile() {
   return (0, import_node_path8.join)(appDataDir(), "workspaces.json");
 }
+function removedWorkspacesFile() {
+  return (0, import_node_path8.join)(appDataDir(), "removed-workspaces.json");
+}
 function readAll() {
   const path = workspacesFile();
   if (!(0, import_node_fs7.existsSync)(path)) return [];
@@ -2610,12 +2792,44 @@ function writeAll(list) {
   (0, import_node_fs7.mkdirSync)(appDataDir(), { recursive: true });
   (0, import_node_fs7.writeFileSync)(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
+function readRemoved() {
+  const path = removedWorkspacesFile();
+  if (!(0, import_node_fs7.existsSync)(path)) return /* @__PURE__ */ new Set();
+  try {
+    const raw = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
+    return new Set(Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function writeRemoved(paths) {
+  (0, import_node_fs7.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs7.writeFileSync)(removedWorkspacesFile(), JSON.stringify([...paths].sort(), null, 2), "utf8");
+}
+function rememberRemoved(repoPath) {
+  const next = readRemoved();
+  next.add(repoPath);
+  writeRemoved(next);
+}
+function forgetRemoved(repoPath) {
+  const next = readRemoved();
+  if (!next.delete(repoPath)) return;
+  writeRemoved(next);
+}
 function listWorkspaces() {
-  return readAll().sort((a, b) => a.name.localeCompare(b.name));
+  const all = readAll();
+  const valid = all.filter(
+    (w) => Boolean(w.path) && w.path !== "/" && w.path !== "." && !isGlobalRepoPath(w.path)
+  );
+  if (valid.length !== all.length) writeAll(valid);
+  return valid.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function addWorkspace(repoPath) {
   const root = await resolveRepoRoot(repoPath);
+  if (!root || root === "/") throw new Error(`Invalid repo path: ${repoPath}`);
   if (!(0, import_node_fs7.existsSync)(root)) throw new Error(`Repo not found: ${root}`);
+  forgetRemoved(root);
+  await ensureGhPreferOrigin(root);
   const current = readAll();
   const existing = current.find((w) => w.path === root);
   if (existing) return existing;
@@ -2629,16 +2843,20 @@ async function addWorkspace(repoPath) {
 }
 function removeWorkspace(repoPath) {
   writeAll(readAll().filter((w) => w.path !== repoPath));
+  rememberRemoved(repoPath);
 }
 async function ensureWorkspace(repoPath) {
   return addWorkspace(repoPath);
 }
 function syncWorkspacesFromThreads(repoPaths) {
   const current = readAll();
+  const removed = readRemoved();
   const byPath = new Map(current.map((w) => [w.path, w]));
   let dirty = false;
   for (const path of repoPaths) {
-    if (!path || isGlobalRepoPath(path) || byPath.has(path)) continue;
+    if (!path || path === "/" || isGlobalRepoPath(path) || byPath.has(path) || removed.has(path)) {
+      continue;
+    }
     if (!(0, import_node_fs7.existsSync)(path)) continue;
     const ws = {
       path,
@@ -4683,11 +4901,13 @@ __export(index_exports, {
   enrichWorkspacesWithGithub: () => enrichWorkspacesWithGithub,
   ensureAgentPath: () => ensureAgentPath,
   ensureCloudCoordinator: () => ensureCloudCoordinator,
+  ensureGhPreferOrigin: () => ensureGhPreferOrigin,
   ensureGlobalCoordinatorCwd: () => ensureGlobalCoordinatorCwd,
   ensureWorkspace: () => ensureWorkspace,
   estimateMessageChars: () => estimateMessageChars,
   estimateThreadChars: () => estimateThreadChars,
   expandComposerPrompt: () => expandComposerPrompt,
+  extractGhErrorDetail: () => extractGhErrorDetail,
   extractiveSummary: () => extractiveSummary,
   fetchPrHead: () => fetchPrHead,
   finalizeParts: () => finalizeParts,
@@ -4700,7 +4920,10 @@ __export(index_exports, {
   forkThreadWorktree: () => forkThreadWorktree,
   formatAgentInstructions: () => formatAgentInstructions,
   formatBrightsyFetchError: () => formatBrightsyFetchError,
+  formatGhLandError: () => formatGhLandError,
+  formatIpcInvokeError: () => formatIpcInvokeError,
   formatMessagesAsTranscript: () => formatMessagesAsTranscript,
+  formatRateLimitResetHint: () => formatRateLimitResetHint,
   formatRenameBranchDirective: () => formatRenameBranchDirective,
   formatTranscriptMarkdown: () => formatTranscriptMarkdown,
   formatWorkspaceInventory: () => formatWorkspaceInventory,
@@ -4717,10 +4940,13 @@ __export(index_exports, {
   getPr: () => getPr,
   getPrChecks: () => getPrChecks,
   getPrDetails: () => getPrDetails,
+  getPrMeta: () => getPrMeta,
   getRepoSetupInfo: () => getRepoSetupInfo,
   getRunMode: () => getRunMode,
   getRunScript: () => getRunScript,
   gh: () => gh,
+  ghHeadRef: () => ghHeadRef,
+  ghRepoSelectArgs: () => ghRepoSelectArgs,
   git: () => git,
   globalAgentCwd: () => globalAgentCwd,
   harnessEnvKey: () => harnessEnvKey,
@@ -4737,6 +4963,7 @@ __export(index_exports, {
   isBrightsyNdjsonLine: () => isBrightsyNdjsonLine,
   isCloudCoordinatorThread: () => isCloudCoordinatorThread,
   isDirty: () => isDirty,
+  isGhRateLimitError: () => isGhRateLimitError,
   isGlobalRepoPath: () => isGlobalRepoPath,
   isGlobalThread: () => isGlobalThread,
   isLinearConnected: () => isLinearConnected,
@@ -4779,6 +5006,7 @@ __export(index_exports, {
   opencodeAdapter: () => opencodeAdapter,
   orchestrationTitleNeedsSoccerNickname: () => orchestrationTitleNeedsSoccerNickname,
   orchestratorSessionPoisonedByBuiltins: () => orchestratorSessionPoisonedByBuiltins,
+  originGhRepoEnv: () => originGhRepoEnv,
   parseCursorRunnerLine: () => parseCursorRunnerLine,
   parseForceStopMessage: () => parseForceStopMessage,
   parseGithubSlugFromRemoteUrl: () => parseGithubSlugFromRemoteUrl,
@@ -4870,6 +5098,7 @@ init_thread_store();
 init_workspaces();
 init_global_workspace();
 init_run();
+init_gh_errors();
 init_worktree();
 
 // src/integrations/github.ts
@@ -5053,7 +5282,9 @@ init_agents();
 // src/agents/spawn.ts
 var import_node_readline = require("readline");
 var import_execa2 = require("execa");
+init_worktree();
 init_app_settings();
+init_global_workspace();
 init_brightsy();
 init_agents();
 
@@ -5287,9 +5518,14 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Agent cwd must be the thread worktree (got ${cmd.cwd}, expected ${thread.worktreePath})`
     );
   }
+  const env = childEnvWithAppSettings(cmd.env);
+  if (!isOrchestratorThread(thread)) {
+    const originEnv = await originGhRepoEnv(thread.worktreePath).catch(() => ({}));
+    Object.assign(env, originEnv);
+  }
   const child = (0, import_execa2.execa)(cmd.file, cmd.args, {
     cwd: cmd.cwd,
-    env: childEnvWithAppSettings(cmd.env),
+    env,
     reject: false,
     stdout: "pipe",
     stderr: "pipe",
@@ -5396,7 +5632,7 @@ function formatRenameBranchDirective(thread, opts) {
   }
   return lines.join("\n");
 }
-function formatWorktreeDirective(thread) {
+function formatWorktreeDirective(thread, opts) {
   const worktree = normPath2(thread.worktreePath);
   const repo = normPath2(thread.repoPath);
   const dir = worktreeNameFromPath(thread.worktreePath);
@@ -5417,7 +5653,13 @@ function formatWorktreeDirective(thread) {
     );
   }
   lines.push("");
-  lines.push("Pull requests (when the work is ready to share):");
+  lines.push("Git remotes + pull requests (when the work is ready to share):");
+  lines.push(
+    "- Always use this worktree's `origin` remote (`git remote get-url origin` from this cwd). Never push to or open PRs against `upstream` (template remotes)."
+  );
+  lines.push(
+    "- Push with `git push -u origin HEAD` (or the current branch name). Do not `git push upstream`."
+  );
   lines.push(
     "- Derive the PR title and body from what the changes actually do and why \u2014 inspect the diff/commits and the user request. Do not use the soccer-team worktree nickname or placeholder branch as the PR title."
   );
@@ -5431,9 +5673,13 @@ function formatWorktreeDirective(thread) {
     lines.push(
       `- A PR already exists (${thread.prUrl}). Update it (push + edit title/body if the purpose drifted) instead of opening a duplicate.`
     );
+  } else if (opts?.githubSlug) {
+    lines.push(
+      `- Prefer a draft PR first: \`gh pr create --draft -R ${opts.githubSlug}\` (or update via \`gh pr edit -R ${opts.githubSlug}\`) once the change set is coherent. Always pass \`-R ${opts.githubSlug}\` (this worktree's origin). Bare \`gh pr create\` may target upstream instead of origin on dual-remote checkouts. Mark ready for review only when asked. Title/body must reflect the change purpose, not the worktree name.`
+    );
   } else {
     lines.push(
-      "- Prefer a draft PR first: `gh pr create --draft` (or update via `gh pr edit`) once the change set is coherent. Mark ready for review only when asked. Title/body must reflect the change purpose, not the worktree name."
+      "- Prefer a draft PR first: `gh pr create --draft -R <origin-owner/name>` (or update via `gh pr edit -R \u2026`) once the change set is coherent. Resolve `<origin-owner/name>` with `git remote get-url origin` in this worktree \u2014 never from `upstream`. Mark ready for review only when asked. Title/body must reflect the change purpose, not the worktree name."
     );
   }
   return lines.join("\n");
@@ -6954,6 +7200,7 @@ async function suggestPrMetadata(worktreePath, opts) {
 }
 
 // src/land/land.ts
+init_gh_errors();
 async function previewLand(thread) {
   if (thread.sourceIsFork) {
     return {
@@ -7017,15 +7264,24 @@ async function confirmLand(thread, opts) {
   const head = headOut.trim();
   const branch = head && head !== "HEAD" ? head : thread.branchName;
   await pushBranch(thread.worktreePath, branch);
-  const prUrl = await createOrUpdatePr(thread.worktreePath, {
-    title: meta.title,
-    body: meta.body,
-    base: preview.target,
-    head: branch,
-    draft: opts?.draft,
-    web: opts?.web
-  });
-  return { prUrl, pushed: true, committed };
+  try {
+    const prUrl = await createOrUpdatePr(thread.worktreePath, {
+      title: meta.title,
+      body: meta.body,
+      base: preview.target,
+      head: branch,
+      draft: opts?.draft,
+      web: opts?.web
+    });
+    return { prUrl, pushed: true, committed };
+  } catch (err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    if (raw.startsWith("GitHub API rate limit exceeded.")) throw err;
+    if (/Command failed with exit code|API rate limit/i.test(raw)) {
+      throw new Error(formatGhLandError(raw));
+    }
+    throw err;
+  }
 }
 
 // src/threads/create.ts
@@ -7923,7 +8179,7 @@ var Orchestrator = class {
     return thread;
   }
   listWorkspaces() {
-    const fromThreads = listThreads({ includeArchived: true }).map((t) => t.repoPath);
+    const fromThreads = listThreads({ includeArchived: false }).map((t) => t.repoPath);
     return syncWorkspacesFromThreads(fromThreads);
   }
   async addWorkspace(repoPath) {
@@ -8069,7 +8325,11 @@ var Orchestrator = class {
     }
     const isBrightsy = fresh.agent === "brightsy";
     const isOrchestration = isOrchestratorThread(fresh);
-    const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh);
+    const worktreeDirective = isBrightsy || isOrchestration ? null : formatWorktreeDirective(fresh, {
+      githubSlug: await resolveGithubRepoSlug(fresh.worktreePath).catch(
+        () => null
+      )
+    });
     const settings = loadWorkspaceSettings(fresh.worktreePath, fresh.repoPath);
     const { autoRenameBranchEnabled: autoRenameBranchEnabled2 } = await Promise.resolve().then(() => (init_app_settings(), app_settings_exports));
     const renameBranchDirective = !isBrightsy && !isOrchestration && autoRenameBranchEnabled2() ? formatRenameBranchDirective(fresh, {
@@ -8540,8 +8800,8 @@ var Orchestrator = class {
     if (result.prUrl) {
       const patch = { prUrl: result.prUrl };
       try {
-        const details = await getPrDetails(thread.worktreePath, result.prUrl);
-        if (details?.title) patch.prTitle = details.title;
+        const meta = await getPrMeta(thread.worktreePath, result.prUrl);
+        if (meta?.title) patch.prTitle = meta.title;
       } catch {
       }
       updateThread(thread.id, patch);
@@ -8574,6 +8834,24 @@ var Orchestrator = class {
     if (!selector) return null;
     return getPrChecks(cwd, selector);
   }
+  async getPrMeta(threadRef) {
+    const { thread, selector, cwd } = await this.withPrSelector(threadRef);
+    if (!selector) return null;
+    const meta = await getPrMeta(cwd, selector);
+    if (meta) {
+      const patch = {};
+      if (meta.url && meta.url !== thread.prUrl) patch.prUrl = meta.url;
+      if (meta.title && meta.title !== thread.prTitle) patch.prTitle = meta.title;
+      if (Object.keys(patch).length > 0) {
+        updateThread(thread.id, patch);
+        const latest = this.requireThread(thread.id);
+        if (!latest.userSetTitle && meta.title && latest.title !== meta.title) {
+          updateThread(thread.id, { title: meta.title });
+        }
+      }
+    }
+    return meta;
+  }
   async getPrDetails(threadRef) {
     const { thread, selector, cwd } = await this.withPrSelector(threadRef);
     if (!selector) return null;
@@ -9232,7 +9510,7 @@ async function startMcpServer() {
   );
   server.tool(
     "create_draft_pr",
-    "Commit dirty changes if needed, push the thread branch, and create/update a DRAFT GitHub PR. Ready-for-review / non-draft land stays human-only (CLI/app confirm_land). Prefer this when the orchestrator should open a PR itself; alternatively send_to_thread asking the worktree agent to run `gh pr create --draft`.",
+    "Commit dirty changes if needed, push the thread branch to origin, and create/update a DRAFT GitHub PR against that worktree's origin (never upstream). Ready-for-review / non-draft land stays human-only (CLI/app confirm_land). Prefer this when the orchestrator should open a PR itself; alternatively send_to_thread asking the worktree agent to run `gh pr create --draft -R <origin-owner/name>`.",
     { ref: import_zod.z.string() },
     async ({ ref }) => {
       try {
@@ -9758,11 +10036,13 @@ init_injected_mcp();
   enrichWorkspacesWithGithub,
   ensureAgentPath,
   ensureCloudCoordinator,
+  ensureGhPreferOrigin,
   ensureGlobalCoordinatorCwd,
   ensureWorkspace,
   estimateMessageChars,
   estimateThreadChars,
   expandComposerPrompt,
+  extractGhErrorDetail,
   extractiveSummary,
   fetchPrHead,
   finalizeParts,
@@ -9775,7 +10055,10 @@ init_injected_mcp();
   forkThreadWorktree,
   formatAgentInstructions,
   formatBrightsyFetchError,
+  formatGhLandError,
+  formatIpcInvokeError,
   formatMessagesAsTranscript,
+  formatRateLimitResetHint,
   formatRenameBranchDirective,
   formatTranscriptMarkdown,
   formatWorkspaceInventory,
@@ -9792,10 +10075,13 @@ init_injected_mcp();
   getPr,
   getPrChecks,
   getPrDetails,
+  getPrMeta,
   getRepoSetupInfo,
   getRunMode,
   getRunScript,
   gh,
+  ghHeadRef,
+  ghRepoSelectArgs,
   git,
   globalAgentCwd,
   harnessEnvKey,
@@ -9812,6 +10098,7 @@ init_injected_mcp();
   isBrightsyNdjsonLine,
   isCloudCoordinatorThread,
   isDirty,
+  isGhRateLimitError,
   isGlobalRepoPath,
   isGlobalThread,
   isLinearConnected,
@@ -9854,6 +10141,7 @@ init_injected_mcp();
   opencodeAdapter,
   orchestrationTitleNeedsSoccerNickname,
   orchestratorSessionPoisonedByBuiltins,
+  originGhRepoEnv,
   parseCursorRunnerLine,
   parseForceStopMessage,
   parseGithubSlugFromRemoteUrl,