Merge pull request #1881 from generalaction/jona/gen-1045-default-task-branch-is-unintuitive

fix: default branch resolution for project base refs

Author: Davidknp

src/main/core/git/impl/git-service.ts

@@ -1455,20 +1455,12 @@ export class GitService implements GitProvider, IDisposable {
     }
 
     let remoteName: string | undefined;
-    let remote: string | undefined;
     try {
       const { stdout } = await this.ctx.exec('git', ['remote']);
       const remotes = stdout.trim().split('\n').filter(Boolean);
       remoteName = remotes.includes('origin') ? 'origin' : remotes[0];
     } catch {}
 
-    if (remoteName) {
-      try {
-        const { stdout } = await this.ctx.exec('git', ['remote', 'get-url', remoteName]);
-        remote = stdout.trim() || undefined;
-      } catch {}
-    }
-
     let branch: string | undefined;
     try {
       const { stdout } = await this.ctx.exec('git', ['branch', '--show-current']);
@@ -1492,8 +1484,6 @@ export class GitService implements GitProvider, IDisposable {
 
     return {
       isGitRepo: true,
-      remote,
-      branch,
       baseRef: computeBaseRef(undefined, remoteName, branch),
       rootPath,
     };

src/main/core/git/repository-service.ts

@@ -12,7 +12,7 @@ import type {
   RemoteBranchesPayload,
   RenameBranchError,
 } from '@shared/git';
-import { computeDefaultBranch, selectPreferredRemote } from '@shared/git-utils';
+import { selectPreferredRemote } from '@shared/git-utils';
 import type { ProjectRemoteState } from '@shared/projects';
 import type { Result } from '@shared/result';
 import type { ProjectSettingsProvider } from '@main/core/projects/settings/schema';
@@ -32,14 +32,6 @@ export class GitRepositoryService {
     return selectPreferredRemote(configured, remotes).name;
   }
 
-  async getDefaultBranchName(): Promise<string> {
-    const configured = await this.settings.getDefaultBranch();
-    const remote = await this.getConfiguredRemote();
-    const branches = await this.git.getBranches();
-    const gitDefault = await this.git.getDefaultBranch(remote);
-    return computeDefaultBranch(configured, branches, remote, gitDefault);
-  }
-
   async getRepositoryInfo(): Promise<{ isUnborn: boolean; currentBranch: string | null }> {
     const headState = await this.git.getHeadState();
     const currentBranch = headState.isUnborn

src/main/core/projects/operations/createProject.test.ts

@@ -6,6 +6,8 @@ import { createLocalProject, createSshProject, getSshProjectPathStatus } from '.
 
 const mocks = vi.hoisted(() => ({
   detectInfoMock: vi.fn(),
+  getBranchesMock: vi.fn(),
+  getDefaultBranchMock: vi.fn(),
   initRepositoryMock: vi.fn(),
   openProjectMock: vi.fn(),
   getProjectMock: vi.fn(),
@@ -20,6 +22,8 @@ vi.mock('@main/core/git/impl/git-service', () => ({
   GitService: vi.fn(function MockGitService() {
     return {
       detectInfo: mocks.detectInfoMock,
+      getBranches: mocks.getBranchesMock,
+      getDefaultBranch: mocks.getDefaultBranchMock,
       initRepository: mocks.initRepositoryMock,
     };
   }),
@@ -59,6 +63,8 @@ beforeEach(() => {
   mocks.valuesMock.mockReturnValue({ returning: mocks.returningMock });
   mocks.openProjectMock.mockResolvedValue(undefined);
   mocks.getProjectMock.mockReturnValue(undefined);
+  mocks.getBranchesMock.mockResolvedValue([]);
+  mocks.getDefaultBranchMock.mockResolvedValue('main');
   mocks.initRepositoryMock.mockResolvedValue(undefined);
   mocks.sshConnectMock.mockResolvedValue({ id: 'ssh-proxy' });
   mocks.sshStatMock.mockResolvedValue({ path: '', type: 'dir' });
@@ -172,6 +178,84 @@ describe('createLocalProject', () => {
     expect(mocks.initRepositoryMock).not.toHaveBeenCalled();
     expect(mocks.detectInfoMock).toHaveBeenCalledTimes(1);
   });
+
+  it('stores the git remote default branch as baseRef instead of the current feature branch', async () => {
+    const projectPath = fs.mkdtempSync(path.join(os.tmpdir(), 'emdash-project-'));
+    tempDirs.push(projectPath);
+    const row = {
+      id: 'project-id',
+      name: 'Project',
+      path: projectPath,
+      baseRef: 'origin/main',
+      createdAt: '2026-04-16T00:00:00.000Z',
+      updatedAt: '2026-04-16T00:00:00.000Z',
+    };
+
+    mocks.detectInfoMock.mockResolvedValue({
+      isGitRepo: true,
+      baseRef: 'origin/feature/current',
+      rootPath: projectPath,
+    });
+    mocks.getDefaultBranchMock.mockResolvedValue('main');
+    mocks.getBranchesMock.mockResolvedValue([
+      {
+        type: 'remote',
+        branch: 'main',
+        remote: { name: 'origin', url: 'git@github.com:example/repo.git' },
+      },
+    ]);
+    mocks.returningMock.mockResolvedValue([row]);
+
+    const created = await createLocalProject({
+      id: 'project-id',
+      name: 'Project',
+      path: projectPath,
+    });
+
+    expect(mocks.valuesMock).toHaveBeenCalledWith(
+      expect.objectContaining({ baseRef: 'origin/main' })
+    );
+    expect(created.baseRef).toBe('origin/main');
+  });
+
+  it('keeps the detected baseRef when the git default branch is not present on the remote', async () => {
+    const projectPath = fs.mkdtempSync(path.join(os.tmpdir(), 'emdash-project-'));
+    tempDirs.push(projectPath);
+    const row = {
+      id: 'project-id',
+      name: 'Project',
+      path: projectPath,
+      baseRef: 'origin/feature/current',
+      createdAt: '2026-04-16T00:00:00.000Z',
+      updatedAt: '2026-04-16T00:00:00.000Z',
+    };
+
+    mocks.detectInfoMock.mockResolvedValue({
+      isGitRepo: true,
+      baseRef: 'origin/feature/current',
+      rootPath: projectPath,
+    });
+    mocks.getDefaultBranchMock.mockResolvedValue('main');
+    mocks.getBranchesMock.mockResolvedValue([
+      {
+        type: 'remote',
+        branch: 'develop',
+        remote: { name: 'origin', url: 'git@github.com:example/repo.git' },
+      },
+    ]);
+    mocks.returningMock.mockResolvedValue([row]);
+
+    const created = await createLocalProject({
+      id: 'project-id',
+      name: 'Project',
+      path: projectPath,
+    });
+
+    expect(mocks.valuesMock).toHaveBeenCalledWith(
+      expect.objectContaining({ baseRef: 'origin/feature/current' })
+    );
+    expect(created.baseRef).toBe('origin/feature/current');
+  });
 });
 
 describe('createSshProject', () => {
@@ -262,6 +346,40 @@ describe('createSshProject', () => {
     expect(mocks.detectInfoMock).not.toHaveBeenCalled();
     expect(mocks.initRepositoryMock).not.toHaveBeenCalled();
   });
+
+  it('stores the git remote default branch as the SSH project baseRef', async () => {
+    const rowWithDefault = {
+      ...row,
+      baseRef: 'origin/main',
+    };
+
+    mocks.detectInfoMock.mockResolvedValue({
+      isGitRepo: true,
+      baseRef: 'origin/feature/current',
+      rootPath: row.path,
+    });
+    mocks.getDefaultBranchMock.mockResolvedValue('main');
+    mocks.getBranchesMock.mockResolvedValue([
+      {
+        type: 'remote',
+        branch: 'main',
+        remote: { name: 'origin', url: 'git@github.com:example/repo.git' },
+      },
+    ]);
+    mocks.returningMock.mockResolvedValue([rowWithDefault]);
+
+    const created = await createSshProject({
+      id: 'project-id',
+      name: 'Project',
+      path: projectPath,
+      connectionId: 'connection-id',
+    });
+
+    expect(mocks.valuesMock).toHaveBeenCalledWith(
+      expect.objectContaining({ baseRef: 'origin/main' })
+    );
+    expect(created.baseRef).toBe('origin/main');
+  });
 });
 
 describe('getSshProjectPathStatus', () => {

src/main/core/projects/operations/createProject.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { sql } from 'drizzle-orm';
+import { remoteNameFromQualifiedRef, resolveBaseRefFromRemoteDefault } from '@shared/git-utils';
 import { type LocalProject, type ProjectPathStatus, type SshProject } from '@shared/projects';
 import { GitHubAuthExecutionContext } from '@main/core/execution-context/github-auth-execution-context';
 import { LocalExecutionContext } from '@main/core/execution-context/local-execution-context';
@@ -13,8 +14,29 @@ import { projectManager } from '@main/core/projects/project-manager';
 import { sshConnectionManager } from '@main/core/ssh/ssh-connection-manager';
 import { db } from '@main/db/client';
 import { projects } from '@main/db/schema';
+import { log } from '@main/lib/logger';
 import { checkIsValidDirectory } from '../path-utils';
 
+async function resolveProjectBaseRef(git: GitService, detectedBaseRef: string): Promise<string> {
+  const remoteName = remoteNameFromQualifiedRef(detectedBaseRef);
+  if (!remoteName) return detectedBaseRef;
+
+  try {
+    const [gitDefaultBranch, branches] = await Promise.all([
+      git.getDefaultBranch(remoteName),
+      git.getBranches(),
+    ]);
+    return resolveBaseRefFromRemoteDefault({ detectedBaseRef, gitDefaultBranch, branches });
+  } catch (error) {
+    log.debug('Failed to resolve project base ref, using detected base ref', {
+      detectedBaseRef,
+      error,
+    });
+  }
+
+  return detectedBaseRef;
+}
+
 async function ensureGitRepository(
   git: GitService,
   initGitRepository?: boolean
@@ -53,6 +75,7 @@ export async function createLocalProject(params: CreateLocalProjectParams): Prom
   const authCtx = new GitHubAuthExecutionContext(baseCtx, () => githubConnectionService.getToken());
   const git = new GitService(baseCtx, authCtx, fs);
   const gitInfo = await ensureGitRepository(git, params.initGitRepository);
+  const baseRef = await resolveProjectBaseRef(git, gitInfo.baseRef);
 
   const [row] = await db
     .insert(projects)
@@ -61,7 +84,7 @@ export async function createLocalProject(params: CreateLocalProjectParams): Prom
       name: params.name,
       path: gitInfo.rootPath,
       workspaceProvider: 'local',
-      baseRef: gitInfo.baseRef,
+      baseRef,
       updatedAt: sql`CURRENT_TIMESTAMP`,
     })
     .returning();
@@ -71,7 +94,7 @@ export async function createLocalProject(params: CreateLocalProjectParams): Prom
     id: row.id,
     name: row.name,
     path: row.path,
-    baseRef: row.baseRef ?? gitInfo.baseRef,
+    baseRef: row.baseRef ?? baseRef,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
   };
@@ -119,6 +142,7 @@ export async function createSshProject(params: CreateSshProjectParams): Promise<
   const git = new GitService(baseSshCtx, authSshCtx, sshFs);
 
   const gitInfo = await ensureGitRepository(git, params.initGitRepository);
+  const baseRef = await resolveProjectBaseRef(git, gitInfo.baseRef);
 
   const [row] = await db
     .insert(projects)
@@ -128,7 +152,7 @@ export async function createSshProject(params: CreateSshProjectParams): Promise<
       path: gitInfo.rootPath,
       workspaceProvider: 'ssh',
       sshConnectionId: params.connectionId,
-      baseRef: gitInfo.baseRef,
+      baseRef,
       updatedAt: sql`CURRENT_TIMESTAMP`,
     })
     .returning();
@@ -139,7 +163,7 @@ export async function createSshProject(params: CreateSshProjectParams): Promise<
     name: row.name,
     path: row.path,
     connectionId: params.connectionId,
-    baseRef: row.baseRef ?? gitInfo.baseRef,
+    baseRef: row.baseRef ?? baseRef,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
   };

src/renderer/features/projects/stores/repository-store.ts

@@ -1,13 +1,14 @@
 import { computed, makeObservable, reaction } from 'mobx';
 import { gitRefChangedChannel, type GitRefChange } from '@shared/events/gitEvents';
 import type {
+  Branch,
   LocalBranch,
   LocalBranchesPayload,
   Remote,
   RemoteBranch,
   RemoteBranchesPayload,
 } from '@shared/git';
-import { bareRefName, computeDefaultBranch, selectPreferredRemote } from '@shared/git-utils';
+import { resolveDefaultBranch, selectPreferredRemote } from '@shared/git-utils';
 import { parseGitHubRepository } from '@shared/github-repository';
 import { events, rpc } from '@renderer/lib/ipc';
 import { Resource } from '@renderer/lib/stores/resource';
@@ -71,14 +72,14 @@ export class RepositoryStore {
       () => this.remoteData.invalidate()
     );
 
-    makeObservable(this, {
+    makeObservable<this, 'defaultBranchPreference'>(this, {
       isUnborn: computed,
       currentBranch: computed,
       branches: computed,
       localBranches: computed,
       remoteBranches: computed,
       configuredRemote: computed,
-      defaultBranchName: computed,
+      defaultBranchPreference: computed,
       defaultBranch: computed,
       remotes: computed,
       loading: computed,
@@ -140,38 +141,35 @@ export class RepositoryStore {
     return parseGitHubRepository(url)?.repositoryUrl ?? null;
   }
 
-  get defaultBranchName(): string {
-    const d = this.remoteData.data;
-    if (!d) return 'main';
+  private get defaultBranchPreference(): Branch | undefined {
     const raw = this.settingsStore.settings?.defaultBranch;
-    const configured =
-      raw === undefined ? bareRefName(this.baseRef) : typeof raw === 'string' ? raw : raw.name;
-    return computeDefaultBranch(
-      configured,
-      this.branches,
-      this.configuredRemote.name,
-      d.gitDefaultBranch
-    );
+    if (raw === undefined) return undefined;
+    if (typeof raw === 'string') return { type: 'local', branch: raw };
+    return { type: 'remote', branch: raw.name, remote: this.configuredRemote };
   }
 
   get defaultBranch(): LocalBranch | RemoteBranch | undefined {
-    const name = this.defaultBranchName;
-    const raw = this.settingsStore.settings?.defaultBranch;
-    const isRemotePref = typeof raw === 'object' && raw.remote === true;
-
-    if (isRemotePref) {
-      const remote = this.remoteBranches.find(
-        (b) => b.branch === name && b.remote.name === this.configuredRemote.name
-      );
-      if (remote) return remote;
-    }
-    const local = this.localBranches.find((b) => b.branch === name);
-    if (local) return local;
-    return this.remoteBranches.find((b) => b.branch === name);
+    const d = this.remoteData.data;
+    if (!d) return undefined;
+    return resolveDefaultBranch({
+      preference: this.defaultBranchPreference,
+      branches: this.branches,
+      configuredRemoteName: this.configuredRemote.name,
+      gitDefaultBranch: d.gitDefaultBranch,
+      baseRef: this.baseRef,
+    });
   }
 
   isDefault(branch: LocalBranch | RemoteBranch): boolean {
-    return branch.branch === this.defaultBranchName;
+    const defaultBranch = this.defaultBranch;
+    if (!defaultBranch) return false;
+    if (branch.type !== defaultBranch.type) return false;
+    if (branch.type === 'remote' && defaultBranch.type === 'remote') {
+      return (
+        branch.branch === defaultBranch.branch && branch.remote.name === defaultBranch.remote.name
+      );
+    }
+    return branch.branch === defaultBranch.branch;
   }
 
   isBranchOnRemote(branchName: string): boolean {