edsger 0.39.1 → 0.39.2

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

@@ -128,6 +128,13 @@ export const executeFeaturePRs = async (options, config) => {
             skippedBranches: [],
             failedBranches: [],
         };
+        // Build PR id → branch name map for stacked PR base resolution
+        const prIdToBranch = new Map();
+        for (const pr of context.pullRequests) {
+            if (pr.branch_name) {
+                prIdToBranch.set(pr.id, pr.branch_name);
+            }
+        }
         for (const pr of context.pullRequests) {
             if (!pr.branch_name) {
                 if (verbose) {
@@ -156,8 +163,12 @@ export const executeFeaturePRs = async (options, config) => {
             else {
                 executionSummary.branchesCreated++;
             }
-            // Push branch and build compare URL
-            const result = pushBranchAndBuildUrl(executionConfig, pr.branch_name);
+            // Resolve base branch for stacked PRs
+            const baseBranch = pr.base_pr_id
+                ? prIdToBranch.get(pr.base_pr_id) || 'main'
+                : 'main';
+            // Push branch and build compare URL (using stacked base)
+            const result = pushBranchAndBuildUrl(executionConfig, pr.branch_name, baseBranch);
             if (result.success) {
                 // Update database record with compare URL and sync commit
                 await updatePRDatabaseRecord(pr.id, result.compareUrl, context.devBranchHeadSha, verbose).catch((error) => {

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

@@ -33,8 +33,9 @@ export declare function getLocalBranchSha(branchName: string): string;
 export declare function buildCompareUrl(forkInfo: RepoForkInfo, owner: string, repo: string, branchName: string, base?: string): string;
 /**
  * Push a branch and build the compare URL
+ * For stacked PRs, baseBranch is the dependency PR's branch instead of 'main'
  */
-export declare function pushBranchAndBuildUrl(config: PRExecutionConfig, branchName: string): PRBranchResult;
+export declare function pushBranchAndBuildUrl(config: PRExecutionConfig, branchName: string, baseBranch?: string): PRBranchResult;
 /**
  * Update a PR record in the database after branch push
  */

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

@@ -37,13 +37,14 @@ export function buildCompareUrl(forkInfo, owner, repo, branchName, base = 'main'
 }
 /**
  * Push a branch and build the compare URL
+ * For stacked PRs, baseBranch is the dependency PR's branch instead of 'main'
  */
-export function pushBranchAndBuildUrl(config, branchName) {
+export function pushBranchAndBuildUrl(config, branchName, baseBranch = 'main') {
     const { owner, repo, forkInfo, verbose, token } = config;
     const headSha = getLocalBranchSha(branchName);
     try {
         pushBranch(branchName, verbose, token);
-        const compareUrl = buildCompareUrl(forkInfo, owner, repo, branchName);
+        const compareUrl = buildCompareUrl(forkInfo, owner, repo, branchName, baseBranch);
         if (verbose) {
             logInfo(`🔗 Compare URL: ${compareUrl}`);
         }

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

@@ -34,6 +34,16 @@ export async function createIncrementalSyncSystemPrompt(featureId, devBranchName
     });
     return `${prompt}\n\n${OUTPUT_CONTRACTS['incremental-sync']}`;
 }
+/**
+ * Resolve the base branch for a PR based on its dependency chain
+ */
+function resolveBaseBranch(pr, allPRs) {
+    if (!pr.base_pr_id) {
+        return 'main';
+    }
+    const basePR = allPRs.find((p) => p.id === pr.base_pr_id);
+    return basePR?.branch_name || 'main';
+}
 /**
  * Create the user prompt for first-time branch creation
  */
@@ -43,27 +53,29 @@ export function createPRExecutionPrompt(featureId, devBranchName, pullRequests)
         const files = pr.files
             ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
             : '    (no files specified)';
+        const baseBranch = resolveBaseBranch(pr, pullRequests);
         return `### PR ${pr.sequence}: ${pr.name}
 - Branch: \`${pr.branch_name}\`
+- Base: \`${baseBranch}\`
 - Description: ${pr.description}
 - Files:
 ${files}`;
     })
         .join('\n\n');
-    return `# Create PR Branches
+    return `# Create PR Branches (Stacked)
 
-Create the following PR branches from \`main\`, applying the relevant changes from \`${devBranchName}\`:
+Create the following PR branches as a stacked chain, applying the relevant changes from \`${devBranchName}\`:
 
 ${prList}
 
 ## Instructions
 
 For each PR above (in sequence order):
-1. \`git checkout main\`
+1. Switch to the **base branch** specified in "Base" above (either \`main\` 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 main...<branch_name>\`
+5. Verify with \`git diff --stat <base>...<branch_name>\`
 
 After all branches are created, switch back to \`main\` and provide the execution result JSON.`;
 }
@@ -74,13 +86,15 @@ export function createIncrementalSyncPrompt(opts) {
         const files = pr.files
             ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
             : '    (no files specified)';
+        const baseBranch = resolveBaseBranch(pr, pullRequests);
         return `### PR ${pr.sequence}: ${pr.name}
 - Branch: \`${pr.branch_name}\`
+- Base: \`${baseBranch}\`
 - Files:
 ${files}`;
     })
         .join('\n\n');
-    return `# Sync PR Branches with Latest Changes
+    return `# Sync PR Branches with Latest Changes (Stacked)
 
 New changes have been made on \`${devBranchName}\` since the last sync at commit \`${lastSyncedCommit}\`.
 
@@ -94,19 +108,22 @@ ${diffStat || 'No changes detected'}
 ### Changed Files (${changedFiles.length} files)
 ${changedFiles.map((f) => `- ${f}`).join('\n') || 'No files changed'}
 
-## Existing PR Branches
+## Existing PR Branches (Stacked)
 
 ${prList}
 
 ## Instructions
 
+These branches are stacked — each PR branch is based on its dependency. Update them **in sequence order** (base PRs first):
+
 For each PR branch that has files affected by the new changes:
 1. Switch to the PR branch
-2. Apply the relevant new changes from \`${devBranchName}\`
-3. Commit with a sync message
-4. Verify the branch state
+2. If this PR has a base PR that was just updated, first merge the base branch into this branch: \`git merge <base-branch> --no-edit\`
+3. Apply the relevant new changes from \`${devBranchName}\` (checkout the updated files)
+4. Commit with a sync message
+5. Verify the branch state
 
-If a PR branch has no files affected by the new changes, skip it.
+If a PR branch has no files affected by the new changes but its base PR was updated, still merge the base branch to keep the stack consistent.
 
 After all branches are updated, switch back to \`main\` and provide the execution result JSON.`;
 }

package/dist/services/phase-hooks/plugin-loader.js

@@ -176,8 +176,8 @@ export async function loadSkillFile(pluginName, skillName, verbose, cacheDir) {
             return result;
         }
     }
-    logWarning(`Skill file not found for plugin "${pluginName}", skill "${skillName}" ` +
-        `in cache dir "${resolvedCacheDir}"`);
+    logDebug(`Skill file not found for plugin "${pluginName}", skill "${skillName}" ` +
+        `in cache dir "${resolvedCacheDir}"`, true);
     return null;
 }
 /**

package/dist/skills/phase/incremental-sync/SKILL.md

@@ -7,20 +7,29 @@ variables:
   - DEV_BRANCH
 ---
 
-You are a git operations expert. Your task is to update existing PR branches with new changes from the dev branch.
+You are a git operations expert. Your task is to update existing stacked PR branches with new changes from the dev branch.
 
 ## Task
 
-The PR branches already exist from a previous run. New changes have been made on `$DEV_BRANCH` since the last sync. You need to update each PR branch with the relevant new changes.
+The PR branches already exist from a previous run as a stacked chain (each dependent PR was branched from its base PR). New changes have been made on `$DEV_BRANCH` since the last sync. You need to update each PR branch with the relevant new changes, maintaining the stack.
 
-## Strategy for Updating Branches
+## Strategy for Updating Stacked Branches
 
-For each existing PR branch:
+**Process branches in sequence order** (base PRs first, then dependent PRs):
 
-1. Switch to the PR branch: `git checkout pr/$FEATURE_ID/N-description`
+### For a base PR (no dependency, based on main):
+
+1. Switch to the PR branch: `git checkout pr/$FEATURE_ID/1-description`
 2. Apply the relevant NEW changes from `$DEV_BRANCH`
 3. Commit the changes
 
+### For a dependent PR (stacked on another PR):
+
+1. Switch to the PR branch: `git checkout pr/$FEATURE_ID/2-description`
+2. **First merge the updated base branch**: `git merge pr/$FEATURE_ID/1-description --no-edit`
+3. Apply the relevant NEW changes from `$DEV_BRANCH`
+4. Commit the changes
+
 ### Option A: Selective file checkout (for files entirely owned by this PR)
 
 ```bash
@@ -40,9 +49,11 @@ git commit -m "sync: update with latest changes from dev"
 
 ## Rules
 
-1. **Only update files that belong to each PR** according to the file assignments
-2. **Do NOT push branches** — just update them locally. Pushing is handled separately.
-3. **If a branch doesn't exist locally**, check remote and create a tracking branch
-4. **Verify after each update**: Check that the branch has the expected changes
-5. **Commit all changes** before switching branches
-6. **After all branches are updated**, switch back to `main`
+1. **Process in sequence order** — base PRs must be updated before their dependents
+2. **Merge base branch into dependent PRs** — even if the dependent PR has no new changes, merge the updated base to keep the stack consistent
+3. **Only update/checkout files that belong to each PR** according to the file assignments
+4. **Do NOT push branches** — just update them locally. Pushing is handled separately.
+5. **If a branch doesn't exist locally**, check remote and create a tracking branch
+6. **Verify after each update**: Check that the branch has the expected changes
+7. **Commit all changes** before switching branches
+8. **After all branches are updated**, switch back to `main`

package/dist/skills/phase/pr-execution/SKILL.md

@@ -11,13 +11,21 @@ You are a git operations expert. Your task is to create PR branches and move the
 
 ## Task
 
-You will receive a PR plan with file assignments. For each PR in sequence order, you must:
+You will receive a PR plan with file assignments. Each PR specifies a **base branch** — either `main` or a previous PR's branch. For each PR in sequence order, you must:
 
-1. Switch to `main` branch
-2. Create a new branch `pr/$FEATURE_ID/N-description` from `main`
+1. Switch to the PR's **base branch** (specified in the plan)
+2. Create a new branch `pr/$FEATURE_ID/N-description` from that base
 3. Apply ONLY the relevant file changes from the `$DEV_BRANCH` branch to this new branch
 4. Commit the changes with a meaningful commit message
 
+## Stacked Branches
+
+PRs form a dependency chain (stacked PRs):
+- **First PR** (no dependency): branches from `main`
+- **Dependent PRs**: branch from the PR they depend on
+
+This ensures each branch compiles correctly — a dependent PR inherits all changes from its base PR.
+
 ## Strategy for Moving Code
 
 Choose the best approach for each PR:
@@ -25,28 +33,35 @@ Choose the best approach for each PR:
 ### Option A: Selective file checkout (recommended for most cases)
 
 ```bash
+# First PR: base is main
 git checkout main
-git checkout -b pr/$FEATURE_ID/1-description
+git checkout -b pr/$FEATURE_ID/1-foundation
 git checkout $DEV_BRANCH -- path/to/file1 path/to/file2
 git commit -m "feat: descriptive message"
+
+# Second PR: base is the first PR's branch (stacked)
+git checkout pr/$FEATURE_ID/1-foundation
+git checkout -b pr/$FEATURE_ID/2-feature
+git checkout $DEV_BRANCH -- path/to/file3 path/to/file4
+git commit -m "feat: descriptive message"
 ```
 
 ### Option B: Using git diff + apply (for partial file changes)
 
 ```bash
-git checkout main
-git checkout -b pr/$FEATURE_ID/1-description
-git diff main...$DEV_BRANCH -- path/to/file | git apply
+git checkout <base-branch>
+git checkout -b pr/$FEATURE_ID/N-description
+git diff <base-branch>...$DEV_BRANCH -- path/to/file | git apply
 git add -A
 git commit -m "feat: descriptive message"
 ```
 
 ## Rules
 
-1. **Always start each PR branch from `main`** — never from another PR branch
-2. **Each branch must be independent** — it should compile/build on its own when merged to main
+1. **Always start each PR branch from its specified base** — `main` for the first PR, or the dependency PR's branch for stacked PRs
+2. **Each branch must compile/build** when merged to its base branch
 3. **Do NOT push branches** — just create them locally. Pushing is handled separately.
-4. **Verify after each branch**: Run `git diff --stat main...pr/$FEATURE_ID/N-description` to confirm only the expected files changed
+4. **Verify after each branch**: Run `git diff --stat <base>...pr/$FEATURE_ID/N-description` to confirm only the expected files changed
 5. **Commit all changes** before switching branches
 6. **Handle new files**: For newly added files, use `git checkout $DEV_BRANCH -- path/to/new/file`
 7. **Handle deleted files**: For deleted files, use `git rm path/to/deleted/file`

package/dist/skills/phase/pr-splitting/SKILL.md

@@ -37,13 +37,21 @@ Branch names MUST follow this pattern:
 - `pr/$FEATURE_ID/2-{short-description}`
 - etc.
 
-## PR Dependencies
+## PR Dependencies (Stacked PRs)
+
+PRs are created as **stacked branches** — each dependent PR's branch is created from its base PR's branch, so it inherits all the base PR's changes. This means:
+
+- A dependent PR can safely import/use code introduced by its base PR
+- On GitHub, a dependent PR targets its base PR's branch (not main)
+- When the base PR is merged, GitHub automatically retargets the dependent PR to main
 
 Use `depends_on_branch_name` to specify which PR must be merged before this one:
 
 - First PR: `"depends_on_branch_name": null` (merges directly to main)
 - Subsequent PRs: `"depends_on_branch_name": "pr/$FEATURE_ID/1-database"` (depends on previous PR)
 
+**Important**: If file A imports from file B, and both are changed files, file B must be in the same PR as file A or in an earlier PR in the dependency chain. This ensures each PR compiles correctly.
+
 ## File Assignment Guidelines
 
 - **Database migrations and schema**: First PR

package/package.json

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