fix(core): pass configured default_branch to syncWorkspace to prevent hard-reset to wrong branch

migrations/000_combined.sql

@@ -29,6 +29,7 @@ CREATE TABLE IF NOT EXISTS remote_agent_codebases (
   name VARCHAR(255) NOT NULL,
   repository_url VARCHAR(500),
   default_cwd VARCHAR(500) NOT NULL,
+  default_branch TEXT DEFAULT 'main',
   ai_assistant_type VARCHAR(20) DEFAULT 'claude',
   allow_env_keys BOOLEAN NOT NULL DEFAULT FALSE,
   commands JSONB DEFAULT '{}'::jsonb,

migrations/022_add_default_branch_to_codebases.sql

@@ -0,0 +1,8 @@
+-- Add default_branch column to remote_agent_codebases.
+-- NULL means "not yet detected"; syncWorkspace falls back to auto-detection
+-- (pre-existing behaviour). New clones set this via the branch-detect path in
+-- clone.ts. Using no DEFAULT so existing rows stay NULL rather than being
+-- silently set to 'main' (which could trigger an unwanted hard-reset for
+-- managed clones on a non-main branch).
+ALTER TABLE remote_agent_codebases
+  ADD COLUMN IF NOT EXISTS default_branch TEXT;

packages/core/src/db/adapters/sqlite.ts

@@ -215,6 +215,20 @@ export class SqliteAdapter implements IDatabase {
     } catch (e: unknown) {
       getLog().warn({ err: e as Error }, 'db.sqlite_migration_session_columns_failed');
     }
+
+    // Codebases columns
+    try {
+      const codebaseCols = this.db.prepare("PRAGMA table_info('remote_agent_codebases')").all() as {
+        name: string;
+      }[];
+      const codebaseColNames = new Set(codebaseCols.map(c => c.name));
+
+      if (!codebaseColNames.has('default_branch')) {
+        this.db.run('ALTER TABLE remote_agent_codebases ADD COLUMN default_branch TEXT');
+      }
+    } catch (e: unknown) {
+      getLog().warn({ err: e as Error }, 'db.sqlite_migration_codebases_columns_failed');
+    }
   }
 
   /**

packages/core/src/db/codebases.test.ts

@@ -35,6 +35,7 @@ describe('codebases', () => {
     name: 'test-project',
     repository_url: 'https://github.com/user/repo',
     default_cwd: '/workspace/test-project',
+    default_branch: 'main',
     ai_assistant_type: 'claude',
     commands: { plan: { path: '.claude/commands/plan.md', description: 'Plan feature' } },
     created_at: new Date(),
@@ -54,8 +55,8 @@ describe('codebases', () => {
 
       expect(result).toEqual(mockCodebase);
       expect(mockQuery).toHaveBeenCalledWith(
-        'INSERT INTO remote_agent_codebases (name, repository_url, default_cwd, ai_assistant_type) VALUES ($1, $2, $3, $4) RETURNING *',
-        ['test-project', 'https://github.com/user/repo', '/workspace/test-project', 'claude']
+        'INSERT INTO remote_agent_codebases (name, repository_url, default_cwd, default_branch, ai_assistant_type) VALUES ($1, $2, $3, $4, $5) RETURNING *',
+        ['test-project', 'https://github.com/user/repo', '/workspace/test-project', null, 'claude']
       );
     });
 
@@ -73,8 +74,25 @@ describe('codebases', () => {
 
       expect(result).toEqual(codebaseWithoutOptional);
       expect(mockQuery).toHaveBeenCalledWith(
-        'INSERT INTO remote_agent_codebases (name, repository_url, default_cwd, ai_assistant_type) VALUES ($1, $2, $3, $4) RETURNING *',
-        ['test-project', null, '/workspace/test-project', 'claude']
+        'INSERT INTO remote_agent_codebases (name, repository_url, default_cwd, default_branch, ai_assistant_type) VALUES ($1, $2, $3, $4, $5) RETURNING *',
+        ['test-project', null, '/workspace/test-project', null, 'claude']
+      );
+    });
+
+    test('creates codebase with explicit default_branch', async () => {
+      mockQuery.mockResolvedValueOnce(
+        createQueryResult([{ ...mockCodebase, default_branch: 'develop' }])
+      );
+
+      await createCodebase({
+        name: 'test-project',
+        default_cwd: '/workspace/test-project',
+        default_branch: 'develop',
+      });
+
+      expect(mockQuery).toHaveBeenCalledWith(
+        'INSERT INTO remote_agent_codebases (name, repository_url, default_cwd, default_branch, ai_assistant_type) VALUES ($1, $2, $3, $4, $5) RETURNING *',
+        ['test-project', null, '/workspace/test-project', 'develop', 'claude']
       );
     });
 
@@ -296,6 +314,7 @@ describe('codebases', () => {
             id: 'cb-123',
             name: 'test-repo',
             default_cwd: '/workspace/test-repo',
+            default_branch: null,
             ai_assistant_type: 'claude',
             repository_url: null,
             commands: {},

packages/core/src/db/codebases.ts

@@ -16,12 +16,19 @@ export async function createCodebase(data: {
   name: string;
   repository_url?: string;
   default_cwd: string;
+  default_branch?: string;
   ai_assistant_type?: string;
 }): Promise<Codebase> {
   const assistantType = data.ai_assistant_type ?? 'claude';
   const result = await pool.query<Codebase>(
-    'INSERT INTO remote_agent_codebases (name, repository_url, default_cwd, ai_assistant_type) VALUES ($1, $2, $3, $4) RETURNING *',
-    [data.name, data.repository_url ?? null, data.default_cwd, assistantType]
+    'INSERT INTO remote_agent_codebases (name, repository_url, default_cwd, default_branch, ai_assistant_type) VALUES ($1, $2, $3, $4, $5) RETURNING *',
+    [
+      data.name,
+      data.repository_url ?? null,
+      data.default_cwd,
+      data.default_branch ?? null,
+      assistantType,
+    ]
   );
   if (!result.rows[0]) {
     throw new Error('Failed to create codebase: INSERT succeeded but no row returned');

packages/core/src/handlers/clone.test.ts

@@ -131,6 +131,7 @@ function makeCodebase(
     name: string;
     repository_url: string | null;
     default_cwd: string;
+    default_branch: string | null;
     ai_assistant_type: string;
   }> = {}
 ): object {
@@ -139,6 +140,7 @@ function makeCodebase(
     name: 'owner/repo',
     repository_url: 'https://github.com/owner/repo',
     default_cwd: '/home/test/.archon/workspaces/owner/repo/source',
+    default_branch: null,
     ai_assistant_type: 'claude',
     commands: {},
     created_at: new Date(),
@@ -301,6 +303,70 @@ describe('cloneRepository', () => {
     });
   });
 
+  // ── Branch detection after clone ──────────────────────────────────────
+  describe('branch detection after clone', () => {
+    test('stores detected branch in createCodebase call', async () => {
+      spyExecFileAsync.mockImplementation((_cmd: string, args: string[]) => {
+        if (args[0] === '-C' && args[2] === 'rev-parse') {
+          return Promise.resolve({ stdout: 'master\n', stderr: '' });
+        }
+        return Promise.resolve({ stdout: '', stderr: '' });
+      });
+      mockCreateCodebase.mockResolvedValueOnce(makeCodebase() as ReturnType<typeof makeCodebase>);
+
+      await cloneRepository('https://github.com/owner/repo');
+
+      const createArg = mockCreateCodebase.mock.calls[0]?.[0] as { default_branch?: string };
+      expect(createArg.default_branch).toBe('master');
+    });
+
+    test('stores undefined (null in DB) when HEAD is detached', async () => {
+      spyExecFileAsync.mockImplementation((_cmd: string, args: string[]) => {
+        if (args[0] === '-C' && args[2] === 'rev-parse') {
+          return Promise.resolve({ stdout: 'HEAD\n', stderr: '' });
+        }
+        return Promise.resolve({ stdout: '', stderr: '' });
+      });
+      mockCreateCodebase.mockResolvedValueOnce(makeCodebase() as ReturnType<typeof makeCodebase>);
+
+      await cloneRepository('https://github.com/owner/repo');
+
+      const createArg = mockCreateCodebase.mock.calls[0]?.[0] as { default_branch?: string };
+      expect(createArg.default_branch).toBeUndefined();
+    });
+
+    test('does not throw and stores undefined when rev-parse fails', async () => {
+      spyExecFileAsync.mockImplementation((_cmd: string, args: string[]) => {
+        if (args[0] === '-C' && args[2] === 'rev-parse') {
+          return Promise.reject(new Error('not a git repo'));
+        }
+        return Promise.resolve({ stdout: '', stderr: '' });
+      });
+      mockCreateCodebase.mockResolvedValueOnce(makeCodebase() as ReturnType<typeof makeCodebase>);
+
+      const result = await cloneRepository('https://github.com/owner/repo');
+      expect(result).toBeDefined();
+
+      const createArg = mockCreateCodebase.mock.calls[0]?.[0] as { default_branch?: string };
+      expect(createArg.default_branch).toBeUndefined();
+    });
+
+    test('stores undefined when rev-parse returns empty string', async () => {
+      spyExecFileAsync.mockImplementation((_cmd: string, args: string[]) => {
+        if (args[0] === '-C' && args[2] === 'rev-parse') {
+          return Promise.resolve({ stdout: '', stderr: '' });
+        }
+        return Promise.resolve({ stdout: '', stderr: '' });
+      });
+      mockCreateCodebase.mockResolvedValueOnce(makeCodebase() as ReturnType<typeof makeCodebase>);
+
+      await cloneRepository('https://github.com/owner/repo');
+
+      const createArg = mockCreateCodebase.mock.calls[0]?.[0] as { default_branch?: string };
+      expect(createArg.default_branch).toBeUndefined();
+    });
+  });
+
   // ── Already-cloned directory ───────────────────────────────────────────
   describe('pre-existing clone', () => {
     beforeEach(() => {

packages/core/src/handlers/clone.ts

@@ -40,7 +40,8 @@ export interface RegisterResult {
 async function registerRepoAtPath(
   targetPath: string,
   name: string,
-  repositoryUrl: string | null
+  repositoryUrl: string | null,
+  defaultBranch?: string
 ): Promise<RegisterResult> {
   // Auto-detect assistant type based on SDK folder conventions.
   // Built-in providers use well-known folders (.claude/, .codex/).
@@ -125,6 +126,7 @@ async function registerRepoAtPath(
     name,
     repository_url: repositoryUrl ?? undefined,
     default_cwd: targetPath,
+    default_branch: defaultBranch,
     ai_assistant_type: suggestedAssistant,
   });
 
@@ -279,7 +281,31 @@ export async function cloneRepository(repoUrl: string): Promise<RegisterResult>
   await execFileAsync('git', ['config', '--global', '--add', 'safe.directory', targetPath]);
   getLog().debug({ path: targetPath }, 'safe_directory_added');
 
-  const result = await registerRepoAtPath(targetPath, `${ownerName}/${repoName}`, workingUrl);
+  // Detect the actual branch checked out after clone (may differ from 'main' for repos with
+  // a non-default HEAD). Non-fatal: if detection fails, NULL is stored and syncWorkspace
+  // auto-detects the branch at runtime (pre-existing behavior).
+  let detectedBranch: string | undefined;
+  try {
+    const { stdout } = await execFileAsync(
+      'git',
+      ['-C', targetPath, 'rev-parse', '--abbrev-ref', 'HEAD'],
+      { timeout: 5000 }
+    );
+    const branch = stdout.trim();
+    if (branch && branch !== 'HEAD') {
+      detectedBranch = branch;
+    }
+  } catch (err) {
+    // Non-fatal — store NULL so syncWorkspace falls back to auto-detection
+    getLog().debug({ path: targetPath, err }, 'clone.branch_detect_failed');
+  }
+
+  const result = await registerRepoAtPath(
+    targetPath,
+    `${ownerName}/${repoName}`,
+    workingUrl,
+    detectedBranch
+  );
   getLog().info({ url: workingUrl, targetPath }, 'clone_completed');
   return result;
 }

packages/core/src/orchestrator/orchestrator-agent.test.ts

@@ -207,6 +207,7 @@ function makeCodebase(name: string, id = `id-${name}`): Codebase {
     name,
     repository_url: null,
     default_cwd: `/repos/${name}`,
+    default_branch: null,
     ai_assistant_type: 'claude',
     commands: {},
     created_at: new Date(),
@@ -830,6 +831,7 @@ function makeCodebaseForSync() {
     name: 'test-repo',
     repository_url: 'https://github.com/test/repo',
     default_cwd: '/repos/test-repo',
+    default_branch: null,
     ai_assistant_type: 'claude',
     commands: {},
     created_at: new Date(),

packages/core/src/orchestrator/orchestrator-agent.ts

@@ -27,7 +27,7 @@ import { toError } from '../utils/error';
 import { getAgentProvider, getProviderCapabilities } from '@archon/providers';
 import { getArchonHome, getArchonWorkspacesPath } from '@archon/paths';
 import { syncArchonToWorktree } from '../utils/worktree-sync';
-import { syncWorkspace, toRepoPath } from '@archon/git';
+import { syncWorkspace, toRepoPath, toBranchName } from '@archon/git';
 import type { WorkspaceSyncResult } from '@archon/git';
 import { discoverWorkflowsWithConfig } from '@archon/workflows/workflow-discovery';
 import { findWorkflow } from '@archon/workflows/router';
@@ -410,7 +410,10 @@ async function discoverAllWorkflows(conversation: Conversation): Promise<Discove
           const isManagedClone = codebase.default_cwd
             .replace(/\\/g, '/')
             .startsWith(getArchonWorkspacesPath().replace(/\\/g, '/'));
-          syncResult = await syncWorkspace(toRepoPath(codebase.default_cwd), undefined, {
+          const configuredBranch = codebase.default_branch
+            ? toBranchName(codebase.default_branch)
+            : undefined;
+          syncResult = await syncWorkspace(toRepoPath(codebase.default_cwd), configuredBranch, {
             resetAfterFetch: isManagedClone,
           });
           getLog().debug(

packages/core/src/orchestrator/orchestrator-isolation.test.ts

@@ -175,7 +175,10 @@ function makeCodebase(overrides?: Partial<Codebase>): Codebase {
   return {
     id: 'cb-1',
     name: 'test-repo',
+    repository_url: null,
     default_cwd: '/workspace/test-repo',
+    default_branch: null,
+    ai_assistant_type: 'claude',
     commands: {},
     created_at: new Date(),
     updated_at: new Date(),