@cellajs/cli 0.0.1 → 0.0.4

package/dist/index.js

@@ -1,24 +1,38 @@
 #!/usr/bin/env tsx
 
 // src/cella-cli.ts
-import { existsSync as existsSync11, statSync as statSync2 } from "fs";
-import { join as join16, resolve as resolve6 } from "path";
-import process8 from "process";
+import { existsSync as existsSync10, statSync as statSync2 } from "fs";
+import { join as join17, resolve as resolve5 } from "path";
+import process9 from "process";
 
 // src/cli.ts
 import { readFileSync } from "fs";
-import { join as join4 } from "path";
-import process4 from "process";
+import { join as join5 } from "path";
+import process5 from "process";
 import { select } from "@inquirer/prompts";
 import { Command } from "commander";
 
 // src/utils/colors.ts
-import process2 from "process";
+import process3 from "process";
 import { styleText } from "util";
+
+// src/utils/env.ts
+import process2 from "process";
+function getEnv(name) {
+  return process2.env[name];
+}
+function hasEnv(name) {
+  return name in process2.env;
+}
+function getEnvSnapshot() {
+  return { ...process2.env };
+}
+
+// src/utils/colors.ts
 function colorsEnabled() {
-  if ("NO_COLOR" in process2.env) return false;
-  if ("FORCE_COLOR" in process2.env) return true;
-  return !!process2.stdout.isTTY;
+  if (hasEnv("NO_COLOR")) return false;
+  if (hasEnv("FORCE_COLOR")) return true;
+  return !!process3.stdout.isTTY;
 }
 function applyStyle(style, text) {
   if (!colorsEnabled()) return text;
@@ -39,8 +53,8 @@ var pc = {
 var colors_default = pc;
 
 // src/utils/config.ts
-import { existsSync, realpathSync } from "fs";
-import { join, resolve } from "path";
+import { existsSync as existsSync2, realpathSync } from "fs";
+import { join as join2, resolve } from "path";
 import { z as z2 } from "zod";
 
 // src/config/types.ts
@@ -82,9 +96,11 @@ var cellaConfigSchema = z.object({
 }).strict();
 
 // src/utils/module-territory.ts
-import { relative, sep } from "path";
+import { existsSync } from "fs";
+import { basename, join, relative, sep } from "path";
 import { Project, SyntaxKind } from "ts-morph";
 var MODULE_FILE_GLOBS = ["backend/src/modules/*/*-module.ts", "frontend/src/modules/*/*-module.ts"];
+var FRONTEND_STATIC_ROOT = "frontend/public/static";
 function readOwner(call) {
   const arg = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
   const initializer = arg?.getProperty("owner")?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
@@ -98,11 +114,19 @@ function resolveAppModuleFolders(repoPath) {
   });
   const sourceFiles = project.addSourceFilesAtPaths(MODULE_FILE_GLOBS.map((glob) => `${repoPath}/${glob}`));
   const folders = /* @__PURE__ */ new Set();
+  const moduleNames = /* @__PURE__ */ new Set();
   for (const sourceFile of sourceFiles) {
     const ownsApp = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).some((call) => call.getExpression().getText() === "registerModule" && readOwner(call) === "app");
     if (!ownsApp) continue;
     const folder = relative(repoPath, sourceFile.getDirectoryPath()).split(sep).join("/");
     folders.add(folder);
+    moduleNames.add(basename(folder));
+  }
+  for (const moduleName of moduleNames) {
+    const staticFolder = `${FRONTEND_STATIC_ROOT}/${moduleName}`;
+    if (existsSync(join(repoPath, staticFolder))) {
+      folders.add(staticFolder);
+    }
   }
   return [...folders];
 }
@@ -131,8 +155,8 @@ function resolveUpstream(settings) {
   return { track, branchRef };
 }
 async function loadConfig(forkPath) {
-  const configPath = join(forkPath, "cella.config.ts");
-  if (!existsSync(configPath)) {
+  const configPath = join2(forkPath, "cella.config.ts");
+  if (!existsSync2(configPath)) {
     throw new Error(`config file not found: ${configPath}`);
   }
   const realConfigPath = realpathSync(configPath);
@@ -165,18 +189,17 @@ ${z2.prettifyError(result.error)}`);
 }
 
 // src/utils/display.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync2, writeFileSync } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
-import process3 from "process";
+import { writeFileSync } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+import process4 from "process";
 
 // package.json
 var package_default = {
   name: "@cellajs/cli",
-  version: "0.0.1",
+  version: "0.0.4",
   private: false,
   license: "MIT",
-  description: "CLI for syncing and managing apps with upstream Cella.",
+  description: "CLI for managing your monorepo and syncing with upstream Cella.",
   repository: {
     type: "git",
     url: "https://github.com/cellajs/cella-cli"
@@ -225,6 +248,7 @@ var package_default = {
   dependencies: {
     "@inquirer/core": "^11.2.1",
     "@inquirer/prompts": "^8.5.2",
+    "@pierre/diffs": "^1.2.12",
     commander: "^15.0.0",
     "ts-morph": "^28.0.0",
     zod: "^4.4.3"
@@ -311,7 +335,7 @@ var checkMark = colors_default.green("\u2713");
 var TerminalSpinner = class {
   constructor(text, isSilent) {
     this.text = text;
-    this.enabled = !isSilent && !!process3.stdout.isTTY;
+    this.enabled = !isSilent && !!process4.stdout.isTTY;
   }
   text;
   frames = ["-", "\\", "|", "/"];
@@ -333,10 +357,10 @@ var TerminalSpinner = class {
       this.timer = null;
     }
     if (!this.enabled) return;
-    process3.stdout.write("\r\x1B[2K");
+    process4.stdout.write("\r\x1B[2K");
   }
   render() {
-    process3.stdout.write(`\r${colors_default.cyan(this.frames[this.frameIndex])} ${this.text}`);
+    process4.stdout.write(`\r${colors_default.cyan(this.frames[this.frameIndex])} ${this.text}`);
   }
 };
 var activeSpinner = null;
@@ -345,7 +369,7 @@ function setJsonMode(enabled) {
   jsonMode = enabled;
   if (!enabled) return;
   const toStderr = (...args) => {
-    process3.stderr.write(`${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+    process4.stderr.write(`${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
 `);
   };
   console.info = toStderr;
@@ -353,7 +377,7 @@ function setJsonMode(enabled) {
   console.warn = toStderr;
 }
 function writeStdout(text) {
-  process3.stdout.write(text.endsWith("\n") ? text : `${text}
+  process4.stdout.write(text.endsWith("\n") ? text : `${text}
 `);
 }
 function getHeader() {
@@ -376,7 +400,7 @@ function printStep(label, detail) {
   }
 }
 function createSpinner(text) {
-  const isTestEnv = !!process3.env.VITEST || process3.env.NODE_ENV === "test";
+  const isTestEnv = !!getEnv("VITEST") || getEnv("NODE_ENV") === "test";
   activeSpinner = new TerminalSpinner(text, isTestEnv || jsonMode);
   activeSpinner.start();
   return activeSpinner;
@@ -402,23 +426,6 @@ function stopSpinner() {
     activeSpinner = null;
   }
 }
-function showDiffInPager(diffOutput) {
-  if (diffOutput.length === 0) return;
-  const hasBat = spawnSync("which", ["bat"], { stdio: "pipe" }).status === 0;
-  process3.stdout.write("\x1B[?25h");
-  if (hasBat) {
-    spawnSync("bat", ["--language", "diff", "--paging", "always", "--style", "plain"], {
-      input: diffOutput,
-      stdio: ["pipe", "inherit", "inherit"]
-    });
-  } else {
-    spawnSync("less", ["-R"], {
-      input: diffOutput,
-      stdio: ["pipe", "inherit", "inherit"]
-    });
-  }
-  process3.stdout.write("\x1B[2J\x1B[0;0H");
-}
 function hyperlink(label, url) {
   if (!url) return label;
   const safeUrl = url.replace(/[\x00-\x1f\x7f]/g, "");
@@ -447,18 +454,12 @@ function formatFetchedUpstreamDetail(commitCount, commits, upstreamGitHubUrl, ma
   return lines.join("\n");
 }
 function getFileLink(filePath, commitHash, options) {
-  const { upstreamGitHubUrl, upstreamBranch, fileLinkMode = "commit", upstreamViewPath, forkPath } = options;
-  if (fileLinkMode === "local" && upstreamViewPath && forkPath) {
-    const absolutePath = resolve2(upstreamViewPath, filePath);
-    if (existsSync2(absolutePath)) {
-      const url = `vscode://file${absolutePath}`;
-      return { label: filePath.split("/").pop() || filePath, url };
-    }
-  }
+  const { upstreamGitHubUrl, upstreamBranch, fileLinkMode = "commit" } = options;
+  const mode = fileLinkMode === "local" ? "file" : fileLinkMode;
   if (!upstreamGitHubUrl) {
     return { label: commitHash?.slice(0, 9) || "" };
   }
-  if (fileLinkMode === "file" && upstreamBranch) {
+  if (mode === "file" && upstreamBranch) {
     const url = `${upstreamGitHubUrl}/blob/${upstreamBranch}/${filePath}`;
     return { label: filePath.split("/").pop() || filePath, url };
   }
@@ -514,7 +515,7 @@ var summaryStatusConfig = {
     icon: colors_default.cyan("\u25C7"),
     label: "managed",
     color: colors_default.cyan,
-    description: "package/config files handled separately"
+    description: "package.jsons & cella.config.ts handled separately"
   },
   ignored: { ...statusConfig.ignored, description: "protected by ignored config" }
 };
@@ -602,7 +603,7 @@ function printAnalysisFileGroups(files, linkOptions) {
   });
 }
 function writeLogFile(forkPath, files) {
-  const logPath = join2(forkPath, "cella-sync.log");
+  const logPath = join3(forkPath, "cella-sync.log");
   const lines = [
     `cella sync analysis - ${(/* @__PURE__ */ new Date()).toISOString()}`,
     DIVIDER,
@@ -625,14 +626,23 @@ function writeLogFile(forkPath, files) {
   writeFileSync(logPath, lines.join("\n"), "utf-8");
   return logPath;
 }
-function printSyncComplete(result) {
+function printSyncComplete(result, options = {}) {
   const updated = result.files.filter((file) => file.status === "behind" || file.status === "diverged").length;
   const diverged = result.files.filter((file) => file.status === "diverged").length;
   const merged = result.autoMergedFiles?.length ?? Math.max(0, diverged - result.conflicts.length);
   const conflicts = result.conflicts.length;
   console.info();
-  console.info(`${colors_default.green("\u2713")} sync complete`);
-  console.info(colors_default.dim(`  ${updated} files updated, ${merged} auto-merged, ${conflicts} conflicts`));
+  if (options.stagedBranch) {
+    console.info(`${colors_default.green("\u2713")} Sync merge staged on '${options.stagedBranch}'`);
+    console.info(
+      colors_default.dim(
+        `  ${updated} files updated, ${merged} auto-merged, ${conflicts} conflicts. Review, then rerun \`pnpm cella sync\` to finish.`
+      )
+    );
+  } else {
+    console.info(`${colors_default.green("\u2713")} sync complete`);
+    console.info(colors_default.dim(`  ${updated} files updated, ${merged} auto-merged, ${conflicts} conflicts`));
+  }
   console.info();
 }
 function printFlagWarnings(options) {
@@ -652,7 +662,7 @@ function printFlagWarnings(options) {
 
 // src/utils/overrides.ts
 import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function isUnderAnyFolder(filePath, folders) {
   return folders.some((folder) => {
     const entry = folder.replace(/\/+$/, "");
@@ -684,7 +694,7 @@ function validateOverrides(config, forkPath) {
         pattern: entry,
         message: `pin uses glob (not supported, use a path or folder): ${entry}`
       });
-    } else if (!existsSync3(join3(forkPath, entry))) {
+    } else if (!existsSync3(join4(forkPath, entry))) {
       warnings.push({
         type: "pinned-not-found",
         pattern: entry,
@@ -700,7 +710,7 @@ function validateOverrides(config, forkPath) {
         pattern: entry,
         message: `ignored entry uses glob (not supported, use a path or folder): ${entry}`
       });
-    } else if (!existsSync3(join3(forkPath, entry.replace(/\/+$/, "")))) {
+    } else if (!existsSync3(join4(forkPath, entry.replace(/\/+$/, "")))) {
       warnings.push({
         type: "ignored-not-found",
         pattern: entry,
@@ -751,7 +761,7 @@ var serviceDefinitions = [
       { 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: "--diff <path>", description: "print unified diff for one file, then exit" },
-      { flags: "--open-diff <path>", description: "open VS Code side-by-side diff for one file, then exit" }
+      { flags: "--open-diff <path>", description: "open a browser diff for one file, then exit" }
     ],
     includeInMenu: (context) => !context.isUpstreamRepo
   },
@@ -810,7 +820,7 @@ var serviceDefinitions = [
 async function getMenuContext(userConfig, forkPath) {
   return {
     hasForks: (userConfig.forks?.length ?? 0) > 0,
-    isUpstreamRepo: JSON.parse(readFileSync(join4(forkPath, "package.json"), "utf8")).name === "cella"
+    isUpstreamRepo: JSON.parse(readFileSync(join5(forkPath, "package.json"), "utf8")).name === "cella"
   };
 }
 function buildServiceChoices(context) {
@@ -878,7 +888,7 @@ async function promptForService(userConfig, forkPath) {
   if (selected === "exit") {
     console.info(colors_default.dim("exiting..."));
     console.info();
-    process4.exit(0);
+    process5.exit(0);
   }
   console.info();
   return selected;
@@ -894,7 +904,7 @@ function buildRuntimeConfig(userConfig, forkPath, selection) {
   };
 }
 async function parseCli(userConfig, forkPath) {
-  const selection = parseCommandLine(process4.argv);
+  const selection = parseCommandLine(process5.argv);
   if (selection.options.json || selection.options.diff) setJsonMode(true);
   printHeader();
   const warnings = validateOverrides(userConfig, forkPath);
@@ -909,29 +919,134 @@ async function parseCli(userConfig, forkPath) {
 }
 
 // src/services/analyze.ts
-import { basename as basename2 } from "path";
+import { basename as basename4 } from "path";
 
-// src/utils/cleanup.ts
-import { existsSync as existsSync5, rmSync } from "fs";
+// src/utils/diff.ts
+import { execFileSync } from "child_process";
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
-import { basename, join as join7 } from "path";
+import { basename as basename2, join as join6 } from "path";
 import process6 from "process";
+function gitDiffFile(cwd, range, filePath, options = {}) {
+  const args = ["diff", "--no-color"];
+  if (options.dstPrefix) args.push("--src-prefix=cella/", `--dst-prefix=${options.dstPrefix}/`);
+  args.push(range, "--", filePath);
+  try {
+    return execFileSync("git", args, { cwd, maxBuffer: 50 * 1024 * 1024 });
+  } catch (error) {
+    const stderr = error.stderr?.toString().trim();
+    throw new Error(stderr || `failed to diff ${filePath}`);
+  }
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function renderDiffPage(patch, meta) {
+  const { preloadPatchDiff } = await import("@pierre/diffs/ssr");
+  const { prerenderedHTML } = await preloadPatchDiff({
+    patch,
+    options: {
+      diffStyle: "split",
+      themeType: "system",
+      lineDiffType: "word-alt",
+      hunkSeparators: "line-info",
+      overflow: "wrap",
+      disableFileHeader: true
+    }
+  });
+  const title = `${escapeHtml(meta.filePath)} \xB7 ${escapeHtml(meta.srcLabel)} vs ${escapeHtml(meta.dstLabel)}`;
+  const note = meta.note ? `<span class="note">\xB7 ${escapeHtml(meta.note)}</span>` : "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>
+  :root { color-scheme: light dark; }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
+    background: light-dark(#fafafa, #111);
+    color: light-dark(#111, #eee);
+  }
+  header {
+    display: flex; align-items: baseline; gap: 0.75rem; flex-wrap: wrap;
+    padding: 0.9rem 1.25rem;
+    border-bottom: 1px solid light-dark(#e2e2e2, #2a2a2a);
+    position: sticky; top: 0;
+    background: inherit;
+  }
+  header .brand { font-weight: 600; color: light-dark(#0891b2, #22d3ee); }
+  header code { font-family: ui-monospace, monospace; font-size: 0.9rem; }
+  header .sides { margin-left: auto; font-size: 0.8rem; opacity: 0.7; }
+  main { max-width: 1400px; margin: 1rem auto; padding: 0 1rem 2rem; }
+  .diff-shell {
+    border: 1px solid light-dark(#e2e2e2, #2a2a2a);
+    border-radius: 8px; overflow: hidden;
+    background: light-dark(#fff, #161616);
+  }
+</style>
+</head>
+<body>
+<header>
+  <span class="brand">\u29C8 cella diff</span>
+  <code>${escapeHtml(meta.filePath)}</code>
+  <span class="sides">${escapeHtml(meta.srcLabel)} \u2190 \u2192 ${escapeHtml(meta.dstLabel)} ${note}</span>
+</header>
+<main>
+  <!-- Declarative shadow DOM: the library's CSS targets :host, which only
+       matches inside a shadow root (its browser component renders into one). -->
+  <div class="diff-shell">
+    <template shadowrootmode="open">
+${prerenderedHTML}
+    </template>
+  </div>
+</main>
+</body>
+</html>`;
+}
+function openWithDefaultApp(target) {
+  try {
+    if (process6.platform === "win32") {
+      execFileSync("rundll32", ["url.dll,FileProtocolHandler", target], { stdio: "ignore" });
+    } else {
+      execFileSync(process6.platform === "darwin" ? "open" : "xdg-open", [target], { stdio: "ignore" });
+    }
+  } catch {
+  }
+}
+async function openDiffInBrowser(patch, meta, repoPath) {
+  const html = await renderDiffPage(patch, meta);
+  const dir = join6(tmpdir(), `cella-diff-${basename2(repoPath)}`);
+  mkdirSync(dir, { recursive: true });
+  const outPath = join6(dir, `${meta.filePath.replace(/[^\w.-]+/g, "-")}.html`);
+  writeFileSync2(outPath, html);
+  openWithDefaultApp(outPath);
+  return outPath;
+}
+
+// src/utils/cleanup.ts
+import { existsSync as existsSync5, rmSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename3, join as join9 } from "path";
+import process7 from "process";
 
 // src/utils/git.ts
 import { execFile } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { mkdir, readdir, rmdir, unlink } from "fs/promises";
-import { dirname, join as join6 } from "path";
-import process5 from "process";
+import { dirname, join as join8 } from "path";
 import { promisify } from "util";
 
 // src/utils/manifest.ts
 import { readFile, writeFile } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 var MANIFEST_FILE = "cella.manifest.json";
 async function readSyncManifest(cwd) {
   try {
-    const parsed = JSON.parse(await readFile(join5(cwd, MANIFEST_FILE), "utf8"));
+    const parsed = JSON.parse(await readFile(join7(cwd, MANIFEST_FILE), "utf8"));
     const commit = parsed?.upstream?.commit;
     if (typeof commit !== "string" || !/^[0-9a-f]{40}$/i.test(commit)) return null;
     return parsed;
@@ -944,7 +1059,7 @@ async function readManifestBase(cwd) {
   return manifest ? manifest.upstream.commit.toLowerCase() : null;
 }
 async function writeSyncManifest(cwd, manifest) {
-  await writeFile(join5(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  await writeFile(join7(cwd, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 
@@ -958,7 +1073,7 @@ function sanitizeCredentials(text) {
 }
 async function git(args, cwd, options = {}) {
   const env = {
-    ...process5.env,
+    ...getEnvSnapshot(),
     ...options.skipEditor ? { GIT_EDITOR: "true" } : {},
     ...options.env
   };
@@ -1000,12 +1115,22 @@ async function getUpstreamStatus(cwd) {
   const [ahead, behind] = counts.split(/\s+/).map((n) => Number.parseInt(n, 10) || 0);
   return { upstream, ahead: ahead ?? 0, behind: behind ?? 0 };
 }
-async function pushBranch(cwd, remote, branch) {
-  await git(["push", "-u", remote, branch], cwd);
+async function pushBranch(cwd, remote, branch, options = {}) {
+  await git(["push", "-u", ...options.forceWithLease ? ["--force-with-lease"] : [], remote, branch], cwd);
+}
+async function listBranchMergeCommits(cwd, baseRef) {
+  const out = await git(["rev-list", "--merges", "--first-parent", `${baseRef}..HEAD`], cwd, { ignoreErrors: true });
+  return out ? out.split("\n").filter(Boolean) : [];
+}
+async function flattenBranch(cwd, baseRef, message) {
+  const parent = await getMergeBase(cwd, baseRef, "HEAD");
+  const tree = await git(["rev-parse", "HEAD^{tree}"], cwd);
+  const commit = await git(["commit-tree", tree, "-p", parent, "-m", message], cwd);
+  await git(["reset", "--hard", commit], cwd);
 }
 async function commitSquash(cwd, message) {
   for (const file of ["MERGE_HEAD", "MERGE_MSG", "MERGE_MODE"]) {
-    const path4 = join6(cwd, ".git", file);
+    const path4 = join8(cwd, ".git", file);
     if (existsSync4(path4)) await unlink(path4);
   }
   await git(["commit", "-m", message], cwd, { skipEditor: true });
@@ -1014,7 +1139,7 @@ async function stageAll(cwd) {
   await git(["add", "-A"], cwd);
 }
 function mergeInProgress(cwd) {
-  return existsSync4(join6(cwd, ".git", "MERGE_HEAD"));
+  return existsSync4(join8(cwd, ".git", "MERGE_HEAD"));
 }
 async function getShortSha(cwd, ref) {
   return git(["rev-parse", "--short", ref], cwd);
@@ -1244,15 +1369,15 @@ async function batchUnstageFiles(cwd, filePaths) {
   await git(["rm", "--cached", "-f", "--", ...filePaths], cwd, { ignoreErrors: true });
 }
 async function gitMv(cwd, oldPath, newPath) {
-  const newDir = dirname(join6(cwd, newPath));
+  const newDir = dirname(join8(cwd, newPath));
   await mkdir(newDir, { recursive: true });
   await git(["mv", "-f", oldPath, newPath], cwd);
 }
 async function fileExistsInWorktree(cwd, filePath) {
-  return existsSync4(join6(cwd, filePath));
+  return existsSync4(join8(cwd, filePath));
 }
 async function removeFileFromWorktree(cwd, filePath) {
-  const fullPath = join6(cwd, filePath);
+  const fullPath = join8(cwd, filePath);
   try {
     await unlink(fullPath);
     await cleanupEmptyParentDirs(cwd, dirname(filePath));
@@ -1265,7 +1390,7 @@ async function removeFileFully(cwd, filePath) {
 }
 async function cleanupEmptyParentDirs(cwd, relativePath) {
   if (!relativePath || relativePath === ".") return;
-  const fullPath = join6(cwd, relativePath);
+  const fullPath = join8(cwd, relativePath);
   try {
     const entries = await readdir(fullPath);
     if (entries.length === 0) {
@@ -1293,14 +1418,28 @@ async function getStoredSyncHead(cwd) {
   const ref = await git(["rev-parse", "refs/cella/last-sync-head"], cwd, { ignoreErrors: true });
   return ref || null;
 }
-async function readManifestBaseAtRef(cwd, ref) {
+async function readManifestAtRef(cwd, ref) {
   const raw = await git(["show", `${ref}:${MANIFEST_FILE}`], cwd, { ignoreErrors: true });
   if (!raw) return null;
   try {
     const parsed = JSON.parse(raw);
     const commit = parsed?.upstream?.commit;
     if (typeof commit !== "string" || !/^[0-9a-f]{40}$/i.test(commit)) return null;
-    return commit.toLowerCase();
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function readManifestBaseAtRef(cwd, ref) {
+  const manifest = await readManifestAtRef(cwd, ref);
+  return manifest ? manifest.upstream.commit.toLowerCase() : null;
+}
+async function readPackageVersionAtRef(cwd, ref) {
+  const raw = await git(["show", `${ref}:package.json`], cwd, { ignoreErrors: true });
+  if (!raw) return null;
+  try {
+    const version = JSON.parse(raw).version;
+    return typeof version === "string" && version ? version : null;
   } catch {
     return null;
   }
@@ -1318,28 +1457,82 @@ async function getRootCommit(cwd, ref) {
   const roots = out.split("\n").filter(Boolean);
   return roots.length > 0 ? roots[roots.length - 1] : null;
 }
+var SCAFFOLD_CANDIDATE_LIMIT = 400;
+var SCAFFOLD_SCORE_CONCURRENCY = 10;
+var SCAFFOLD_MATCH_MAX_DIFF_RATIO = 0.3;
+async function inferScaffoldBase(cwd, headRef, upstreamRef) {
+  const root = await getRootCommit(cwd, headRef);
+  if (!root) return null;
+  const rootDate = await git(["show", "-s", "--format=%cI", root], cwd, { ignoreErrors: true });
+  if (!rootDate) return null;
+  const before = new Date(new Date(rootDate).getTime() + 24 * 60 * 60 * 1e3).toISOString();
+  const revList = await git(
+    ["rev-list", `--max-count=${SCAFFOLD_CANDIDATE_LIMIT}`, `--before=${before}`, upstreamRef],
+    cwd,
+    { ignoreErrors: true }
+  );
+  const candidates = revList.split("\n").filter(Boolean);
+  if (candidates.length === 0) return null;
+  const totalPaths = (await git(["ls-tree", "-r", "--name-only", root], cwd)).split("\n").filter(Boolean).length;
+  if (totalPaths === 0) return null;
+  let best = null;
+  outer: for (let i = 0; i < candidates.length; i += SCAFFOLD_SCORE_CONCURRENCY) {
+    const chunk = candidates.slice(i, i + SCAFFOLD_SCORE_CONCURRENCY);
+    const scores = await Promise.all(
+      chunk.map(async (sha) => {
+        try {
+          const out = await git(["diff-tree", "-r", "--name-only", sha, root], cwd);
+          return { sha, diff: out ? out.split("\n").length : 0 };
+        } catch {
+          return { sha, diff: Number.POSITIVE_INFINITY };
+        }
+      })
+    );
+    for (const score of scores) {
+      if (!best || score.diff < best.diff) best = score;
+      if (best.diff === 0) break outer;
+    }
+  }
+  if (!best || best.diff / totalPaths > SCAFFOLD_MATCH_MAX_DIFF_RATIO) return null;
+  return best.sha;
+}
+async function readRootTrailerBase(cwd, headRef) {
+  const root = await getRootCommit(cwd, headRef);
+  if (!root) return null;
+  const message = await git(["show", "-s", "--format=%B", root], cwd, { ignoreErrors: true });
+  const match = message.match(/^cella-base:\s*([0-9a-f]{40})$/im);
+  return match ? match[1].toLowerCase() : null;
+}
 async function ensureSyncBase(cwd, headRef, upstreamRef) {
   const nativeBase = await git(["merge-base", headRef, upstreamRef], cwd, { ignoreErrors: true });
   if (nativeBase) return;
-  const baseSha = await getStoredSyncRef(cwd) ?? await readManifestBaseAtRef(cwd, headRef) ?? await readManifestBase(cwd);
+  const sources = [
+    () => getStoredSyncRef(cwd),
+    () => readManifestBaseAtRef(cwd, headRef),
+    () => readManifestBase(cwd),
+    () => readRootTrailerBase(cwd, headRef),
+    () => inferScaffoldBase(cwd, headRef, upstreamRef)
+  ];
+  let baseSha = null;
+  for (const source of sources) {
+    const sha = await source();
+    if (sha && await commitObjectExists(cwd, sha)) {
+      baseSha = sha;
+      break;
+    }
+  }
   if (!baseSha) {
     throw new Error(
-      `no common ancestor between the fork and '${upstreamRef}', and no sync base recorded.
+      `no common ancestor between the fork and '${upstreamRef}', and no sync base could be determined.
 
 This fork has unrelated history with upstream \u2014 typical for a create-cella scaffold, or after
-upstream squashed its history. Seed the base with the upstream commit the fork was created from,
-then re-run sync:
+upstream squashed its history \u2014 and no recorded or inferable base commit exists after fetching
+upstream. Seed it manually with the upstream commit the fork was created from, then re-run sync:
 
   git update-ref refs/cella/last-sync <upstream-sha>
 `
     );
   }
-  if (!await commitObjectExists(cwd, baseSha)) {
-    throw new Error(
-      `recorded sync base ${baseSha.slice(0, 12)} is not present after fetching '${upstreamRef}'.
-It may belong to a different upstream, or have been dropped by an upstream history rewrite.`
-    );
-  }
   const root = await getRootCommit(cwd, headRef);
   if (!root) throw new Error("could not determine the fork's root commit to bootstrap sync ancestry");
   await git(["replace", "-f", "--graft", root, baseSha], cwd);
@@ -1382,23 +1575,11 @@ var WORKTREE_PREFIXES = {
   view: "cella-view-"
 };
 function buildWorktreePath(kind, repoPath) {
-  return join7(tmpdir(), `${WORKTREE_PREFIXES[kind]}${basename(repoPath)}`);
+  return join9(tmpdir2(), `${WORKTREE_PREFIXES[kind]}${basename3(repoPath)}`);
 }
 function getWorktreePath(repoPath) {
   return buildWorktreePath("sync", repoPath);
 }
-function getViewWorktreePath(repoPath) {
-  return buildWorktreePath("view", repoPath);
-}
-async function refreshViewWorktree(repoPath, upstreamRef) {
-  const viewPath = getViewWorktreePath(repoPath);
-  await removeWorktree(repoPath, viewPath);
-  if (existsSync5(viewPath)) {
-    rmSync(viewPath, { recursive: true, force: true });
-  }
-  await createWorktree(repoPath, viewPath, upstreamRef);
-  return viewPath;
-}
 var cleanupRegistered = false;
 var currentWorktreePath = null;
 var currentRepoPath = null;
@@ -1418,9 +1599,11 @@ async function cleanupWorktree(repoPath, worktreePath) {
   unregisterWorktree();
 }
 async function cleanupLeftoverWorktrees(repoPath) {
-  const worktreePath = getWorktreePath(repoPath);
-  if (existsSync5(worktreePath)) {
-    await cleanupWorktree(repoPath, worktreePath);
+  for (const kind of Object.keys(WORKTREE_PREFIXES)) {
+    const worktreePath = buildWorktreePath(kind, repoPath);
+    if (existsSync5(worktreePath)) {
+      await cleanupWorktree(repoPath, worktreePath);
+    }
   }
   const prefixes = Object.values(WORKTREE_PREFIXES);
   const worktrees = await listWorktrees(repoPath);
@@ -1447,56 +1630,15 @@ async function handleAbort(signal) {
       );
     }
   }
-  process6.exit(1);
+  process7.exit(1);
 }
 function registerSignalHandlers() {
   if (cleanupRegistered) return;
-  process6.on("SIGINT", () => handleAbort("SIGINT"));
-  process6.on("SIGTERM", () => handleAbort("SIGTERM"));
+  process7.on("SIGINT", () => handleAbort("SIGINT"));
+  process7.on("SIGTERM", () => handleAbort("SIGTERM"));
   cleanupRegistered = true;
 }
 
-// src/utils/diff.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync6, mkdtempSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join8, resolve as resolve3 } from "path";
-function gitDiffFile(cwd, range, filePath, options) {
-  const args = ["diff"];
-  if (options.color === "always") args.push("--color=always");
-  if (options.color === "never") args.push("--no-color");
-  args.push("--src-prefix=cella/", `--dst-prefix=${options.dstPrefix}/`, range, "--", filePath);
-  const result = spawnSync2("git", args, { cwd, maxBuffer: 50 * 1024 * 1024 });
-  if (result.status !== 0) {
-    const stderr = result.stderr?.toString().trim();
-    throw new Error(stderr || `failed to diff ${filePath}`);
-  }
-  return result.stdout;
-}
-function openVsCodeDiff(forkPath, upstreamRef, viewPath, filePath) {
-  const forkFile = resolve3(forkPath, filePath);
-  if (viewPath) {
-    const upstreamFile = resolve3(viewPath, filePath);
-    if (existsSync6(upstreamFile)) {
-      spawnSync2("code", ["--diff", upstreamFile, forkFile], { stdio: "ignore" });
-      return;
-    }
-  }
-  const tmpDir = mkdtempSync(join8(tmpdir2(), "cella-analyze-diff-"));
-  const fileName = filePath.split("/").pop() || "file";
-  const tmpFile = join8(tmpDir, `upstream-${fileName}`);
-  const result = spawnSync2("git", ["show", `${upstreamRef}:${filePath}`], {
-    cwd: forkPath,
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.status !== 0) {
-    const stderr = result.stderr.toString().trim();
-    throw new Error(stderr || `failed to read upstream version for ${filePath}`);
-  }
-  writeFileSync2(tmpFile, result.stdout);
-  spawnSync2("code", ["--diff", tmpFile, forkFile], { stdio: "ignore" });
-}
-
 // src/services/analyze-core.ts
 async function analyzeRefs(repoPath, localRef, incomingRef, mergeBaseRef, predicates, onProgress) {
   onProgress?.("collecting file hashes (batch)...");
@@ -2009,8 +2151,7 @@ function findTargetFile(files, targetPath) {
 }
 function printUnifiedDiff(config, filePath) {
   const diff = gitDiffFile(config.forkPath, `${config.upstreamRef}..HEAD`, filePath, {
-    dstPrefix: basename2(config.forkPath),
-    color: "never"
+    dstPrefix: basename4(config.forkPath)
   });
   writeStdout(diff.toString());
 }
@@ -2052,19 +2193,32 @@ async function runAnalyze(config) {
     }
     return result;
   }
-  const upstreamViewPath = await refreshViewWorktree(config.forkPath, config.upstreamRef);
   if (config.openDiff) {
     const file = findTargetFile(scopedFiles, config.openDiff) ?? findTargetFile(result.files, config.openDiff);
     if (!file) throw new Error(`file not found in analysis results: ${config.openDiff}`);
-    openVsCodeDiff(config.forkPath, config.upstreamRef, upstreamViewPath, file.path);
-    console.info(`${colors_default.green("\u2713")} opened VS Code diff for ${file.path}`);
+    const patch = gitDiffFile(config.forkPath, config.upstreamRef, file.path);
+    if (patch.length === 0) {
+      console.info(`${colors_default.green("\u2713")} ${file.path} is identical to upstream`);
+      return result;
+    }
+    const pagePath = await openDiffInBrowser(
+      patch.toString(),
+      {
+        filePath: file.path,
+        srcLabel: "cella",
+        dstLabel: basename4(config.forkPath),
+        note: "local working tree"
+      },
+      config.forkPath
+    );
+    console.info(`${colors_default.green("\u2713")} opened browser diff for ${file.path}`);
+    console.info(colors_default.dim(`  ${pagePath}`));
     return result;
   }
   const linkOptions = {
     upstreamGitHubUrl: result.upstreamGitHubUrl,
     upstreamBranch: result.upstreamBranch,
     fileLinkMode: config.settings.fileLinkMode,
-    upstreamViewPath,
     forkPath: config.forkPath
   };
   printAnalysisFileGroups(result.files, linkOptions);
@@ -2079,7 +2233,7 @@ async function runAnalyze(config) {
 }
 
 // src/services/audit.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync } from "child_process";
 import * as fs2 from "fs";
 import * as path2 from "path";
 import { checkbox, confirm, Separator } from "@inquirer/prompts";
@@ -2370,7 +2524,7 @@ async function runAudit(config, options = {}) {
     if (options.force) {
       spinnerText("clearing pnpm metadata cache...");
       clearCache();
-      spawnSync3("pnpm", ["cache", "delete", "*"], {
+      spawnSync("pnpm", ["cache", "delete", "*"], {
         cwd: forkPath,
         stdio: "ignore"
       });
@@ -2660,7 +2814,7 @@ async function promptForUpdates(packages, forkPath, auditResult) {
   }
   if (runAuditFix) {
     console.info(colors_default.dim("running pnpm audit --fix override..."));
-    const auditFixResult = spawnSync3("pnpm", ["audit", "--fix", "override"], {
+    const auditFixResult = spawnSync("pnpm", ["audit", "--fix", "override"], {
       cwd: forkPath,
       stdio: "inherit"
     });
@@ -2680,7 +2834,7 @@ async function promptForUpdates(packages, forkPath, auditResult) {
     const selectedCatalogPackages = selectedPackages.filter((pkgName) => catalogPackages.has(pkgName));
     if (selectedCatalogPackages.length > 0) {
       console.info(colors_default.dim(`normalizing catalog consumers: ${selectedCatalogPackages.join(", ")}`));
-      const normalizeResult = spawnSync3("pnpm", ["-r", "up", ...selectedCatalogPackages], {
+      const normalizeResult = spawnSync("pnpm", ["-r", "up", ...selectedCatalogPackages], {
         cwd: forkPath,
         stdio: "inherit"
       });
@@ -2690,7 +2844,7 @@ async function promptForUpdates(packages, forkPath, auditResult) {
         return;
       }
     }
-    const result = spawnSync3("pnpm", ["-r", "up", "--latest", ...selectedPackages], {
+    const result = spawnSync("pnpm", ["-r", "up", "--latest", ...selectedPackages], {
       cwd: forkPath,
       stdio: "inherit"
     });
@@ -2847,7 +3001,7 @@ async function checkOverrides(forkPath) {
 
 // src/services/contributions.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import {
   createPrompt,
   isDownKey,
@@ -2862,7 +3016,7 @@ import {
 import { select as select2 } from "@inquirer/prompts";
 
 // src/services/contrib-core.ts
-import { dirname as dirname2, join as join11 } from "path";
+import { dirname as dirname2, join as join12 } 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));
@@ -2924,7 +3078,7 @@ async function readBlobInfo(repoPath, ref, filePath) {
 }
 async function buildContribBranch(repoPath, baseRef, forkRef, detection, forkName) {
   const branch = `contrib/${forkName}`;
-  const tmpIndex = join11(repoPath, ".git", `tmp-contrib-index-${forkName.replace(/[^\w.-]/g, "_")}`);
+  const tmpIndex = join12(repoPath, ".git", `tmp-contrib-index-${forkName.replace(/[^\w.-]/g, "_")}`);
   const indexEnv = { GIT_INDEX_FILE: tmpIndex };
   try {
     await git(["read-tree", baseRef], repoPath, { env: indexEnv });
@@ -2967,16 +3121,16 @@ ${commitBody}`;
 }
 
 // src/services/fork-utils.ts
-import { existsSync as existsSync8 } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve3 } from "path";
 function validateForkPath(fork, basePath, requireConfig = false) {
-  const resolvedPath = resolve4(basePath, fork.localPath);
-  if (!resolvedPath.startsWith(resolve4(basePath, ".."))) {
+  const resolvedPath = resolve3(basePath, fork.localPath);
+  if (!resolvedPath.startsWith(resolve3(basePath, ".."))) {
     return { fork, resolvedPath, valid: false, error: "path resolves outside parent directory" };
   }
-  if (!existsSync8(resolvedPath)) return { fork, resolvedPath, valid: false, error: "path does not exist" };
-  if (!existsSync8(`${resolvedPath}/.git`)) return { fork, resolvedPath, valid: false, error: "not a git repository" };
-  if (requireConfig && !existsSync8(`${resolvedPath}/cella.config.ts`)) {
+  if (!existsSync7(resolvedPath)) return { fork, resolvedPath, valid: false, error: "path does not exist" };
+  if (!existsSync7(`${resolvedPath}/.git`)) return { fork, resolvedPath, valid: false, error: "not a git repository" };
+  if (requireConfig && !existsSync7(`${resolvedPath}/cella.config.ts`)) {
     return { fork, resolvedPath, valid: false, error: "missing cella.config.ts" };
   }
   return { fork, resolvedPath, valid: true };
@@ -2988,12 +3142,13 @@ function printNoForksHint(action) {
 }
 
 // src/services/contributions.ts
-function showContribDiff(item, baseRef, cwd, forkName) {
-  const diff = gitDiffFile(cwd, `${baseRef}..${item.ref}`, item.path, { dstPrefix: forkName, color: "always" });
-  showDiffInPager(diff);
+async function showContribDiff(item, baseRef, cwd, forkName) {
+  const patch = gitDiffFile(cwd, `${baseRef}..${item.ref}`, item.path);
+  if (patch.length === 0) return null;
+  return openDiffInBrowser(patch.toString(), { filePath: item.path, srcLabel: "cella", dstLabel: forkName }, cwd);
 }
 function shouldApplyContributionsUnstaged(repoPath) {
-  return JSON.parse(readFileSync4(join12(repoPath, "package.json"), "utf8")).name === "cella";
+  return JSON.parse(readFileSync4(join13(repoPath, "package.json"), "utf8")).name === "cella";
 }
 var contribPrompt = createPrompt((config, done) => {
   const { pageSize = 20, baseRef, cwd, forkName } = config;
@@ -3053,8 +3208,12 @@ var contribPrompt = createPrompt((config, done) => {
       return;
     }
     if (key.name === "d") {
-      showContribDiff(items[active], baseRef, cwd, forkName);
-      setStatusMsg(`viewed ${items[active].path}`);
+      try {
+        const pagePath = await showContribDiff(items[active], baseRef, cwd, forkName);
+        setStatusMsg(pagePath ? `opened ${items[active].path} in browser` : `no changes for ${items[active].path}`);
+      } catch (error) {
+        setStatusMsg(`diff failed: ${error instanceof Error ? error.message : "unknown error"}`);
+      }
       return;
     }
     if (key.name === "a") {
@@ -3095,7 +3254,7 @@ var contribPrompt = createPrompt((config, done) => {
   const header = `${colors_default.cyan("\u2B07")} ${config.message} ${colors_default.dim(`(${countInfo})`)}`;
   const keys = [
     ["\u2191\u2193", "navigate"],
-    ["d", "diff"],
+    ["d", "diff in browser"],
     ["a", "(de)select all"],
     ["space", "select"],
     ["\u23CE", "accept"],
@@ -3336,11 +3495,6 @@ async function runContributions(config) {
     spinnerSuccess(`applied ${applied} files ${colors_default.dim(applyUnstaged ? "(unstaged)" : "(staged)")}`);
   }
   console.info();
-  console.info(`  ${colors_default.cyan(forkName)} ${colors_default.dim(`(${selected.length} files)`)}`);
-  for (const item of selected) {
-    console.info(`    ${colors_default.dim("\u2192")} ${item.deleted ? `(deleted) ${item.path}` : item.path}`);
-  }
-  console.info();
   console.info(
     colors_default.dim(
       applyUnstaged ? "  files are unstaged \u2014 review, stage what you want, and commit when ready" : "  files are staged \u2014 review and commit when ready"
@@ -3350,16 +3504,16 @@ async function runContributions(config) {
 }
 
 // src/services/forks.ts
-import { resolve as resolve5 } from "path";
-import process7 from "process";
+import { resolve as resolve4 } from "path";
+import process8 from "process";
 import { Separator as Separator2, select as select3 } from "@inquirer/prompts";
 
 // src/services/sync.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 
 // src/services/packages.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join14 } from "path";
 function parseComparableVersion(version) {
   const trimmed = version.trim();
   if (trimmed === "" || trimmed === "*" || trimmed.includes("workspace:") || trimmed.includes("catalog:") || trimmed.includes("file:") || trimmed.includes("link:") || trimmed.includes("git+") || trimmed.includes("github:") || trimmed.includes("http://") || trimmed.includes("https://") || trimmed.includes("||")) {
@@ -3463,7 +3617,7 @@ function safeMergePnpm(forkPnpm, upstreamPnpm) {
   return { merged, changed };
 }
 function readPackageJson(filePath) {
-  if (!existsSync9(filePath)) return null;
+  if (!existsSync8(filePath)) return null;
   try {
     return JSON.parse(readFileSync5(filePath, "utf-8"));
   } catch {
@@ -3485,11 +3639,11 @@ async function getUpstreamPackageJson(forkPath, upstreamRef, relativePath) {
 async function discoverPackageLocations(forkPath, upstreamRef) {
   const stdout = await git(["ls-tree", "-r", "--name-only", upstreamRef], forkPath, { ignoreErrors: true });
   const upstreamPaths = stdout.split("\n").filter((p) => p.endsWith("/package.json") || p === "package.json").map((p) => p === "package.json" ? "" : p.replace("/package.json", ""));
-  return upstreamPaths.filter((loc) => existsSync9(join13(forkPath, loc, "package.json")));
+  return upstreamPaths.filter((loc) => existsSync8(join14(forkPath, loc, "package.json")));
 }
 async function syncPackageJson(forkPath, upstreamRef, relativePath, keysToSync) {
   const changes = [];
-  const pkgPath = join13(forkPath, relativePath, "package.json");
+  const pkgPath = join14(forkPath, relativePath, "package.json");
   const forkPkg = readPackageJson(pkgPath);
   const upstreamPkg = await getUpstreamPackageJson(forkPath, upstreamRef, relativePath);
   if (!forkPkg || !upstreamPkg) {
@@ -3544,7 +3698,7 @@ async function runPackages(config, options = {}) {
   const keysToSync = config.settings.packageJsonSync || ["dependencies", "devDependencies"];
   const conflictedSet = new Set(options.conflictedFiles ?? []);
   const locations = await discoverPackageLocations(config.forkPath, config.upstreamRef);
-  const results = [];
+  let changedCount = 0;
   const skipped = [];
   for (const location of locations) {
     const pkgRelPath = location ? `${location}/package.json` : "package.json";
@@ -3553,22 +3707,15 @@ async function runPackages(config, options = {}) {
       continue;
     }
     spinnerText(`syncing ${location || "root"}/package.json...`);
-    const { updated, changes } = await syncPackageJson(config.forkPath, config.upstreamRef, location, keysToSync);
+    const { updated } = await syncPackageJson(config.forkPath, config.upstreamRef, location, keysToSync);
     if (updated) {
-      results.push({ location: location || "root", changes });
-    }
-  }
-  spinnerSuccess("package sync complete");
-  if (results.length === 0) {
-    console.info(colors_default.dim("  no package.json changes needed"));
-  } else {
-    for (const { location, changes } of results) {
-      console.info(`  ${colors_default.green("\u2713")} ${location}/package.json`);
-      for (const change of changes) {
-        console.info(`    ${colors_default.dim("\u2192")} ${change}`);
-      }
+      changedCount += 1;
     }
   }
+  spinnerSuccess(
+    "package sync complete",
+    `${changedCount} package.json${changedCount === 1 ? " was" : "s were"} changed`
+  );
   if (skipped.length > 0) {
     console.info();
     console.warn(
@@ -3633,23 +3780,68 @@ async function runSync(config, options) {
     spinnerFail("sync completed with conflicts");
   }
   printSummary(result.summary, "merge summary");
-  options?.onAfterSummary?.(result);
   if (config.logFile) {
     const logPath = writeLogFile(config.forkPath, result.files);
     console.info();
     console.info(colors_default.dim(`full file list written to: ${logPath}`));
   }
-  printSyncComplete(result);
+  const stagedBranch = options?.stagedBranch && result.conflicts.length === 0 && hasStagedSyncChanges(result) ? options.stagedBranch : void 0;
+  printSyncComplete(result, { stagedBranch });
   printFlagWarnings({ hard: config.hard, unpinned: config.unpinned });
   return result;
 }
 var SYNC_PR_TITLE = "chore: sync upstream cella";
-function printPrCreateStep(branch, base) {
-  console.info(colors_default.dim(`  gh pr create --base ${base} --head ${branch} --title "${SYNC_PR_TITLE}" --fill`));
+var PR_BODY_COMMIT_MAX = 50;
+async function buildSyncCommitMessage(forkPath, upstreamRef) {
+  const shortSha = await getShortSha(forkPath, upstreamRef).catch(() => "");
+  if (!shortSha) return SYNC_PR_TITLE;
+  const manifest = await readSyncManifest(forkPath);
+  const version = manifest?.upstream.release ?? await readPackageVersionAtRef(forkPath, upstreamRef).catch(() => null);
+  return version ? `${SYNC_PR_TITLE} v${version.replace(/^v/, "")} (${shortSha})` : `${SYNC_PR_TITLE} ${shortSha}`;
+}
+function qualifyPrRefs(subject, repoSlug) {
+  if (!repoSlug) return subject;
+  return subject.replace(/(^|[^\w/])#(\d+)\b/g, `$1${repoSlug}#$2`);
+}
+function buildSyncPrBody(input) {
+  const { repoSlug, version, fromSha, toSha, commits, totalCount } = input;
+  const githubUrl = repoSlug ? `https://github.com/${repoSlug}` : void 0;
+  const short = (sha) => sha.slice(0, 7);
+  const commitRef = (sha) => githubUrl ? `[\`${short(sha)}\`](${githubUrl}/commit/${sha})` : `\`${short(sha)}\``;
+  const upstreamName = githubUrl ? `[${repoSlug}](${githubUrl})` : "cella";
+  const versionSuffix = version ? ` (v${version.replace(/^v/, "")})` : "";
+  const lines = [`Syncs upstream ${upstreamName} to ${commitRef(toSha)}${versionSuffix}.`];
+  if (totalCount > 0 && fromSha) {
+    const compare = githubUrl ? ` ([compare](${githubUrl}/compare/${short(fromSha)}...${short(toSha)}))` : "";
+    lines.push("", `**${totalCount} upstream commit${totalCount === 1 ? "" : "s"} since last sync**${compare}:`, "");
+    if (totalCount > commits.length) lines.push(`- \u2026${totalCount - commits.length} earlier commit(s) not shown`);
+    for (const commit of commits) {
+      lines.push(`- ${commitRef(commit.hash)} ${qualifyPrRefs(commit.message, repoSlug)}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function buildSyncPrBodyForBranch(forkPath, base) {
+  const manifest = await readManifestAtRef(forkPath, "HEAD");
+  if (!manifest) return void 0;
+  const toSha = manifest.upstream.commit.toLowerCase();
+  const fromSha = await readManifestBaseAtRef(forkPath, base) ?? await getMergeBase(forkPath, base, toSha).catch(() => null);
+  const version = manifest.upstream.release ?? await readPackageVersionAtRef(forkPath, toSha).catch(() => null);
+  const totalCount = fromSha ? await countCommitsBetween(forkPath, fromSha, toSha).catch(() => 0) : 0;
+  const commits = fromSha && totalCount > 0 ? await listCommitsBetween(forkPath, fromSha, toSha, {
+    oldestFirst: true,
+    skip: totalCount > PR_BODY_COMMIT_MAX ? totalCount - PR_BODY_COMMIT_MAX : 0,
+    limit: PR_BODY_COMMIT_MAX
+  }) : [];
+  return buildSyncPrBody({ repoSlug: manifest.upstream.repo, version, fromSha, toSha, commits, totalCount });
+}
+function printPrCreateStep(branch, base, title = SYNC_PR_TITLE) {
+  console.info(colors_default.dim(`  gh pr create --base ${base} --head ${branch} --title "${title}" --fill`));
 }
-function printShipSteps(temporaryBranch, base) {
+function printShipSteps(temporaryBranch, base, title) {
   console.info(colors_default.dim(`  git push -u origin ${temporaryBranch}`));
-  printPrCreateStep(temporaryBranch, base);
+  printPrCreateStep(temporaryBranch, base, title);
 }
 function printFinishSteps() {
   console.info(colors_default.dim("  pnpm cella sync"));
@@ -3657,51 +3849,80 @@ function printFinishSteps() {
 function hasStagedSyncChanges(result) {
   return result.files.some((file) => ["behind", "diverged", "renamed", "ignored", "pinned"].includes(file.status));
 }
-function printCleanSyncNextStep(branch) {
-  console.info();
-  console.info(`${checkMark} ${colors_default.green(`Sync merge staged on '${branch}'. No conflicts. Review, then finish with:`)}`);
-  printFinishSteps();
-  console.info(colors_default.dim("  rerun commits the sync, pushes the branch, and opens a PR."));
-}
 function ghAvailable() {
-  return spawnSync4("gh", ["--version"], { stdio: "ignore" }).status === 0;
+  return spawnSync2("gh", ["--version"], { stdio: "ignore" }).status === 0;
+}
+function extractFirstUrl(output) {
+  return output.match(/https?:\/\/\S+/)?.[0];
+}
+async function flattenSyncBranch(forkPath, branch, base) {
+  const mergeCommits = await listBranchMergeCommits(forkPath, base);
+  if (mergeCommits.length === 0) return false;
+  const message = await buildSyncCommitMessage(forkPath, `${mergeCommits[0]}^2`);
+  console.info(
+    colors_default.yellow(
+      `'${branch}' contains ${mergeCommits.length} merge commit(s) \u2014 the PR would list the entire upstream history.`
+    )
+  );
+  console.info(colors_default.dim(`flattening '${branch}' to a single commit (same content)...`));
+  await flattenBranch(forkPath, base, message);
+  return true;
 }
 async function shipSyncBranch(config, branch) {
   const { forkPath, settings } = config;
   const base = resolveReleaseBase(settings);
+  const flattened = await flattenSyncBranch(forkPath, branch, base);
+  let prUrl;
+  let prOpened = false;
+  const headSubject = (await getCommitInfo(forkPath, "HEAD").catch(() => null))?.message;
+  const prTitle = headSubject?.startsWith(SYNC_PR_TITLE) ? headSubject : SYNC_PR_TITLE;
   console.info(colors_default.dim(`pushing '${branch}' to origin...`));
   try {
-    await pushBranch(forkPath, "origin", branch);
+    await pushBranch(forkPath, "origin", branch, { forceWithLease: flattened });
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     console.info(colors_default.yellow(`push failed (${detail.split("\n")[0]}). finish manually:`));
-    printShipSteps(branch, base);
+    printShipSteps(branch, base, prTitle);
     return;
   }
   if (ghAvailable()) {
     console.info(colors_default.dim("opening a pull request..."));
-    const pr = spawnSync4("gh", ["pr", "create", "--base", base, "--head", branch, "--title", SYNC_PR_TITLE, "--fill"], {
+    const prBody = await buildSyncPrBodyForBranch(forkPath, base);
+    const bodyArgs = prBody ? ["--body", prBody] : ["--fill"];
+    const pr = spawnSync2("gh", ["pr", "create", "--base", base, "--head", branch, "--title", prTitle, ...bodyArgs], {
       cwd: forkPath,
-      stdio: "inherit"
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    if (pr.status !== 0) {
+    prUrl = extractFirstUrl(`${pr.stdout ?? ""}
+${pr.stderr ?? ""}`);
+    prOpened = pr.status === 0;
+    if (!prOpened) {
       console.info(colors_default.yellow("could not open the PR automatically (it may already exist). open it with:"));
-      printPrCreateStep(branch, base);
+      if (prUrl) console.info(colors_default.dim(`  ${prUrl}`));
+      printPrCreateStep(branch, base, prTitle);
     }
   } else {
     console.info(colors_default.yellow("`gh` not found \u2014 open the PR manually:"));
-    printPrCreateStep(branch, base);
+    printPrCreateStep(branch, base, prTitle);
   }
   console.info(colors_default.dim(`switching back to '${base}'...`));
   await switchBranch(forkPath, base);
   await pullFastForward(forkPath).catch(() => {
   });
-  console.info(colors_default.green(`done \u2014 '${branch}' is pushed and you're back on '${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}'`));
+  } else {
+    console.info(`${colors_default.green("\u2713")} Sync branch pushed`);
+    console.info(colors_default.dim(`  '${branch}' is on origin, back on '${base}'`));
+  }
 }
 function finalizeWorkspace(forkPath) {
   for (const args of [["install"], ["check"]]) {
     console.info(colors_default.dim(`running pnpm ${args.join(" ")}...`));
-    const result = spawnSync4("pnpm", args, { cwd: forkPath, stdio: "inherit" });
+    const result = spawnSync2("pnpm", args, { cwd: forkPath, stdio: "inherit" });
     if (result.status !== 0) return false;
   }
   return true;
@@ -3709,13 +3930,7 @@ function finalizeWorkspace(forkPath) {
 async function runSyncCycle(config) {
   const { forkPath } = config;
   const branch = await setupTemporarySyncBranch(config);
-  const result = await runSync(config, {
-    onAfterSummary: (syncResult) => {
-      if (syncResult.conflicts.length === 0 && hasStagedSyncChanges(syncResult)) {
-        printCleanSyncNextStep(branch.temporaryBranch);
-      }
-    }
-  });
+  const result = await runSync(config, { stagedBranch: branch.temporaryBranch });
   if (config.settings.syncWithPackages !== false) {
     await runPackages(config, { conflictedFiles: result.conflicts });
   }
@@ -3734,7 +3949,7 @@ async function resumeSyncMerge(config, branch) {
   if (conflicts.length > 0) {
     console.info(colors_default.yellow(`${conflicts.length} file(s) still conflict on '${branch}':`));
     for (const file of conflicts) console.info(colors_default.dim(`  ${file}`));
-    console.info(colors_default.dim("resolve and stage them, then re-run `pnpm cella sync` to finish."));
+    console.info(colors_default.dim("resolve and stage them, then re-run `pnpm cella sync` to finish (it commits for you)."));
     return;
   }
   await stageAll(forkPath);
@@ -3745,9 +3960,8 @@ async function resumeSyncMerge(config, branch) {
     );
     return;
   }
-  const upstreamSha = await getShortSha(forkPath, "MERGE_HEAD").catch(() => "");
+  const message = await buildSyncCommitMessage(forkPath, "MERGE_HEAD");
   await stageAll(forkPath);
-  const message = upstreamSha ? `${SYNC_PR_TITLE} ${upstreamSha}` : SYNC_PR_TITLE;
   await commitSquash(forkPath, message);
   console.info();
   console.info(colors_default.green(`committed the sync on '${branch}' as '${message}'.`));
@@ -3766,14 +3980,12 @@ async function runSyncCommand(config) {
       console.info();
       console.info(
         colors_default.yellow(
-          `sync branch '${currentBranch}' has uncommitted changes that would not be shipped.
-commit them (\`git commit --amend --no-edit\` or a new commit), then re-run \`pnpm cella sync\`.`
+          `sync branch '${currentBranch}' has uncommitted changes.
+commit them first (\`git commit --amend --no-edit\` or a new commit).`
         )
       );
       return;
     }
-    console.info();
-    console.info(colors_default.green(`sync branch '${currentBranch}' is already committed.`));
     await shipSyncBranch(config, currentBranch);
     return;
   }
@@ -3786,8 +3998,10 @@ commit them (\`git commit --amend --no-edit\` or a new commit), then re-run \`pn
   }
   const { temporaryBranch } = outcome.branch;
   if (outcome.status === "conflicts") {
-    console.info(`${warningMark} ${colors_default.yellow(`conflicts on '${temporaryBranch}'. Resolve them and then:`)}`);
+    console.info(`${warningMark} ${colors_default.yellow(`conflicts on '${temporaryBranch}'. Resolve and stage them, then:`)}`);
     printFinishSteps();
+    console.info(colors_default.dim("  rerun commits the sync, pushes the branch, and opens a PR."));
+    console.info(colors_default.dim("  let the rerun commit \u2014 a manual `git commit` records a merge commit that bloats the PR."));
   }
 }
 
@@ -3877,7 +4091,7 @@ async function runForks(config) {
       console.error(colors_default.red(`fork '${config.fork}' not found in config`));
       return;
     }
-    const resolvedPath = resolve5(config.forkPath, match.localPath);
+    const resolvedPath = resolve4(config.forkPath, match.localPath);
     await syncFork(config, match, resolvedPath);
     return;
   }
@@ -3890,9 +4104,9 @@ async function runForks(config) {
       loop: false
     });
     if (selectedPath === "_exit") {
-      process7.exit(0);
+      process8.exit(0);
     }
-    const resolvedForkPath = resolve5(config.forkPath, selectedPath);
+    const resolvedForkPath = resolve4(config.forkPath, selectedPath);
     const selectedFork = forks.find((f) => f.localPath === selectedPath);
     if (!selectedFork) {
       console.error(colors_default.red(`fork '${selectedPath}' not found in config`));
@@ -3905,10 +4119,10 @@ async function runForks(config) {
 
 // src/services/stats.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/utils/coverage-utils.ts
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import * as fs3 from "fs";
 import * as path3 from "path";
 var STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -3931,7 +4145,7 @@ function formatAge(ms) {
 }
 function refreshCoverage(forkPath) {
   console.info(colors_default.dim("running `pnpm test` (this spins up Docker and runs the full suite)..."));
-  const result = spawnSync5("pnpm", ["test"], { cwd: forkPath, stdio: "inherit" });
+  const result = spawnSync3("pnpm", ["test"], { cwd: forkPath, stdio: "inherit" });
   return result.status === 0;
 }
 function printCoverageSummary(forkPath, options = {}) {
@@ -3993,7 +4207,7 @@ function printCoverageSummary(forkPath, options = {}) {
 // src/services/stats.ts
 var sourceExtensions = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mjs", "cjs", "json", "jsonc", "css", "html"]);
 async function getWorkspacePackages(forkPath) {
-  const content = await readFile2(join15(forkPath, "pnpm-workspace.yaml"), "utf-8");
+  const content = await readFile2(join16(forkPath, "pnpm-workspace.yaml"), "utf-8");
   return parseYamlBlockList(content, "packages").map((pattern) => {
     if (pattern.endsWith("/*")) {
       const base = pattern.slice(0, -2);
@@ -4148,27 +4362,27 @@ async function runStats(forkPath, options = {}) {
 
 // src/cella-cli.ts
 function getForkPath() {
-  const envPath = process8.env.CELLA_FORK_PATH;
+  const envPath = getEnv("CELLA_FORK_PATH");
   if (envPath) {
-    const resolved = resolve6(envPath);
-    if (!existsSync11(resolved) || !statSync2(resolved).isDirectory()) {
+    const resolved = resolve5(envPath);
+    if (!existsSync10(resolved) || !statSync2(resolved).isDirectory()) {
       throw new Error(`CELLA_FORK_PATH is not a valid directory: ${resolved}`);
     }
     return resolved;
   }
-  let cwd = process8.cwd();
+  let cwd = process9.cwd();
   if (cwd.endsWith("/cli/cella") || cwd.endsWith("\\cli\\cella")) {
-    cwd = resolve6(cwd, "../..");
+    cwd = resolve5(cwd, "../..");
   }
   return cwd;
 }
 async function preflight(forkPath) {
-  if (!existsSync11(join16(forkPath, ".git"))) {
+  if (!existsSync10(join17(forkPath, ".git"))) {
     throw new Error(`not a git repository: ${forkPath}`);
   }
 }
 function isHelpOrVersionRequest() {
-  return process8.argv.slice(2).some((arg) => arg === "--help" || arg === "-h" || arg === "--version" || arg === "-v") || process8.argv[2] === "help";
+  return process9.argv.slice(2).some((arg) => arg === "--help" || arg === "-h" || arg === "--version" || arg === "-v") || process9.argv[2] === "help";
 }
 async function main() {
   registerSignalHandlers();
@@ -4209,7 +4423,7 @@ async function main() {
   } catch (error) {
     console.error();
     console.error(`${colors_default.red("\u2717")} ${error instanceof Error ? error.message : "unknown error"}`);
-    process8.exit(1);
+    process9.exit(1);
   }
 }
 main();