@sideboard-ai/core 0.1.144 → 0.1.146

package/dist/{chunk-O3JEC2UJ.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) {
@@ -2396,6 +2476,32 @@ async function listWorktrees(repoPath) {
   if (current) entries.push(current);
   return entries;
 }
+async function countUnpushedVsOrigin(worktreePath) {
+  const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath, {
+    reject: false
+  });
+  const branch = head.stdout.trim();
+  if (branch && branch !== "HEAD") {
+    const remote = await git(
+      ["rev-list", "--count", `origin/${branch}..HEAD`],
+      worktreePath,
+      { reject: false }
+    );
+    if (remote.exitCode === 0) {
+      const n = Number(remote.stdout.trim());
+      return Number.isFinite(n) ? n : 1;
+    }
+    const all = await git(["rev-list", "--count", "HEAD"], worktreePath, {
+      reject: false
+    });
+    if (all.exitCode === 0) {
+      const n = Number(all.stdout.trim());
+      if (Number.isFinite(n) && n > 0) return n;
+    }
+    return 1;
+  }
+  return 1;
+}
 async function isDirty(worktreePath) {
   const { stdout } = await git(["status", "--porcelain"], worktreePath);
   for (const line of stdout.split("\n")) {
@@ -2459,6 +2565,54 @@ async function pushBranch(worktreePath, branchName) {
   const httpsErr = (basicPush.stderr || bearer.stderr || bearer.stdout).trim();
   throw new Error(httpsErr || sshErr || `git push origin ${branchName} failed`);
 }
+async function runPrReady(cwd, selector, slug) {
+  const readyArgs = ["pr", "ready", selector];
+  if (slug) readyArgs.push("--repo", slug);
+  const ready = await gh(readyArgs, cwd, { reject: false });
+  if (ready.exitCode !== 0) {
+    throw new Error(
+      ready.stderr.trim() || ready.stdout.trim() || "Could not mark draft pull request as ready"
+    );
+  }
+}
+async function markPrReady(cwd, selector) {
+  const slug = await resolveGithubRepoSlug(cwd);
+  const viewArgs = ["pr", "view", selector, "--json", "url,state,isDraft"];
+  if (slug) viewArgs.push("--repo", slug);
+  const before = await gh(viewArgs, cwd, { reject: false });
+  if (before.exitCode !== 0 || !before.stdout.trim()) {
+    throw new Error(before.stderr.trim() || "Could not load pull request");
+  }
+  let url = "";
+  let state = "";
+  let isDraft = false;
+  try {
+    const parsed = JSON.parse(before.stdout);
+    url = String(parsed.url ?? "");
+    state = String(parsed.state ?? "").toUpperCase();
+    isDraft = Boolean(parsed.isDraft);
+  } catch {
+    throw new Error("Could not parse pull request details");
+  }
+  if (state === "MERGED" || state === "CLOSED") {
+    return { url, state, isDraft: false };
+  }
+  if (isDraft) {
+    if (await isDirty(cwd)) {
+      throw new Error(
+        "Commit and push local work before marking the pull request ready for review."
+      );
+    }
+    const unpushed = await countUnpushedVsOrigin(cwd);
+    if (unpushed > 0) {
+      throw new Error(
+        "Push this branch to origin before marking the pull request ready for review."
+      );
+    }
+    await runPrReady(cwd, selector, slug);
+  }
+  return { url, state: state || "OPEN", isDraft: false };
+}
 async function mergePr(cwd, selector, opts) {
   const slug = await resolveGithubRepoSlug(cwd);
   const viewArgs = ["pr", "view", selector, "--json", "url,state,isDraft,number"];
@@ -2493,14 +2647,7 @@ async function mergePr(cwd, selector, opts) {
     return { url, state: "MERGED" };
   }
   if (isDraft) {
-    const readyArgs = ["pr", "ready", selector];
-    if (slug) readyArgs.push("--repo", slug);
-    const ready = await gh(readyArgs, cwd, { reject: false });
-    if (ready.exitCode !== 0) {
-      throw new Error(
-        ready.stderr.trim() || ready.stdout.trim() || "Could not mark draft pull request as ready"
-      );
-    }
+    await runPrReady(cwd, selector, slug);
   }
   const method = opts?.method ?? "squash";
   const mergeFlag = method === "rebase" ? "--rebase" : method === "merge" ? "--merge" : "--squash";
@@ -2725,15 +2872,20 @@ export {
   getPrDetails,
   fetchPrHead,
   resolveWorktreeStartPoint,
+  originFetchBranch,
+  fetchOriginForWorktree,
+  fastForwardMainCheckoutIfSafe,
   createThreadWorktree,
   createExistingBranchWorktree,
   removeWorktree,
   listWorktrees,
+  countUnpushedVsOrigin,
   isDirty,
   isSideboardScratchPath,
   currentBranch,
   commitAll,
   pushBranch,
+  markPrReady,
   mergePr,
   createOrUpdatePr,
   suggestSlug,

package/dist/{chunk-FGT26PJE.js → chunk-ZZBN2MR7.js}

@@ -18,13 +18,13 @@ import {
   stripBrightsyNdjsonNoise,
   sumUsageList,
   toolDescription
-} from "./chunk-VHTIHOHE.js";
+} from "./chunk-WWH4NNBH.js";
 import {
   addWorkspace,
   ensureWorkspace,
   removeWorkspace,
   syncWorkspacesFromThreads
-} from "./chunk-HC5N3BDL.js";
+} from "./chunk-JHZ6HGRI.js";
 import {
   assertOrchestratorCapableAgent,
   attachmentsFromWorktreePaths,
@@ -41,14 +41,14 @@ import {
   persistPendingFileAttachments,
   stageAbsolutePathsAsAttachments,
   stageBuffersAsAttachments
-} from "./chunk-R2W7A2UO.js";
+} from "./chunk-IHSR7EVK.js";
 import {
   SLACK_REPLY_FORMATTING,
   coordinatorSystemPrompt,
   coordinatorTurnReminder,
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd
-} from "./chunk-UG5N7ET3.js";
+} from "./chunk-SXPTL222.js";
 import {
   httpFetch
 } from "./chunk-ELBYOGVA.js";
@@ -90,6 +90,8 @@ import {
   currentBranch,
   detectGhStack,
   enqueueByKey,
+  fastForwardMainCheckoutIfSafe,
+  fetchOriginForWorktree,
   fetchPrHead,
   formatGhLandError,
   formatGitAuthModeDirective,
@@ -104,6 +106,7 @@ import {
   isPlaceholderBranch,
   isSideboardScratchPath,
   listWorktrees,
+  markPrReady,
   mergeAgentGitAuthEnv,
   mergePr,
   normalizeWorktreePath,
@@ -122,7 +125,7 @@ import {
   withRepoGitLock,
   worktreeDisplayLabelForGroup,
   worktreeNameFromPath
-} from "./chunk-O3JEC2UJ.js";
+} from "./chunk-YP3CSOZ6.js";
 import {
   ATTACHMENTS_DIR,
   LEGACY_ATTACHMENTS_DIR
@@ -453,7 +456,7 @@ async function continueSourceThread(threadId, prompt) {
       await continueOnReply(threadId, prompt);
       return;
     }
-    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-DB5ZSE6M.js");
+    const { getOrchestrator: getOrchestrator2 } = await import("./orchestrator-KWV2PPML.js");
     await getOrchestrator2().send(threadId, prompt);
   } catch {
   }
@@ -733,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-NG7SU3GV.js");
+  const { isGlobalThread: isGlobalThread2 } = await import("./global-workspace-EZVQPMWT.js");
   if (isGlobalThread2(thread)) {
-    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-2LD3C74O.js");
+    const { ensureGlobalCoordinatorCwd: ensureGlobalCoordinatorCwd2 } = await import("./coordinator-prompt-6EPVHVGJ.js");
     ensureGlobalCoordinatorCwd2(
       isOrchestratorThread(thread) ? { orchestratorThreadId: thread.id } : void 0
     );
@@ -2962,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}`,
@@ -3068,7 +3073,7 @@ async function createThread(input, _onSetupLine) {
   return readThread(thread.id) ?? thread;
 }
 async function listLinearIssues(agent, repoPath) {
-  const { getAdapter: getAdapter2 } = await import("./agents-E5AAMHDY.js");
+  const { getAdapter: getAdapter2 } = await import("./agents-YVETHB2R.js");
   await requireAgent(agent, { requireLinear: true });
   const adapter = getAdapter2(agent);
   if (!adapter.listLinearIssues) {
@@ -3475,7 +3480,7 @@ async function adoptThread(input) {
     messages: input.messages ?? []
   });
   writeThread(thread);
-  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-PU5YHQ7Z.js");
+  const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ZJATBC4A.js");
   await ensureWorkspace2(repoPath);
   return thread;
 }
@@ -5923,7 +5928,7 @@ function formatScheduledPrompt(name, prompt) {
 ${prompt}`;
 }
 async function defaultDeps() {
-  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-DB5ZSE6M.js");
+  const { getOrchestrator: getOrchestrator2, startOrchestration: startOrchestration2 } = await import("./orchestrator-KWV2PPML.js");
   const orch = getOrchestrator2();
   return {
     findThread: (id) => findThreadByRef(id),
@@ -7448,6 +7453,32 @@ var Orchestrator = class {
     }
     return result;
   }
+  async markPrReady(threadRef) {
+    const { thread, selectors, cwd } = await this.withPrSelector(threadRef);
+    this.assertNotGlobal(thread, "Ready for review");
+    const selector = selectors[0];
+    if (!selector) throw new Error("No pull request linked to this thread");
+    const result = await markPrReady(cwd, selector);
+    const meta = await getPrMeta(cwd, selector);
+    if (meta) {
+      await this.persistPrMetaAndMaybeArchive(thread, { ...meta, isDraft: false });
+      return { url: meta.url || result.url, state: meta.state || result.state, isDraft: false };
+    }
+    await this.persistPrMetaAndMaybeArchive(thread, {
+      number: 0,
+      title: thread.prTitle ?? thread.title,
+      url: result.url || thread.prUrl || "",
+      state: result.state || "OPEN",
+      isDraft: false,
+      reviewDecision: null,
+      baseRefName: "",
+      headRefName: "",
+      isInMergeQueue: false,
+      mergeable: null,
+      mergeStateStatus: null
+    });
+    return { ...result, isDraft: false };
+  }
   async mergePr(threadRef) {
     const { thread, selectors, cwd } = await this.withPrSelector(threadRef);
     this.assertNotGlobal(thread, "Merge PR");
@@ -7833,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-PU5YHQ7Z.js");
+        const { ensureWorkspace: ensureWorkspace2 } = await import("./workspaces-ZJATBC4A.js");
         await ensureWorkspace2(thread.repoPath);
       } catch {
       }
@@ -7887,7 +7918,7 @@ var Orchestrator = class {
           `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
         );
       }
-      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-GKLPPNWR.js");
+      const { createThreadWorktree: createThreadWorktree2 } = await import("./worktree-RZRJNHYL.js");
       const slug = thread.worktreePath.split("/").pop();
       const dest = thread.worktreePath;
       await withRepoGitLock(thread.repoPath, async () => {
@@ -7995,7 +8026,7 @@ async function startOrchestration(opts) {
     sourceRef: "default",
     ...createOpts
   }).catch(async () => {
-    const { resolveDefaultBranch: resolveDefaultBranch2, resolveRepoRoot: resolveRepoRoot2 } = await import("./worktree-GKLPPNWR.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-FBX7Y4EM.js → coordinator-prompt-2EOR35TP.js}

@@ -9,8 +9,8 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-OHWN4JEL.js";
-import "./chunk-4Q45TLZ5.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-2LD3C74O.js → coordinator-prompt-6EPVHVGJ.js}

@@ -7,8 +7,8 @@ import {
   enrichWorkspacesWithGithub,
   ensureGlobalCoordinatorCwd,
   formatWorkspaceInventory
-} from "./chunk-UG5N7ET3.js";
-import "./chunk-O3JEC2UJ.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-NG7SU3GV.js → global-workspace-EZVQPMWT.js}

@@ -15,9 +15,9 @@ import {
   orchestratorSessionPoisonedByBuiltins,
   slackCoordinatorSourceRef,
   takenTeamSlugsForOrchestration
-} from "./chunk-R2W7A2UO.js";
-import "./chunk-UG5N7ET3.js";
-import "./chunk-O3JEC2UJ.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-OCV77UYF.js → global-workspace-PANZGRUS.js}

@@ -17,9 +17,9 @@ import {
   orchestratorSessionPoisonedByBuiltins,
   slackCoordinatorSourceRef,
   takenTeamSlugsForOrchestration
-} from "./chunk-FADNFPZO.js";
-import "./chunk-OHWN4JEL.js";
-import "./chunk-4Q45TLZ5.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";