@sideboard-ai/core 0.1.15 → 0.1.19

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

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

package/dist/{chunk-3OJG4LP4.js → chunk-5263JXQY.js}

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

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

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

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

@@ -1,9 +1,10 @@
 import {
   isGlobalRepoPath
-} from "./chunk-3OJG4LP4.js";
+} from "./chunk-5263JXQY.js";
 import {
+  ensureGhPreferOrigin,
   resolveRepoRoot
-} from "./chunk-L44AX7IG.js";
+} from "./chunk-LXHSRNJJ.js";
 import {
   appDataDir
 } from "./chunk-M37RITA6.js";
@@ -57,7 +58,9 @@ function forgetRemoved(repoPath) {
 }
 function listWorkspaces() {
   const all = readAll();
-  const valid = all.filter((w) => Boolean(w.path) && w.path !== "/" && w.path !== ".");
+  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));
 }
@@ -66,6 +69,7 @@ async function addWorkspace(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;

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

@@ -492,6 +492,16 @@ function formatGhLandError(raw, opts) {
     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.";
@@ -606,12 +616,19 @@ async function lookupGithubGraphqlReset(cwd) {
     return void 0;
   }
 }
-async function formatPrCreateFailure(raw, cwd) {
+async function formatPrCreateFailure(raw, cwd, ctx) {
   if (!isGhRateLimitError(raw)) {
-    return formatGhLandError(raw);
+    return formatGhLandError(raw, {
+      targetedRepo: ctx?.slug,
+      headRef: ctx?.head
+    });
   }
   const resetAt = await lookupGithubGraphqlReset(cwd);
-  return formatGhLandError(raw, { resetAt });
+  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);
@@ -621,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, {
@@ -636,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);
@@ -650,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,
@@ -667,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}`],
@@ -1072,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, {
@@ -1100,6 +1169,7 @@ ${add.stdout}`;
         );
         if (retry.exitCode === 0) {
           branchName = alt;
+          await ensureGhPreferOrigin(worktreePath);
           return { branchName, worktreePath };
         }
       }
@@ -1108,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) {
@@ -1208,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 }
   );
@@ -1217,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",
@@ -1232,6 +1314,7 @@ async function createOrUpdatePr(worktreePath, opts) {
   }
   if (opts.web) {
     const args2 = [
+      ...repoArgs,
       "pr",
       "create",
       "--web",
@@ -1242,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",
@@ -1263,13 +1347,13 @@ async function createOrUpdatePr(worktreePath, opts) {
     "--base",
     opts.base,
     "--head",
-    opts.head
+    headRef
   ];
   if (opts.draft) args.push("--draft");
   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));
+    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;
@@ -1344,6 +1428,10 @@ export {
   resolveRepoRoot,
   parseGithubSlugFromRemoteUrl,
   resolveGithubRepoSlug,
+  ghRepoSelectArgs,
+  ghHeadRef,
+  ensureGhPreferOrigin,
+  originGhRepoEnv,
   resolveDefaultBranch,
   resolveDiffBaseRef,
   listBranches,

package/dist/{chunk-TNIAXABV.js → chunk-SNHWAARD.js}

@@ -1,6 +1,6 @@
 import {
   resolveGithubRepoSlug
-} from "./chunk-L44AX7IG.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}`,

package/dist/{chunk-MAWKQA2Y.js → chunk-WWBC56EL.js}

@@ -3,7 +3,7 @@ import {
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-MGSJQMJA.js";
+} from "./chunk-LIUV5ONW.js";
 import {
   GLOBAL_WORKSPACE_ID,
   createGlobalChat,
@@ -13,19 +13,19 @@ import {
   isGlobalThread,
   isOrchestratorThread,
   orchestratorSessionPoisonedByBuiltins
-} from "./chunk-3OJG4LP4.js";
+} from "./chunk-5263JXQY.js";
 import {
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "./chunk-TNIAXABV.js";
+} from "./chunk-SNHWAARD.js";
 import {
   PLAN_MODE_INSTRUCTION,
   allAdapters,
   getAdapter,
   parseBrightsyCliLine
-} from "./chunk-MEI4AXV4.js";
+} from "./chunk-JQJZTL2Q.js";
 import {
   childEnvWithAppSettings,
   getLinearApiKey,
@@ -53,6 +53,7 @@ import {
   listWorktrees,
   mergePr,
   normalizeWorktreePath,
+  originGhRepoEnv,
   pushBranch,
   removeWorktree,
   resolveDefaultBranch,
@@ -63,7 +64,7 @@ import {
   takenSlugsFromThread,
   threadDisplayLabel,
   worktreeNameFromPath
-} from "./chunk-L44AX7IG.js";
+} from "./chunk-LXHSRNJJ.js";
 import {
   appendMessage,
   createEmptyThread,
@@ -431,9 +432,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-H642B5OI.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-IV6LIDTO.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-G6T7ORT3.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-QPTX6YCW.js");
     ensureGlobalCoordinatorCwd2();
   }
   const adapter = getAdapter(thread.agent);
@@ -443,9 +444,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 = execa(cmd.file, cmd.args, {
     cwd: cmd.cwd,
-    env: childEnvWithAppSettings(cmd.env),
+    env,
     reject: false,
     stdout: "pipe",
     stderr: "pipe",
@@ -548,7 +554,7 @@ function formatRenameBranchDirective(thread, opts) {
   }
   return lines.join("\n");
 }
-function formatWorktreeDirective(thread) {
+function formatWorktreeDirective(thread, opts) {
   const worktree = normPath(thread.worktreePath);
   const repo = normPath(thread.repoPath);
   const dir = worktreeNameFromPath(thread.worktreePath);
@@ -569,7 +575,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."
   );
@@ -583,9 +595,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");
@@ -2257,7 +2273,7 @@ async function createThread(input, onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-RO3AJ76Q.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-2XMZO3CY.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -2473,7 +2489,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-4EREGLB7.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-JBWIRU55.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -3195,7 +3211,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 } = await import("./app-settings-BDMLWCWI.js");
     const renameBranchDirective = !isBrightsy && !isOrchestration && autoRenameBranchEnabled() ? formatRenameBranchDirective(fresh, {
@@ -3839,7 +3859,7 @@ var Orchestrator = class {
       return setStatus(thread.id, "idle");
     }
     if (!existsSync10(thread.worktreePath)) {
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-ZDHZMLSJ.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-TYI2SANE.js");
       const { execa: execa6 } = await import("execa");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
@@ -3916,7 +3936,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-ZDHZMLSJ.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-TYI2SANE.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return createThread({
@@ -4370,7 +4390,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: z.string() },
     async ({ ref }) => {
       try {

package/dist/{coordinator-prompt-G6T7ORT3.js → coordinator-prompt-QPTX6YCW.js}

@@ -6,8 +6,8 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-TNIAXABV.js";
-import "./chunk-L44AX7IG.js";
+} from "./chunk-SNHWAARD.js";
+import "./chunk-LXHSRNJJ.js";
 import "./chunk-HYRHI3QU.js";
 import "./chunk-M37RITA6.js";
 import "./chunk-AJ6ROGD7.js";

package/dist/{global-workspace-H642B5OI.js → global-workspace-IV6LIDTO.js}

@@ -11,9 +11,9 @@ import {
   orchestrationTitleNeedsSoccerNickname,
   orchestratorSessionPoisonedByBuiltins,
   takenTeamSlugsForOrchestration
-} from "./chunk-3OJG4LP4.js";
-import "./chunk-TNIAXABV.js";
-import "./chunk-L44AX7IG.js";
+} from "./chunk-5263JXQY.js";
+import "./chunk-SNHWAARD.js";
+import "./chunk-LXHSRNJJ.js";
 import "./chunk-HYRHI3QU.js";
 import {
   globalAgentCwd