edsger 0.52.0 → 0.54.0

package/dist/phases/autonomous/index.js

@@ -12,6 +12,7 @@ import { getIssue } from '../../api/issues/get-issue.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logIssuePhaseEvent } from '../../services/audit-logs.js';
 import { createBranches, getCurrentBranch, updateBranch, } from '../../services/branches.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { prepareCustomBranchGitEnvironmentAsync, resetUncommittedChanges, } from '../../utils/git-branch-manager.js';
 import { gitPush } from '../../utils/git-push.js';
 import { logDebug, logError, logInfo } from '../../utils/logger.js';
@@ -128,7 +129,7 @@ function parseIterationResult(responseText) {
  * Handle a successful iteration: push, create PR, and log
  */
 async function handleSuccessfulIteration(opts) {
-    const { issueId, devBranchName, currentBranch, iterationResult, totalIterations, iterationDuration, startTime, endTime, existingPrUrl, verbose, } = opts;
+    const { issueId, devBranchName, currentBranch, iterationResult, totalIterations, iterationDuration, startTime, endTime, existingPrUrl, defaultBranch, verbose, } = opts;
     // Get GitHub config for push authentication and PR creation
     const githubConfig = await getGitHubConfig(issueId, verbose);
     // Push to remote with authentication
@@ -144,7 +145,7 @@ async function handleSuccessfulIteration(opts) {
     let prUrl = existingPrUrl;
     let prNumber;
     if (!prUrl) {
-        const prInfo = await createAutonomousPR(githubConfig, devBranchName, currentBranch, verbose);
+        const prInfo = await createAutonomousPR(githubConfig, devBranchName, currentBranch, defaultBranch, verbose);
         ({ prUrl, prNumber } = prInfo);
     }
     // Log iteration completion to audit logs
@@ -173,7 +174,7 @@ async function handleSuccessfulIteration(opts) {
  */
 async function createAutonomousPR(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-githubConfig, devBranchName, currentBranch, verbose) {
+githubConfig, devBranchName, currentBranch, defaultBranch, verbose) {
     if (!githubConfig.configured ||
         !githubConfig.token ||
         !githubConfig.owner ||
@@ -190,7 +191,7 @@ githubConfig, devBranchName, currentBranch, verbose) {
         verbose,
     };
     logInfo(`📝 Creating pull request for autonomous work...`);
-    const prResult = await createBranchPullRequest(prConfig, devBranchName, currentBranch.name, currentBranch.description || 'Autonomous development implementation', 'main');
+    const prResult = await createBranchPullRequest(prConfig, devBranchName, currentBranch.name, currentBranch.description || 'Autonomous development implementation', defaultBranch);
     if (prResult.success) {
         logInfo(`✅ Pull request created: ${prResult.pullRequestUrl}`);
         return {
@@ -299,10 +300,11 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
             }
         }
     }
-    // 4. Prepare git environment (checkout branch + rebase with main)
+    // 4. Prepare git environment (checkout branch + rebase with default branch)
+    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
     const { cleanup: cleanupGit } = await prepareCustomBranchGitEnvironmentAsync({
         issueBranch: devBranchName,
-        baseBranch: 'main',
+        baseBranch: defaultBranch,
         verbose,
         resolveConflicts: true,
         conflictResolverConfig: {
@@ -334,6 +336,7 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
                     startTime,
                     endTime,
                     existingPrUrl: prUrl,
+                    defaultBranch,
                     verbose,
                 });
                 prUrl = prInfo.prUrl || prUrl;

package/dist/phases/branch-planning/index.js

@@ -169,7 +169,7 @@ export const planIssueBranches = async (options, config) => {
         // Build the user prompt based on mode
         const contextInfo = formatContextForPrompt(context.issue, context.product, context.user_stories, context.test_cases);
         const existingBranchesInfo = formatExistingBranchesForPrompt(context.existing_branches);
-        const systemPrompt = await createBranchPlanningSystemPrompt(config, issueId);
+        const systemPrompt = await createBranchPlanningSystemPrompt(config, issueId, undefined, verbose);
         const userPrompt = await buildUserPrompt({
             isIncrementalUpdate,
             feedbacksContext,

package/dist/phases/branch-planning/prompts.d.ts

@@ -2,7 +2,7 @@ import { type EdsgerConfig } from '../../types/index.js';
 /**
  * Create the system prompt for branch planning
  */
-export declare function createBranchPlanningSystemPrompt(config: EdsgerConfig, issueId: string, projectDir?: string): Promise<string>;
+export declare function createBranchPlanningSystemPrompt(config: EdsgerConfig, issueId: string, projectDir?: string, verbose?: boolean): Promise<string>;
 /**
  * Create the user prompt with context for branch planning
  */

package/dist/phases/branch-planning/prompts.js

@@ -1,9 +1,10 @@
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
 import { OUTPUT_CONTRACTS } from '../output-contracts.js';
 /**
  * Create the system prompt for branch planning
  */
-export async function createBranchPlanningSystemPrompt(config, issueId, projectDir) {
+export async function createBranchPlanningSystemPrompt(config, issueId, projectDir, verbose) {
     const skill = await resolveSkill('phase/branch-planning', {
         projectDir,
     });
@@ -12,7 +13,7 @@ export async function createBranchPlanningSystemPrompt(config, issueId, projectD
     }
     let { prompt } = skill;
     prompt = substituteVariables(prompt, {
-        BASE_BRANCH: 'main',
+        BASE_BRANCH: await getDefaultBranchForIssue(issueId, verbose),
         ISSUE_ID: issueId,
     });
     return `${prompt}\n\n${OUTPUT_CONTRACTS['branch-planning']}`;

package/dist/phases/bug-fixing/analyzer.js

@@ -1,6 +1,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
 import { extractJsonFromResponse } from '../../utils/json-extractor.js';
 import { logDebug, logError, logInfo } from '../../utils/logger.js';
@@ -38,8 +39,11 @@ export const fixTestFailures = async (options, config) => {
     if (verbose) {
         logInfo(`Starting bug fixing for issue ID: ${issueId} (Attempt ${attemptNumber})`);
     }
-    // Prepare git environment: switch to issue branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(issueId, 'main', verbose);
+    // Prepare git environment: switch to issue branch and rebase with the
+    // repo's default branch (resolved via GitHub API for consistency with
+    // other phases — same source of truth for forks where origin/HEAD may lag).
+    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
+    const cleanupGit = preparePhaseGitEnvironment(issueId, defaultBranch, verbose);
     try {
         // Fetch all required context information via MCP endpoints
         if (verbose) {

package/dist/phases/code-implementation/branch-pr-creator.js

@@ -4,6 +4,7 @@
  */
 import { Octokit } from '@octokit/rest';
 import { gitPush } from '../../utils/git-push.js';
+import { resolveDefaultBranch } from '../../utils/github-repo-info.js';
 import { logError, logInfo } from '../../utils/logger.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
@@ -44,7 +45,8 @@ export function devBranchToFeatBranch(devBranchName) {
  * Create a pull request from a dev/ branch to its corresponding feat/ branch
  * This is used after code implementation in multi-branch issues
  */
-export async function createBranchPullRequest(config, devBranchName, issueName, branchDescription, baseBranch = 'main') {
+export async function createBranchPullRequest(config, devBranchName, issueName, branchDescription, baseBranch) {
+    const resolvedBaseBranch = baseBranch ?? resolveDefaultBranch();
     const { githubToken, owner, repo, verbose } = config;
     if (!devBranchName.startsWith('dev/')) {
         return {
@@ -75,13 +77,13 @@ export async function createBranchPullRequest(config, devBranchName, issueName,
             logInfo(`📝 Ensuring target branch ${featBranchName} exists...`);
         }
         try {
-            // Get the base branch (main) SHA
+            // Get the base branch SHA
             const { data: baseBranchData } = await octokit.repos.getBranch({
                 owner,
                 repo,
-                branch: baseBranch,
+                branch: resolvedBaseBranch,
             });
-            // Create the feat/ branch from main
+            // Create the feat/ branch from the resolved base
             await octokit.git.createRef({
                 owner,
                 repo,
@@ -89,7 +91,7 @@ export async function createBranchPullRequest(config, devBranchName, issueName,
                 sha: baseBranchData.commit.sha,
             });
             if (verbose) {
-                logInfo(`✅ Created target branch ${featBranchName} from ${baseBranch}`);
+                logInfo(`✅ Created target branch ${featBranchName} from ${resolvedBaseBranch}`);
             }
         }
         catch (error) {

package/dist/phases/code-implementation/index.js

@@ -8,6 +8,7 @@ import { createBranches, getBaseBranchInfo, getBranches, getCurrentBranch, updat
 import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { prepareCustomBranchGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { gitPush } from '../../utils/git-push.js';
 import { extractJsonFromResponse } from '../../utils/json-extractor.js';
@@ -172,7 +173,10 @@ message, lastAssistantResponse, issueId, verbose
 }
 // eslint-disable-next-line complexity
 export const implementIssueCode = async (options, config, checklistContext) => {
-    const { issueId, verbose, baseBranch = 'main' } = options;
+    const { issueId, verbose } = options;
+    // Resolve the repo's default branch (handles forks where default is master, etc.).
+    // Caller may override via options.baseBranch (e.g. branch-chained PR base).
+    const baseBranch = options.baseBranch ?? (await getDefaultBranchForIssue(issueId, verbose));
     if (verbose) {
         logInfo(`Starting code implementation for issue ID: ${issueId}`);
         logInfo(`Base branch: ${baseBranch}`);
@@ -322,7 +326,7 @@ export const implementIssueCode = async (options, config, checklistContext) => {
                     githubToken: githubConfig.token,
                     owner: githubConfig.owner,
                     repo: githubConfig.repo,
-                    baseBranch: 'main',
+                    baseBranch,
                     verbose,
                 });
             }

package/dist/phases/code-refine/index.js

@@ -6,6 +6,7 @@
 import { getGitHubConfig } from '../../api/github.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { getBaseBranchInfo, getBranches, updateBranch, } from '../../services/branches.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { getUncommittedFiles, hasUncommittedChanges, prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { gitPushCurrentBranch } from '../../utils/git-push.js';
 import { logError, logInfo } from '../../utils/logger.js';
@@ -47,12 +48,14 @@ export const refineCodeFromPRFeedback = async (options, config, checklistContext
     if (verbose) {
         logInfo(`Starting code refine for issue ID: ${issueId}`);
     }
+    // Resolve the repo's default branch (handles forks where default is master, etc.)
+    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
     // For multi-branch issues, find the branch that has been reviewed
     // (status = 'reviewed' after code-review phase) and use its branch_name for refine
     let branchName = `dev/${issueId}`; // Default for single-branch issues
     let currentBranch = null;
     let allBranches = [];
-    let baseBranchForRebase = 'main'; // Default base branch for rebase
+    let baseBranchForRebase = defaultBranch; // Default base branch for rebase
     let rebaseTargetBranchForRebase; // Target for --onto rebase (e.g., main)
     let originalBaseBranchForRebase; // For --onto when base was squash-merged
     let baseBranchCompletedForRebase = false;
@@ -68,7 +71,7 @@ export const refineCodeFromPRFeedback = async (options, config, checklistContext
                 logInfo(`   Using dev branch: ${branchName}`);
             }
             // Determine the correct base branch for rebase using base_branch_id
-            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, 'main');
+            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, defaultBranch);
             // Always use the baseBranch from getBaseBranchInfo - it handles all cases:
             // - No base branch: returns 'main'
             // - Base branch merged: returns feat branch (new branches created from feat/xxx)
@@ -114,14 +117,14 @@ export const refineCodeFromPRFeedback = async (options, config, checklistContext
                 githubConfig.repo) {
                 const featBranchName = branchName.replace(/^dev\//, 'feat/');
                 if (verbose) {
-                    logInfo(`📥 Syncing ${featBranchName} with main before rebase...`);
+                    logInfo(`📥 Syncing ${featBranchName} with ${defaultBranch} before rebase...`);
                 }
                 featSyncedToMain = await syncFeatBranchWithMain({
                     featBranch: featBranchName,
                     githubToken: githubConfig.token,
                     owner: githubConfig.owner,
                     repo: githubConfig.repo,
-                    baseBranch: 'main',
+                    baseBranch: defaultBranch,
                     verbose,
                 });
             }
@@ -150,7 +153,7 @@ export const refineCodeFromPRFeedback = async (options, config, checklistContext
             baseBranchCompleted: baseBranchCompletedForRebase,
             githubToken,
         })
-        : await preparePhaseGitEnvironmentAsync(issueId, 'main', verbose, true, {
+        : await preparePhaseGitEnvironmentAsync(issueId, defaultBranch, verbose, true, {
             model: DEFAULT_MODEL,
         });
     const cleanupGit = gitEnvResult.cleanup;

package/dist/phases/code-review/index.js

@@ -10,6 +10,7 @@ import { DEFAULT_MODEL } from '../../constants.js';
 import { getBaseBranchInfo, getBranches, updateBranch, } from '../../services/branches.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { logError, logInfo } from '../../utils/logger.js';
 import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
@@ -73,12 +74,14 @@ export const reviewPullRequest = async (options, config, checklistContext) => {
     if (verbose) {
         logInfo(`Starting code review for issue ID: ${issueId}`);
     }
+    // Resolve the repo's default branch (handles forks where default is master, etc.)
+    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
     // For multi-branch issues, find the branch that is ready for review
     // and use its branch_name for review (branch_name is stored as dev/...)
     let branchName = `dev/${issueId}`; // Default for single-branch issues
     let currentBranch = null;
     let allBranches = [];
-    let baseBranchForRebase = 'main'; // Default base branch for rebase
+    let baseBranchForRebase = defaultBranch; // Default base branch for rebase
     let rebaseTargetBranchForRebase; // Target for --onto rebase (e.g., main)
     let originalBaseBranchForRebase; // For --onto when base was squash-merged
     let baseBranchCompletedForRebase = false;
@@ -95,7 +98,7 @@ export const reviewPullRequest = async (options, config, checklistContext) => {
                 logInfo(`   Using dev branch: ${branchName}`);
             }
             // Determine the correct base branch for rebase using base_branch_id
-            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, 'main');
+            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, defaultBranch);
             // Always use the baseBranch from getBaseBranchInfo - it handles all cases:
             // - No base branch: returns 'main'
             // - Base branch merged: returns feat branch (new branches created from feat/xxx)
@@ -141,14 +144,14 @@ export const reviewPullRequest = async (options, config, checklistContext) => {
                 githubConfig.repo) {
                 const featBranchName = branchName.replace(/^dev\//, 'feat/');
                 if (verbose) {
-                    logInfo(`📥 Syncing ${featBranchName} with main before rebase...`);
+                    logInfo(`📥 Syncing ${featBranchName} with ${defaultBranch} before rebase...`);
                 }
                 featSyncedToMain = await syncFeatBranchWithMain({
                     featBranch: featBranchName,
                     githubToken: githubConfig.token,
                     owner: githubConfig.owner,
                     repo: githubConfig.repo,
-                    baseBranch: 'main',
+                    baseBranch: defaultBranch,
                     verbose,
                 });
             }
@@ -177,7 +180,7 @@ export const reviewPullRequest = async (options, config, checklistContext) => {
             baseBranchCompleted: baseBranchCompletedForRebase,
             githubToken,
         })
-        : await preparePhaseGitEnvironmentAsync(issueId, 'main', verbose, true, {
+        : await preparePhaseGitEnvironmentAsync(issueId, defaultBranch, verbose, true, {
             model: DEFAULT_MODEL,
         });
     const cleanupGit = gitEnvResult.cleanup;

package/dist/phases/code-testing/analyzer.js

@@ -1,5 +1,11 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
+import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
+import { extractJsonFromResponse } from '../../utils/json-extractor.js';
+import { logDebug, logError, logInfo } from '../../utils/logger.js';
+import { fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';
+import { createCodeTestingPromptWithContext, createCodeTestingSystemPrompt, } from './prompts.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function processAssistantContent(content, verbose) {
     let text = '';
@@ -14,11 +20,6 @@ function processAssistantContent(content, verbose) {
     }
     return text;
 }
-import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
-import { extractJsonFromResponse } from '../../utils/json-extractor.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';
-import { createCodeTestingPromptWithContext, createCodeTestingSystemPrompt, } from './prompts.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -37,8 +38,11 @@ export const writeCodeTests = async (options, config) => {
     if (verbose) {
         logInfo(`Starting code testing phase for issue ID: ${issueId}`);
     }
-    // Prepare git environment: switch to issue branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(issueId, 'main', verbose);
+    // Prepare git environment: switch to issue branch and rebase with the
+    // repo's default branch (resolved via GitHub API for consistency with
+    // other phases — same source of truth for forks where origin/HEAD may lag).
+    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
+    const cleanupGit = preparePhaseGitEnvironment(issueId, defaultBranch, verbose);
     try {
         // Fetch all required context information via MCP endpoints
         if (verbose) {

package/dist/phases/pr-execution/context.d.ts

@@ -19,6 +19,8 @@ export interface PRExecutionContext {
     devBranchHeadSha: string;
     githubConfig: GitHubConfigInfo;
     forkInfo: RepoForkInfo;
+    /** Resolved default branch (e.g. main, master). Used for checkout/diff. */
+    defaultBranch: string;
     isIncrementalSync: boolean;
     lastSyncedCommit: string | null;
     diffStat: string;

package/dist/phases/pr-execution/context.js

@@ -1,10 +1,10 @@
-import { execFileSync, execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { getGitHubConfig } from '../../api/github.js';
 import { getIssue } from '../../api/issues/index.js';
 import { getPullRequests, } from '../../services/pull-requests.js';
 import { branchExists, remoteBranchExists, } from '../../utils/git-branch-manager.js';
 import { buildCredentialArgs } from '../../utils/git-push.js';
-import { getRepoForkInfo, } from '../../utils/github-repo-info.js';
+import { getRepoForkInfo, resolveDefaultBranch, } from '../../utils/github-repo-info.js';
 import { logError, logInfo } from '../../utils/logger.js';
 /**
  * Get the dev branch name for an issue
@@ -16,14 +16,16 @@ function getDevBranchName(issueId) {
  * Get the HEAD SHA of a branch
  */
 function getBranchHeadSha(branchName) {
-    return execSync(`git rev-parse ${branchName}`, { encoding: 'utf-8' }).trim();
+    return execFileSync('git', ['rev-parse', branchName], {
+        encoding: 'utf-8',
+    }).trim();
 }
 /**
  * Get diff stat between two refs
  */
 function getDiffStat(baseRef, headRef) {
     try {
-        return execSync(`git diff --stat ${baseRef}...${headRef}`, {
+        return execFileSync('git', ['diff', '--stat', `${baseRef}...${headRef}`], {
             encoding: 'utf-8',
         }).trim();
     }
@@ -51,9 +53,7 @@ function parseGitStatus(status) {
  */
 function getChangedFiles(baseRef, headRef) {
     try {
-        const output = execSync(`git diff --name-status ${baseRef}...${headRef}`, {
-            encoding: 'utf-8',
-        }).trim();
+        const output = execFileSync('git', ['diff', '--name-status', `${baseRef}...${headRef}`], { encoding: 'utf-8' }).trim();
         if (!output) {
             return [];
         }
@@ -77,7 +77,7 @@ function getChangedFiles(baseRef, headRef) {
  */
 function isAncestor(commitSha, ref) {
     try {
-        execSync(`git merge-base --is-ancestor ${commitSha} ${ref}`, {
+        execFileSync('git', ['merge-base', '--is-ancestor', commitSha, ref], {
             encoding: 'utf-8',
             stdio: 'pipe',
         });
@@ -121,25 +121,50 @@ export async function fetchPRExecutionContext(issueId, verbose) {
             getPullRequests({ issueId, verbose }),
             getGitHubConfig(issueId, verbose),
         ]);
-        // Fetch latest remote refs and fast-forward local main
+        // Detect fork status + default branch (used by the fast-forward step below)
+        let forkInfo = { isFork: false };
+        if (githubConfig.token && githubConfig.owner && githubConfig.repo) {
+            try {
+                forkInfo = await getRepoForkInfo(githubConfig.token, githubConfig.owner, githubConfig.repo);
+                if (verbose) {
+                    logInfo(forkInfo.isFork
+                        ? `📌 Repository is a fork of ${forkInfo.upstream?.owner}/${forkInfo.upstream?.repo}`
+                        : `📌 Repository is not a fork`);
+                }
+            }
+            catch (error) {
+                if (verbose) {
+                    logError(`Failed to detect fork status: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        // Resolve the repo's default branch (e.g. main, master, develop). Falls back
+        // through GitHub API → local symbolic-ref → literal 'main'.
+        const defaultBranch = resolveDefaultBranch(forkInfo.defaultBranch);
+        // Fetch latest remote refs and fast-forward the local default branch.
+        // Use execFileSync (not execSync) so defaultBranch — which can flow in from
+        // the GitHub API's default_branch field — is never passed through a shell.
         try {
             const credArgs = buildCredentialArgs(githubConfig.token);
             execFileSync('git', [...credArgs, 'fetch', 'origin'], {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             });
-            execSync('git checkout main', { encoding: 'utf-8', stdio: 'pipe' });
-            execSync('git merge --ff-only origin/main', {
+            execFileSync('git', ['checkout', defaultBranch], {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            execFileSync('git', ['merge', '--ff-only', `origin/${defaultBranch}`], {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             });
             if (verbose) {
-                logInfo('✅ Local main synced with origin/main');
+                logInfo(`✅ Local ${defaultBranch} synced with origin/${defaultBranch}`);
             }
         }
         catch (error) {
             if (verbose) {
-                logInfo(`⚠️  Could not sync main with origin: ${error instanceof Error ? error.message : String(error)}`);
+                logInfo(`⚠️  Could not sync ${defaultBranch} with origin: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         // Verify dev branch exists
@@ -168,23 +193,6 @@ export async function fetchPRExecutionContext(issueId, verbose) {
         if (!githubConfig.configured) {
             throw new Error(`GitHub is not configured. ${githubConfig.message || 'Please configure GitHub integration.'}`);
         }
-        // Detect fork status
-        let forkInfo = { isFork: false };
-        if (githubConfig.token && githubConfig.owner && githubConfig.repo) {
-            try {
-                forkInfo = await getRepoForkInfo(githubConfig.token, githubConfig.owner, githubConfig.repo);
-                if (verbose) {
-                    logInfo(forkInfo.isFork
-                        ? `📌 Repository is a fork of ${forkInfo.upstream?.owner}/${forkInfo.upstream?.repo}`
-                        : `📌 Repository is not a fork`);
-                }
-            }
-            catch (error) {
-                if (verbose) {
-                    logError(`Failed to detect fork status: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
         // Determine sync mode
         const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
         const devBranchHeadSha = getBranchHeadSha(devRef);
@@ -202,8 +210,8 @@ export async function fetchPRExecutionContext(issueId, verbose) {
             lastSyncedCommit = null;
             isIncrementalSync = false;
         }
-        // Get diff info: for incremental, diff from last sync; for first run, diff from main
-        const diffBase = isIncrementalSync && lastSyncedCommit ? lastSyncedCommit : 'main';
+        // Get diff info: for incremental, diff from last sync; for first run, diff from default branch
+        const diffBase = isIncrementalSync && lastSyncedCommit ? lastSyncedCommit : defaultBranch;
         const diffStat = getDiffStat(diffBase, devRef);
         const changedFiles = getChangedFiles(diffBase, devRef);
         if (verbose) {
@@ -223,6 +231,7 @@ export async function fetchPRExecutionContext(issueId, verbose) {
             devBranchHeadSha,
             githubConfig,
             forkInfo,
+            defaultBranch,
             isIncrementalSync,
             lastSyncedCommit,
             diffStat,

package/dist/phases/pr-execution/index.js

@@ -1,9 +1,10 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logIssuePhaseEvent } from '../../services/audit-logs.js';
 import { getPullRequests, } from '../../services/pull-requests.js';
 import { getCurrentBranch, returnToMainBranch, } from '../../utils/git-branch-manager.js';
+import { resolveDefaultBranch } from '../../utils/github-repo-info.js';
 import { logDebug, logError, logInfo } from '../../utils/logger.js';
 import { fetchPRExecutionContext } from './context.js';
 import { assignNewFilesToPRs, removeDeletedFilesFromPRs, removeStaleFilesFromPRs, } from './file-assigner.js';
@@ -118,13 +119,16 @@ export const executeIssuePRs = async (options, config) => {
                 ? '\n🔄 Syncing PR branches with latest changes...'
                 : '\n🔧 Creating PR branches and moving code...');
         }
-        // Ensure we're on main before the agent starts
+        // Ensure we're on the repo's default branch before the agent starts
         const currentBranch = getCurrentBranch();
-        if (currentBranch !== 'main') {
+        if (currentBranch !== context.defaultBranch) {
             if (verbose) {
-                logInfo(`Switching from ${currentBranch} to main...`);
+                logInfo(`Switching from ${currentBranch} to ${context.defaultBranch}...`);
             }
-            execSync('git checkout main', { encoding: 'utf-8', stdio: 'pipe' });
+            execFileSync('git', ['checkout', context.defaultBranch], {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
         }
         let systemPrompt;
         let userPrompt;
@@ -137,11 +141,12 @@ export const executeIssuePRs = async (options, config) => {
                 lastSyncedCommit: context.lastSyncedCommit,
                 diffStat: context.diffStat,
                 changedFiles: context.changedFiles,
+                defaultBranch: context.defaultBranch,
             });
         }
         else {
             systemPrompt = await createPRExecutionSystemPrompt(issueId, context.devBranchName);
-            userPrompt = createPRExecutionPrompt(issueId, context.devBranchName, activePullRequests);
+            userPrompt = createPRExecutionPrompt(issueId, context.devBranchName, activePullRequests, context.defaultBranch);
         }
         // Execute agent query
         const agentResult = await executeAgentQuery(userPrompt, systemPrompt, config, verbose);
@@ -151,12 +156,15 @@ export const executeIssuePRs = async (options, config) => {
         if (verbose) {
             logInfo('\n🚀 Pushing branches to remote...');
         }
-        // Ensure we're on main before pushing
+        // Ensure we're back on the default branch before pushing
         try {
-            execSync('git checkout main', { encoding: 'utf-8', stdio: 'pipe' });
+            execFileSync('git', ['checkout', context.defaultBranch], {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
         }
         catch {
-            // Ignore if already on main
+            // Ignore if already on the default branch
         }
         if (!context.githubConfig.owner || !context.githubConfig.repo) {
             throw new Error('GitHub owner and repo must be configured for PR execution');
@@ -191,7 +199,7 @@ export const executeIssuePRs = async (options, config) => {
             }
             // Verify the branch exists locally
             try {
-                execSync(`git rev-parse --verify ${pr.branch_name}`, {
+                execFileSync('git', ['rev-parse', '--verify', pr.branch_name], {
                     encoding: 'utf-8',
                     stdio: 'pipe',
                 });
@@ -209,10 +217,10 @@ export const executeIssuePRs = async (options, config) => {
             else {
                 executionSummary.branchesCreated++;
             }
-            // Resolve base branch for stacked PRs
+            // Resolve base branch for stacked PRs (default to repo's default branch)
             const baseBranch = pr.base_pr_id
-                ? prIdToBranch.get(pr.base_pr_id) || 'main'
-                : 'main';
+                ? prIdToBranch.get(pr.base_pr_id) || context.defaultBranch
+                : context.defaultBranch;
             // Push branch and build compare URL (using stacked base)
             const result = pushBranchAndBuildUrl(executionConfig, pr.branch_name, baseBranch);
             if (result.success) {
@@ -225,9 +233,9 @@ export const executeIssuePRs = async (options, config) => {
                 executionSummary.failedBranches.push(pr.branch_name);
             }
         }
-        // Return to main branch
+        // Return to the repo's default branch
         try {
-            returnToMainBranch('main', verbose);
+            returnToMainBranch(context.defaultBranch, verbose);
         }
         catch {
             // Best effort
@@ -278,9 +286,10 @@ export const executeIssuePRs = async (options, config) => {
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logError(`PR execution failed: ${errorMessage}`);
-        // Try to return to main branch
+        // Try to return to the repo's default branch (best effort — context may
+        // have failed before defaultBranch was resolved, so look it up locally)
         try {
-            returnToMainBranch('main', false);
+            returnToMainBranch(resolveDefaultBranch(), false);
         }
         catch {
             // Best effort

package/dist/phases/pr-execution/prompts.d.ts

@@ -11,7 +11,7 @@ export declare function createIncrementalSyncSystemPrompt(issueId: string, devBr
 /**
  * Create the user prompt for first-time branch creation
  */
-export declare function createPRExecutionPrompt(issueId: string, devBranchName: string, pullRequests: PullRequest[]): string;
+export declare function createPRExecutionPrompt(issueId: string, devBranchName: string, pullRequests: PullRequest[], defaultBranch: string): string;
 /**
  * Create the user prompt for incremental sync
  */
@@ -22,5 +22,6 @@ export interface IncrementalSyncPromptOptions {
     lastSyncedCommit: string;
     diffStat: string;
     changedFiles: ChangedFileInfo[];
+    defaultBranch: string;
 }
 export declare function createIncrementalSyncPrompt(opts: IncrementalSyncPromptOptions): string;

package/dist/phases/pr-execution/prompts.js

@@ -35,25 +35,27 @@ export async function createIncrementalSyncSystemPrompt(issueId, devBranchName,
     return `${prompt}\n\n${OUTPUT_CONTRACTS['incremental-sync']}`;
 }
 /**
- * Resolve the base branch for a PR based on its dependency chain
+ * Resolve the base branch for a PR based on its dependency chain.
+ * Falls back to the repo's default branch (main, master, …) when the PR has
+ * no upstream dependency.
  */
-function resolveBaseBranch(pr, allPRs) {
+function resolveBaseBranch(pr, allPRs, defaultBranch) {
     if (!pr.base_pr_id) {
-        return 'main';
+        return defaultBranch;
     }
     const basePR = allPRs.find((p) => p.id === pr.base_pr_id);
-    return basePR?.branch_name || 'main';
+    return basePR?.branch_name || defaultBranch;
 }
 /**
  * Create the user prompt for first-time branch creation
  */
-export function createPRExecutionPrompt(issueId, devBranchName, pullRequests) {
+export function createPRExecutionPrompt(issueId, devBranchName, pullRequests, defaultBranch) {
     const prList = pullRequests
         .map((pr) => {
         const files = pr.files
             ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
             : '    (no files specified)';
-        const baseBranch = resolveBaseBranch(pr, pullRequests);
+        const baseBranch = resolveBaseBranch(pr, pullRequests, defaultBranch);
         return `### PR ${pr.sequence}: ${pr.name}
 - Branch: \`${pr.branch_name}\`
 - Base: \`${baseBranch}\`
@@ -71,22 +73,22 @@ ${prList}
 ## Instructions
 
 For each PR above (in sequence order):
-1. Switch to the **base branch** specified in "Base" above (either \`main\` or a previous PR's branch)
+1. Switch to the **base branch** specified in "Base" above (either \`${defaultBranch}\` or a previous PR's branch)
 2. Create the branch: \`git checkout -b <branch_name>\`
 3. Apply only the listed files from \`${devBranchName}\`
 4. Commit with a descriptive message
 5. Verify with \`git diff --stat <base>...<branch_name>\`
 
-After all branches are created, switch back to \`main\` and provide the execution result JSON.`;
+After all branches are created, switch back to \`${defaultBranch}\` and provide the execution result JSON.`;
 }
 export function createIncrementalSyncPrompt(opts) {
-    const { issueId: _issueId, devBranchName, pullRequests, lastSyncedCommit, diffStat, changedFiles, } = opts;
+    const { issueId: _issueId, devBranchName, pullRequests, lastSyncedCommit, diffStat, changedFiles, defaultBranch, } = opts;
     const prList = pullRequests
         .map((pr) => {
         const files = pr.files
             ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
             : '    (no files specified)';
-        const baseBranch = resolveBaseBranch(pr, pullRequests);
+        const baseBranch = resolveBaseBranch(pr, pullRequests, defaultBranch);
         return `### PR ${pr.sequence}: ${pr.name}
 - Branch: \`${pr.branch_name}\`
 - Base: \`${baseBranch}\`

package/dist/phases/pr-splitting/context.js

@@ -1,4 +1,4 @@
-import { execFileSync, execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { getGitHubConfig } from '../../api/github.js';
 import { getIssue } from '../../api/issues/index.js';
 import { getProduct } from '../../api/products.js';
@@ -6,7 +6,7 @@ import { getBranches } from '../../services/branches.js';
 import { getPullRequests, } from '../../services/pull-requests.js';
 import { branchExists, remoteBranchExists, } from '../../utils/git-branch-manager.js';
 import { buildCredentialArgs } from '../../utils/git-push.js';
-import { getRepoForkInfo, } from '../../utils/github-repo-info.js';
+import { getRepoForkInfo, resolveDefaultBranch, } from '../../utils/github-repo-info.js';
 import { logError, logInfo } from '../../utils/logger.js';
 /**
  * Get the dev branch name for an issue
@@ -18,14 +18,16 @@ function getDevBranchName(issueId) {
  * Get the HEAD SHA of a branch
  */
 function getBranchHeadSha(branchName) {
-    return execSync(`git rev-parse ${branchName}`, { encoding: 'utf-8' }).trim();
+    return execFileSync('git', ['rev-parse', branchName], {
+        encoding: 'utf-8',
+    }).trim();
 }
 /**
  * Get diff stat between two refs
  */
 function getDiffStat(baseRef, headRef) {
     try {
-        return execSync(`git diff --stat ${baseRef}...${headRef}`, {
+        return execFileSync('git', ['diff', '--stat', `${baseRef}...${headRef}`], {
             encoding: 'utf-8',
         }).trim();
     }
@@ -38,9 +40,7 @@ function getDiffStat(baseRef, headRef) {
  */
 function getChangedFiles(baseRef, headRef) {
     try {
-        const output = execSync(`git diff --name-only ${baseRef}...${headRef}`, {
-            encoding: 'utf-8',
-        }).trim();
+        const output = execFileSync('git', ['diff', '--name-only', `${baseRef}...${headRef}`], { encoding: 'utf-8' }).trim();
         if (!output) {
             return [];
         }
@@ -53,18 +53,18 @@ function getChangedFiles(baseRef, headRef) {
 /**
  * Determine the diff base ref for incremental re-runs
  * If existing PRs have last_synced_commit, use the earliest one
- * Otherwise use origin/main (remote-tracking ref, always up-to-date after fetch)
+ * Otherwise use origin/<defaultBranch> (remote-tracking ref, always up-to-date after fetch)
  */
-function determineDiffBaseRef(existingPRs, replaceExisting) {
+function determineDiffBaseRef(existingPRs, defaultBranchRef, replaceExisting) {
     if (replaceExisting || existingPRs.length === 0) {
-        return 'origin/main';
+        return defaultBranchRef;
     }
     // Find the minimum last_synced_commit (earliest sync point)
     const syncedCommits = existingPRs
         .map((pr) => pr.last_synced_commit)
         .filter((c) => c !== null);
     if (syncedCommits.length === 0) {
-        return 'origin/main';
+        return defaultBranchRef;
     }
     // All PRs should have been synced to the same commit
     // Use the first one (they should all be equal after a successful sync)
@@ -131,12 +131,17 @@ export async function fetchPRSplittingContext(issueId, verbose, replaceExisting)
                 }
             }
         }
+        // Resolve the repo's default branch (handles non-main defaults and forks).
+        // Prefer the GitHub API value (already fetched in forkInfo above); fall back
+        // to the local symbolic-ref, then to literal 'main'.
+        const defaultBranch = resolveDefaultBranch(forkInfo.defaultBranch);
+        const defaultBranchRef = `origin/${defaultBranch}`;
         // Determine diff range
         const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
-        const baseRef = determineDiffBaseRef(existingPullRequests, replaceExisting);
+        const baseRef = determineDiffBaseRef(existingPullRequests, defaultBranchRef, replaceExisting);
         const devBranchHeadSha = getBranchHeadSha(devRef);
         // Check if there are new changes since last sync
-        if (baseRef !== 'origin/main' && baseRef === devBranchHeadSha) {
+        if (baseRef !== defaultBranchRef && baseRef === devBranchHeadSha) {
             if (verbose) {
                 logInfo(`No new changes since last sync (HEAD: ${devBranchHeadSha})`);
             }

package/dist/phases/pr-splitting/index.js

@@ -102,7 +102,7 @@ export const splitIssueIntoPRs = async (options, config) => {
         }
         const contextInfo = formatContextForPrompt(context.issue, context.product, context.existing_branches);
         const existingPRsInfo = formatExistingPRsForPrompt(context.existing_pull_requests);
-        const systemPrompt = await createPRSplittingSystemPrompt(config, issueId);
+        const systemPrompt = await createPRSplittingSystemPrompt(config, issueId, undefined, verbose);
         let userPrompt;
         if (isIncrementalUpdate && feedbacksContext) {
             if (verbose) {

package/dist/phases/pr-splitting/prompts.d.ts

@@ -2,7 +2,7 @@ import { type EdsgerConfig } from '../../types/index.js';
 /**
  * Create the system prompt for PR splitting: Diff analysis and PR planning
  */
-export declare function createPRSplittingSystemPrompt(config: EdsgerConfig, issueId: string, projectDir?: string): Promise<string>;
+export declare function createPRSplittingSystemPrompt(config: EdsgerConfig, issueId: string, projectDir?: string, verbose?: boolean): Promise<string>;
 /**
  * Create the user prompt with diff context for PR splitting
  */

package/dist/phases/pr-splitting/prompts.js

@@ -1,9 +1,10 @@
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
 import { OUTPUT_CONTRACTS } from '../output-contracts.js';
 /**
  * Create the system prompt for PR splitting: Diff analysis and PR planning
  */
-export async function createPRSplittingSystemPrompt(config, issueId, projectDir) {
+export async function createPRSplittingSystemPrompt(config, issueId, projectDir, verbose) {
     const skill = await resolveSkill('phase/pr-splitting', {
         projectDir,
     });
@@ -12,7 +13,7 @@ export async function createPRSplittingSystemPrompt(config, issueId, projectDir)
     }
     let { prompt } = skill;
     prompt = substituteVariables(prompt, {
-        BASE_BRANCH: 'main',
+        BASE_BRANCH: await getDefaultBranchForIssue(issueId, verbose),
         ISSUE_ID: issueId,
     });
     return `${prompt}\n\n${OUTPUT_CONTRACTS['pr-splitting']}`;

package/dist/phases/pull-request/creator.js

@@ -5,6 +5,7 @@
 import { Octokit } from '@octokit/rest';
 import { execFileSync, execSync } from 'child_process';
 import { buildCredentialArgs, gitPush } from '../../utils/git-push.js';
+import { resolveDefaultBranch } from '../../utils/github-repo-info.js';
 import { logDebug } from '../../utils/logger.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
@@ -108,18 +109,20 @@ const switchToBranch = (branch, verbose, githubToken) => {
     }
 };
 /**
- * Switch to main branch
+ * Switch to the repo's default branch (e.g. main, master). Caller passes the
+ * resolved branch name; falls back to local origin/HEAD if undefined.
  */
-const switchToMainBranch = (mainBranch = 'main', verbose) => {
+const switchToMainBranch = (mainBranch, verbose) => {
+    const target = mainBranch ?? resolveDefaultBranch();
     try {
-        logDebug(`Switching to ${mainBranch} branch...`, verbose);
+        logDebug(`Switching to ${target} branch...`, verbose);
         // Discard any uncommitted changes before switching
         discardUncommittedChanges(verbose);
-        execSync(`git checkout ${mainBranch}`, { encoding: 'utf-8' });
-        logDebug(`Switched to ${mainBranch} branch`, verbose);
+        execFileSync('git', ['checkout', target], { encoding: 'utf-8' });
+        logDebug(`Switched to ${target} branch`, verbose);
     }
     catch (error) {
-        throw new Error(`Failed to switch to ${mainBranch} branch: ${error}`);
+        throw new Error(`Failed to switch to ${target} branch: ${error}`);
     }
 };
 /**
@@ -189,7 +192,7 @@ const generatePRBody = (issue) => {
  * Create a pull request for the issue
  */
 export async function createPullRequest(config, issue) {
-    const { githubToken, owner, repo, baseBranch = 'main', verbose } = config;
+    const { githubToken, owner, repo, baseBranch = resolveDefaultBranch(), verbose, } = config;
     try {
         // Initialize Octokit with personal access token
         const octokit = new Octokit({

package/dist/phases/pull-request/handler.js

@@ -4,6 +4,7 @@
 import { getGitHubConfig } from '../../api/github.js';
 import { getIssue } from '../../api/issues/index.js';
 import { getCurrentBranch, updateBranch, } from '../../services/branches.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { logDebug } from '../../utils/logger.js';
 import { createPullRequest } from './creator.js';
 /**
@@ -45,11 +46,12 @@ export async function handlePullRequestCreation({ issueId, results, testingResul
     }
     const { token: githubToken, owner: githubOwner, repo: githubRepo, } = githubConfig;
     logDebug(`Using GitHub config from product developer: ${githubOwner}/${githubRepo}`, verbose);
+    const baseBranch = await getDefaultBranchForIssue(issueId, verbose);
     const prResult = await createPullRequest({
         githubToken,
         owner: githubOwner,
         repo: githubRepo,
-        baseBranch: 'main',
+        baseBranch,
         verbose,
     }, {
         id: issue.id,

package/dist/services/repo-config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Per-issue repo configuration helpers.
+ *
+ * Right now this just exposes the resolved default branch for a given issue,
+ * combining the GitHub API answer (most authoritative) with local-git and
+ * literal-`main` fallbacks. Phases that previously hardcoded `'main'` should
+ * call `getDefaultBranchForIssue(issueId)` instead so forks whose default
+ * branch is `master` / `develop` / `trunk` work correctly.
+ */
+/**
+ * Resolve the default branch for the repository attached to this issue.
+ * Order of precedence: GitHub API `default_branch` → local symbolic-ref → 'main'.
+ *
+ * Cached per `issueId` for the lifetime of the process. Never throws; on any
+ * error it falls back to local resolution.
+ */
+export declare function getDefaultBranchForIssue(issueId: string, verbose?: boolean): Promise<string>;

package/dist/services/repo-config.js

@@ -0,0 +1,50 @@
+/**
+ * Per-issue repo configuration helpers.
+ *
+ * Right now this just exposes the resolved default branch for a given issue,
+ * combining the GitHub API answer (most authoritative) with local-git and
+ * literal-`main` fallbacks. Phases that previously hardcoded `'main'` should
+ * call `getDefaultBranchForIssue(issueId)` instead so forks whose default
+ * branch is `master` / `develop` / `trunk` work correctly.
+ */
+import { getGitHubConfig } from '../api/github.js';
+import { getRepoForkInfo, resolveDefaultBranch, } from '../utils/github-repo-info.js';
+// Memoized resolutions keyed by issueId. A worker process handles one issue
+// per invocation, but a phase can call getDefaultBranchForIssue from several
+// places (entry, prompt builders, helper functions) — caching avoids
+// re-hitting the GitHub API for each one.
+const defaultBranchCache = new Map();
+/**
+ * Resolve the default branch for the repository attached to this issue.
+ * Order of precedence: GitHub API `default_branch` → local symbolic-ref → 'main'.
+ *
+ * Cached per `issueId` for the lifetime of the process. Never throws; on any
+ * error it falls back to local resolution.
+ */
+export async function getDefaultBranchForIssue(issueId, verbose) {
+    const cached = defaultBranchCache.get(issueId);
+    if (cached) {
+        return cached;
+    }
+    const promise = resolveOnce(issueId, verbose).catch((error) => {
+        // If the lookup itself blows up unexpectedly, drop the cached failure so
+        // a later call can retry; then fall back locally.
+        defaultBranchCache.delete(issueId);
+        throw error;
+    });
+    defaultBranchCache.set(issueId, promise);
+    return promise;
+}
+async function resolveOnce(issueId, verbose) {
+    try {
+        const config = await getGitHubConfig(issueId, verbose);
+        if (config.token && config.owner && config.repo) {
+            const info = await getRepoForkInfo(config.token, config.owner, config.repo);
+            return resolveDefaultBranch(info.defaultBranch);
+        }
+    }
+    catch {
+        // Fall through to local resolution
+    }
+    return resolveDefaultBranch();
+}

package/dist/utils/git-branch-manager-async.js

@@ -7,10 +7,11 @@ import { Octokit } from '@octokit/rest';
 import { execFileSync, execSync } from 'child_process';
 import { abortRebase, branchExists, getCurrentBranch, hasConflicts, hasUncommittedChanges, isRebaseInProgress, pullLatestFromBranch, resetUncommittedChanges, returnToMainBranch, switchToBranch, } from './git-branch-manager.js';
 import { buildCredentialArgs, gitForcePush } from './git-push.js';
+import { resolveDefaultBranch } from './github-repo-info.js';
 import { logError, logInfo } from './logger.js';
 // eslint-disable-next-line complexity -- git sync with fetch, merge/rebase, and conflict handling
 export async function syncFeatBranchWithMain(opts) {
-    const { featBranch, githubToken, owner, repo, baseBranch = 'main', verbose, } = opts;
+    const { featBranch, githubToken, owner, repo, baseBranch = resolveDefaultBranch(), verbose, } = opts;
     try {
         const octokit = new Octokit({ auth: githubToken });
         // Check if feat branch exists
@@ -108,7 +109,7 @@ export async function syncFeatBranchWithMain(opts) {
  */
 // eslint-disable-next-line complexity -- async git branch management with rebase, conflict resolution, and recovery
 export async function switchToIssueBranchAndRebaseAsync(options) {
-    const { issueBranch, baseBranch = 'main', rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, baseBranchCompleted = false, githubToken, } = options;
+    const { issueBranch, baseBranch = resolveDefaultBranch(), rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, baseBranchCompleted = false, githubToken, } = options;
     // Determine the actual target branch for rebase
     // If rebaseTargetBranch is set (e.g., main), use it; otherwise use baseBranch
     const actualRebaseTarget = rebaseTargetBranch || baseBranch;
@@ -375,9 +376,12 @@ export async function switchToIssueBranchAndRebaseAsync(options) {
  */
 export async function prepareCustomBranchGitEnvironmentAsync(options) {
     const { verbose } = options;
-    // Create cleanup function BEFORE any operations that might fail
+    const resolvedDefault = resolveDefaultBranch();
+    // Create cleanup function BEFORE any operations that might fail.
+    // Always return to the repo's default branch (main, master, …), not the
+    // baseBranch — baseBranch may be an intermediate branch in a chained PR.
     const cleanup = () => {
-        returnToMainBranch('main', verbose);
+        returnToMainBranch(resolvedDefault, verbose);
     };
     try {
         const result = await switchToIssueBranchAndRebaseAsync(options);
@@ -409,7 +413,7 @@ export async function prepareCustomBranchGitEnvironmentAsync(options) {
  * @param conflictResolverConfig - Configuration for the conflict resolver
  * @returns Cleanup function and conflict resolution info
  */
-export async function preparePhaseGitEnvironmentAsync(issueId, baseBranch = 'main', verbose, resolveConflicts, conflictResolverConfig) {
+export async function preparePhaseGitEnvironmentAsync(issueId, baseBranch, verbose, resolveConflicts, conflictResolverConfig) {
     const issueBranch = `dev/${issueId}`;
     return prepareCustomBranchGitEnvironmentAsync({
         issueBranch,

package/dist/utils/git-branch-manager.js

@@ -6,6 +6,7 @@ import { execFileSync, execSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { buildCredentialArgs } from './git-push.js';
+import { resolveDefaultBranch } from './github-repo-info.js';
 import { logError, logInfo } from './logger.js';
 /**
  * Get current Git branch name
@@ -359,7 +360,9 @@ export function pullLatestFromBranch(branch, verbose, githubToken) {
  * @returns Object containing the previous branch name
  */
 // eslint-disable-next-line complexity -- git branch management with rebase, conflict handling, and fallback strategies
-export function switchToIssueBranchAndRebase(issueBranch, baseBranch = 'main', verbose, githubToken) {
+export function switchToIssueBranchAndRebase(issueBranch, baseBranch, verbose, githubToken) {
+    // eslint-disable-next-line no-param-reassign -- assigning default to optional param
+    baseBranch ??= resolveDefaultBranch();
     const previousBranch = getCurrentBranch();
     if (verbose) {
         logInfo(`\n🔄 Preparing issue branch: ${issueBranch}`);
@@ -502,7 +505,9 @@ export function switchToIssueBranchAndRebase(issueBranch, baseBranch = 'main', v
  * Return to main branch after phase completion
  * This should be called at the END of each phase
  */
-export function returnToMainBranch(baseBranch = 'main', verbose) {
+export function returnToMainBranch(baseBranch, verbose) {
+    // eslint-disable-next-line no-param-reassign -- assigning default to optional param
+    baseBranch ??= resolveDefaultBranch();
     const currentBranch = getCurrentBranch();
     if (currentBranch === baseBranch) {
         if (verbose) {
@@ -551,7 +556,7 @@ export function returnToMainBranch(baseBranch = 'main', verbose) {
  * @param verbose - Whether to log verbose output
  * @returns Cleanup function that will return to main branch
  */
-export function preparePhaseGitEnvironment(issueId, baseBranch = 'main', verbose) {
+export function preparePhaseGitEnvironment(issueId, baseBranch, verbose) {
     const issueBranch = `dev/${issueId}`;
     return prepareCustomBranchGitEnvironment(issueBranch, baseBranch, verbose);
 }
@@ -572,15 +577,20 @@ export function preparePhaseGitEnvironment(issueId, baseBranch = 'main', verbose
  * @param verbose - Whether to log verbose output
  * @returns Cleanup function that will return to main branch
  */
-export function prepareCustomBranchGitEnvironment(issueBranch, baseBranch = 'main', verbose) {
+export function prepareCustomBranchGitEnvironment(issueBranch, baseBranch, verbose) {
+    // Resolve once so cleanup and rebase agree on the same target branch.
+    const resolvedDefault = resolveDefaultBranch();
+    const resolvedBase = baseBranch ?? resolvedDefault;
     // Create cleanup function BEFORE any operations that might fail
-    // This ensures cleanup can be called even if switchToIssueBranchAndRebase throws
+    // This ensures cleanup can be called even if switchToIssueBranchAndRebase throws.
+    // We always return to the repo's default branch (e.g. main, master), not
+    // baseBranch — baseBranch may be an intermediate branch in a chained PR.
     const cleanup = () => {
-        returnToMainBranch('main', verbose); // Always return to main, not the baseBranch
+        returnToMainBranch(resolvedDefault, verbose);
     };
     try {
         // Switch to issue branch and rebase with base branch
-        switchToIssueBranchAndRebase(issueBranch, baseBranch, verbose);
+        switchToIssueBranchAndRebase(issueBranch, resolvedBase, verbose);
     }
     catch (error) {
         // If setup fails, try to cleanup before re-throwing

package/dist/utils/github-repo-info.d.ts

@@ -7,8 +7,20 @@ export interface RepoForkInfo {
         owner: string;
         repo: string;
     };
+    defaultBranch?: string;
 }
 /**
- * Detect if a repository is a fork and get upstream info
+ * Detect if a repository is a fork and get upstream + default branch info
  */
 export declare function getRepoForkInfo(token: string, owner: string, repo: string): Promise<RepoForkInfo>;
+/**
+ * Resolve the repo's default branch with a multi-tier fallback:
+ *   1. `apiValue` from GitHub API (most authoritative)
+ *   2. local `git symbolic-ref refs/remotes/origin/HEAD`
+ *   3. literal `'main'`
+ *
+ * Use this anywhere we need to diff/merge against the upstream default branch.
+ * The hardcoded `origin/main` assumption breaks for repos whose default is
+ * `master`, `develop`, etc., or for forks that inherited a non-`main` default.
+ */
+export declare function resolveDefaultBranch(apiValue?: string): string;

package/dist/utils/github-repo-info.js

@@ -2,18 +2,44 @@
  * GitHub repository information utilities
  */
 import { Octokit } from '@octokit/rest';
+import { execFileSync } from 'child_process';
 /**
- * Detect if a repository is a fork and get upstream info
+ * Detect if a repository is a fork and get upstream + default branch info
  */
 export async function getRepoForkInfo(token, owner, repo) {
     const octokit = new Octokit({ auth: token });
     const { data } = await octokit.repos.get({ owner, repo });
+    const result = {
+        isFork: false,
+        defaultBranch: data.default_branch,
+    };
     if (data.fork && data.parent) {
         const [upstreamOwner, upstreamRepo] = data.parent.full_name.split('/');
-        return {
-            isFork: true,
-            upstream: { owner: upstreamOwner, repo: upstreamRepo },
-        };
+        result.isFork = true;
+        result.upstream = { owner: upstreamOwner, repo: upstreamRepo };
+    }
+    return result;
+}
+/**
+ * Resolve the repo's default branch with a multi-tier fallback:
+ *   1. `apiValue` from GitHub API (most authoritative)
+ *   2. local `git symbolic-ref refs/remotes/origin/HEAD`
+ *   3. literal `'main'`
+ *
+ * Use this anywhere we need to diff/merge against the upstream default branch.
+ * The hardcoded `origin/main` assumption breaks for repos whose default is
+ * `master`, `develop`, etc., or for forks that inherited a non-`main` default.
+ */
+export function resolveDefaultBranch(apiValue) {
+    if (apiValue) {
+        return apiValue;
+    }
+    try {
+        const ref = execFileSync('git', ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const stripped = ref.replace(/^origin\//, '');
+        return stripped || 'main';
+    }
+    catch {
+        return 'main';
     }
-    return { isFork: false };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.52.0",
+  "version": "0.54.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"