@sideboard-ai/core 0.1.145 → 0.1.146

package/dist/{chunk-JSYIBLBK.js → chunk-YP3CSOZ6.js}

@@ -2252,45 +2252,128 @@ async function resolveWorktreeStartPoint(repoPath, sourceRef) {
 function isLocalPrFetchBranch(ref) {
   return /^sideboard-pr-\d+$/.test(ref.trim());
 }
-async function createThreadWorktree(opts) {
-  let branchName = `thread/${opts.slug}`;
-  const worktreePath = join2(worktreesRoot(opts.repoPath), opts.slug);
-  if (existsSync2(worktreePath)) {
-    throw new Error(`Worktree already exists at ${worktreePath}`);
+function originFetchBranch(sourceRef) {
+  const ref = sourceRef.trim();
+  if (!ref || isLocalPrFetchBranch(ref)) return null;
+  if (ref.startsWith("refs/remotes/origin/")) {
+    return ref.slice("refs/remotes/origin/".length) || null;
   }
-  await ensureGhPreferOrigin(opts.repoPath);
-  let startPoint = null;
+  if (ref.startsWith("refs/heads/")) {
+    return ref.slice("refs/heads/".length) || null;
+  }
+  if (ref.startsWith("refs/")) return null;
+  if (ref.startsWith("origin/")) return ref.slice("origin/".length) || null;
+  return ref;
+}
+async function fetchOriginWithAuth(repoPath, args, timeoutMs) {
+  const first = await git(args, repoPath, { reject: false, timeoutMs });
+  if (first.exitCode === 0) return true;
+  let mode;
   try {
-    startPoint = await resolveWorktreeStartPoint(opts.repoPath, opts.sourceRef);
+    mode = getGithubGitAuthMode();
   } catch {
-    startPoint = null;
+    return false;
   }
-  if (!isLocalPrFetchBranch(opts.sourceRef)) {
-    const fetchTimeoutMs = startPoint ? 12e3 : 45e3;
-    await git(["fetch", "origin", "--prune"], opts.repoPath, {
-      reject: false,
-      timeoutMs: fetchTimeoutMs
+  if (mode === "ssh") return false;
+  const token = await resolveGithubAgentToken(mode, repoPath);
+  if (!token) return false;
+  const tryHttps = async (header) => git(args, repoPath, {
+    reject: false,
+    timeoutMs,
+    env: { GIT_TERMINAL_PROMPT: "0" },
+    config: {
+      "url.https://github.com/.insteadOf": "git@github.com:",
+      "http.extraHeader": header
+    }
+  });
+  const bearer = await tryHttps(`AUTHORIZATION: bearer ${token}`);
+  if (bearer.exitCode === 0) return true;
+  const basic = Buffer.from(`x-access-token:${token}`, "utf8").toString("base64");
+  const basicFetch = await tryHttps(`Authorization: Basic ${basic}`);
+  return basicFetch.exitCode === 0;
+}
+async function fetchOriginForWorktree(repoPath, sourceRef, opts) {
+  const timeoutMs = opts?.timeoutMs ?? 2e4;
+  const branch = originFetchBranch(sourceRef);
+  if (!branch) return false;
+  const tipOk = await fetchOriginWithAuth(
+    repoPath,
+    ["fetch", "origin", branch],
+    timeoutMs
+  );
+  await fetchOriginWithAuth(repoPath, ["fetch", "origin", "--prune"], timeoutMs);
+  return tipOk;
+}
+async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
+  try {
+    const branch = opts?.branch?.trim() || await resolveDefaultBranch(repoPath, { network: false });
+    const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], repoPath, {
+      reject: false
     });
-    if (!opts.sourceRef.startsWith("origin/") && !opts.sourceRef.startsWith("refs/")) {
-      await git(["fetch", "origin", opts.sourceRef], opts.repoPath, {
-        reject: false,
-        timeoutMs: fetchTimeoutMs
-      });
+    const current = head.stdout.trim();
+    if (head.exitCode !== 0 || !current || current === "HEAD" || current !== branch) {
+      return { updated: false, reason: "not-on-default" };
     }
-    try {
-      startPoint = await resolveWorktreeStartPoint(
-        opts.repoPath,
-        opts.sourceRef
-      );
-    } catch (err) {
-      if (!startPoint) throw err;
+    if (await isDirty(repoPath)) {
+      return { updated: false, reason: "dirty" };
     }
-  }
-  if (!startPoint) {
-    throw new Error(
-      `Invalid git reference: ${opts.sourceRef} (and fetch did not resolve it)`
+    const remote = `origin/${branch}`;
+    const remoteOk = await git(["rev-parse", "--verify", remote], repoPath, {
+      reject: false
+    });
+    if (remoteOk.exitCode !== 0) {
+      return { updated: false, reason: "no-origin-tip" };
+    }
+    const ancestor = await git(
+      ["merge-base", "--is-ancestor", "HEAD", remote],
+      repoPath,
+      { reject: false }
+    );
+    if (ancestor.exitCode !== 0) {
+      return { updated: false, reason: "diverged" };
+    }
+    const behind = await git(
+      ["rev-list", "--count", `HEAD..${remote}`],
+      repoPath,
+      { reject: false }
     );
+    const n = Number(behind.stdout.trim());
+    if (behind.exitCode !== 0 || !Number.isFinite(n) || n <= 0) {
+      return { updated: false, reason: "already-current" };
+    }
+    const ff = await git(["merge", "--ff-only", remote], repoPath, {
+      reject: false
+    });
+    if (ff.exitCode !== 0) {
+      return { updated: false, reason: "ff-failed" };
+    }
+    return { updated: true, reason: "updated" };
+  } catch {
+    return { updated: false, reason: "ff-failed" };
+  }
+}
+async function refreshOriginAndMaybeFastForwardMain(repoPath, sourceRef) {
+  if (!isLocalPrFetchBranch(sourceRef)) {
+    await fetchOriginForWorktree(repoPath, sourceRef);
+  }
+  const def = await resolveDefaultBranch(repoPath, { network: false });
+  if (originFetchBranch(sourceRef) !== def) {
+    await fetchOriginForWorktree(repoPath, def);
+  }
+  await fastForwardMainCheckoutIfSafe(repoPath, { branch: def });
+}
+async function createThreadWorktree(opts) {
+  let branchName = `thread/${opts.slug}`;
+  const worktreePath = join2(worktreesRoot(opts.repoPath), opts.slug);
+  if (existsSync2(worktreePath)) {
+    throw new Error(`Worktree already exists at ${worktreePath}`);
   }
+  await ensureGhPreferOrigin(opts.repoPath);
+  await refreshOriginAndMaybeFastForwardMain(opts.repoPath, opts.sourceRef);
+  const startPoint = await resolveWorktreeStartPoint(
+    opts.repoPath,
+    opts.sourceRef
+  );
   const added = await withRepoGitLock(opts.repoPath, async () => {
     const add = await git(
       ["worktree", "add", "-b", branchName, worktreePath, startPoint],
@@ -2327,10 +2410,7 @@ async function createExistingBranchWorktree(opts) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
-  await git(["fetch", "origin", "--prune"], opts.repoPath, { reject: false });
-  if (!branchName.startsWith("origin/") && !branchName.startsWith("refs/")) {
-    await git(["fetch", "origin", branchName], opts.repoPath, { reject: false });
-  }
+  await refreshOriginAndMaybeFastForwardMain(opts.repoPath, branchName);
   const existing = await listWorktrees(opts.repoPath);
   const already = existing.find((w) => w.branch === branchName);
   if (already?.path) {
@@ -2792,6 +2872,9 @@ export {
   getPrDetails,
   fetchPrHead,
   resolveWorktreeStartPoint,
+  originFetchBranch,
+  fetchOriginForWorktree,
+  fastForwardMainCheckoutIfSafe,
   createThreadWorktree,
   createExistingBranchWorktree,
   removeWorktree,

package/dist/{chunk-3EMJ5LVV.js → chunk-ZZBN2MR7.js}

@@ -18,13 +18,13 @@ import {
   stripBrightsyNdjsonNoise,
   sumUsageList,
   toolDescription
-} from "./chunk-UJWGZM4K.js";
+} from "./chunk-WWH4NNBH.js";
 import {
   addWorkspace,
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-3UD2LW4P.js";
+} from "./chunk-JHZ6HGRI.js";
 import {
   assertOrchestratorCapableAgent,
   attachmentsFromWorktreePaths,
@@ -41,14 +41,14 @@ import {
   persistPendingFileAttachments,
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments
-} from "./chunk-G3KLNP2B.js";
+} from "./chunk-IHSR7EVK.js";
 import {
   SLACK_REPLY_FORMATTING,
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "./chunk-DN7UA3UT.js";
+} from "./chunk-SXPTL222.js";
 import {
   httpFetch
 } from "./chunk-ELBYOGVA.js";
@@ -90,6 +90,8 @@ import {
   currentBranch,
   detectGhStack,
   enqueueByKey,
+  fastForwardMainCheckoutIfSafe,
+  fetchOriginForWorktree,
   fetchPrHead,
   formatGhLandError,
   formatGitAuthModeDirective,
@@ -123,7 +125,7 @@ import {
   withRepoGitLock,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-JSYIBLBK.js";
+} from "./chunk-YP3CSOZ6.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR
@@ -454,7 +456,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-XPGJV7JK.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-KWV2PPML.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -734,9 +736,9 @@ async function spawnAgentTurn(thread, input, onEvent) {
       `Cannot spawn ${thread.agent}: thread ${thread.id} has no worktreePath`
     );
   }
-  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-6WR7OGMI.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-EZVQPMWT.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-J2WBXGLP.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-6EPVHVGJ.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -2963,6 +2965,8 @@ async function createThread(input, _onSetupLine) {
         `Cowboy mode uses ${defaultBranch} in the project folder. Switch that checkout to ${defaultBranch} first (currently ${head}).`
       );
     }
+    await fetchOriginForWorktree(repoPath, defaultBranch);
+    await fastForwardMainCheckoutIfSafe(repoPath, { branch: defaultBranch });
     const explicitTitle2 = input.title?.trim();
     const thread2 = createEmptyThread({
       title: explicitTitle2 || `Cowboy \xB7 ${head}`,
@@ -3069,7 +3073,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-VFBNZHI4.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-YVETHB2R.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -3476,7 +3480,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-WALT3MJB.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ZJATBC4A.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -5924,7 +5928,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-XPGJV7JK.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-KWV2PPML.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -7860,7 +7864,7 @@ var Orchestrator = class {
     this.emit({ type: "status_changed", threadId: archived.id, status: "archived" });
     if (thread.repoPath && !isGlobalRepoPath(thread.repoPath)) {
       try {
-        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-WALT3MJB.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ZJATBC4A.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -7914,7 +7918,7 @@ var Orchestrator = class {
           `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
         );
       }
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-3NLPMA7K.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-RZRJNHYL.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -8022,7 +8026,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-3NLPMA7K.js");
+    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-RZRJNHYL.js");
     const repo = await resolveRepoRoot2(repoPath);
     const def = await resolveDefaultBranch2(repo);
     return orch.createThread({

package/dist/{coordinator-prompt-JSX22ULD.js → coordinator-prompt-2EOR35TP.js}

@@ -9,8 +9,8 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-2C5RE7K4.js";
-import "./chunk-QS5JJ2IM.js";
+} from "./chunk-67K3FRKR.js";
+import "./chunk-JTPDWTWJ.js";
 import "./chunk-B3SJXYIJ.js";
 import "./chunk-EUXOHTUK.js";
 import "./chunk-KPIYENTF.js";

package/dist/{coordinator-prompt-J2WBXGLP.js → coordinator-prompt-6EPVHVGJ.js}

@@ -7,8 +7,8 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-DN7UA3UT.js";
-import "./chunk-JSYIBLBK.js";
+} from "./chunk-SXPTL222.js";
+import "./chunk-YP3CSOZ6.js";
 import "./chunk-FKOIHGKV.js";
 import "./chunk-I77RYPOH.js";
 import "./chunk-4TR3HZFT.js";

package/dist/{global-workspace-6WR7OGMI.js → global-workspace-EZVQPMWT.js}

@@ -15,9 +15,9 @@ import {
   orchestratorSessionPoisonedByBuiltins,
   slackCoordinatorSourceRef,
   takenTeamSlugsForOrchestration
-} from "./chunk-G3KLNP2B.js";
-import "./chunk-DN7UA3UT.js";
-import "./chunk-JSYIBLBK.js";
+} from "./chunk-IHSR7EVK.js";
+import "./chunk-SXPTL222.js";
+import "./chunk-YP3CSOZ6.js";
 import "./chunk-FKOIHGKV.js";
 import "./chunk-I77RYPOH.js";
 import "./chunk-4TR3HZFT.js";

package/dist/{global-workspace-AQESFS7I.js → global-workspace-PANZGRUS.js}

@@ -17,9 +17,9 @@ import {
   orchestratorSessionPoisonedByBuiltins,
   slackCoordinatorSourceRef,
   takenTeamSlugsForOrchestration
-} from "./chunk-XUYIJY6D.js";
-import "./chunk-2C5RE7K4.js";
-import "./chunk-QS5JJ2IM.js";
+} from "./chunk-KNE3FZ46.js";
+import "./chunk-67K3FRKR.js";
+import "./chunk-JTPDWTWJ.js";
 import "./chunk-B3SJXYIJ.js";
 import "./chunk-EUXOHTUK.js";
 import "./chunk-KPIYENTF.js";

package/dist/index.cjs

@@ -4952,6 +4952,8 @@ __export(worktree_exports, {
   currentBranch: () => currentBranch,
   detectLocalMergeConflicts: () => detectLocalMergeConflicts,
   ensureGhPreferOrigin: () => ensureGhPreferOrigin,
+  fastForwardMainCheckoutIfSafe: () => fastForwardMainCheckoutIfSafe,
+  fetchOriginForWorktree: () => fetchOriginForWorktree,
   fetchPrHead: () => fetchPrHead,
   getPr: () => getPr,
   getPrChecks: () => getPrChecks,
@@ -4972,6 +4974,7 @@ __export(worktree_exports, {
   markPrReady: () => markPrReady,
   mergePr: () => mergePr,
   normalizeWorktreePath: () => normalizeWorktreePath,
+  originFetchBranch: () => originFetchBranch,
   originGhRepoEnv: () => originGhRepoEnv,
   parseGithubSlugFromRemoteUrl: () => parseGithubSlugFromRemoteUrl,
   pushBranch: () => pushBranch,
@@ -5750,45 +5753,128 @@ async function resolveWorktreeStartPoint(repoPath, sourceRef) {
 function isLocalPrFetchBranch(ref) {
   return /^sideboard-pr-\d+$/.test(ref.trim());
 }
-async function createThreadWorktree(opts) {
-  let branchName = `thread/${opts.slug}`;
-  const worktreePath = (0, import_node_path18.join)(worktreesRoot(opts.repoPath), opts.slug);
-  if ((0, import_node_fs16.existsSync)(worktreePath)) {
-    throw new Error(`Worktree already exists at ${worktreePath}`);
+function originFetchBranch(sourceRef) {
+  const ref = sourceRef.trim();
+  if (!ref || isLocalPrFetchBranch(ref)) return null;
+  if (ref.startsWith("refs/remotes/origin/")) {
+    return ref.slice("refs/remotes/origin/".length) || null;
   }
-  await ensureGhPreferOrigin(opts.repoPath);
-  let startPoint = null;
+  if (ref.startsWith("refs/heads/")) {
+    return ref.slice("refs/heads/".length) || null;
+  }
+  if (ref.startsWith("refs/")) return null;
+  if (ref.startsWith("origin/")) return ref.slice("origin/".length) || null;
+  return ref;
+}
+async function fetchOriginWithAuth(repoPath, args, timeoutMs) {
+  const first = await git(args, repoPath, { reject: false, timeoutMs });
+  if (first.exitCode === 0) return true;
+  let mode;
   try {
-    startPoint = await resolveWorktreeStartPoint(opts.repoPath, opts.sourceRef);
+    mode = getGithubGitAuthMode();
   } catch {
-    startPoint = null;
+    return false;
   }
-  if (!isLocalPrFetchBranch(opts.sourceRef)) {
-    const fetchTimeoutMs = startPoint ? 12e3 : 45e3;
-    await git(["fetch", "origin", "--prune"], opts.repoPath, {
-      reject: false,
-      timeoutMs: fetchTimeoutMs
+  if (mode === "ssh") return false;
+  const token = await resolveGithubAgentToken(mode, repoPath);
+  if (!token) return false;
+  const tryHttps = async (header) => git(args, repoPath, {
+    reject: false,
+    timeoutMs,
+    env: { GIT_TERMINAL_PROMPT: "0" },
+    config: {
+      "url.https://github.com/.insteadOf": "git@github.com:",
+      "http.extraHeader": header
+    }
+  });
+  const bearer = await tryHttps(`AUTHORIZATION: bearer ${token}`);
+  if (bearer.exitCode === 0) return true;
+  const basic = Buffer.from(`x-access-token:${token}`, "utf8").toString("base64");
+  const basicFetch = await tryHttps(`Authorization: Basic ${basic}`);
+  return basicFetch.exitCode === 0;
+}
+async function fetchOriginForWorktree(repoPath, sourceRef, opts) {
+  const timeoutMs = opts?.timeoutMs ?? 2e4;
+  const branch = originFetchBranch(sourceRef);
+  if (!branch) return false;
+  const tipOk = await fetchOriginWithAuth(
+    repoPath,
+    ["fetch", "origin", branch],
+    timeoutMs
+  );
+  await fetchOriginWithAuth(repoPath, ["fetch", "origin", "--prune"], timeoutMs);
+  return tipOk;
+}
+async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
+  try {
+    const branch = opts?.branch?.trim() || await resolveDefaultBranch(repoPath, { network: false });
+    const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], repoPath, {
+      reject: false
     });
-    if (!opts.sourceRef.startsWith("origin/") && !opts.sourceRef.startsWith("refs/")) {
-      await git(["fetch", "origin", opts.sourceRef], opts.repoPath, {
-        reject: false,
-        timeoutMs: fetchTimeoutMs
-      });
+    const current = head.stdout.trim();
+    if (head.exitCode !== 0 || !current || current === "HEAD" || current !== branch) {
+      return { updated: false, reason: "not-on-default" };
     }
-    try {
-      startPoint = await resolveWorktreeStartPoint(
-        opts.repoPath,
-        opts.sourceRef
-      );
-    } catch (err) {
-      if (!startPoint) throw err;
+    if (await isDirty(repoPath)) {
+      return { updated: false, reason: "dirty" };
     }
-  }
-  if (!startPoint) {
-    throw new Error(
-      `Invalid git reference: ${opts.sourceRef} (and fetch did not resolve it)`
+    const remote = `origin/${branch}`;
+    const remoteOk = await git(["rev-parse", "--verify", remote], repoPath, {
+      reject: false
+    });
+    if (remoteOk.exitCode !== 0) {
+      return { updated: false, reason: "no-origin-tip" };
+    }
+    const ancestor = await git(
+      ["merge-base", "--is-ancestor", "HEAD", remote],
+      repoPath,
+      { reject: false }
     );
+    if (ancestor.exitCode !== 0) {
+      return { updated: false, reason: "diverged" };
+    }
+    const behind = await git(
+      ["rev-list", "--count", `HEAD..${remote}`],
+      repoPath,
+      { reject: false }
+    );
+    const n = Number(behind.stdout.trim());
+    if (behind.exitCode !== 0 || !Number.isFinite(n) || n <= 0) {
+      return { updated: false, reason: "already-current" };
+    }
+    const ff = await git(["merge", "--ff-only", remote], repoPath, {
+      reject: false
+    });
+    if (ff.exitCode !== 0) {
+      return { updated: false, reason: "ff-failed" };
+    }
+    return { updated: true, reason: "updated" };
+  } catch {
+    return { updated: false, reason: "ff-failed" };
+  }
+}
+async function refreshOriginAndMaybeFastForwardMain(repoPath, sourceRef) {
+  if (!isLocalPrFetchBranch(sourceRef)) {
+    await fetchOriginForWorktree(repoPath, sourceRef);
   }
+  const def = await resolveDefaultBranch(repoPath, { network: false });
+  if (originFetchBranch(sourceRef) !== def) {
+    await fetchOriginForWorktree(repoPath, def);
+  }
+  await fastForwardMainCheckoutIfSafe(repoPath, { branch: def });
+}
+async function createThreadWorktree(opts) {
+  let branchName = `thread/${opts.slug}`;
+  const worktreePath = (0, import_node_path18.join)(worktreesRoot(opts.repoPath), opts.slug);
+  if ((0, import_node_fs16.existsSync)(worktreePath)) {
+    throw new Error(`Worktree already exists at ${worktreePath}`);
+  }
+  await ensureGhPreferOrigin(opts.repoPath);
+  await refreshOriginAndMaybeFastForwardMain(opts.repoPath, opts.sourceRef);
+  const startPoint = await resolveWorktreeStartPoint(
+    opts.repoPath,
+    opts.sourceRef
+  );
   const added = await withRepoGitLock(opts.repoPath, async () => {
     const add = await git(
       ["worktree", "add", "-b", branchName, worktreePath, startPoint],
@@ -5825,10 +5911,7 @@ async function createExistingBranchWorktree(opts) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
-  await git(["fetch", "origin", "--prune"], opts.repoPath, { reject: false });
-  if (!branchName.startsWith("origin/") && !branchName.startsWith("refs/")) {
-    await git(["fetch", "origin", branchName], opts.repoPath, { reject: false });
-  }
+  await refreshOriginAndMaybeFastForwardMain(opts.repoPath, branchName);
   const existing = await listWorktrees(opts.repoPath);
   const already = existing.find((w) => w.branch === branchName);
   if (already?.path) {
@@ -14964,6 +15047,8 @@ async function createThread(input, _onSetupLine) {
         `Cowboy mode uses ${defaultBranch} in the project folder. Switch that checkout to ${defaultBranch} first (currently ${head}).`
       );
     }
+    await fetchOriginForWorktree(repoPath, defaultBranch);
+    await fastForwardMainCheckoutIfSafe(repoPath, { branch: defaultBranch });
     const explicitTitle2 = input.title?.trim();
     const thread2 = createEmptyThread({
       title: explicitTitle2 || `Cowboy \xB7 ${head}`,
@@ -20481,6 +20566,8 @@ __export(index_exports, {
   extractPendingPlanQuestions: () => extractPendingPlanQuestions,
   extractPresentedPlan: () => extractPresentedPlan,
   extractiveSummary: () => extractiveSummary,
+  fastForwardMainCheckoutIfSafe: () => fastForwardMainCheckoutIfSafe,
+  fetchOriginForWorktree: () => fetchOriginForWorktree,
   fetchPrHead: () => fetchPrHead,
   finalizeParts: () => finalizeParts,
   findConventionSetup: () => findConventionSetup,
@@ -20723,6 +20810,7 @@ __export(index_exports, {
   orchestrationQuotaOnLimit: () => orchestrationQuotaOnLimit,
   orchestrationTitleNeedsSoccerNickname: () => orchestrationTitleNeedsSoccerNickname,
   orchestratorSessionPoisonedByBuiltins: () => orchestratorSessionPoisonedByBuiltins,
+  originFetchBranch: () => originFetchBranch,
   originGhRepoEnv: () => originGhRepoEnv,
   packagedDetachedJobPath: () => packagedDetachedJobPath,
   parseCursorRunnerLine: () => parseCursorRunnerLine,
@@ -27069,6 +27157,8 @@ init_outbound_watch();
   extractPendingPlanQuestions,
   extractPresentedPlan,
   extractiveSummary,
+  fastForwardMainCheckoutIfSafe,
+  fetchOriginForWorktree,
   fetchPrHead,
   finalizeParts,
   findConventionSetup,
@@ -27311,6 +27401,7 @@ init_outbound_watch();
   orchestrationQuotaOnLimit,
   orchestrationTitleNeedsSoccerNickname,
   orchestratorSessionPoisonedByBuiltins,
+  originFetchBranch,
   originGhRepoEnv,
   packagedDetachedJobPath,
   parseCursorRunnerLine,