edsger 0.39.3 → 0.40.0

package/dist/phases/pr-execution/__tests__/file-assigner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/phases/pr-execution/__tests__/file-assigner.test.js

@@ -0,0 +1,294 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { applyAssignments, findUnassignedFiles, removeDeletedFilesFromPRs, } from '../file-assigner.js';
+function makePR(overrides) {
+    return {
+        feature_id: 'feat-1',
+        name: `PR ${overrides.sequence}`,
+        description: null,
+        branch_name: null,
+        base_pr_id: null,
+        pull_request_url: null,
+        pull_request_number: null,
+        compare_url: null,
+        status: 'pending',
+        last_synced_commit: null,
+        files: null,
+        created_by: 'user',
+        created_at: '2026-01-01',
+        updated_at: '2026-01-01',
+        ...overrides,
+    };
+}
+function cf(path, change_type = 'modified') {
+    return { path, change_type };
+}
+// ============================================================
+// findUnassignedFiles
+// ============================================================
+void describe('findUnassignedFiles', () => {
+    void it('returns all files when no PR has files', () => {
+        const prs = [makePR({ id: '1', sequence: 1, files: null })];
+        const result = findUnassignedFiles([cf('a.ts'), cf('b.ts')], prs);
+        assert.deepStrictEqual(result, [cf('a.ts'), cf('b.ts')]);
+    });
+    void it('returns empty when all files are assigned', () => {
+        const prs = [
+            makePR({
+                id: '1',
+                sequence: 1,
+                files: [
+                    { path: 'a.ts', change_type: 'modified' },
+                    { path: 'b.ts', change_type: 'added' },
+                ],
+            }),
+        ];
+        const result = findUnassignedFiles([cf('a.ts'), cf('b.ts', 'added')], prs);
+        assert.deepStrictEqual(result, []);
+    });
+    void it('returns only unassigned files', () => {
+        const prs = [
+            makePR({
+                id: '1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+            makePR({
+                id: '2',
+                sequence: 2,
+                files: [{ path: 'b.ts', change_type: 'added' }],
+            }),
+        ];
+        const result = findUnassignedFiles([cf('a.ts'), cf('b.ts'), cf('c.ts'), cf('d.ts', 'added')], prs);
+        assert.deepStrictEqual(result, [cf('c.ts'), cf('d.ts', 'added')]);
+    });
+    void it('handles PRs with empty files array', () => {
+        const prs = [
+            makePR({ id: '1', sequence: 1, files: [] }),
+            makePR({
+                id: '2',
+                sequence: 2,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        const result = findUnassignedFiles([cf('a.ts'), cf('b.ts')], prs);
+        assert.deepStrictEqual(result, [cf('b.ts')]);
+    });
+    void it('returns empty for empty changed files', () => {
+        const prs = [
+            makePR({
+                id: '1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        const result = findUnassignedFiles([], prs);
+        assert.deepStrictEqual(result, []);
+    });
+    void it('handles files spread across multiple PRs', () => {
+        const prs = [
+            makePR({
+                id: '1',
+                sequence: 1,
+                files: [
+                    { path: 'src/auth/login.ts', change_type: 'modified' },
+                    { path: 'src/auth/session.ts', change_type: 'modified' },
+                ],
+            }),
+            makePR({
+                id: '2',
+                sequence: 2,
+                files: [
+                    { path: 'src/api/users.ts', change_type: 'added' },
+                    { path: 'src/api/roles.ts', change_type: 'added' },
+                ],
+            }),
+        ];
+        const changedFiles = [
+            cf('src/auth/login.ts'),
+            cf('src/auth/session.ts'),
+            cf('src/api/users.ts'),
+            cf('src/api/roles.ts'),
+            cf('src/auth/oauth.ts', 'added'),
+            cf('README.md'),
+        ];
+        const result = findUnassignedFiles(changedFiles, prs);
+        assert.deepStrictEqual(result, [
+            cf('src/auth/oauth.ts', 'added'),
+            cf('README.md'),
+        ]);
+    });
+});
+// ============================================================
+// applyAssignments
+// ============================================================
+void describe('applyAssignments', () => {
+    void it('merges new files into existing PR files', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        const unassigned = [cf('b.ts', 'added')];
+        const updates = [];
+        const mockUpdater = async (prId, u) => {
+            updates.push({ prId, files: u.files });
+        };
+        const count = await applyAssignments([{ file: 'b.ts', pr_id: 'pr-1' }], unassigned, prs, mockUpdater);
+        assert.strictEqual(count, 1);
+        assert.strictEqual(updates.length, 1);
+        assert.strictEqual(updates[0].prId, 'pr-1');
+        assert.deepStrictEqual(updates[0].files, [
+            { path: 'a.ts', change_type: 'modified' },
+            { path: 'b.ts', change_type: 'added' },
+        ]);
+    });
+    void it('deduplicates files already in PR', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        const unassigned = [cf('a.ts')];
+        const updates = [];
+        const mockUpdater = async (_prId, u) => {
+            updates.push({ files: u.files });
+        };
+        await applyAssignments([{ file: 'a.ts', pr_id: 'pr-1' }], unassigned, prs, mockUpdater);
+        // File list should not have duplicates
+        assert.deepStrictEqual(updates[0].files, [
+            { path: 'a.ts', change_type: 'modified' },
+        ]);
+    });
+    void it('skips unknown PR ids', async () => {
+        const prs = [makePR({ id: 'pr-1', sequence: 1, files: [] })];
+        const unassigned = [cf('x.ts', 'added')];
+        let called = false;
+        const mockUpdater = async () => {
+            called = true;
+        };
+        const count = await applyAssignments([{ file: 'x.ts', pr_id: 'unknown-id' }], unassigned, prs, mockUpdater);
+        assert.strictEqual(count, 0);
+        assert.strictEqual(called, false);
+    });
+    void it('uses change_type from git, not a hardcoded default', async () => {
+        const prs = [makePR({ id: 'pr-1', sequence: 1, files: [] })];
+        const unassigned = [cf('new.ts', 'added')];
+        const updates = [];
+        const mockUpdater = async (_prId, u) => {
+            updates.push({ files: u.files });
+        };
+        await applyAssignments([{ file: 'new.ts', pr_id: 'pr-1' }], unassigned, prs, mockUpdater);
+        assert.strictEqual(updates[0].files[0].change_type, 'added');
+    });
+    void it('distributes files to multiple PRs', async () => {
+        const prs = [
+            makePR({ id: 'pr-1', sequence: 1, files: [] }),
+            makePR({ id: 'pr-2', sequence: 2, files: [] }),
+        ];
+        const unassigned = [
+            cf('a.ts', 'added'),
+            cf('b.ts', 'modified'),
+        ];
+        const updates = [];
+        const mockUpdater = async (prId) => {
+            updates.push({ prId });
+        };
+        const count = await applyAssignments([
+            { file: 'a.ts', pr_id: 'pr-1' },
+            { file: 'b.ts', pr_id: 'pr-2' },
+        ], unassigned, prs, mockUpdater);
+        assert.strictEqual(count, 2);
+        assert.deepStrictEqual(updates.map((u) => u.prId), ['pr-1', 'pr-2']);
+    });
+    void it('handles updater failure gracefully', async () => {
+        const prs = [makePR({ id: 'pr-1', sequence: 1, files: [] })];
+        const unassigned = [cf('a.ts')];
+        const mockUpdater = async () => {
+            throw new Error('DB error');
+        };
+        const count = await applyAssignments([{ file: 'a.ts', pr_id: 'pr-1' }], unassigned, prs, mockUpdater);
+        assert.strictEqual(count, 0);
+    });
+});
+// ============================================================
+// removeDeletedFilesFromPRs
+// ============================================================
+void describe('removeDeletedFilesFromPRs', () => {
+    void it('removes deleted files from PR file lists', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [
+                    { path: 'keep.ts', change_type: 'modified' },
+                    { path: 'gone.ts', change_type: 'added' },
+                ],
+            }),
+        ];
+        const changedFiles = [
+            cf('keep.ts'),
+            cf('gone.ts', 'deleted'),
+        ];
+        const updates = [];
+        const mockUpdater = async (prId, u) => {
+            updates.push({ prId, files: u.files });
+        };
+        const count = await removeDeletedFilesFromPRs(changedFiles, prs, mockUpdater);
+        assert.strictEqual(count, 1);
+        assert.deepStrictEqual(updates[0].files, [
+            { path: 'keep.ts', change_type: 'modified' },
+        ]);
+    });
+    void it('returns 0 when no files are deleted', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+        ];
+        let called = false;
+        const mockUpdater = async () => {
+            called = true;
+        };
+        const count = await removeDeletedFilesFromPRs([cf('a.ts')], prs, mockUpdater);
+        assert.strictEqual(count, 0);
+        assert.strictEqual(called, false);
+    });
+    void it('skips PRs with no matching deleted files', async () => {
+        const prs = [
+            makePR({
+                id: 'pr-1',
+                sequence: 1,
+                files: [{ path: 'a.ts', change_type: 'modified' }],
+            }),
+            makePR({
+                id: 'pr-2',
+                sequence: 2,
+                files: [{ path: 'b.ts', change_type: 'added' }],
+            }),
+        ];
+        const updates = [];
+        const mockUpdater = async (prId) => {
+            updates.push(prId);
+        };
+        await removeDeletedFilesFromPRs([cf('b.ts', 'deleted')], prs, mockUpdater);
+        // Only pr-2 should be updated
+        assert.deepStrictEqual(updates, ['pr-2']);
+    });
+    void it('handles PRs with null files', async () => {
+        const prs = [makePR({ id: 'pr-1', sequence: 1, files: null })];
+        let called = false;
+        const mockUpdater = async () => {
+            called = true;
+        };
+        const count = await removeDeletedFilesFromPRs([cf('a.ts', 'deleted')], prs, mockUpdater);
+        assert.strictEqual(count, 0);
+        assert.strictEqual(called, false);
+    });
+});

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

@@ -8,6 +8,10 @@ export interface GitHubConfigInfo {
     repo?: string;
     message?: string;
 }
+export interface ChangedFileInfo {
+    path: string;
+    change_type: 'added' | 'modified' | 'deleted' | 'renamed';
+}
 export interface PRExecutionContext {
     feature: FeatureInfo;
     pullRequests: PullRequest[];
@@ -18,7 +22,7 @@ export interface PRExecutionContext {
     isIncrementalSync: boolean;
     lastSyncedCommit: string | null;
     diffStat: string;
-    changedFiles: string[];
+    changedFiles: ChangedFileInfo[];
 }
 /**
  * Fetch context for PR execution phase

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

@@ -32,22 +32,61 @@ function getDiffStat(baseRef, headRef) {
     }
 }
 /**
- * Get list of changed files between two refs
+ * Map git diff --name-status letter to a readable change type
+ */
+function parseGitStatus(status) {
+    switch (status[0]) {
+        case 'A':
+            return 'added';
+        case 'D':
+            return 'deleted';
+        case 'R':
+            return 'renamed';
+        default:
+            return 'modified';
+    }
+}
+/**
+ * Get list of changed files with their change types between two refs
  */
 function getChangedFiles(baseRef, headRef) {
     try {
-        const output = execSync(`git diff --name-only ${baseRef}...${headRef}`, {
+        const output = execSync(`git diff --name-status ${baseRef}...${headRef}`, {
             encoding: 'utf-8',
         }).trim();
         if (!output) {
             return [];
         }
-        return output.split('\n').filter((f) => f.length > 0);
+        return output
+            .split('\n')
+            .filter((line) => line.length > 0)
+            .map((line) => {
+            const [status, ...pathParts] = line.split('\t');
+            // For renames (R100\told\tnew), use the new path
+            const path = pathParts.length > 1 ? pathParts[1] : pathParts[0];
+            return { path, change_type: parseGitStatus(status) };
+        });
     }
     catch {
         return [];
     }
 }
+/**
+ * Check if a commit exists in the ancestry of a given ref.
+ * Returns false if the commit was orphaned (e.g. after a rebase).
+ */
+function isAncestor(commitSha, ref) {
+    try {
+        execSync(`git merge-base --is-ancestor ${commitSha} ${ref}`, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Determine the common last_synced_commit from existing PRs
  * Returns null if any PR hasn't been synced yet (first run)
@@ -82,6 +121,27 @@ export async function fetchPRExecutionContext(featureId, verbose) {
             getPullRequests({ featureId, verbose }),
             getGitHubConfig(featureId, verbose),
         ]);
+        // Fetch latest remote refs and fast-forward local main
+        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', {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            if (verbose) {
+                logInfo('✅ Local main synced with origin/main');
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logInfo(`⚠️  Could not sync main with origin: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
         // Verify dev branch exists
         const localExists = branchExists(devBranchName);
         const remoteExists = !localExists && remoteBranchExists(devBranchName, githubConfig.token);
@@ -95,10 +155,12 @@ export async function fetchPRExecutionContext(featureId, verbose) {
                 logInfo(`Fetching remote branch ${devBranchName}...`);
             }
             const credArgs = buildCredentialArgs(githubConfig.token);
-            execFileSync('git', [...credArgs, 'fetch', 'origin', devBranchName], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
+            execFileSync('git', [
+                ...credArgs,
+                'fetch',
+                'origin',
+                `${devBranchName}:refs/remotes/origin/${devBranchName}`,
+            ], { encoding: 'utf-8', stdio: 'pipe' });
         }
         if (pullRequests.length === 0) {
             throw new Error('No PR plan found. Run the pr-splitting phase first to create a PR plan.');
@@ -126,8 +188,18 @@ export async function fetchPRExecutionContext(featureId, verbose) {
         // Determine sync mode
         const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
         const devBranchHeadSha = getBranchHeadSha(devRef);
-        const lastSyncedCommit = getLastSyncedCommit(pullRequests);
-        const isIncrementalSync = lastSyncedCommit !== null;
+        let lastSyncedCommit = getLastSyncedCommit(pullRequests);
+        let isIncrementalSync = lastSyncedCommit !== null;
+        // If the branch was rebased, lastSyncedCommit is no longer in the history.
+        // Treat this as a full re-execution so downstream logic uses the correct
+        // prompt and skips incremental file-assignment against an invalid base.
+        if (isIncrementalSync && !isAncestor(lastSyncedCommit, devRef)) {
+            if (verbose) {
+                logInfo(`⚠️  Last synced commit ${lastSyncedCommit} is no longer in branch history (likely rebased). Treating as full re-execution.`);
+            }
+            lastSyncedCommit = null;
+            isIncrementalSync = false;
+        }
         // Get diff info: for incremental, diff from last sync; for first run, diff from main
         const diffBase = isIncrementalSync ? lastSyncedCommit : 'main';
         const diffStat = getDiffStat(diffBase, devRef);

package/dist/phases/pr-execution/file-assigner.d.ts

@@ -0,0 +1,45 @@
+/**
+ * File assignment for incremental sync.
+ *
+ * When new changes on the dev branch include files not covered by any
+ * existing PR's file list, this module asks an LLM to assign them to
+ * the most appropriate PR, then updates the PR records in the database.
+ */
+import { type PullRequest } from '../../services/pull-requests.js';
+import type { ChangedFileInfo } from './context.js';
+export interface FileAssignment {
+    file: string;
+    pr_id: string;
+}
+export interface FileAssignmentResult {
+    assignments: FileAssignment[];
+}
+/**
+ * Find changed files that are not covered by any PR's file list.
+ */
+export declare function findUnassignedFiles(changedFiles: ChangedFileInfo[], pullRequests: PullRequest[]): ChangedFileInfo[];
+/**
+ * Update PR records in the database with newly assigned files.
+ * Exported for testing via dependency injection of the updater function.
+ */
+export declare function applyAssignments(assignments: FileAssignment[], unassignedFiles: ChangedFileInfo[], pullRequests: PullRequest[], updater?: (prId: string, updates: {
+    files: {
+        path: string;
+        change_type: string;
+    }[];
+}, verbose?: boolean) => Promise<unknown>, verbose?: boolean): Promise<number>;
+/**
+ * Remove files that were deleted on the dev branch from PR file lists.
+ * Returns the number of PRs updated.
+ */
+export declare function removeDeletedFilesFromPRs(changedFiles: ChangedFileInfo[], pullRequests: PullRequest[], updater?: (prId: string, updates: {
+    files: {
+        path: string;
+        change_type: string;
+    }[];
+}, verbose?: boolean) => Promise<unknown>, verbose?: boolean): Promise<number>;
+/**
+ * Detect unassigned files and use LLM to assign them to existing PRs.
+ * Returns the number of files assigned, or 0 if none needed assignment.
+ */
+export declare function assignNewFilesToPRs(changedFiles: ChangedFileInfo[], pullRequests: PullRequest[], verbose?: boolean): Promise<number>;

package/dist/phases/pr-execution/file-assigner.js

@@ -0,0 +1,244 @@
+/**
+ * File assignment for incremental sync.
+ *
+ * When new changes on the dev branch include files not covered by any
+ * existing PR's file list, this module asks an LLM to assign them to
+ * the most appropriate PR, then updates the PR records in the database.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { updatePullRequest, } from '../../services/pull-requests.js';
+import { extractJsonFromResponse } from '../../utils/json-extractor.js';
+import { logError, logInfo } from '../../utils/logger.js';
+/**
+ * Find changed files that are not covered by any PR's file list.
+ */
+export function findUnassignedFiles(changedFiles, pullRequests) {
+    const assignedPaths = new Set();
+    for (const pr of pullRequests) {
+        if (pr.files) {
+            for (const f of pr.files) {
+                assignedPaths.add(f.path);
+            }
+        }
+    }
+    return changedFiles.filter((f) => !assignedPaths.has(f.path));
+}
+/**
+ * Build a prompt asking the LLM to assign unassigned files to PRs.
+ */
+function buildAssignmentPrompt(unassignedFiles, pullRequests) {
+    const prList = pullRequests
+        .map((pr) => {
+        const files = pr.files
+            ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
+            : '    (no files)';
+        return `### PR ${pr.sequence}: ${pr.name} (id: ${pr.id})
+- Description: ${pr.description || 'No description'}
+- Files:
+${files}`;
+    })
+        .join('\n\n');
+    const fileList = unassignedFiles
+        .map((f) => `- ${f.path} (${f.change_type})`)
+        .join('\n');
+    return `# Assign New Files to Existing PRs
+
+The following files were changed on the dev branch but are not assigned to any existing PR.
+Assign each file to the most appropriate PR based on the PR's purpose and existing file list.
+
+## Unassigned Files (${unassignedFiles.length})
+${fileList}
+
+## Existing PRs
+${prList}
+
+## Instructions
+For each unassigned file, decide which PR it belongs to based on:
+1. Directory proximity (same package/module as existing PR files)
+2. Logical cohesion (related functionality)
+3. Dependency order (if file B imports from file A, they may belong together)
+
+Return ONLY a JSON object:
+
+\`\`\`json
+{
+  "assignments": [
+    {
+      "file": "path/to/file.ts",
+      "pr_id": "uuid-of-target-pr"
+    }
+  ]
+}
+\`\`\`
+
+Every file in the unassigned list MUST appear exactly once in the assignments array.
+Do NOT create new PRs — assign all files to existing PRs only.`;
+}
+/**
+ * Call LLM to assign files, returning structured assignments.
+ */
+async function callLLMForAssignment(prompt, verbose) {
+    let responseText = '';
+    function* userMessage() {
+        yield {
+            type: 'user',
+            message: { role: 'user', content: prompt },
+        };
+    }
+    for await (const message of query({
+        prompt: userMessage(),
+        options: {
+            model: DEFAULT_MODEL,
+            maxTurns: 1,
+            permissionMode: 'bypassPermissions',
+        },
+    })) {
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const item of message.message.content) {
+                if (item.type === 'text') {
+                    responseText += `${item.text}\n`;
+                }
+            }
+        }
+    }
+    const parsed = extractJsonFromResponse(responseText, '"assignments"');
+    if (!parsed || !Array.isArray(parsed.assignments)) {
+        if (verbose) {
+            logError('Failed to parse file assignment response from LLM');
+        }
+        return null;
+    }
+    return parsed;
+}
+/**
+ * Update PR records in the database with newly assigned files.
+ * Exported for testing via dependency injection of the updater function.
+ */
+export async function applyAssignments(assignments, unassignedFiles, pullRequests, updater = updatePullRequest, verbose) {
+    // Build a lookup from file path to its git change_type
+    const changeTypeByPath = new Map();
+    for (const f of unassignedFiles) {
+        changeTypeByPath.set(f.path, f.change_type);
+    }
+    // Group assignments by PR id
+    const byPR = new Map();
+    for (const a of assignments) {
+        const list = byPR.get(a.pr_id) || [];
+        list.push(a);
+        byPR.set(a.pr_id, list);
+    }
+    let updatedCount = 0;
+    for (const [prId, newFiles] of byPR) {
+        const pr = pullRequests.find((p) => p.id === prId);
+        if (!pr) {
+            if (verbose) {
+                logError(`Assignment references unknown PR id: ${prId}`);
+            }
+            continue;
+        }
+        const existingFiles = pr.files || [];
+        const existingPaths = new Set(existingFiles.map((f) => f.path));
+        const mergedFiles = [...existingFiles];
+        for (const nf of newFiles) {
+            if (!existingPaths.has(nf.file)) {
+                const changeType = changeTypeByPath.get(nf.file) || 'modified';
+                mergedFiles.push({ path: nf.file, change_type: changeType });
+            }
+        }
+        try {
+            await updater(prId, { files: mergedFiles }, verbose);
+            updatedCount++;
+            if (verbose) {
+                logInfo(`   Updated PR "${pr.name}": +${newFiles.length} files (${newFiles.map((f) => f.file).join(', ')})`);
+            }
+        }
+        catch (error) {
+            logError(`Failed to update PR ${prId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return updatedCount;
+}
+/**
+ * Remove files that were deleted on the dev branch from PR file lists.
+ * Returns the number of PRs updated.
+ */
+export async function removeDeletedFilesFromPRs(changedFiles, pullRequests, updater = updatePullRequest, verbose) {
+    const deletedPaths = new Set(changedFiles.filter((f) => f.change_type === 'deleted').map((f) => f.path));
+    if (deletedPaths.size === 0) {
+        return 0;
+    }
+    let updatedCount = 0;
+    for (const pr of pullRequests) {
+        if (!pr.files || pr.files.length === 0) {
+            continue;
+        }
+        const filtered = pr.files.filter((f) => !deletedPaths.has(f.path));
+        if (filtered.length === pr.files.length) {
+            continue;
+        }
+        const removed = pr.files.length - filtered.length;
+        try {
+            await updater(pr.id, { files: filtered }, verbose);
+            updatedCount++;
+            if (verbose) {
+                logInfo(`   Cleaned PR "${pr.name}": removed ${removed} deleted file(s)`);
+            }
+        }
+        catch (error) {
+            logError(`Failed to clean PR ${pr.id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (verbose && updatedCount > 0) {
+        logInfo(`🗑️  Cleaned deleted files from ${updatedCount} PR(s)`);
+    }
+    return updatedCount;
+}
+/**
+ * Detect unassigned files and use LLM to assign them to existing PRs.
+ * Returns the number of files assigned, or 0 if none needed assignment.
+ */
+export async function assignNewFilesToPRs(changedFiles, pullRequests, verbose) {
+    const unassigned = findUnassignedFiles(changedFiles, pullRequests);
+    if (unassigned.length === 0) {
+        if (verbose) {
+            logInfo('All changed files are already assigned to PRs.');
+        }
+        return 0;
+    }
+    if (verbose) {
+        logInfo(`\n📂 ${unassigned.length} changed file(s) not assigned to any PR:`);
+        for (const f of unassigned) {
+            logInfo(`   - ${f.path} (${f.change_type})`);
+        }
+        logInfo('🤖 Asking LLM to assign them...');
+    }
+    const prompt = buildAssignmentPrompt(unassigned, pullRequests);
+    const result = await callLLMForAssignment(prompt, verbose);
+    if (!result) {
+        logError('LLM file assignment failed. Proceeding with existing file lists.');
+        return 0;
+    }
+    // Validate: every unassigned file should appear in assignments
+    const assignedFiles = new Set(result.assignments.map((a) => a.file));
+    const missing = unassigned.filter((f) => !assignedFiles.has(f.path));
+    if (missing.length > 0 && verbose) {
+        logInfo(`⚠️  LLM did not assign ${missing.length} file(s): ${missing.map((f) => f.path).join(', ')}`);
+    }
+    // Validate: all pr_ids reference existing PRs
+    const validPRIds = new Set(pullRequests.map((pr) => pr.id));
+    const validAssignments = result.assignments.filter((a) => {
+        if (!validPRIds.has(a.pr_id)) {
+            if (verbose) {
+                logError(`Assignment for ${a.file} references unknown PR: ${a.pr_id}`);
+            }
+            return false;
+        }
+        return true;
+    });
+    const updatedCount = await applyAssignments(validAssignments, unassigned, pullRequests, updatePullRequest, verbose);
+    if (verbose) {
+        logInfo(`✅ Assigned ${validAssignments.length} file(s) to ${updatedCount} PR(s)`);
+    }
+    return validAssignments.length;
+}

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

@@ -2,9 +2,11 @@ import { query } from '@anthropic-ai/claude-agent-sdk';
 import { execSync } from 'child_process';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { getPullRequests } from '../../services/pull-requests.js';
 import { getCurrentBranch, returnToMainBranch, } from '../../utils/git-branch-manager.js';
 import { logDebug, logError, logInfo } from '../../utils/logger.js';
 import { fetchPRExecutionContext } from './context.js';
+import { assignNewFilesToPRs, removeDeletedFilesFromPRs, } from './file-assigner.js';
 import { buildExecutionErrorResult, buildExecutionSuccessResult, buildNoChangeResult, } from './outcome.js';
 import { pushBranchAndBuildUrl, updatePRDatabaseRecord, } from './pr-executor.js';
 import { createIncrementalSyncPrompt, createIncrementalSyncSystemPrompt, createPRExecutionPrompt, createPRExecutionSystemPrompt, } from './prompts.js';
@@ -65,6 +67,20 @@ export const executeFeaturePRs = async (options, config) => {
             return buildNoChangeResult(featureId, context.pullRequests.length);
         }
         // ======================================
+        // Assign unassigned files to PRs (incremental sync only)
+        // ======================================
+        let activePullRequests = context.pullRequests;
+        if (context.isIncrementalSync) {
+            // Remove deleted files from PR file lists
+            const deletedCount = await removeDeletedFilesFromPRs(context.changedFiles, activePullRequests, undefined, verbose);
+            // Assign new/modified files not covered by any PR
+            const assignedCount = await assignNewFilesToPRs(context.changedFiles, activePullRequests, verbose);
+            if (assignedCount > 0 || deletedCount > 0) {
+                // Re-fetch PR records so prompts use the updated file lists
+                activePullRequests = await getPullRequests({ featureId, verbose });
+            }
+        }
+        // ======================================
         // Agent: Create/Update branches
         // ======================================
         if (verbose) {
@@ -87,7 +103,7 @@ export const executeFeaturePRs = async (options, config) => {
             userPrompt = createIncrementalSyncPrompt({
                 featureId,
                 devBranchName: context.devBranchName,
-                pullRequests: context.pullRequests,
+                pullRequests: activePullRequests,
                 lastSyncedCommit: context.lastSyncedCommit,
                 diffStat: context.diffStat,
                 changedFiles: context.changedFiles,
@@ -95,7 +111,7 @@ export const executeFeaturePRs = async (options, config) => {
         }
         else {
             systemPrompt = await createPRExecutionSystemPrompt(featureId, context.devBranchName);
-            userPrompt = createPRExecutionPrompt(featureId, context.devBranchName, context.pullRequests);
+            userPrompt = createPRExecutionPrompt(featureId, context.devBranchName, activePullRequests);
         }
         // Execute agent query
         const agentResult = await executeAgentQuery(userPrompt, systemPrompt, config, verbose);
@@ -130,12 +146,12 @@ export const executeFeaturePRs = async (options, config) => {
         };
         // Build PR id → branch name map for stacked PR base resolution
         const prIdToBranch = new Map();
-        for (const pr of context.pullRequests) {
+        for (const pr of activePullRequests) {
             if (pr.branch_name) {
                 prIdToBranch.set(pr.id, pr.branch_name);
             }
         }
-        for (const pr of context.pullRequests) {
+        for (const pr of activePullRequests) {
             if (!pr.branch_name) {
                 if (verbose) {
                     logError(`PR "${pr.name}" has no branch name, skipping`);

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

@@ -1,4 +1,5 @@
 import type { PullRequest } from '../../services/pull-requests.js';
+import type { ChangedFileInfo } from './context.js';
 /**
  * Create the system prompt for branch creation and code splitting
  */
@@ -20,6 +21,6 @@ export interface IncrementalSyncPromptOptions {
     pullRequests: PullRequest[];
     lastSyncedCommit: string;
     diffStat: string;
-    changedFiles: string[];
+    changedFiles: ChangedFileInfo[];
 }
 export declare function createIncrementalSyncPrompt(opts: IncrementalSyncPromptOptions): string;

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

@@ -106,7 +106,7 @@ ${diffStat || 'No changes detected'}
 \`\`\`
 
 ### Changed Files (${changedFiles.length} files)
-${changedFiles.map((f) => `- ${f}`).join('\n') || 'No files changed'}
+${changedFiles.map((f) => `- ${f.path} (${f.change_type})`).join('\n') || 'No files changed'}
 
 ## Existing PR Branches (Stacked)
 

package/dist/phases/pr-splitting/import-dep-validator.js

@@ -156,8 +156,9 @@ export function getTransitiveDependencies(file, graph) {
     while (stack.length > 0) {
         const current = stack.pop();
         const deps = graph.get(current);
-        if (!deps)
+        if (!deps) {
             continue;
+        }
         for (const dep of deps) {
             if (!result.has(dep)) {
                 result.add(dep);
@@ -168,6 +169,35 @@ export function getTransitiveDependencies(file, graph) {
     return result;
 }
 const MAX_FIX_ITERATIONS = 100;
+/**
+ * Move a dependency file from a later PR to an earlier PR that needs it.
+ * Returns true if a file was moved.
+ */
+function moveDepToEarlierPR(dep, prIdx, sorted, fileToPRIndex, movedFiles, reason) {
+    const depPRIdx = fileToPRIndex.get(dep);
+    if (depPRIdx === undefined || depPRIdx <= prIdx) {
+        return false;
+    }
+    const sourcePR = sorted[depPRIdx];
+    const targetPR = sorted[prIdx];
+    const depFileEntry = sourcePR.files?.find((f) => f.path === dep);
+    if (!depFileEntry) {
+        return false;
+    }
+    sourcePR.files = sourcePR.files?.filter((f) => f.path !== dep) ?? [];
+    if (!targetPR.files) {
+        targetPR.files = [];
+    }
+    targetPR.files.push(depFileEntry);
+    fileToPRIndex.set(dep, prIdx);
+    movedFiles.push({
+        file: dep,
+        fromPR: `PR #${sourcePR.sequence} (${sourcePR.name})`,
+        toPR: `PR #${targetPR.sequence} (${targetPR.name})`,
+        reason,
+    });
+    return true;
+}
 /**
  * Given PRs sorted by sequence and a dependency graph, detect violations
  * and auto-fix by moving files to earlier PRs.
@@ -196,32 +226,13 @@ export function autoFixPROrdering(pullRequests, dependencyGraph) {
         changed = false;
         iterations++;
         for (let prIdx = 0; prIdx < sorted.length; prIdx++) {
-            const pr = sorted[prIdx];
-            for (const file of pr.files ?? []) {
+            for (const file of sorted[prIdx].files ?? []) {
                 const transitiveDeps = getTransitiveDependencies(file.path, dependencyGraph);
                 for (const dep of transitiveDeps) {
-                    const depPRIdx = fileToPRIndex.get(dep);
-                    if (depPRIdx === undefined || depPRIdx <= prIdx)
-                        continue;
-                    // Violation: dep is in a later PR but needed here
-                    const sourcePR = sorted[depPRIdx];
-                    const targetPR = sorted[prIdx];
-                    const depFileEntry = sourcePR.files?.find((f) => f.path === dep);
-                    if (!depFileEntry)
-                        continue;
-                    // Move from source to target
-                    sourcePR.files = sourcePR.files?.filter((f) => f.path !== dep) ?? [];
-                    if (!targetPR.files)
-                        targetPR.files = [];
-                    targetPR.files.push(depFileEntry);
-                    fileToPRIndex.set(dep, prIdx);
-                    movedFiles.push({
-                        file: dep,
-                        fromPR: `PR #${sourcePR.sequence} (${sourcePR.name})`,
-                        toPR: `PR #${targetPR.sequence} (${targetPR.name})`,
-                        reason: `imported by ${file.path}`,
-                    });
-                    changed = true;
+                    const moved = moveDepToEarlierPR(dep, prIdx, sorted, fileToPRIndex, movedFiles, `imported by ${file.path}`);
+                    if (moved) {
+                        changed = true;
+                    }
                 }
             }
         }

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

@@ -2,7 +2,7 @@ import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { clearPullRequests, createPullRequests, } from '../../services/pull-requests.js';
+import { clearPullRequests, createPullRequests, updatePullRequest, } from '../../services/pull-requests.js';
 import { logDebug, logError, logInfo } from '../../utils/logger.js';
 import { fetchPRSplittingContext } from './context.js';
 import { validateAndFixImportDependencies } from './import-dep-validator.js';
@@ -151,28 +151,33 @@ export const splitFeatureIntoPRs = async (options, config
             await clearPullRequests({ featureId, verbose: false }, true);
         }
         // Save PR plan to database
-        const prInputs = [];
-        const prBranchNameToId = new Map();
-        for (const pr of finalPRs) {
-            let basePrId;
-            if (pr.depends_on_branch_name) {
-                basePrId = prBranchNameToId.get(pr.depends_on_branch_name);
-            }
-            prInputs.push({
-                sequence: pr.sequence,
-                name: pr.name,
-                description: pr.description,
-                branch_name: pr.branch_name,
-                base_pr_id: basePrId,
-                files: pr.files,
-            });
-        }
+        // Step 1: Create all PRs without base_pr_id (batch)
+        const prInputs = finalPRs.map((pr) => ({
+            sequence: pr.sequence,
+            name: pr.name,
+            description: pr.description,
+            branch_name: pr.branch_name,
+            files: pr.files,
+        }));
         const createdPRRecords = await createPullRequests({ featureId, verbose: false }, prInputs);
+        // Step 2: Build branch_name → ID map from created records
+        const prBranchNameToId = new Map();
         createdPRRecords.forEach((createdPR) => {
             if (createdPR.branch_name) {
                 prBranchNameToId.set(createdPR.branch_name, createdPR.id);
             }
         });
+        // Step 3: Update base_pr_id for PRs with dependencies
+        for (const pr of finalPRs) {
+            if (!pr.depends_on_branch_name || !pr.branch_name) {
+                continue;
+            }
+            const basePrId = prBranchNameToId.get(pr.depends_on_branch_name);
+            const thisPrId = prBranchNameToId.get(pr.branch_name);
+            if (basePrId && thisPrId) {
+                await updatePullRequest(thisPrId, { base_pr_id: basePrId }, false);
+            }
+        }
         if (verbose) {
             logInfo(`\n📝 Saved ${createdPRRecords.length} PR records to database. Awaiting human review before execution.`);
         }

package/package.json

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