@sideboard-ai/core 0.1.292 → 0.1.294

package/dist/agents/cursor-runner.js

@@ -35,9 +35,291 @@ import {
 import "../chunk-EHT2DRT4.js";
 
 // src/agents/cursor-runner.ts
-import { mkdirSync } from "fs";
+import { mkdirSync as mkdirSync2 } from "fs";
 import { createInterface } from "readline";
 
+// src/agents/cursor-catalog.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join } from "path";
+import lockfile from "proper-lockfile";
+var CATALOG_FILES = ["agents.ndjson", "runs.ndjson", "run_events.ndjson", "checkpoints.ndjson"];
+var INTERRUPTED_TMP = /^\.(agents|runs|run_events|checkpoints)\.ndjson\.[0-9a-f]{16}\.tmp$/;
+async function acquireCursorCatalogLock(storeDir) {
+  mkdirSync(storeDir, { recursive: true });
+  const lockPath = join(storeDir, ".catalog.lock");
+  writeFileSync(lockPath, "", { flag: "a" });
+  try {
+    return await lockfile.lock(lockPath, {
+      retries: { retries: 40, minTimeout: 50, maxTimeout: 500 },
+      stale: 5e3,
+      update: 2e3
+    });
+  } catch {
+    return async () => {
+    };
+  }
+}
+var heldCatalogRelease;
+function publishRepair(repair, note) {
+  for (const line of repair.notes) note(line);
+}
+async function openCursorCatalogTurn(storeDir, note) {
+  mkdirSync(storeDir, { recursive: true });
+  heldCatalogRelease = await acquireCursorCatalogLock(storeDir);
+  publishRepair(repairCursorLocalCatalog(storeDir), note);
+}
+function repairCursorCatalogForResume(storeDir, note) {
+  const repair = repairCursorLocalCatalog(storeDir);
+  publishRepair(repair, note);
+  return repair.repaired;
+}
+async function closeCursorCatalogTurn() {
+  const release = heldCatalogRelease;
+  heldCatalogRelease = void 0;
+  if (release) await release().catch(() => void 0);
+}
+function repairCursorLocalCatalog(storeDir) {
+  if (!existsSync(storeDir)) return { repaired: false, notes: [] };
+  const notes = [];
+  let repaired = false;
+  const loaded = /* @__PURE__ */ new Map();
+  for (const file of CATALOG_FILES) {
+    loaded.set(file, loadCatalogFile(storeDir, file));
+  }
+  const checkpoints = mergeByKey(
+    loaded.get("checkpoints.ndjson").main,
+    loaded.get("checkpoints.ndjson").tmpRows,
+    (row) => checkpointKey(row),
+    (main2) => main2
+  );
+  const blobs = checkpointBlobs(checkpoints.rows);
+  const agents = mergeByKey(
+    loaded.get("agents.ndjson").main,
+    loaded.get("agents.ndjson").tmpRows,
+    (row) => typeof row.agentId === "string" ? row.agentId : null,
+    (main2, extra) => preferAgent(main2, extra, blobs)
+  );
+  const runs = mergeByKey(
+    loaded.get("runs.ndjson").main,
+    loaded.get("runs.ndjson").tmpRows,
+    (row) => runKey(row),
+    (main2, extra) => num(extra.updatedAt) >= num(main2.updatedAt) ? extra : main2
+  );
+  const events = mergeByKey(
+    loaded.get("run_events.ndjson").main,
+    loaded.get("run_events.ndjson").tmpRows,
+    (row) => eventKey(row),
+    (main2) => main2
+  );
+  const merged = {
+    "checkpoints.ndjson": checkpoints.rows,
+    "agents.ndjson": agents.rows,
+    "runs.ndjson": runs.rows,
+    "run_events.ndjson": events.rows
+  };
+  for (const agent of merged["agents.ndjson"]) {
+    if (restoreAgentCheckpoint(agent, merged["runs.ndjson"], blobs, notes)) repaired = true;
+    if (clearMissingActiveRun(agent, merged["runs.ndjson"], notes)) repaired = true;
+  }
+  for (const file of CATALOG_FILES) {
+    const prior = loaded.get(file);
+    const next = merged[file];
+    const recovered = countNewKeys(prior.main, next, keyFor(file));
+    if (recovered > 0) {
+      notes.push(`Cursor catalog recovered ${recovered} ${file} row(s) from an interrupted write`);
+      repaired = true;
+    }
+    if (!sameRows(prior.main, next)) {
+      writeCatalogFile(join(storeDir, file), next);
+      repaired = true;
+    }
+    for (const tmp of prior.tmps) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+    }
+  }
+  return { repaired, notes };
+}
+function loadCatalogFile(storeDir, file) {
+  const tmps = interruptedTmps(storeDir, file);
+  return {
+    main: readRows(join(storeDir, file)),
+    tmps,
+    tmpRows: tmps.flatMap((tmp) => readRows(tmp))
+  };
+}
+function keyFor(file) {
+  if (file === "checkpoints.ndjson") return checkpointKey;
+  if (file === "agents.ndjson") return (row) => typeof row.agentId === "string" ? row.agentId : null;
+  if (file === "runs.ndjson") return runKey;
+  return eventKey;
+}
+function countNewKeys(main2, next, keyOf) {
+  const had = new Set(main2.map(keyOf).filter((key) => Boolean(key)));
+  let n = 0;
+  for (const row of next) {
+    const key = keyOf(row);
+    if (key && !had.has(key)) n += 1;
+  }
+  return n;
+}
+function interruptedTmps(storeDir, file) {
+  let names = [];
+  try {
+    names = readdirSync(storeDir);
+  } catch {
+    return [];
+  }
+  const prefix = `.${file}.`;
+  return names.filter((name) => name.startsWith(prefix) && INTERRUPTED_TMP.test(name)).map((name) => join(storeDir, name));
+}
+function readRows(file) {
+  if (!existsSync(file)) return [];
+  let raw = "";
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isRow(parsed)) rows.push(parsed);
+    } catch {
+    }
+  }
+  return rows;
+}
+function writeCatalogFile(file, rows) {
+  if (rows.length === 0 && !existsSync(file)) return;
+  const body = rows.map((row) => JSON.stringify(row)).join("\n");
+  const dir = dirname(file);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.${basename(file)}.repair.tmp`);
+  writeFileSync(tmp, body);
+  renameSync(tmp, file);
+}
+function mergeByKey(main2, extra, keyOf, prefer) {
+  const out = [];
+  const index = /* @__PURE__ */ new Map();
+  for (const row of main2) {
+    const key = keyOf(row);
+    if (!key || index.has(key)) continue;
+    index.set(key, out.length);
+    out.push(structuredClone(row));
+  }
+  for (const row of extra) {
+    const key = keyOf(row);
+    if (!key) continue;
+    const at = index.get(key);
+    if (at == null) {
+      index.set(key, out.length);
+      out.push(structuredClone(row));
+      continue;
+    }
+    out[at] = structuredClone(prefer(out[at], row));
+  }
+  return { rows: out };
+}
+function restoreAgentCheckpoint(agent, runs, blobs, notes) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const current = rootBlobId(agent.latestCheckpoint);
+  if (!agentId || !current || blobs.has(`${agentId}\0${current}`)) return false;
+  const fallback = fallbackCheckpoint(runs, agentId, blobs);
+  const fallbackId = rootBlobId(fallback);
+  if (!fallback || !fallbackId) return false;
+  agent.latestCheckpoint = fallback;
+  agent.updatedAt = Date.now();
+  notes.push(
+    `Cursor catalog restored agent ${agentId} to checkpoint ${fallbackId} (root blob ${current} was missing)`
+  );
+  return true;
+}
+function clearMissingActiveRun(agent, runs, notes) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const active = typeof agent.activeRunId === "string" ? agent.activeRunId : "";
+  if (!agentId || !active) return false;
+  const live = runs.some((run) => run.agentId === agentId && run.runId === active);
+  if (live) return false;
+  agent.activeRunId = null;
+  if (agent.status === "running") agent.status = "idle";
+  notes.push(`Cursor catalog cleared missing run ${active} on agent ${agentId}`);
+  return true;
+}
+function fallbackCheckpoint(runs, agentId, blobs) {
+  const mine = runs.filter((run) => run.agentId === agentId).slice().sort((a, b) => num(b.updatedAt) - num(a.updatedAt));
+  for (const run of mine) {
+    for (const field of ["latestCheckpointRef", "startCheckpointRef"]) {
+      const ref = run[field];
+      const id = rootBlobId(ref);
+      if (id && blobs.has(`${agentId}\0${id}`) && isRow(ref)) return ref;
+    }
+  }
+  return null;
+}
+function preferAgent(main2, extra, blobs) {
+  const mainOk = checkpointPresent(main2, blobs);
+  const extraOk = checkpointPresent(extra, blobs);
+  if (mainOk && !extraOk) return main2;
+  if (extraOk && !mainOk) return extra;
+  return num(extra.updatedAt) >= num(main2.updatedAt) ? extra : main2;
+}
+function checkpointPresent(agent, blobs) {
+  const agentId = typeof agent.agentId === "string" ? agent.agentId : "";
+  const id = rootBlobId(agent.latestCheckpoint);
+  if (!id) return true;
+  return blobs.has(`${agentId}\0${id}`);
+}
+function checkpointBlobs(rows) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (typeof row.agentId !== "string" || typeof row.blobId !== "string") continue;
+    if (typeof row.dataBase64 !== "string" || !row.dataBase64) continue;
+    ids.add(`${row.agentId}\0${row.blobId}`);
+  }
+  return ids;
+}
+function checkpointKey(row) {
+  if (typeof row.agentId !== "string" || typeof row.blobId !== "string") return null;
+  return `${row.agentId}\0${row.blobId}`;
+}
+function runKey(row) {
+  if (typeof row.agentId !== "string" || typeof row.runId !== "string") return null;
+  return `${row.agentId}\0${row.runId}`;
+}
+function eventKey(row) {
+  if (typeof row.runId !== "string") return null;
+  if (typeof row.seq === "number") return `${row.runId}\0${row.seq}`;
+  if (typeof row.offset === "string") return `${row.runId}\0${row.offset}`;
+  return null;
+}
+function rootBlobId(ref) {
+  if (!isRow(ref) || typeof ref.rootBlobId !== "string" || !ref.rootBlobId) return null;
+  return ref.rootBlobId;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function sameRows(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function isRow(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/agents/cursor-session.ts
 function cursorErrorMessage(err) {
   if (err instanceof Error) return err.message.trim();
@@ -146,7 +428,7 @@ async function* iterateUntilIdle(iterable, idleMs, onIdle, activity) {
 }
 
 // src/agents/sliced-file-read.ts
-import { readFileSync, realpathSync, statSync } from "fs";
+import { readFileSync as readFileSync2, realpathSync, statSync } from "fs";
 import { isAbsolute, relative, resolve, sep } from "path";
 var SLICED_READ_DEFAULT_LIMIT = 200;
 var SLICED_READ_MAX_LINE_CHARS = 2e3;
@@ -221,7 +503,7 @@ function executeSlicedFileRead(cwd, args) {
   try {
     const st = statSync(abs);
     if (!st.isFile()) return `Error: not a file: ${rawPath}`;
-    buf = readFileSync(abs);
+    buf = readFileSync2(abs);
   } catch (err) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -306,7 +588,7 @@ function emit(event) {
 }
 function localAgentStore(Store, threadId) {
   const root = cursorSdkStoreDir(threadId);
-  mkdirSync(root, { recursive: true });
+  mkdirSync2(root, { recursive: true });
   return new Store(root);
 }
 async function cancelStaleRuns(Agent, agentId, opts) {
@@ -396,6 +678,9 @@ async function main() {
     fast: Boolean(req.fast)
   });
   const mode = req.planMode ? "plan" : "agent";
+  const storeRoot = cursorSdkStoreDir(req.threadId);
+  const note = (line) => emit({ type: "stderr", data: line });
+  await openCursorCatalogTurn(storeRoot, note);
   const store = localAgentStore(JsonlLocalAgentStore, req.threadId);
   const isolateSources = [];
   let onRpcProgress = () => {
@@ -444,20 +729,22 @@ async function main() {
   async function createAgent() {
     return retryTransport(() => Agent.create(createOpts));
   }
+  function resumeAgent(agentId) {
+    const { name: _name, ...opts } = createOpts;
+    return retryTransport(() => Agent.resume(agentId, opts));
+  }
   async function openAgent() {
     try {
-      return req.agentId ? await retryTransport(
-        () => Agent.resume(req.agentId, {
-          apiKey,
-          model,
-          mode,
-          local,
-          disallowedTools: ["read"],
-          ...mcpServers ? { mcpServers } : {}
-        })
-      ) : await createAgent();
+      return req.agentId ? await resumeAgent(req.agentId) : await createAgent();
     } catch (err) {
       if (!isUnresumableCursorSession(err)) throw err;
+      if (repairCursorCatalogForResume(storeRoot, note) && req.agentId) {
+        try {
+          return await resumeAgent(req.agentId);
+        } catch (err2) {
+          if (!isUnresumableCursorSession(err2)) throw err2;
+        }
+      }
       emit({
         type: "stderr",
         data: cursorSessionRecoveryMessage(err, req.agentId)
@@ -511,7 +798,9 @@ async function main() {
       new Promise((resolve2) => {
         setTimeout(resolve2, 2e3);
       })
-    ]).finally(() => process.exit(1));
+    ]).finally(() => {
+      void closeCursorCatalogTurn().finally(() => process.exit(1));
+    });
   };
   process.once("SIGTERM", onSignal);
   process.once("SIGINT", onSignal);
@@ -609,11 +898,21 @@ async function main() {
           return await runTurn(agent);
         }
         if (!isUnresumableCursorSession(err)) throw err;
+        const agentId = agent.agentId;
+        await agent[Symbol.asyncDispose]().catch(() => void 0);
+        const repaired = repairCursorCatalogForResume(storeRoot, note);
+        if (repaired) {
+          try {
+            agent = await resumeAgent(agentId);
+            return await runTurn(agent);
+          } catch (err2) {
+            if (!isUnresumableCursorSession(err2)) throw err2;
+          }
+        }
         emit({
           type: "stderr",
-          data: cursorSessionRecoveryMessage(err, agent.agentId)
+          data: cursorSessionRecoveryMessage(err, agentId)
         });
-        await agent[Symbol.asyncDispose]().catch(() => void 0);
         agent = await createAgent();
         return await runTurn(agent);
       }
@@ -631,6 +930,8 @@ async function main() {
     const message = err instanceof Error ? err.message : String(err);
     emit({ type: "stderr", data: message });
     return 1;
+  } finally {
+    await closeCursorCatalogTurn();
   }
 }
 main().then(

package/dist/{agents-XAKSP653.js → agents-2PDBDZPS.js}

@@ -46,7 +46,7 @@ import {
   resolveCursorSdkRoot,
   resolveQuotaFallbackAgent,
   turnCostUsdFromCursorUsage
-} from "./chunk-LUQ7MIVD.js";
+} from "./chunk-SVQTKVXH.js";
 import {
   getAgentSetupInfo,
   installAgent,
@@ -58,13 +58,13 @@ import {
   prepareTerminalCommand,
   resolveLoginCommand,
   whichOnPath
-} from "./chunk-W2KZTDET.js";
+} from "./chunk-WZCPZVUC.js";
 import "./chunk-7IAMHN2N.js";
 import "./chunk-PXMLMBMI.js";
 import "./chunk-2GPQZZLY.js";
 import "./chunk-AFLNFGGB.js";
-import "./chunk-O4324MXE.js";
-import "./chunk-5HPMKLJ7.js";
+import "./chunk-E7G7RY6T.js";
+import "./chunk-6SGYGYH7.js";
 import "./chunk-N2WW62LF.js";
 import "./chunk-DD67JWTN.js";
 import {
@@ -83,7 +83,7 @@ import {
   assertOrchestratorCapableAgent,
   coerceOrchestratorAgent,
   isOrchestratorCapableAgent
-} from "./chunk-MVZO7QZ2.js";
+} from "./chunk-BU6HH5VA.js";
 import "./chunk-NSTQ6QKD.js";
 import "./chunk-WWUABK6B.js";
 import "./chunk-FJZWM2ON.js";

package/dist/{agents-4BBCKITL.js → agents-73JXQXF2.js}

@@ -37,7 +37,7 @@ import {
   planModeTurnInstruction,
   resolveCursorModelId,
   resolveQuotaFallbackAgent
-} from "./chunk-VNCPRMIK.js";
+} from "./chunk-JEYJGQ33.js";
 import "./chunk-VGNLMGBK.js";
 import "./chunk-YSLCWCMJ.js";
 import {
@@ -51,9 +51,9 @@ import {
   prepareTerminalCommand,
   resolveLoginCommand,
   whichOnPath
-} from "./chunk-NXXQFLNQ.js";
-import "./chunk-V3BSO2O6.js";
-import "./chunk-2IXKTAIT.js";
+} from "./chunk-B42H6GJR.js";
+import "./chunk-YEIPPZ5W.js";
+import "./chunk-ZEP6JIRF.js";
 import "./chunk-QB5MDOHL.js";
 import "./chunk-2P4XKWV2.js";
 import "./chunk-33KDPEK4.js";
@@ -87,7 +87,7 @@ import {
   assertOrchestratorCapableAgent,
   coerceOrchestratorAgent,
   isOrchestratorCapableAgent
-} from "./chunk-36J3IZBS.js";
+} from "./chunk-RSATPXU4.js";
 import "./chunk-77WWLBCI.js";
 import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";

package/dist/{app-settings-EHMXHNG5.js → app-settings-2IH42VA5.js}

@@ -64,6 +64,7 @@ import {
   isChatTextScale,
   isIssueSourceConnected,
   isLinearConnected,
+  isPosthogConnected,
   isUsageOnLimit,
   issueSourceLabel,
   loadAppSettings,
@@ -107,7 +108,7 @@ import {
   updateProjectProfileSettings,
   usageOnLimit,
   writeViewerContext
-} from "./chunk-MVZO7QZ2.js";
+} from "./chunk-BU6HH5VA.js";
 import "./chunk-NSTQ6QKD.js";
 import "./chunk-WWUABK6B.js";
 import "./chunk-FJZWM2ON.js";
@@ -178,6 +179,7 @@ export {
   isChatTextScale,
   isIssueSourceConnected,
   isLinearConnected,
+  isPosthogConnected,
   isUsageOnLimit,
   issueSourceLabel,
   loadAppSettings,

package/dist/{app-settings-MR2U6AXN.js → app-settings-3OQWRKOK.js}

@@ -62,6 +62,7 @@ import {
   isChatTextScale,
   isIssueSourceConnected,
   isLinearConnected,
+  isPosthogConnected,
   isUsageOnLimit,
   issueSourceLabel,
   loadAppSettings,
@@ -105,7 +106,7 @@ import {
   updateProjectProfileSettings,
   usageOnLimit,
   writeViewerContext
-} from "./chunk-36J3IZBS.js";
+} from "./chunk-RSATPXU4.js";
 import "./chunk-77WWLBCI.js";
 import "./chunk-4TR3HZFT.js";
 import "./chunk-WDRMZKVB.js";
@@ -176,6 +177,7 @@ export {
   isChatTextScale,
   isIssueSourceConnected,
   isLinearConnected,
+  isPosthogConnected,
   isUsageOnLimit,
   issueSourceLabel,
   loadAppSettings,

package/dist/{chunk-3E4NOIXN.js → chunk-3D3GGL6X.js}

@@ -1,7 +1,7 @@
 import {
   DEFAULT_ABLETIME_HOST,
   normalizeAbleTimeHost
-} from "./chunk-NFPWLDCH.js";
+} from "./chunk-FAXOEKQR.js";
 import {
   httpFetch
 } from "./chunk-JAT3JFOS.js";
@@ -10,7 +10,7 @@ import {
   getAbleTimeHost,
   loadAppSettings,
   saveAbleTimeConnection
-} from "./chunk-36J3IZBS.js";
+} from "./chunk-RSATPXU4.js";
 
 // src/integrations/abletime-oauth.ts
 import { createHash, randomBytes } from "crypto";
@@ -280,7 +280,7 @@ async function startAbleTimeOAuth(opts) {
   persistAbleTimeTokens(data, { host });
   const token = data.access_token.trim();
   try {
-    const { getAbleTimeOrientation } = await import("./abletime-4WJUVE64.js");
+    const { getAbleTimeOrientation } = await import("./abletime-RYDAQ3FE.js");
     const orientation = await getAbleTimeOrientation({ token, host });
     return saveAbleTimeConnection({
       accessToken: token,

package/dist/{chunk-5HPMKLJ7.js → chunk-6SGYGYH7.js}

@@ -19,7 +19,7 @@ import {
 import {
   getGithubGitAuthMode,
   getGithubPat
-} from "./chunk-MVZO7QZ2.js";
+} from "./chunk-BU6HH5VA.js";
 import {
   allocateTeamName,
   listThreads,
@@ -1984,15 +1984,8 @@ async function fetchOriginForWorktree(repoPath, sourceRef, opts) {
 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
-    });
-    const current = head.stdout.trim();
-    if (head.exitCode !== 0 || !current || current === "HEAD" || current !== branch) {
-      return { updated: false, reason: "not-on-default" };
-    }
-    if (await isDirty(repoPath)) {
-      return { updated: false, reason: "dirty" };
+    if (!branch || branch === "HEAD" || branch.includes("..")) {
+      return { updated: false, reason: "ff-failed" };
     }
     const remote = `origin/${branch}`;
     const remoteOk = await git(["rev-parse", "--verify", remote], repoPath, {
@@ -2001,8 +1994,27 @@ async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
     if (remoteOk.exitCode !== 0) {
       return { updated: false, reason: "no-origin-tip" };
     }
+    const worktrees = await listWorktrees(repoPath);
+    if (worktrees.length === 0) {
+      return { updated: false, reason: "ff-failed" };
+    }
+    const checkout = worktrees.find((entry) => entry.branch === branch) ?? null;
+    const localRef = `refs/heads/${branch}`;
+    const localOk = await git(["rev-parse", "--verify", localRef], repoPath, {
+      reject: false
+    });
+    if (localOk.exitCode !== 0) {
+      if (checkout) return { updated: false, reason: "ff-failed" };
+      const created = await git(["branch", "--track", branch, remote], repoPath, {
+        reject: false
+      });
+      if (created.exitCode !== 0) {
+        return { updated: false, reason: "ff-failed" };
+      }
+      return { updated: true, reason: "updated" };
+    }
     const ancestor = await git(
-      ["merge-base", "--is-ancestor", "HEAD", remote],
+      ["merge-base", "--is-ancestor", localRef, remote],
       repoPath,
       { reject: false }
     );
@@ -2010,7 +2022,7 @@ async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
       return { updated: false, reason: "diverged" };
     }
     const behind = await git(
-      ["rev-list", "--count", `HEAD..${remote}`],
+      ["rev-list", "--count", `${localRef}..${remote}`],
       repoPath,
       { reject: false }
     );
@@ -2018,10 +2030,22 @@ async function fastForwardMainCheckoutIfSafe(repoPath, opts) {
     if (behind.exitCode !== 0 || !Number.isFinite(n) || n <= 0) {
       return { updated: false, reason: "already-current" };
     }
-    const ff = await git(["merge", "--ff-only", remote], repoPath, {
+    if (checkout) {
+      if (await isDirty(checkout.path)) {
+        return { updated: false, reason: "dirty" };
+      }
+      const ff = await git(["merge", "--ff-only", remote], checkout.path, {
+        reject: false
+      });
+      if (ff.exitCode !== 0) {
+        return { updated: false, reason: "ff-failed" };
+      }
+      return { updated: true, reason: "updated" };
+    }
+    const moved = await git(["branch", "-f", branch, remote], repoPath, {
       reject: false
     });
-    if (ff.exitCode !== 0) {
+    if (moved.exitCode !== 0) {
       return { updated: false, reason: "ff-failed" };
     }
     return { updated: true, reason: "updated" };

package/dist/{chunk-NXXQFLNQ.js → chunk-B42H6GJR.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-QVN2WOKJ.js";
 import {
   resolveAgentExecutable
-} from "./chunk-36J3IZBS.js";
+} from "./chunk-RSATPXU4.js";
 
 // src/agents/install.ts
 import { existsSync } from "fs";
@@ -265,7 +265,7 @@ async function loginAgent(agent) {
   };
 }
 async function loginManagedAccount(accountId) {
-  const { loadAppSettings } = await import("./app-settings-MR2U6AXN.js");
+  const { loadAppSettings } = await import("./app-settings-3OQWRKOK.js");
   const { loginEnvPrefix } = await import("./managed-accounts-2AK5RIAF.js");
   const account = loadAppSettings().accounts.accounts.find((a) => a.id === accountId);
   if (!account) {

package/dist/{chunk-G74TSBJ3.js → chunk-BJUHZSZQ.js}

@@ -11,11 +11,11 @@ import {
   isGlobalThread,
   isOrchestratorThread,
   isSlackCoordinatorThread
-} from "./chunk-O4324MXE.js";
+} from "./chunk-E7G7RY6T.js";
 import {
   mergeAgentGitAuthEnv,
   resolveAgentGitAuthEnv
-} from "./chunk-5HPMKLJ7.js";
+} from "./chunk-6SGYGYH7.js";
 import {
   ATTACHMENTS_DIR,
   DETACHED_JOBS_DIR,
@@ -32,7 +32,7 @@ import {
 import {
   assertOrchestratorCapableAgent,
   contextTokens
-} from "./chunk-MVZO7QZ2.js";
+} from "./chunk-BU6HH5VA.js";
 import {
   stripNestedElectronEnv
 } from "./chunk-WWUABK6B.js";
@@ -1674,7 +1674,7 @@ var PORT_RANGE_SIZE = 10;
 var RECLAIM_RETRY_DELAY_MS = 40;
 var RECLAIM_TRIES = 8;
 async function killReclaimable(ports, worktreePath, signal) {
-  const { killListenersOnPorts: killListenersOnPorts2, killStaleWorktreeListeners: killStaleWorktreeListeners2 } = await import("./conductor-5MNGC25D.js");
+  const { killListenersOnPorts: killListenersOnPorts2, killStaleWorktreeListeners: killStaleWorktreeListeners2 } = await import("./conductor-7DEMFEIO.js");
   if (worktreePath) killStaleWorktreeListeners2(ports, worktreePath, signal);
   else killListenersOnPorts2(ports);
 }