@astroanywhere/agent 0.4.4 → 0.5.1

package/dist/lib/task-executor.js

@@ -13,11 +13,11 @@ import { createProviderAdapter } from '../providers/index.js';
 import { ClaudeSdkAdapter } from '../providers/claude-sdk-adapter.js';
 import { OpenClawAdapter } from '../providers/openclaw-adapter.js';
 import { SlurmJobMonitor } from './slurm-job-monitor.js';
-import { createWorktree, syncProjectWorktree } from './worktree.js';
+import { createWorktree, syncDeliveryWorktree, getGitRoot } from './worktree.js';
 import { ensureProjectWorkspace } from './workspace-root.js';
 import { BranchLockManager } from './branch-lock.js';
 import { pushAndCreatePR, mergePullRequest, getRemoteBranchSha, isGhAvailable, getRepoSlug } from './git-pr.js';
-import { localMergeIntoProjectBranch } from './local-merge.js';
+import { localMergeIntoDeliveryBranch } from './local-merge.js';
 import { checkWorkdirSafety, isGitAvailable, isGitRepo, isUntrackedInParentRepo, createSandbox, WorkdirSafetyTier, } from './workdir-safety.js';
 import { initializeGit } from './git-bootstrap.js';
 const execFileAsync = promisify(execFileCb);
@@ -32,24 +32,24 @@ function sanitizeGitRef(ref) {
 /**
  * Build a prompt instructing the agent to resolve merge conflicts.
  * The agent's worktree has the task branch checked out; it needs to
- * rebase onto the project branch to resolve conflicts, then commit.
+ * rebase onto the delivery branch to resolve conflicts, then commit.
  */
-function buildConflictResolutionPrompt(conflictFiles, projectBranch, attempt, maxAttempts) {
-    const safeBranch = sanitizeGitRef(projectBranch);
+function buildConflictResolutionPrompt(conflictFiles, deliveryBranch, attempt, maxAttempts) {
+    const safeBranch = sanitizeGitRef(deliveryBranch);
     const fileList = conflictFiles.map(f => `- ${f}`).join('\n');
     return `MERGE CONFLICT DETECTED (attempt ${attempt}/${maxAttempts})
 
-Your task branch cannot be cleanly merged into the project branch because
+Your task branch cannot be cleanly merged into the delivery branch because
 parallel tasks have modified overlapping files since you branched.
 
 Conflicting files:
 ${fileList}
 
-The project branch is: ${safeBranch}
+The delivery branch is: ${safeBranch}
 
 Please resolve this:
-1. Fetch the latest project branch: git fetch origin 2>/dev/null; git fetch . ${safeBranch}:${safeBranch} 2>/dev/null || true
-2. Rebase onto the project branch: git rebase ${safeBranch}
+1. Fetch the latest delivery branch: git fetch origin 2>/dev/null; git fetch . ${safeBranch}:${safeBranch} 2>/dev/null || true
+2. Rebase onto the delivery branch: git rebase ${safeBranch}
 3. For each conflict, open the file, resolve the conflict markers (<<<<<<< / ======= / >>>>>>>), keeping the correct combination of both changes
 4. Stage resolved files: git add <resolved-files>
 5. Continue the rebase: git rebase --continue
@@ -63,12 +63,12 @@ After you finish resolving, I will automatically retry the merge.`;
  * Similar to local mode, but the agent must also force-push after rebasing
  * because the merge happens via GitHub API (gh pr merge), not locally.
  */
-function buildPRConflictResolutionPrompt(projectBranch, branchName, attempt, maxAttempts) {
-    const safeBranch = sanitizeGitRef(projectBranch);
+function buildPRConflictResolutionPrompt(deliveryBranch, branchName, attempt, maxAttempts) {
+    const safeBranch = sanitizeGitRef(deliveryBranch);
     const safeTaskBranch = sanitizeGitRef(branchName);
     return `MERGE CONFLICT DETECTED ON GITHUB (attempt ${attempt}/${maxAttempts})
 
-Your pull request cannot be automatically merged into the project branch because
+Your pull request cannot be automatically merged into the delivery branch because
 parallel tasks have modified overlapping files.
 
 Your task branch is: ${safeTaskBranch}
@@ -87,7 +87,7 @@ IMPORTANT: Do NOT create a merge commit. Use rebase so the history is clean.
 After you force-push, I will automatically retry the GitHub merge.`;
 }
 /**
- * Best-effort pre-merge rebase: if the project branch has moved forward
+ * Best-effort pre-merge rebase: if the delivery branch has moved forward
  * (another task merged), rebase the task branch onto the latest tip before
  * attempting the squash merge. This avoids conflicts in the common case
  * where changes don't overlap. On any failure, silently aborts — the
@@ -180,6 +180,8 @@ export class TaskExecutor {
     /** Tasks claimed by submitTask() but not yet in runningTasks (closes TOCTOU dedup gap). */
     claimedTasks = new Set();
     openclawBridge = null;
+    /** Branch names that are singleton delivery branches — must not be deleted by cleanupTask. */
+    singletonBranches = new Set();
     // Safety tracking
     tasksByDirectory = new Map(); // workdir -> taskIds
     pendingSafetyChecks = new Map(); // taskId -> pending check
@@ -439,21 +441,29 @@ export class TaskExecutor {
                     }
                     console.log(`[executor] Task ${taskId}: worktree removed`);
                 }
-                // Delete local branch
-                try {
-                    execSync(`git branch -D "${branchName}"`, { encoding: 'utf-8', timeout: 10_000 });
-                    console.log(`[executor] Task ${taskId}: local branch ${branchName} deleted`);
-                }
-                catch {
-                    console.log(`[executor] Task ${taskId}: local branch ${branchName} not found or already deleted`);
+                // Skip branch deletion for singleton delivery branches — these are shared
+                // accumulation branches that outlive individual tasks and will be used for
+                // the component's final PR to the base branch.
+                if (this.singletonBranches.has(branchName)) {
+                    console.log(`[executor] Task ${taskId}: skipping branch deletion — ${branchName} is a singleton delivery branch`);
                 }
-                // Delete remote branch
-                try {
-                    execSync(`git push origin --delete "${branchName}"`, { encoding: 'utf-8', timeout: 30_000 });
-                    console.log(`[executor] Task ${taskId}: remote branch ${branchName} deleted`);
-                }
-                catch {
-                    console.log(`[executor] Task ${taskId}: remote branch ${branchName} not found or already deleted`);
+                else {
+                    // Delete local branch
+                    try {
+                        execSync(`git branch -D "${branchName}"`, { encoding: 'utf-8', timeout: 10_000 });
+                        console.log(`[executor] Task ${taskId}: local branch ${branchName} deleted`);
+                    }
+                    catch {
+                        console.log(`[executor] Task ${taskId}: local branch ${branchName} not found or already deleted`);
+                    }
+                    // Delete remote branch
+                    try {
+                        execSync(`git push origin --delete "${branchName}"`, { encoding: 'utf-8', timeout: 30_000 });
+                        console.log(`[executor] Task ${taskId}: remote branch ${branchName} deleted`);
+                    }
+                    catch {
+                        console.log(`[executor] Task ${taskId}: remote branch ${branchName} not found or already deleted`);
+                    }
                 }
             }
             catch (error) {
@@ -501,6 +511,8 @@ export class TaskExecutor {
         // Release all locks to unblock any waiting tasks
         this.branchLockManager.releaseAll();
         this.directoryLockManager.releaseAll();
+        // Clear singleton tracking — all tasks cancelled, no branches to protect
+        this.singletonBranches.clear();
         // Stop job monitor
         this.jobMonitor.stop();
     }
@@ -622,9 +634,9 @@ export class TaskExecutor {
         if (resumeDir && !existsSync(resumeDir)) {
             const meta = this.completedTaskMeta.get(taskId);
             if (meta?.originalWorkingDirectory && existsSync(meta.originalWorkingDirectory)) {
-                // Try to recreate a worktree from the project branch (like a new task)
+                // Try to recreate a worktree from the delivery branch (like a new task)
                 try {
-                    console.log(`[executor] Task ${taskId}: worktree gone, recreating from project branch at ${meta.originalWorkingDirectory}`);
+                    console.log(`[executor] Task ${taskId}: worktree gone, recreating from delivery branch at ${meta.originalWorkingDirectory}`);
                     const worktree = await createWorktree({
                         workingDirectory: meta.originalWorkingDirectory,
                         taskId: `resume-${taskId.slice(0, 12)}-${Date.now()}`,
@@ -633,7 +645,8 @@ export class TaskExecutor {
                         shortNodeId: meta.shortNodeId,
                         agentDir: meta.agentDir,
                         baseBranch: meta.baseBranch,
-                        projectBranch: meta.projectBranch,
+                        deliveryBranch: meta.deliveryBranch,
+                        deliveryBranchIsSingleton: meta.deliveryBranchIsSingleton,
                         stdout: stream.stdout,
                         stderr: stream.stderr,
                         operational: stream.operational,
@@ -1077,12 +1090,13 @@ export class TaskExecutor {
                 this.cleanupExpiredTaskMeta();
                 this.completedTaskMeta.set(task.id, {
                     originalWorkingDirectory: normalizedTask.workingDirectory,
-                    projectBranch: normalizedTask.projectBranch,
+                    deliveryBranch: normalizedTask.deliveryBranch ?? normalizedTask.projectBranch,
                     baseBranch: normalizedTask.baseBranch,
                     agentDir: normalizedTask.agentDir,
                     shortProjectId: normalizedTask.shortProjectId,
                     shortNodeId: normalizedTask.shortNodeId,
                     projectId: normalizedTask.projectId,
+                    deliveryBranchIsSingleton: normalizedTask.deliveryBranchIsSingleton,
                     storedAt: Date.now(),
                 });
             }
@@ -1092,7 +1106,7 @@ export class TaskExecutor {
             }
             // Delivery-mode-aware result handling
             // If pr mode is requested but gh is unavailable, fall back to branch mode
-            // so the work is still merged locally into the project branch.
+            // so the work is still merged locally into the delivery branch.
             let deliveryMode = task.deliveryMode ?? 'pr';
             if (deliveryMode === 'pr' && !(await isGhAvailable())) {
                 console.log(`[executor] Task ${task.id}: gh CLI not available, falling back from 'pr' to 'branch' mode`);
@@ -1160,26 +1174,26 @@ export class TaskExecutor {
                         console.log(`[executor] Task ${task.id}: copy mode, worktree preserved at ${prepared.workingDirectory}`);
                     }
                     else if (deliveryMode === 'branch') {
-                        stream.operational?.(`Merging into project branch ${prepared.projectBranch ?? 'local'}...`, 'git');
-                        // Branch mode: commit locally, merge into project branch if available.
+                        stream.operational?.(`Merging into delivery branch ${prepared.deliveryBranch ?? 'local'}...`, 'git');
+                        // Branch mode: commit locally, merge into delivery branch if available.
                         // The merge lock is held only during the squash-merge (seconds, not minutes),
                         // allowing tasks to execute in parallel. The squash merge naturally handles
-                        // the case where the project branch moved forward (another task merged first)
+                        // the case where the delivery branch moved forward (another task merged first)
                         // because it computes the diff from the merge-base and applies it on the
-                        // current project branch tip.
+                        // current delivery branch tip.
                         //
                         // On conflict: if the provider supports session resume (Claude SDK), we
                         // resume the agent session to let it resolve the conflict, then retry.
                         result.branchName = prepared.branchName;
                         keepBranch = true;
-                        if (prepared.gitRoot && prepared.projectBranch && prepared.branchName) {
-                            // Pre-merge rebase: if the project branch moved forward (another task
+                        if (prepared.gitRoot && prepared.deliveryBranch && prepared.branchName) {
+                            // Pre-merge rebase: if the delivery branch moved forward (another task
                             // merged), rebase our task branch first. Avoids conflicts when changes
                             // don't overlap, and saves one retry cycle when they do.
-                            const preRebase = await tryPreMergeRebase(prepared.workingDirectory, prepared.projectBranch, false);
+                            const preRebase = await tryPreMergeRebase(prepared.workingDirectory, prepared.deliveryBranch, false);
                             if (preRebase.rebased) {
-                                stream.operational?.(`Rebased onto ${prepared.projectBranch}`, 'git');
-                                console.log(`[executor] Task ${task.id}: pre-merge rebase onto ${prepared.projectBranch} succeeded`);
+                                stream.operational?.(`Rebased onto ${prepared.deliveryBranch}`, 'git');
+                                console.log(`[executor] Task ${task.id}: pre-merge rebase onto ${prepared.deliveryBranch} succeeded`);
                             }
                             else if (!preRebase.skipped) {
                                 stream.operational?.('Rebase skipped (conflicts), retrying via merge', 'git');
@@ -1194,8 +1208,8 @@ export class TaskExecutor {
                                 const mergeLock = await this.branchLockManager.acquire(mergeLockKey, task.id);
                                 let mergeResult;
                                 try {
-                                    this.wsClient.sendTaskStatus(task.id, 'running', 96, 'Merging into project branch...');
-                                    mergeResult = await localMergeIntoProjectBranch(prepared.gitRoot, prepared.branchName, prepared.projectBranch, commitMessage, (msg) => stream.operational?.(msg, 'git'));
+                                    this.wsClient.sendTaskStatus(task.id, 'running', 96, 'Merging into delivery branch...');
+                                    mergeResult = await localMergeIntoDeliveryBranch(prepared.gitRoot, prepared.branchName, prepared.deliveryBranch, commitMessage, (msg) => stream.operational?.(msg, 'git'));
                                 }
                                 finally {
                                     mergeLock.release();
@@ -1204,11 +1218,11 @@ export class TaskExecutor {
                                 if (mergeResult.merged) {
                                     result.deliveryStatus = 'success';
                                     result.commitAfterSha = mergeResult.commitSha;
-                                    stream.operational?.(`Merged into ${prepared.projectBranch} (${mergeResult.commitSha?.slice(0, 7)})`, 'git');
-                                    console.log(`[executor] Task ${task.id}: merged into ${prepared.projectBranch} (${mergeResult.commitSha})`);
-                                    // Sync project worktree to reflect the merged changes on disk
-                                    if (prepared.projectWorktreePath && prepared.projectBranch && prepared.gitRoot) {
-                                        await syncProjectWorktree(prepared.projectWorktreePath, prepared.projectBranch, prepared.gitRoot);
+                                    stream.operational?.(`Merged into ${prepared.deliveryBranch} (${mergeResult.commitSha?.slice(0, 7)})`, 'git');
+                                    console.log(`[executor] Task ${task.id}: merged into ${prepared.deliveryBranch} (${mergeResult.commitSha})`);
+                                    // Sync delivery worktree to reflect the merged changes on disk
+                                    if (prepared.deliveryWorktreePath && prepared.deliveryBranch && prepared.gitRoot) {
+                                        await syncDeliveryWorktree(prepared.deliveryWorktreePath, prepared.deliveryBranch, prepared.gitRoot);
                                     }
                                     break;
                                 }
@@ -1226,7 +1240,7 @@ export class TaskExecutor {
                                         // Resume agent session with conflict resolution instructions.
                                         // No merge lock held during this — agent may take minutes.
                                         try {
-                                            await adapter.resumeTask(task.id, buildConflictResolutionPrompt(mergeResult.conflictFiles ?? [], prepared.projectBranch, attempt, MAX_MERGE_ATTEMPTS), prepared.workingDirectory, taskContext.sessionId, stream, abortController.signal);
+                                            await adapter.resumeTask(task.id, buildConflictResolutionPrompt(mergeResult.conflictFiles ?? [], prepared.deliveryBranch, attempt, MAX_MERGE_ATTEMPTS), prepared.workingDirectory, taskContext.sessionId, stream, abortController.signal);
                                             console.log(`[executor] Task ${task.id}: agent conflict resolution session completed (attempt ${attempt})`);
                                         }
                                         catch (resumeErr) {
@@ -1260,11 +1274,11 @@ export class TaskExecutor {
                                 }
                             }
                         }
-                        else if (prepared.projectBranch) {
-                            console.warn(`[executor] Task ${task.id}: projectBranch=${prepared.projectBranch} but gitRoot=${prepared.gitRoot}, branchName=${prepared.branchName} — skipping local merge`);
+                        else if (prepared.deliveryBranch) {
+                            console.warn(`[executor] Task ${task.id}: deliveryBranch=${prepared.deliveryBranch} but gitRoot=${prepared.gitRoot}, branchName=${prepared.branchName} — skipping local merge`);
                         }
                         else {
-                            console.log(`[executor] Task ${task.id}: branch mode, committing locally (no project branch)`);
+                            console.log(`[executor] Task ${task.id}: branch mode, committing locally (no delivery branch)`);
                         }
                     }
                     else if (deliveryMode === 'push') {
@@ -1301,7 +1315,7 @@ export class TaskExecutor {
                         }
                     }
                     else {
-                        // 'pr' — push + create PR, auto-merge into project branch if applicable
+                        // 'pr' — push + create PR, auto-merge into delivery branch if applicable
                         stream.operational?.(`Creating PR: ${prepared.branchName} → ${prepared.baseBranch ?? 'main'}...`, 'git');
                         this.wsClient.sendTaskStatus(task.id, 'running', 94, 'Rebasing before push...');
                         // Pre-push rebase: if the target branch moved forward, rebase our task
@@ -1320,14 +1334,17 @@ export class TaskExecutor {
                         }
                         this.wsClient.sendTaskStatus(task.id, 'running', 95, 'Creating pull request...');
                         console.log(`[executor] Task ${task.id}: pr mode, attempting PR creation for branch ${prepared.branchName}`);
-                        const hasProjectBranch = !!task.projectBranch;
+                        // Singleton delivery branches create PRs directly to the base branch
+                        // (no auto-merge into an accumulation branch). Multi-task components
+                        // auto-merge per-task PRs into the delivery branch.
+                        const hasDeliveryBranch = !!(task.deliveryBranch ?? task.projectBranch) && !task.deliveryBranchIsSingleton;
                         const prResult = await pushAndCreatePR(prepared.workingDirectory, {
                             branchName: prepared.branchName,
                             taskTitle: prTitle,
                             taskDescription: task.description || task.prompt.slice(0, 500),
                             body: prBody,
                             baseBranch: prepared.baseBranch,
-                            autoMerge: hasProjectBranch,
+                            autoMerge: hasDeliveryBranch,
                             commitBeforeSha: prepared.commitBeforeSha,
                             gitRoot: prepared.gitRoot,
                         });
@@ -1348,7 +1365,7 @@ export class TaskExecutor {
                                 const prTaskContext = this.isResumableAdapter(adapter)
                                     ? adapter.getTaskContext(task.id)
                                     : null;
-                                if (prTaskContext?.sessionId && this.isResumableAdapter(adapter) && hasProjectBranch && prepared.branchName && prepared.baseBranch && prResult.prNumber && prepared.gitRoot) {
+                                if (prTaskContext?.sessionId && this.isResumableAdapter(adapter) && hasDeliveryBranch && prepared.branchName && prepared.baseBranch && prResult.prNumber && prepared.gitRoot) {
                                     for (let attempt = 1; attempt <= MAX_PR_MERGE_ATTEMPTS; attempt++) {
                                         stream.operational?.(`Auto-merge failed — agent resolving conflict (attempt ${attempt})...`, 'git');
                                         console.log(`[executor] Task ${task.id}: PR auto-merge failed (attempt ${attempt}), resuming ${adapter.name} to resolve`);
@@ -1378,8 +1395,8 @@ export class TaskExecutor {
                                             result.deliveryStatus = 'success';
                                             prMergeResolved = true;
                                             console.log(`[executor] Task ${task.id}: PR merged on retry (attempt ${attempt}), commitAfterSha=${result.commitAfterSha}`);
-                                            if (prepared.projectWorktreePath && prepared.projectBranch && prepared.gitRoot) {
-                                                await syncProjectWorktree(prepared.projectWorktreePath, prepared.projectBranch, prepared.gitRoot);
+                                            if (prepared.deliveryWorktreePath && prepared.deliveryBranch && prepared.gitRoot) {
+                                                await syncDeliveryWorktree(prepared.deliveryWorktreePath, prepared.deliveryBranch, prepared.gitRoot);
                                             }
                                             break;
                                         }
@@ -1394,15 +1411,15 @@ export class TaskExecutor {
                                 if (!prMergeResolved && !result.deliveryError) {
                                     // No resume capability or not applicable — original failure
                                     result.deliveryStatus = 'failed';
-                                    result.deliveryError = 'PR created but auto-merge into project branch failed';
+                                    result.deliveryError = 'PR created but auto-merge into delivery branch failed';
                                     console.error(`[executor] Task ${task.id}: PR created at ${prResult.prUrl} but auto-merge failed (no resume capability)`);
                                 }
                             }
                             else {
                                 result.deliveryStatus = 'success';
                                 console.log(`[executor] Task ${task.id}: PR created at ${prResult.prUrl}`);
-                                if (prepared.projectWorktreePath && prepared.projectBranch && prepared.gitRoot) {
-                                    await syncProjectWorktree(prepared.projectWorktreePath, prepared.projectBranch, prepared.gitRoot);
+                                if (prepared.deliveryWorktreePath && prepared.deliveryBranch && prepared.gitRoot) {
+                                    await syncDeliveryWorktree(prepared.deliveryWorktreePath, prepared.deliveryBranch, prepared.gitRoot);
                                 }
                             }
                         }
@@ -1629,7 +1646,26 @@ export class TaskExecutor {
         // Git worktree path — worktree creation must succeed or fail the task.
         // Running in the raw workdir without isolation risks cross-task commit
         // contamination and breaks PR creation.
+        //
+        // Singleton delivery branches: acquire a branch-level lock during worktree
+        // creation to prevent concurrent dispatches (if server-side invariant fails)
+        // from fighting over the same branch. The lock is held only during worktree
+        // setup (seconds), not the entire task execution.
+        let singletonLock;
         try {
+            if (task.deliveryBranchIsSingleton && (task.deliveryBranch ?? task.projectBranch)) {
+                // Use git root (not workingDirectory) for the lock key so that tasks
+                // dispatched to different subdirectories of the same repo (e.g., repo/
+                // and repo/subdir/) share the same lock for the same branch.
+                const gitRoot = await getGitRoot(task.workingDirectory);
+                if (!gitRoot) {
+                    throw new Error(`Cannot resolve git root for singleton branch lock (workdir: ${task.workingDirectory}). ` +
+                        `Singleton worktrees require a valid git repository.`);
+                }
+                const lockKey = BranchLockManager.computeLockKey(gitRoot, undefined, undefined, `singleton::${task.deliveryBranch ?? task.projectBranch}`);
+                console.log(`[executor] Task ${task.id}: acquiring singleton branch lock: ${lockKey}`);
+                singletonLock = await this.branchLockManager.acquire(lockKey, task.id);
+            }
             console.log(`[executor] Task ${task.id}: creating worktree for workdir=${task.workingDirectory}`);
             const worktree = await createWorktree({
                 workingDirectory: task.workingDirectory,
@@ -1641,7 +1677,8 @@ export class TaskExecutor {
                 shortNodeId: task.shortNodeId,
                 agentDir: task.agentDir,
                 baseBranch: task.baseBranch,
-                projectBranch: task.projectBranch,
+                deliveryBranch: task.deliveryBranch ?? task.projectBranch,
+                deliveryBranchIsSingleton: task.deliveryBranchIsSingleton,
                 stdout: stream.stdout,
                 stderr: stream.stderr,
                 operational: stream.operational,
@@ -1651,6 +1688,12 @@ export class TaskExecutor {
                 throw new Error(`Worktree creation returned null for ${task.workingDirectory}. Cannot proceed without isolation.`);
             }
             console.log(`[executor] Task ${task.id}: worktree created at ${worktree.workingDirectory} (branch: ${worktree.branchName})`);
+            // Track singleton delivery branches so cleanupTask won't destroy them.
+            // Singleton branches are shared across the delivery lifecycle — deleting
+            // them would orphan the delivery branch and its eventual PR.
+            if (task.deliveryBranchIsSingleton && worktree.branchName) {
+                this.singletonBranches.add(worktree.branchName);
+            }
             return worktree;
         }
         catch (error) {
@@ -1659,6 +1702,9 @@ export class TaskExecutor {
             this.wsClient.sendTaskStatus(task.id, 'failed', 0, `Worktree setup failed: ${errorMsg}`);
             throw error;
         }
+        finally {
+            singletonLock?.release();
+        }
     }
     /**
      * Run `git diff --numstat` after task execution to emit accurate file_change