@cellajs/cli 0.3.0 → 0.3.1

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/cella-cli.ts
 import { existsSync as existsSync13, statSync as statSync3 } from "fs";
-import { join as join21, resolve as resolve7 } from "path";
+import { join as join21, resolve as resolve8 } from "path";
 import process9 from "process";
 
 // src/cli.ts
@@ -220,7 +220,7 @@ import process4 from "process";
 // package.json
 var package_default = {
   name: "@cellajs/cli",
-  version: "0.3.0",
+  version: "0.3.1",
   private: false,
   license: "MIT",
   description: "CLI for managing your monorepo and syncing with upstream Cella.",
@@ -287,7 +287,7 @@ var package_default = {
     rimraf: "^6.1.3",
     tsup: "^8.5.1",
     tsx: "^4.23.15",
-    typescript: "^6.0.3",
+    typescript: "6.0.3",
     vitest: "^5.0.3"
   },
   publishConfig: {
@@ -812,7 +812,7 @@ import { dirname as dirname3, join as join6 } from "path";
 import { execFile } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 import { mkdir as mkdir2, readdir, rmdir, unlink } from "fs/promises";
-import { dirname as dirname2, join as join5 } from "path";
+import { dirname as dirname2, join as join5, resolve as resolve3 } from "path";
 import { promisify } from "util";
 
 // src/utils/manifest.ts
@@ -872,8 +872,26 @@ async function getCurrentBranch(cwd) {
 async function switchBranch(cwd, branch) {
   await git(["switch", branch], cwd);
 }
+async function switchDetached(cwd, ref) {
+  await git(["switch", "--detach", ref], cwd);
+}
 async function createBranchFrom(cwd, branch, startPoint) {
-  await git(["switch", "-c", branch, startPoint], cwd);
+  await git(["switch", "-c", branch, "--no-track", startPoint], cwd);
+}
+async function branchExists(cwd, branch) {
+  return await git(["rev-parse", "-q", "--verify", `refs/heads/${branch}`], cwd, { ignoreErrors: true }) !== "";
+}
+async function getBranchWorktree(cwd, branch) {
+  const output = await git(["worktree", "list", "--porcelain"], cwd, { ignoreErrors: true });
+  let worktree = null;
+  for (const line of output.split("\n")) {
+    if (line.startsWith("worktree ")) worktree = line.slice("worktree ".length);
+    else if (line === `branch refs/heads/${branch}`) return worktree;
+  }
+  return null;
+}
+async function fastForwardBranch(cwd, branch, ref) {
+  await git(["fetch", "--quiet", ".", `${ref}:refs/heads/${branch}`], cwd);
 }
 async function deleteBranch(cwd, branch) {
   await git(["branch", "-D", branch], cwd, { ignoreErrors: true });
@@ -881,14 +899,21 @@ async function deleteBranch(cwd, branch) {
 async function pullFastForward(cwd) {
   await git(["pull", "--ff-only"], cwd, { ignoreErrors: true, skipEditor: true });
 }
-async function getUpstreamStatus(cwd) {
-  const upstream = await git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], cwd, {
+async function getBranchUpstream(cwd, branch = "") {
+  const upstream = await git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", `${branch}@{upstream}`], cwd, {
     ignoreErrors: true
   });
+  return upstream || null;
+}
+async function getUpstreamStatus(cwd, branch) {
+  const local = branch ? `refs/heads/${branch}` : "HEAD";
+  const upstream = await getBranchUpstream(cwd, branch);
   if (!upstream) return { upstream: null, ahead: 0, behind: 0 };
   const remote = upstream.split("/")[0];
   await git(["fetch", remote], cwd, { ignoreErrors: true, skipEditor: true });
-  const counts = await git(["rev-list", "--left-right", "--count", `HEAD...${upstream}`], cwd, { ignoreErrors: true });
+  const counts = await git(["rev-list", "--left-right", "--count", `${local}...${upstream}`], cwd, {
+    ignoreErrors: true
+  });
   const [ahead, behind] = counts.split(/\s+/).map((n) => Number.parseInt(n, 10) || 0);
   return { upstream, ahead: ahead ?? 0, behind: behind ?? 0 };
 }
@@ -907,16 +932,19 @@ async function flattenBranch(cwd, baseRef, message) {
 }
 async function commitSquash(cwd, message) {
   for (const file of ["MERGE_HEAD", "MERGE_MSG", "MERGE_MODE"]) {
-    const path4 = join5(cwd, ".git", file);
+    const path4 = await gitPath(cwd, file);
     if (existsSync3(path4)) await unlink(path4);
   }
   await git(["commit", "-m", message], cwd, { skipEditor: true });
 }
+async function gitPath(cwd, file) {
+  return resolve3(cwd, await git(["rev-parse", "--git-path", file], cwd));
+}
 async function stageAll(cwd) {
   await git(["add", "-A"], cwd);
 }
-function mergeInProgress(cwd) {
-  return existsSync3(join5(cwd, ".git", "MERGE_HEAD"));
+async function mergeInProgress(cwd) {
+  return await git(["rev-parse", "-q", "--verify", "MERGE_HEAD"], cwd, { ignoreErrors: true }) !== "";
 }
 async function getShortSha(cwd, ref) {
   return git(["rev-parse", "--short", ref], cwd);
@@ -957,6 +985,33 @@ async function resolveLatestReleaseTag(cwd, remoteName) {
   }
   return null;
 }
+async function resolveUpstreamCommit(cwd, remoteName, ref) {
+  if (ref.startsWith("-")) return null;
+  const tagRef = `refs/${remoteName}/tags/${ref}`;
+  for (const candidate of [`refs/remotes/${remoteName}/${ref}`, tagRef, ref]) {
+    const sha = await git(["rev-parse", "-q", "--verify", `${candidate}^{commit}`], cwd, { ignoreErrors: true });
+    if (!sha) continue;
+    const release = candidate === tagRef && /^v\d[\w.+-]*$/.test(ref) ? { tag: ref, ref: tagRef } : void 0;
+    return { sha, release };
+  }
+  return null;
+}
+async function isPublishedUpstream(cwd, remoteName, branchRef, sha) {
+  const containing = await git(
+    [
+      "for-each-ref",
+      "--count=1",
+      "--format=%(refname)",
+      "--contains",
+      sha,
+      `refs/remotes/${branchRef}`,
+      `refs/${remoteName}/tags/v*`
+    ],
+    cwd,
+    { ignoreErrors: true }
+  );
+  return containing !== "";
+}
 async function getCommitInfo(cwd, ref) {
   const format = "%H%n%s%n%ar";
   const output = await git(["log", "-1", `--format=${format}`, ref], cwd);
@@ -1586,6 +1641,7 @@ function readOptions(opts) {
     hard: opts.hard === true,
     unpinned: opts.unpinned === true,
     track: opts.track === "release" || opts.track === "branch" ? opts.track : void 0,
+    ref: typeof opts.ref === "string" && opts.ref ? opts.ref : void 0,
     force: opts.force === true,
     checkOverrides: opts.checkOverrides === true,
     coverage: opts.coverage === true,
@@ -1605,6 +1661,7 @@ var serviceDefinitions = [
       { flags: "--json", description: "machine-readable output for tooling/agents" },
       { flags: "--scope <scope>", description: "analyze scope for --list/--json: all|risk|protected" },
       { flags: "--track <mode>", description: "override upstream tracking for this run: release|branch" },
+      { flags: "--ref <ref>", description: "pin the upstream commit for this run: sha, release tag or branch" },
       { flags: "--diff <path>", description: "print unified diff for one file, then exit" },
       { flags: "--open-diff <path>", description: "open a browser diff for one file, then exit" }
     ],
@@ -1617,7 +1674,8 @@ var serviceDefinitions = [
       { flags: "--log", description: "write complete file list to cella-sync.log" },
       { flags: "--hard", description: "overwrite drifted files with upstream version (aggressive realignment)" },
       { flags: "--unpinned", description: "ignore pinned files (except package.json) to resurface upstream changes" },
-      { flags: "--track <mode>", description: "override upstream tracking for this run: release|branch" }
+      { flags: "--track <mode>", description: "override upstream tracking for this run: release|branch" },
+      { flags: "--ref <ref>", description: "pin the upstream commit for this run: sha, release tag or branch" }
     ],
     includeInMenu: (context) => !context.isUpstreamRepo,
     menuDescription: () => "merge upstream changes + sync package.json"
@@ -1716,6 +1774,7 @@ function buildProgram(setSelection) {
       "  $ cella sync --hard",
       "  $ cella sync --unpinned",
       "  $ cella sync --track branch",
+      "  $ cella sync --ref 4f7d87c",
       "  $ cella migrate --mark 20261002T0614-config-switch",
       "  $ cella audit --check-overrides",
       "  $ cella contributions --fork raak --json"
@@ -1894,14 +1953,14 @@ import { join as join11 } from "path";
 import { createHash } from "crypto";
 import { existsSync as existsSync6, rmSync } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename3, join as join10, resolve as resolve3 } from "path";
+import { basename as basename3, join as join10, resolve as resolve4 } from "path";
 import process7 from "process";
 var WORKTREE_PREFIXES = {
   sync: "cella-sync-",
   view: "cella-view-"
 };
 function buildWorktreePath(kind, repoPath) {
-  const key = createHash("sha256").update(resolve3(repoPath)).digest("hex").slice(0, 8);
+  const key = createHash("sha256").update(resolve4(repoPath)).digest("hex").slice(0, 8);
   return join10(tmpdir2(), `${WORKTREE_PREFIXES[kind]}${basename3(repoPath)}-${key}`);
 }
 function legacyWorktreePath(kind, repoPath) {
@@ -2511,6 +2570,20 @@ function formatLocalCheckoutDetail(forkPath, branch, headSha, changeCount, upstr
   const workingTree = changeCount === 0 ? "  working tree clean" : `  ${changeCount} uncommitted change${changeCount === 1 ? "" : "s"} in working tree, not included in analysis`;
   return [`${forkPath}`, `  ${branch} @ ${headSha}${tracking}`, workingTree].join("\n");
 }
+async function resolvePinnedRef(forkPath, config, remoteName, branchRef, ref) {
+  const resolved = await resolveUpstreamCommit(forkPath, remoteName, ref);
+  if (!resolved) {
+    throw new Error(
+      `--ref '${ref}' does not resolve to a commit. Pass a commit sha, a release tag (v*) or a branch on ${config.settings.upstreamUrl}.`
+    );
+  }
+  if (!await isPublishedUpstream(forkPath, remoteName, branchRef, resolved.sha)) {
+    throw new Error(
+      `--ref '${ref}' (${resolved.sha.slice(0, 7)}) is not on ${branchRef} or in an upstream release (v*). Sync only to commits upstream has published there.`
+    );
+  }
+  return resolved.release ? { ref: resolved.release.ref, releaseTag: resolved.release.tag } : { ref: resolved.sha };
+}
 async function prepareUpstream(config, onProgress, onStep) {
   const { forkPath } = config;
   onProgress?.("checking local checkout...");
@@ -2530,7 +2603,12 @@ async function prepareUpstream(config, onProgress, onStep) {
   await fetch2(forkPath, remoteName);
   let upstreamRef = branchRef;
   let releaseTag;
-  if (track === "release") {
+  if (config.ref) {
+    await fetchUpstreamTags(forkPath, remoteName);
+    const pinned = await resolvePinnedRef(forkPath, config, remoteName, branchRef, config.ref);
+    upstreamRef = pinned.ref;
+    releaseTag = pinned.releaseTag;
+  } else if (track === "release") {
     await fetchUpstreamTags(forkPath, remoteName);
     const latest = await resolveLatestReleaseTag(forkPath, remoteName);
     if (!latest) {
@@ -2541,8 +2619,9 @@ async function prepareUpstream(config, onProgress, onStep) {
     upstreamRef = latest.ref;
     releaseTag = latest.tag;
   }
+  const upstreamLabel = releaseTag ?? (config.ref ? `--ref ${config.ref}` : upstreamRef);
   config.upstreamRef = upstreamRef;
-  onStep?.("remote configured", `${releaseTag ?? upstreamRef} \u2192 ${config.settings.upstreamUrl}`);
+  onStep?.("remote configured", `${upstreamLabel} \u2192 ${config.settings.upstreamUrl}`);
   const cliRange = await readUpstreamCliRange(forkPath, upstreamRef);
   const cliMismatch = cliRange ? cliVersionMismatch(VERSION, cliRange) : null;
   if (cliMismatch) throw new Error(cliMismatch);
@@ -2550,8 +2629,20 @@ async function prepareUpstream(config, onProgress, onStep) {
   await ensureSyncBase(forkPath, "HEAD", upstreamRef);
   const upstreamGitHubUrl = getGitHubBaseUrl(config.settings.upstreamUrl) ?? void 0;
   const aggressive = config.hard === true || config.unpinned === true;
-  const mergeBase = aggressive ? await getMergeBase(forkPath, "HEAD", upstreamRef) : (await getEffectiveMergeBase(forkPath, "HEAD", upstreamRef)).base;
+  const syncPoint = (await getEffectiveMergeBase(forkPath, "HEAD", upstreamRef)).base;
+  const mergeBase = aggressive ? await getMergeBase(forkPath, "HEAD", upstreamRef) : syncPoint;
   const upstreamCommit = await getCommitInfo(forkPath, upstreamRef);
+  if (upstreamCommit.hash !== syncPoint && await isAncestor(forkPath, upstreamCommit.hash, syncPoint)) {
+    const [upstreamShort, syncShort] = await Promise.all([
+      getShortSha(forkPath, upstreamCommit.hash),
+      getShortSha(forkPath, syncPoint)
+    ]);
+    const hint = config.ref ? "Pick a newer --ref." : releaseTag ? `Nothing to sync until a release past ${syncShort}; to follow the tip instead, run with --track branch.` : `Nothing to sync until '${branchRef}' moves past ${syncShort}.`;
+    throw new Error(
+      `upstream ${upstreamLabel} (${upstreamShort}) is behind the last sync point ${syncShort}: the fork already has it, and syncing it would revert the upstream changes after it.
+${hint}`
+    );
+  }
   const commitCount = await countCommitsBetween(forkPath, mergeBase, upstreamRef);
   const commitListMax = 50;
   const commitSkip = commitCount > commitListMax ? commitCount - commitListMax : 0;
@@ -3776,7 +3867,7 @@ import {
 import { select as select2 } from "@inquirer/prompts";
 
 // src/services/contrib-core.ts
-import { dirname as dirname5, join as join15, resolve as resolve4 } from "path";
+import { dirname as dirname5, join as join15, resolve as resolve5 } from "path";
 async function listFilesAtRef(repoPath, ref) {
   const raw = await git(["ls-tree", "-r", "--name-only", ref], repoPath);
   return new Set(raw.split("\n").filter(Boolean));
@@ -3839,7 +3930,7 @@ async function readBlobInfo(repoPath, ref, filePath) {
 }
 async function buildContribBranch(repoPath, baseRef, forkRef, detection, forkName) {
   const branch = `contrib/${forkName}`;
-  const gitDir = resolve4(repoPath, await git(["rev-parse", "--git-dir"], repoPath));
+  const gitDir = resolve5(repoPath, await git(["rev-parse", "--git-dir"], repoPath));
   const tmpIndex = join15(gitDir, `tmp-contrib-index-${forkName.replace(/[^\w.-]/g, "_")}`);
   const indexEnv = { GIT_INDEX_FILE: tmpIndex };
   try {
@@ -3884,14 +3975,14 @@ ${commitBody}`;
 
 // src/services/fork-utils.ts
 import { existsSync as existsSync9 } from "fs";
-import { dirname as dirname6, resolve as resolve5 } from "path";
+import { dirname as dirname6, resolve as resolve6 } from "path";
 async function resolveForkBasePath(repoPath) {
   const commonDir = await git(["rev-parse", "--git-common-dir"], repoPath, { ignoreErrors: true });
-  return commonDir ? dirname6(resolve5(repoPath, commonDir)) : repoPath;
+  return commonDir ? dirname6(resolve6(repoPath, commonDir)) : repoPath;
 }
 function validateForkPath(fork, basePath, requireConfig = false) {
-  const resolvedPath = resolve5(basePath, fork.localPath);
-  if (!resolvedPath.startsWith(resolve5(basePath, ".."))) {
+  const resolvedPath = resolve6(basePath, fork.localPath);
+  if (!resolvedPath.startsWith(resolve6(basePath, ".."))) {
     return { fork, resolvedPath, valid: false, error: "path resolves outside parent directory" };
   }
   if (!existsSync9(resolvedPath)) return { fork, resolvedPath, valid: false, error: "path does not exist" };
@@ -4259,7 +4350,7 @@ async function runContributions(config) {
 }
 
 // src/services/forks.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import process8 from "process";
 import { Separator as Separator2, select as select4 } from "@inquirer/prompts";
 
@@ -4517,6 +4608,26 @@ function safeMergePnpm(forkPnpm, upstreamPnpm, basePnpm) {
   }
   return { merged, changed };
 }
+function mergeModuleType(forkType, upstreamType, baseType) {
+  const asString = (value) => typeof value === "string" ? value : void 0;
+  const fork = asString(forkType);
+  const upstream = asString(upstreamType);
+  if (fork === upstream) return null;
+  if (fork === void 0) return { value: upstream, change: "added" };
+  if (fork !== asString(baseType)) return null;
+  return { value: upstream, change: upstream === void 0 ? "removed" : "updated" };
+}
+function setTopLevelKey(pkg, key, value) {
+  if (key in pkg) {
+    pkg[key] = value;
+    return;
+  }
+  const entries = Object.entries(pkg);
+  const after = Math.max(...["name", "version", "private"].map((name) => entries.findIndex(([k]) => k === name)));
+  entries.splice(after + 1, 0, [key, value]);
+  for (const name of Object.keys(pkg)) delete pkg[name];
+  Object.assign(pkg, Object.fromEntries(entries));
+}
 function readPackageJson(filePath) {
   if (!existsSync11(filePath)) return null;
   try {
@@ -4570,6 +4681,13 @@ async function syncPackageJson(config, baseRef, usage, relativePath, keysToSync)
   }
   const upstreamPkg = upstream.data;
   let updated = false;
+  const type = mergeModuleType(forkPkg.type, upstreamPkg.type, basePkg?.type);
+  if (type) {
+    if (type.value === void 0) delete forkPkg.type;
+    else setTopLevelKey(forkPkg, "type", type.value);
+    updated = true;
+    changes.push(`type: ${type.change}`);
+  }
   for (const key of keysToSync) {
     if (key === "pnpm") {
       const result2 = safeMergePnpm(forkPkg.pnpm, upstreamPkg.pnpm, basePkg?.pnpm);
@@ -4677,11 +4795,17 @@ async function runPackages(config, options = {}) {
 }
 
 // src/services/sync.ts
-async function ensureBaseUpToDate(forkPath, base) {
-  const { upstream, ahead, behind } = await getUpstreamStatus(forkPath);
+async function resolveCycleStart(forkPath, base, currentBranch) {
+  if (!await branchExists(forkPath, base)) {
+    await fetch2(forkPath, "origin").catch(() => {
+    });
+    console.info(colors_default.dim(`'${base}' has no local branch \u2014 cutting from 'origin/${base}'.`));
+    return `origin/${base}`;
+  }
+  const { upstream, ahead, behind } = await getUpstreamStatus(forkPath, base);
   if (!upstream) {
     console.info(colors_default.dim(`'${base}' has no upstream \u2014 skipping the up-to-date check.`));
-    return;
+    return base;
   }
   if (ahead > 0 && behind > 0) {
     throw new Error(
@@ -4690,26 +4814,53 @@ Reconcile '${base}' with '${upstream}' first (e.g. rebase or reset it), then re-
     );
   }
   if (behind > 0) {
+    const worktree = currentBranch === base ? null : await getBranchWorktree(forkPath, base);
+    if (worktree) {
+      console.info(
+        colors_default.dim(`'${base}' is ${behind} behind '${upstream}' but checked out at ${worktree} \u2014 leaving it as it is.`)
+      );
+      return upstream;
+    }
     console.info(colors_default.dim(`fast-forwarding '${base}' to '${upstream}' (${behind} behind)...`));
-    await pullFastForward(forkPath);
-    return;
+    if (currentBranch === base) await pullFastForward(forkPath);
+    else await fastForwardBranch(forkPath, base, upstream);
+    return base;
   }
   if (ahead > 0) {
     console.info(colors_default.dim(`'${base}' is ${ahead} commit(s) ahead of '${upstream}' (unpushed) \u2014 continuing.`));
   }
+  return base;
 }
 async function setupTemporarySyncBranch(config) {
   const { forkPath, settings } = config;
   const base = resolveReleaseBase(settings);
   const startBranch = await getCurrentBranch(forkPath);
-  console.info(colors_default.dim(`switching to '${base}' and updating...`));
-  await switchBranch(forkPath, base);
-  await ensureBaseUpToDate(forkPath, base);
+  const startCommit = (await getCommitInfo(forkPath, "HEAD")).hash;
+  console.info(colors_default.dim(`updating '${base}'...`));
+  const startPoint = await resolveCycleStart(forkPath, base, startBranch);
   const temporaryBranch = buildTemporarySyncBranch();
-  console.info(colors_default.dim(`creating temporary sync branch '${temporaryBranch}' from '${base}'...`));
+  console.info(colors_default.dim(`creating temporary sync branch '${temporaryBranch}' from '${startPoint}'...`));
   console.info();
-  await createBranchFrom(forkPath, temporaryBranch, base);
-  return { temporaryBranch, base, startBranch };
+  await createBranchFrom(forkPath, temporaryBranch, startPoint);
+  return { temporaryBranch, base, startBranch, startCommit };
+}
+async function resolveCutBase(forkPath, base) {
+  if (!await branchExists(forkPath, base)) return `origin/${base}`;
+  const upstream = await getBranchUpstream(forkPath, base);
+  return upstream && await isAncestor(forkPath, base, upstream) ? upstream : base;
+}
+async function returnToBase(forkPath, base) {
+  const worktree = await getBranchWorktree(forkPath, base);
+  if (worktree) {
+    console.info(colors_default.dim(`'${base}' is checked out at ${worktree} \u2014 detaching at '${base}' here instead...`));
+    await switchDetached(forkPath, base);
+    return `detached at '${base}'`;
+  }
+  console.info(colors_default.dim(`switching back to '${base}'...`));
+  await switchBranch(forkPath, base);
+  await pullFastForward(forkPath).catch(() => {
+  });
+  return `back on '${base}'`;
 }
 async function runSync(config, options) {
   createSpinner("starting sync...");
@@ -4850,7 +5001,8 @@ function indentLines(text) {
 async function shipSyncBranch(config, branch) {
   const { forkPath, settings } = config;
   const base = resolveReleaseBase(settings);
-  const flattened = await flattenSyncBranch(forkPath, branch, base);
+  const cutBase = await resolveCutBase(forkPath, base);
+  const flattened = await flattenSyncBranch(forkPath, branch, cutBase);
   let prUrl;
   let prOpened = false;
   const headSubject = (await getCommitInfo(forkPath, "HEAD").catch(() => null))?.message;
@@ -4866,7 +5018,7 @@ async function shipSyncBranch(config, branch) {
   }
   if (ghAvailable()) {
     console.info(colors_default.dim("opening a pull request..."));
-    const prBody = await buildSyncPrBodyForBranch(forkPath, base);
+    const prBody = await buildSyncPrBodyForBranch(forkPath, cutBase);
     const bodyArgs = prBody ? ["--body", prBody] : ["--fill"];
     const pr = spawnSync3("gh", ["pr", "create", "--base", base, "--head", branch, "--title", prTitle, ...bodyArgs], {
       cwd: forkPath,
@@ -4885,17 +5037,14 @@ ${pr.stderr ?? ""}`);
     console.info(colors_default.yellow("`gh` not found \u2014 open the PR manually:"));
     printPrCreateStep(branch, base, prTitle);
   }
-  console.info(colors_default.dim(`switching back to '${base}'...`));
-  await switchBranch(forkPath, base);
-  await pullFastForward(forkPath).catch(() => {
-  });
+  const position = await returnToBase(forkPath, base);
   console.info();
   if (prUrl) {
     console.info(`${colors_default.green("\u2713")} Sync pull request ${prOpened ? "opened" : "ready"}`);
-    console.info(colors_default.dim(`  ${prUrl} \xB7 branch pushed, back on '${base}'`));
+    console.info(colors_default.dim(`  ${prUrl} \xB7 branch pushed, ${position}`));
   } else {
     console.info(`${colors_default.green("\u2713")} Sync branch pushed`);
-    console.info(colors_default.dim(`  '${branch}' is on origin, back on '${base}'`));
+    console.info(colors_default.dim(`  '${branch}' is on origin, ${position}`));
   }
   await printMigrationNotesLine(config);
 }
@@ -4915,8 +5064,9 @@ async function runSyncCycle(config) {
     await runPackages(config, { conflictedFiles: result.conflicts });
   }
   if (result.conflicts.length > 0) return { status: "conflicts", branch };
-  if (!mergeInProgress(forkPath)) {
-    await switchBranch(forkPath, branch.startBranch === branch.temporaryBranch ? branch.base : branch.startBranch);
+  if (!await mergeInProgress(forkPath)) {
+    if (branch.startBranch === "HEAD") await switchDetached(forkPath, branch.startCommit);
+    else await switchBranch(forkPath, branch.startBranch);
     await deleteBranch(forkPath, branch.temporaryBranch);
     return { status: "noop" };
   }
@@ -4974,9 +5124,6 @@ async function mergeOpenSyncPrs(config, open) {
     closePr(forkPath, pr.number);
     await deleteBranch(forkPath, pr.headRefName);
   }
-  console.info(colors_default.dim(`switching to '${base}' and fast-forwarding...`));
-  await switchBranch(forkPath, base);
-  await pullFastForward(forkPath);
   return "continue";
 }
 async function guardAgainstOpenSyncPr(config) {
@@ -5015,7 +5162,7 @@ async function runSyncCommand(config) {
   const { forkPath } = config;
   const currentBranch = await getCurrentBranch(forkPath);
   const onSyncBranch = isTemporarySyncBranch(currentBranch);
-  if (onSyncBranch && mergeInProgress(forkPath)) {
+  if (onSyncBranch && await mergeInProgress(forkPath)) {
     await commitSyncMerge(config, currentBranch);
     return;
   }
@@ -5138,7 +5285,7 @@ async function runForks(config) {
       console.error(colors_default.red(`fork '${config.fork}' not found in config`));
       return;
     }
-    const resolvedPath = resolve6(await resolveForkBasePath(config.forkPath), match.localPath);
+    const resolvedPath = resolve7(await resolveForkBasePath(config.forkPath), match.localPath);
     await syncFork(config, match, resolvedPath);
     return;
   }
@@ -5154,7 +5301,7 @@ async function runForks(config) {
     if (selectedPath === "_exit") {
       process8.exit(0);
     }
-    const resolvedForkPath = resolve6(forkBasePath, selectedPath);
+    const resolvedForkPath = resolve7(forkBasePath, selectedPath);
     const selectedFork = forks.find((f) => f.localPath === selectedPath);
     if (!selectedFork) {
       console.error(colors_default.red(`fork '${selectedPath}' not found in config`));
@@ -5424,7 +5571,7 @@ async function runStats(forkPath, options = {}) {
 function getForkPath() {
   const envPath = getEnv("CELLA_FORK_PATH");
   if (envPath) {
-    const resolved = resolve7(envPath);
+    const resolved = resolve8(envPath);
     if (!existsSync13(resolved) || !statSync3(resolved).isDirectory()) {
       throw new Error(`CELLA_FORK_PATH is not a valid directory: ${resolved}`);
     }
@@ -5432,7 +5579,7 @@ function getForkPath() {
   }
   let cwd = process9.cwd();
   if (cwd.endsWith("/cli/cella") || cwd.endsWith("\\cli\\cella")) {
-    cwd = resolve7(cwd, "../..");
+    cwd = resolve8(cwd, "../..");
   }
   return cwd;
 }