@sideboard-ai/core 0.1.10 → 0.1.19

package/dist/{agents-OAX7XPKX.js → agents-2XMZO3CY.js}

@@ -11,7 +11,7 @@ import {
   listBrightsyChatTargets,
   opencodeAdapter,
   permissionMode
-} from "./chunk-WMCPLDW3.js";
+} from "./chunk-JQJZTL2Q.js";
 import "./chunk-ILQK4P5R.js";
 import {
   cursorSdkMessageToEvents,

package/dist/{chunk-2M4OHXYX.js → chunk-5263JXQY.js}

@@ -1,11 +1,11 @@
 import {
   ensureGlobalCoordinatorCwd
-} from "./chunk-2R5VV4BA.js";
+} from "./chunk-SNHWAARD.js";
 import {
   allocateTeamName,
   takenSlugsFromThread,
   teamSlugFromName
-} from "./chunk-LL7DTZ5B.js";
+} from "./chunk-LXHSRNJJ.js";
 import {
   createEmptyThread,
   listThreads,

package/dist/{chunk-WMCPLDW3.js → chunk-JQJZTL2Q.js}

@@ -719,7 +719,7 @@ var claudeAdapter = {
       );
     }
     const mode = permissionMode(thread);
-    const { isOrchestratorThread } = await import("./global-workspace-R44HGBU6.js");
+    const { isOrchestratorThread } = await import("./global-workspace-IV6LIDTO.js");
     const isOrchestrator = isOrchestratorThread(thread);
     const injectedServers = await buildInjectedMcpServers({
       includeSideboard: isOrchestrator,

package/dist/{chunk-TLJH3L2C.js → chunk-LIUV5ONW.js}

@@ -1,9 +1,10 @@
 import {
   isGlobalRepoPath
-} from "./chunk-2M4OHXYX.js";
+} from "./chunk-5263JXQY.js";
 import {
+  ensureGhPreferOrigin,
   resolveRepoRoot
-} from "./chunk-LL7DTZ5B.js";
+} from "./chunk-LXHSRNJJ.js";
 import {
   appDataDir
 } from "./chunk-M37RITA6.js";
@@ -14,6 +15,9 @@ import { basename, join } from "path";
 function workspacesFile() {
   return join(appDataDir(), "workspaces.json");
 }
+function removedWorkspacesFile() {
+  return join(appDataDir(), "removed-workspaces.json");
+}
 function readAll() {
   const path = workspacesFile();
   if (!existsSync(path)) return [];
@@ -28,12 +32,44 @@ function writeAll(list) {
   mkdirSync(appDataDir(), { recursive: true });
   writeFileSync(workspacesFile(), JSON.stringify(list, null, 2), "utf8");
 }
+function readRemoved() {
+  const path = removedWorkspacesFile();
+  if (!existsSync(path)) return /* @__PURE__ */ new Set();
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    return new Set(Array.isArray(raw) ? raw.filter((p) => typeof p === "string") : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function writeRemoved(paths) {
+  mkdirSync(appDataDir(), { recursive: true });
+  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 (!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;
@@ -47,16 +83,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 (!existsSync(path)) continue;
     const ws = {
       path,

package/dist/{chunk-LL7DTZ5B.js → chunk-LXHSRNJJ.js}

@@ -459,6 +459,64 @@ function worktreeDisplayLabelForGroup(threads) {
   return threadDisplayLabel(canonical);
 }
 
+// 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);
+}
+
 // src/git/pr-gates.ts
 function buildMergeGateChecks(gate, opts = {}) {
   const rows = [];
@@ -547,6 +605,31 @@ function buildMergeGateChecks(gate, opts = {}) {
 }
 
 // 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);
 }
@@ -555,10 +638,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, {
@@ -570,13 +656,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);
@@ -584,15 +673,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,
@@ -601,6 +710,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}`],
@@ -861,6 +995,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 = [
@@ -882,7 +1047,6 @@ async function getPrDetails(cwd, selector) {
       "additions",
       "deletions",
       "changedFiles",
-      "commits",
       "comments",
       "reviews"
     ].join(",")
@@ -901,14 +1065,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 {
@@ -925,19 +1082,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 ?? {};
@@ -957,7 +1103,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) {
@@ -993,6 +1140,7 @@ async function createThreadWorktree(opts) {
   if (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, {
@@ -1021,6 +1169,7 @@ ${add.stdout}`;
         );
         if (retry.exitCode === 0) {
           branchName = alt;
+          await ensureGhPreferOrigin(worktreePath);
           return { branchName, worktreePath };
         }
       }
@@ -1029,6 +1178,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) {
@@ -1129,8 +1279,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 }
   );
@@ -1138,9 +1298,10 @@ async function createOrUpdatePr(worktreePath, opts) {
     const url2 = existing.stdout.trim();
     await gh(
       [
+        ...repoArgs,
         "pr",
         "edit",
-        opts.head,
+        branchOnly,
         "--title",
         opts.title,
         "--body",
@@ -1153,6 +1314,7 @@ async function createOrUpdatePr(worktreePath, opts) {
   }
   if (opts.web) {
     const args2 = [
+      ...repoArgs,
       "pr",
       "create",
       "--web",
@@ -1163,18 +1325,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",
@@ -1184,11 +1347,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) {
@@ -1252,10 +1419,19 @@ export {
   threadDisplayLabel,
   worktreeDisplayLabel,
   worktreeDisplayLabelForGroup,
+  isGhRateLimitError,
+  formatRateLimitResetHint,
+  extractGhErrorDetail,
+  formatGhLandError,
+  formatIpcInvokeError,
   slugify,
   resolveRepoRoot,
   parseGithubSlugFromRemoteUrl,
   resolveGithubRepoSlug,
+  ghRepoSelectArgs,
+  ghHeadRef,
+  ensureGhPreferOrigin,
+  originGhRepoEnv,
   resolveDefaultBranch,
   resolveDiffBaseRef,
   listBranches,
@@ -1264,6 +1440,7 @@ export {
   resolvePrSelector,
   detectLocalMergeConflicts,
   getPrChecks,
+  getPrMeta,
   getPrDetails,
   fetchPrHead,
   resolveWorktreeStartPoint,

package/dist/{chunk-2R5VV4BA.js → chunk-SNHWAARD.js}

@@ -1,6 +1,6 @@
 import {
   resolveGithubRepoSlug
-} from "./chunk-LL7DTZ5B.js";
+} from "./chunk-LXHSRNJJ.js";
 import {
   globalAgentCwd,
   sideboardReposDir
@@ -31,7 +31,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");
 }
@@ -56,8 +57,8 @@ var COORDINATOR_TOOL_PLAYBOOK = [
   "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."
@@ -123,7 +124,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}`,