Merge remote-tracking branch 'origin/main' into merge/main-into-dev

# Conflicts:
#	CLAUDE.md
#	nix/package.nix
#	packages/app/src/components/combined-model-selector.tsx
#	packages/app/src/hooks/use-sidebar-workspaces-list.ts
#	packages/app/src/screens/workspace/workspace-screen.tsx
#	packages/app/src/stores/session-store.test.ts
#	packages/server/src/client/daemon-client.ts
#	packages/server/src/server/agent/agent-manager.ts
#	packages/server/src/server/session.ts
#	packages/server/src/server/session.workspace-git-watch.test.ts
#	packages/server/src/server/session.workspaces.test.ts
#	packages/server/src/shared/messages.ts

packages/server/src/utils/checkout-git.test.ts

@@ -110,6 +110,21 @@ describe("checkout git utilities", () => {
     expect(message).toBe("update file");
   });
 
+  it("hides whitespace-only changes when requested", async () => {
+    writeFileSync(join(repoDir, "file.txt"), "hello  \n");
+
+    const visibleDiff = await getCheckoutDiff(repoDir, { mode: "uncommitted" });
+    expect(visibleDiff.diff).toContain("file.txt");
+
+    const hiddenDiff = await getCheckoutDiff(repoDir, {
+      mode: "uncommitted",
+      ignoreWhitespace: true,
+      includeStructured: true,
+    });
+    expect(hiddenDiff.diff).toBe("");
+    expect(hiddenDiff.structured).toEqual([]);
+  });
+
   it("preserves removed-line syntax highlighting with structured diffs", async () => {
     const originalContent = `/*
 comment line 1

packages/server/src/utils/checkout-git.ts

@@ -309,13 +309,25 @@ export async function listBranchSuggestions(
   return ordered.slice(0, limit);
 }
 
-async function listCheckoutFileChanges(cwd: string, ref: string): Promise<CheckoutFileChange[]> {
+async function listCheckoutFileChanges(
+  cwd: string,
+  ref: string,
+  ignoreWhitespace = false,
+): Promise<CheckoutFileChange[]> {
   const changes: CheckoutFileChange[] = [];
 
-  const { stdout: nameStatusOut } = await execGit(`git diff --name-status ${ref}`, {
-    cwd,
-    env: READ_ONLY_GIT_ENV,
-  });
+  const { stdout: nameStatusOut } = await execFileAsync(
+    "git",
+    buildGitDiffArgs({
+      ignoreWhitespace,
+      extra: ["--name-status", ref],
+    }),
+    {
+      cwd,
+      env: READ_ONLY_GIT_ENV,
+      maxBuffer: SMALL_OUTPUT_MAX_BUFFER,
+    },
+  );
   for (const line of nameStatusOut
     .split("\n")
     .map((l) => l.trim())
@@ -430,13 +442,24 @@ function normalizeNumstatPath(pathField: string): string {
   return pathField;
 }
 
+function buildGitDiffArgs(args: { ignoreWhitespace?: boolean; extra: string[] }): string[] {
+  return ["diff", ...(args.ignoreWhitespace ? ["-w"] : []), ...args.extra];
+}
+
 const TRACKED_DIFF_NUMSTAT_MAX_BYTES = 2 * 1024 * 1024; // 2MB
 const TRACKED_MAX_CHANGED_LINES = 40_000;
 
-async function getTrackedNumstatByPath(cwd: string, ref: string): Promise<Map<string, FileStat>> {
+async function getTrackedNumstatByPath(
+  cwd: string,
+  ref: string,
+  ignoreWhitespace = false,
+): Promise<Map<string, FileStat>> {
   const result = await spawnLimitedText({
     cmd: "git",
-    args: ["diff", "--numstat", ref],
+    args: buildGitDiffArgs({
+      ignoreWhitespace,
+      extra: ["--numstat", ref],
+    }),
     cwd,
     env: READ_ONLY_GIT_ENV,
     maxBytes: TRACKED_DIFF_NUMSTAT_MAX_BYTES,
@@ -612,6 +635,7 @@ export interface CheckoutDiffResult {
 export interface CheckoutDiffCompare {
   mode: "uncommitted" | "base";
   baseRef?: string;
+  ignoreWhitespace?: boolean;
   includeStructured?: boolean;
 }
 
@@ -1106,6 +1130,7 @@ function buildPlaceholderParsedDiffFile(
 async function getUntrackedDiffText(
   cwd: string,
   change: CheckoutFileChange,
+  ignoreWhitespace = false,
 ): Promise<{ text: string; truncated: boolean; stat: FileStat }> {
   try {
     const inspected = await inspectUntrackedFile(cwd, change.path);
@@ -1118,7 +1143,10 @@ async function getUntrackedDiffText(
 
   const result = await spawnLimitedText({
     cmd: "git",
-    args: ["diff", "--no-index", "/dev/null", "--", change.path],
+    args: buildGitDiffArgs({
+      ignoreWhitespace,
+      extra: ["--no-index", "/dev/null", "--", change.path],
+    }),
     cwd,
     env: READ_ONLY_GIT_ENV,
     maxBytes: PER_FILE_DIFF_MAX_BYTES,
@@ -1391,7 +1419,8 @@ export async function getCheckoutDiff(
     refForDiff = (await tryResolveMergeBase(cwd, bestBaseRef)) ?? bestBaseRef;
   }
 
-  const changes = await listCheckoutFileChanges(cwd, refForDiff);
+  const ignoreWhitespace = compare.ignoreWhitespace === true;
+  const changes = await listCheckoutFileChanges(cwd, refForDiff, ignoreWhitespace);
   changes.sort((a, b) => {
     if (a.path === b.path) return 0;
     return a.path < b.path ? -1 : 1;
@@ -1422,7 +1451,7 @@ export async function getCheckoutDiff(
 
   const trackedNumstatByPath =
     trackedChanges.length > 0
-      ? await getTrackedNumstatByPath(cwd, refForDiff)
+      ? await getTrackedNumstatByPath(cwd, refForDiff, ignoreWhitespace)
       : new Map<string, FileStat>();
   const trackedDiffPaths: string[] = [];
   const trackedPlaceholderByPath = new Map<
@@ -1448,7 +1477,10 @@ export async function getCheckoutDiff(
   if (trackedDiffPaths.length > 0) {
     const trackedDiffResult = await spawnLimitedText({
       cmd: "git",
-      args: ["diff", refForDiff, "--", ...trackedDiffPaths],
+      args: buildGitDiffArgs({
+        ignoreWhitespace,
+        extra: [refForDiff, "--", ...trackedDiffPaths],
+      }),
       cwd,
       env: READ_ONLY_GIT_ENV,
       maxBytes: TOTAL_DIFF_MAX_BYTES,
@@ -1537,7 +1569,11 @@ export async function getCheckoutDiff(
     if (diffBytes >= TOTAL_DIFF_MAX_BYTES) {
       break;
     }
-    const { text, truncated, stat } = await getUntrackedDiffText(cwd, change);
+    const { text, truncated, stat } = await getUntrackedDiffText(
+      cwd,
+      change,
+      ignoreWhitespace,
+    );
 
     if (!compare.includeStructured) {
       if (stat?.isBinary) {

packages/server/src/utils/worktree.test.ts

@@ -149,6 +149,71 @@ describe("createWorktree", () => {
     expect(metadata).toMatchObject({ version: 1, baseRefName: "main" });
   });
 
+  it("prefers origin/{branch} over local {branch} when both exist", async () => {
+    const remoteDir = join(tempDir, "remote.git");
+    const remoteCloneDir = join(tempDir, "remote-clone");
+    execSync(`git init --bare ${remoteDir}`);
+    execSync(`git remote add origin ${remoteDir}`, { cwd: repoDir });
+    execSync("git push -u origin main", { cwd: repoDir });
+
+    execSync(`git clone ${remoteDir} ${remoteCloneDir}`);
+    execSync("git config user.email 'test@test.com'", { cwd: remoteCloneDir });
+    execSync("git config user.name 'Test'", { cwd: remoteCloneDir });
+    writeFileSync(join(remoteCloneDir, "file.txt"), "from-origin\n");
+    execSync("git add file.txt", { cwd: remoteCloneDir });
+    execSync("git -c commit.gpgsign=false commit -m 'advance origin main'", {
+      cwd: remoteCloneDir,
+    });
+    execSync("git push origin main", { cwd: remoteCloneDir });
+
+    writeFileSync(join(repoDir, "file.txt"), "from-local\n");
+    execSync("git add file.txt", { cwd: repoDir });
+    execSync("git -c commit.gpgsign=false commit -m 'advance local main'", { cwd: repoDir });
+
+    execSync("git fetch origin", { cwd: repoDir });
+
+    const result = await createWorktree({
+      branchName: "prefer-origin-feature",
+      cwd: repoDir,
+      baseBranch: "main",
+      worktreeSlug: "prefer-origin-feature",
+      runSetup: false,
+      paseoHome,
+    });
+
+    expect(readFileSync(join(result.worktreePath, "file.txt"), "utf8")).toBe("from-origin\n");
+  });
+
+  it("falls back to local {branch} when origin/{branch} does not exist", async () => {
+    writeFileSync(join(repoDir, "file.txt"), "from-local-only\n");
+    execSync("git add file.txt", { cwd: repoDir });
+    execSync("git -c commit.gpgsign=false commit -m 'advance local main only'", { cwd: repoDir });
+
+    const result = await createWorktree({
+      branchName: "prefer-local-fallback-feature",
+      cwd: repoDir,
+      baseBranch: "main",
+      worktreeSlug: "prefer-local-fallback-feature",
+      runSetup: false,
+      paseoHome,
+    });
+
+    expect(readFileSync(join(result.worktreePath, "file.txt"), "utf8")).toBe("from-local-only\n");
+  });
+
+  it("throws when neither origin/{branch} nor local {branch} exists", async () => {
+    await expect(
+      createWorktree({
+        branchName: "missing-base-feature",
+        cwd: repoDir,
+        baseBranch: "does-not-exist",
+        worktreeSlug: "missing-base-feature",
+        runSetup: false,
+        paseoHome,
+      }),
+    ).rejects.toThrow("Base branch not found: does-not-exist");
+  });
+
   it("fails with invalid branch name", async () => {
     await expect(
       createWorktree({

packages/server/src/utils/worktree.ts

@@ -1046,15 +1046,14 @@ export async function createWorktree({
     throw new Error("Base branch cannot be HEAD when creating a Paseo worktree");
   }
 
-  // Resolve the base branch - try local first, then remote
+  // Resolve the base branch - prefer origin/{branch}, then fall back to local
   let resolvedBaseBranch = normalizedBaseBranch;
   try {
-    await execAsync(`git rev-parse --verify ${normalizedBaseBranch}`, { cwd });
+    await execAsync(`git rev-parse --verify origin/${normalizedBaseBranch}`, { cwd });
+    resolvedBaseBranch = `origin/${normalizedBaseBranch}`;
   } catch {
-    // Local branch doesn't exist, try remote (origin/{branch})
     try {
-      await execAsync(`git rev-parse --verify origin/${normalizedBaseBranch}`, { cwd });
-      resolvedBaseBranch = `origin/${normalizedBaseBranch}`;
+      await execAsync(`git rev-parse --verify ${normalizedBaseBranch}`, { cwd });
     } catch {
       throw new Error(`Base branch not found: ${normalizedBaseBranch}`);
     }