@astroanywhere/agent 0.1.0

package/dist/lib/task-executor.js

@@ -0,0 +1,753 @@
+/**
+ * Task executor with multiplexing support
+ *
+ * Handles concurrent task execution, routing to providers,
+ * and streaming output back over WebSocket
+ */
+import { createProviderAdapter } from '../providers/index.js';
+import { ClaudeSdkAdapter } from '../providers/claude-sdk-adapter.js';
+import { SlurmJobMonitor } from './slurm-job-monitor.js';
+import { createWorktree } from './worktree.js';
+import { pushAndCreatePR } from './git-pr.js';
+import { checkWorkdirSafety, isGitAvailable, createSandbox, WorkdirSafetyTier, } from './workdir-safety.js';
+export class TaskExecutor {
+    wsClient;
+    runningTasks = new Map();
+    taskQueue = [];
+    maxConcurrentTasks;
+    defaultTimeout;
+    adapters = new Map();
+    useWorktree;
+    worktreeRoot;
+    preserveWorktrees;
+    jobMonitor;
+    allowNonGit;
+    useSandbox;
+    maxSandboxSize;
+    gitAvailable = false;
+    // Safety tracking
+    tasksByDirectory = new Map(); // workdir -> taskIds
+    pendingSafetyChecks = new Map(); // taskId -> pending check
+    constructor(options) {
+        this.wsClient = options.wsClient;
+        this.maxConcurrentTasks = options.maxConcurrentTasks ?? 4;
+        this.defaultTimeout = options.defaultTimeout ?? 3600000; // 1 hour
+        this.useWorktree = options.useWorktree ?? true;
+        this.worktreeRoot = options.worktreeRoot;
+        this.preserveWorktrees = options.preserveWorktrees ?? false;
+        this.allowNonGit = options.allowNonGit ?? false;
+        this.useSandbox = options.useSandbox ?? false;
+        this.maxSandboxSize = options.maxSandboxSize ?? 100 * 1024 * 1024; // 100MB
+        this.jobMonitor = new SlurmJobMonitor(options.wsClient);
+        // Check git availability on startup
+        isGitAvailable().then((available) => {
+            this.gitAvailable = available;
+            console.log(`[executor] Git ${available ? 'available' : 'not available'}`);
+        }).catch(() => {
+            this.gitAvailable = false;
+        });
+    }
+    /**
+     * Submit a task for execution (with safety checks)
+     */
+    async submitTask(task) {
+        const normalizedTask = {
+            ...task,
+            workingDirectory: resolveWorkingDirectory(task.workingDirectory),
+        };
+        // Perform safety check
+        const safetyCheck = await this.performSafetyCheck(normalizedTask);
+        // Handle safety tiers
+        if (safetyCheck.tier === WorkdirSafetyTier.UNSAFE) {
+            // BLOCK: unsafe conditions
+            this.wsClient.sendTaskResult({
+                taskId: normalizedTask.id,
+                status: 'failed',
+                error: safetyCheck.blockReason,
+                completedAt: new Date().toISOString(),
+            });
+            return;
+        }
+        if (safetyCheck.tier === WorkdirSafetyTier.RISKY && !this.allowNonGit) {
+            // PROMPT: risky conditions require user decision
+            await this.requestSafetyDecision(normalizedTask, safetyCheck);
+            // Execution will continue when decision is received
+            return;
+        }
+        if (safetyCheck.tier === WorkdirSafetyTier.GUARDED) {
+            // WARN: inform user but continue
+            this.wsClient.sendTaskStatus(normalizedTask.id, 'queued', 0, safetyCheck.warning);
+        }
+        // Track task by directory
+        this.trackTaskDirectory(normalizedTask);
+        // Check if we can run immediately
+        if (this.runningTasks.size < this.maxConcurrentTasks) {
+            await this.executeTask(normalizedTask, this.useSandbox);
+        }
+        else {
+            // Queue the task
+            this.taskQueue.push(normalizedTask);
+            this.wsClient.sendTaskStatus(normalizedTask.id, 'queued', 0, 'Waiting for available slot');
+        }
+    }
+    /**
+     * Handle safety decision from user (via server)
+     */
+    async handleSafetyDecision(taskId, decision) {
+        const pending = this.pendingSafetyChecks.get(taskId);
+        if (!pending) {
+            console.warn(`[executor] Safety decision for ${taskId} but no pending check`);
+            return;
+        }
+        this.pendingSafetyChecks.delete(taskId);
+        pending.resolveDecision(decision);
+    }
+    /**
+     * Cancel a running or queued task
+     */
+    cancelTask(taskId) {
+        // Check running tasks
+        const running = this.runningTasks.get(taskId);
+        if (running) {
+            running.abortController.abort();
+            return true;
+        }
+        // Check queue
+        const queueIndex = this.taskQueue.findIndex((t) => t.id === taskId);
+        if (queueIndex >= 0) {
+            this.taskQueue.splice(queueIndex, 1);
+            this.wsClient.sendTaskResult({
+                taskId,
+                status: 'cancelled',
+                completedAt: new Date().toISOString(),
+            });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get current task counts
+     */
+    getTaskCounts() {
+        return {
+            running: this.runningTasks.size,
+            queued: this.taskQueue.length,
+        };
+    }
+    /**
+     * Cancel all tasks and clear queue
+     */
+    cancelAll() {
+        // Cancel all running tasks
+        for (const [taskId, running] of this.runningTasks) {
+            running.abortController.abort();
+            this.wsClient.sendTaskResult({
+                taskId,
+                status: 'cancelled',
+                completedAt: new Date().toISOString(),
+            });
+        }
+        this.runningTasks.clear();
+        // Clear queue
+        for (const task of this.taskQueue) {
+            this.wsClient.sendTaskResult({
+                taskId: task.id,
+                status: 'cancelled',
+                completedAt: new Date().toISOString(),
+            });
+        }
+        this.taskQueue = [];
+        // Stop job monitor
+        this.jobMonitor.stop();
+    }
+    /**
+     * Update max concurrent tasks
+     */
+    setMaxConcurrentTasks(max) {
+        this.maxConcurrentTasks = max;
+        // Process queue in case we can now run more tasks
+        this.processQueue();
+    }
+    /**
+     * Steer a running task by injecting a message into the agent session.
+     * When interrupt=true, interrupts the current turn before injecting.
+     *
+     * For completed tasks with a preserved session, this triggers a full
+     * resume via the SDK's `resume` option for post-completion follow-up.
+     */
+    async steerTask(taskId, message, interrupt = false) {
+        const running = this.runningTasks.get(taskId);
+        if (running) {
+            // Task is still running — inject message into the live session
+            if (running.adapter instanceof ClaudeSdkAdapter && typeof running.adapter.injectMessage === 'function') {
+                const injected = await running.adapter.injectMessage(taskId, message, interrupt);
+                if (injected) {
+                    return { accepted: true };
+                }
+                return { accepted: false, reason: 'Failed to inject message into running session' };
+            }
+            return { accepted: false, reason: 'Provider does not support mid-execution steering' };
+        }
+        // Task is not running — check if we have a preserved session for resume
+        const adapter = this.findAdapterWithSession(taskId);
+        if (adapter) {
+            const context = adapter.getTaskContext(taskId);
+            if (context) {
+                // Launch a resume as a new "task" execution
+                this.resumeCompletedTask(taskId, message, adapter, context);
+                return { accepted: true };
+            }
+        }
+        return { accepted: false, reason: 'Task not found or session expired' };
+    }
+    /**
+     * Find the ClaudeSdkAdapter that has a preserved session for the given task.
+     */
+    findAdapterWithSession(taskId) {
+        for (const adapter of this.adapters.values()) {
+            if (adapter instanceof ClaudeSdkAdapter) {
+                const context = adapter.getTaskContext(taskId);
+                if (context)
+                    return adapter;
+            }
+        }
+        return null;
+    }
+    /**
+     * Resume a completed task session for post-completion steering.
+     * Runs in the background, streaming output back through the WebSocket.
+     */
+    async resumeCompletedTask(taskId, message, adapter, context) {
+        const abortController = new AbortController();
+        let textSequence = 0;
+        const stream = {
+            stdout: (data) => {
+                this.wsClient.sendTaskOutput(taskId, 'stdout', data, 0);
+            },
+            stderr: (data) => {
+                this.wsClient.sendTaskOutput(taskId, 'stderr', data, 0);
+            },
+            status: (status, progress, statusMessage) => {
+                this.wsClient.sendTaskStatus(taskId, status, progress, statusMessage);
+            },
+            toolTrace: (toolName, toolInput, toolResult, success) => {
+                this.wsClient.sendToolTrace(taskId, toolName, toolInput, toolResult, success);
+            },
+            text: (data) => {
+                this.wsClient.sendTaskText(taskId, data, textSequence++);
+            },
+            toolUse: (toolName, toolInput) => {
+                this.wsClient.sendTaskToolUse(taskId, toolName, toolInput);
+            },
+            toolResult: (toolName, result, success) => {
+                this.wsClient.sendTaskToolResult(taskId, toolName, result, success);
+            },
+            fileChange: (path, action, linesAdded, linesRemoved, diff) => {
+                this.wsClient.sendTaskFileChange(taskId, path, action, linesAdded, linesRemoved, diff);
+            },
+            sessionInit: (sessionId, model) => {
+                this.wsClient.sendTaskSessionInit(taskId, sessionId, model);
+            },
+            approvalRequest: async (question, options) => {
+                return this.wsClient.sendApprovalRequest(taskId, question, options);
+            },
+        };
+        try {
+            this.wsClient.sendTaskStatus(taskId, 'running', 0, 'Resuming session...');
+            const result = await adapter.resumeTask(taskId, message, context.workingDirectory ?? process.cwd(), context.sessionId, stream, abortController.signal);
+            this.wsClient.sendTaskResult({
+                taskId,
+                status: result.success ? 'completed' : 'failed',
+                output: result.output,
+                error: result.error,
+                completedAt: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.wsClient.sendTaskResult({
+                taskId,
+                status: 'failed',
+                error: `Resume failed: ${errorMsg}`,
+                completedAt: new Date().toISOString(),
+            });
+        }
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    /**
+     * Perform safety check on working directory
+     */
+    async performSafetyCheck(task) {
+        const activeTasksInDir = this.getActiveTasksInDirectory(task.workingDirectory);
+        return await checkWorkdirSafety(task.workingDirectory, activeTasksInDir, this.gitAvailable);
+    }
+    /**
+     * Request safety decision from user
+     */
+    async requestSafetyDecision(task, safetyCheck) {
+        // Send safety prompt to server (which forwards to UI)
+        const options = [
+            { id: 'proceed', label: 'Continue anyway', description: 'Execute in non-git directory at your own risk' },
+            { id: 'init-git', label: 'Initialize git first', description: 'Create git repository before execution' },
+            { id: 'sandbox', label: 'Use sandbox mode', description: 'Work on a copy, review changes before applying' },
+            { id: 'cancel', label: 'Cancel task', description: 'Do not execute this task' },
+        ];
+        // Create promise that will be resolved when decision arrives, with a 5-minute timeout
+        const SAFETY_DECISION_TIMEOUT_MS = 5 * 60 * 1000;
+        const decisionPromise = new Promise((resolve) => {
+            this.pendingSafetyChecks.set(task.id, {
+                task,
+                safetyResult: safetyCheck,
+                resolveDecision: resolve,
+            });
+            // Auto-cancel if no decision within timeout
+            setTimeout(() => {
+                if (this.pendingSafetyChecks.has(task.id)) {
+                    console.warn(`[executor] Safety decision for task ${task.id} timed out after ${SAFETY_DECISION_TIMEOUT_MS / 1000}s, auto-cancelling`);
+                    this.pendingSafetyChecks.delete(task.id);
+                    resolve('cancel');
+                }
+            }, SAFETY_DECISION_TIMEOUT_MS).unref();
+        });
+        // Send prompt
+        this.wsClient.sendSafetyPrompt(task.id, safetyCheck.tier, safetyCheck.warning, options);
+        // Wait for decision
+        const decision = await decisionPromise;
+        // Handle decision
+        switch (decision) {
+            case 'proceed':
+                // Mark as allowed and continue
+                this.trackTaskDirectory(task);
+                if (this.runningTasks.size < this.maxConcurrentTasks) {
+                    await this.executeTask(task, false);
+                }
+                else {
+                    this.taskQueue.push(task);
+                    this.wsClient.sendTaskStatus(task.id, 'queued', 0, 'Waiting for available slot');
+                }
+                break;
+            case 'sandbox':
+                // Execute in sandbox mode
+                this.trackTaskDirectory(task);
+                if (this.runningTasks.size < this.maxConcurrentTasks) {
+                    await this.executeTask(task, true); // Force sandbox mode
+                }
+                else {
+                    this.taskQueue.push(task);
+                    this.wsClient.sendTaskStatus(task.id, 'queued', 0, 'Waiting for available slot (sandbox)');
+                }
+                break;
+            case 'init-git':
+                // Initialize git and retry
+                try {
+                    await this.initializeGit(task.workingDirectory);
+                    this.wsClient.sendTaskStatus(task.id, 'queued', 0, 'Git initialized, proceeding...');
+                    this.trackTaskDirectory(task);
+                    if (this.runningTasks.size < this.maxConcurrentTasks) {
+                        await this.executeTask(task, false);
+                    }
+                    else {
+                        this.taskQueue.push(task);
+                        this.wsClient.sendTaskStatus(task.id, 'queued', 0, 'Waiting for available slot');
+                    }
+                }
+                catch (error) {
+                    this.wsClient.sendTaskResult({
+                        taskId: task.id,
+                        status: 'failed',
+                        error: `Failed to initialize git: ${error instanceof Error ? error.message : String(error)}`,
+                        completedAt: new Date().toISOString(),
+                    });
+                }
+                break;
+            case 'cancel':
+                // Cancel the task
+                this.wsClient.sendTaskResult({
+                    taskId: task.id,
+                    status: 'cancelled',
+                    completedAt: new Date().toISOString(),
+                });
+                break;
+        }
+    }
+    /**
+     * Initialize git repository in a directory
+     */
+    async initializeGit(workdir) {
+        const { execFile } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const execFileAsync = promisify(execFile);
+        await execFileAsync('git', ['init'], { cwd: workdir, timeout: 10_000 });
+        await execFileAsync('git', ['add', '.'], { cwd: workdir, timeout: 10_000 });
+        await execFileAsync('git', ['commit', '-m', 'Initial commit'], { cwd: workdir, timeout: 10_000 });
+    }
+    /**
+     * Track task by directory for parallel execution safety
+     */
+    trackTaskDirectory(task) {
+        const tasks = this.tasksByDirectory.get(task.workingDirectory) || new Set();
+        tasks.add(task.id);
+        this.tasksByDirectory.set(task.workingDirectory, tasks);
+    }
+    /**
+     * Untrack task from directory
+     */
+    untrackTaskDirectory(task) {
+        const tasks = this.tasksByDirectory.get(task.workingDirectory);
+        if (tasks) {
+            tasks.delete(task.id);
+            if (tasks.size === 0) {
+                this.tasksByDirectory.delete(task.workingDirectory);
+            }
+        }
+    }
+    /**
+     * Get count of active tasks in a directory
+     */
+    getActiveTasksInDirectory(workdir) {
+        const tasks = this.tasksByDirectory.get(workdir);
+        return tasks ? tasks.size : 0;
+    }
+    async executeTask(task, useSandbox = false) {
+        console.log(`[executor] Task ${task.id}: workingDirectory=${task.workingDirectory} sandbox=${useSandbox}`);
+        // Setup sandbox if requested
+        let sandbox;
+        let workdir = task.workingDirectory;
+        if (useSandbox) {
+            try {
+                this.wsClient.sendTaskStatus(task.id, 'running', 0, 'Creating sandbox...');
+                sandbox = await createSandbox({
+                    workdir: task.workingDirectory,
+                    taskId: task.id,
+                    maxSize: this.maxSandboxSize,
+                });
+                workdir = sandbox.sandboxPath;
+                console.log(`[executor] Task ${task.id}: sandbox created at ${sandbox.sandboxPath}`);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`[executor] Task ${task.id}: sandbox creation failed: ${errorMsg}`);
+                this.wsClient.sendTaskResult({
+                    taskId: task.id,
+                    status: 'failed',
+                    error: `Sandbox creation failed: ${errorMsg}`,
+                    completedAt: new Date().toISOString(),
+                });
+                this.untrackTaskDirectory(task);
+                this.processQueue();
+                return;
+            }
+        }
+        const normalizedTask = { ...task, workingDirectory: workdir };
+        // Get or create adapter for this provider
+        const adapter = await this.getAdapter(normalizedTask.provider);
+        if (!adapter) {
+            console.error(`[executor] Task ${task.id}: provider ${normalizedTask.provider} not available`);
+            this.wsClient.sendTaskResult({
+                taskId: normalizedTask.id,
+                status: 'failed',
+                error: `Provider ${normalizedTask.provider} not available`,
+                completedAt: new Date().toISOString(),
+            });
+            if (sandbox)
+                await sandbox.cleanup();
+            this.untrackTaskDirectory(task);
+            this.processQueue();
+            return;
+        }
+        console.log(`[executor] Task ${task.id}: adapter ${adapter.name} (${adapter.type}) ready`);
+        const abortController = new AbortController();
+        const outputSequence = { stdout: 0, stderr: 0 };
+        // Create stream handlers before workspace prep so setup output is captured
+        let textSequence = 0;
+        const stream = {
+            stdout: (data) => {
+                this.wsClient.sendTaskOutput(normalizedTask.id, 'stdout', data, outputSequence.stdout++);
+            },
+            stderr: (data) => {
+                this.wsClient.sendTaskOutput(normalizedTask.id, 'stderr', data, outputSequence.stderr++);
+            },
+            status: (status, progress, message) => {
+                this.wsClient.sendTaskStatus(normalizedTask.id, status, progress, message);
+            },
+            toolTrace: (toolName, toolInput, toolResult, success) => {
+                this.wsClient.sendToolTrace(normalizedTask.id, toolName, toolInput, toolResult, success);
+            },
+            text: (data) => {
+                this.wsClient.sendTaskText(normalizedTask.id, data, textSequence++);
+            },
+            toolUse: (toolName, toolInput) => {
+                this.wsClient.sendTaskToolUse(normalizedTask.id, toolName, toolInput);
+            },
+            toolResult: (toolName, result, success) => {
+                this.wsClient.sendTaskToolResult(normalizedTask.id, toolName, result, success);
+            },
+            fileChange: (path, action, linesAdded, linesRemoved, diff) => {
+                this.wsClient.sendTaskFileChange(normalizedTask.id, path, action, linesAdded, linesRemoved, diff);
+            },
+            sessionInit: (sessionId, model) => {
+                this.wsClient.sendTaskSessionInit(normalizedTask.id, sessionId, model);
+            },
+            approvalRequest: async (question, options) => {
+                return this.wsClient.sendApprovalRequest(normalizedTask.id, question, options);
+            },
+        };
+        const runningTask = {
+            task: normalizedTask,
+            abortController,
+            adapter,
+            outputSequence,
+            sandbox,
+        };
+        this.runningTasks.set(normalizedTask.id, runningTask);
+        this.wsClient.addActiveTask(normalizedTask.id);
+        const prepared = await this.prepareTaskWorkspace(normalizedTask, stream);
+        const taskWithWorkspace = { ...normalizedTask, workingDirectory: prepared.workingDirectory };
+        runningTask.task = taskWithWorkspace;
+        console.log(`[executor] Task ${task.id}: workspace prepared, cwd=${prepared.workingDirectory}`);
+        // Execute with timeout
+        const timeout = task.timeout ?? this.defaultTimeout;
+        const timeoutId = setTimeout(() => {
+            abortController.abort();
+        }, timeout);
+        let keepBranch = false;
+        try {
+            // Notify task started
+            this.wsClient.sendTaskStatus(task.id, 'running', 0, 'Starting');
+            console.log(`[executor] Task ${task.id}: executing with ${adapter.name}...`);
+            // Execute the task
+            const result = await adapter.execute(taskWithWorkspace, stream, abortController.signal);
+            // Delivery-mode-aware result handling
+            const deliveryMode = task.deliveryMode ?? 'pr';
+            if (prepared.branchName && (result.status === 'completed' || !result.error)) {
+                try {
+                    if (deliveryMode === 'direct') {
+                        // No git delivery — files modified in-place
+                        console.log(`[executor] Task ${task.id}: direct mode, skipping git delivery`);
+                    }
+                    else if (deliveryMode === 'copy') {
+                        // Copy mode: worktree preserved, no git operations
+                        console.log(`[executor] Task ${task.id}: copy mode, worktree preserved at ${prepared.workingDirectory}`);
+                    }
+                    else if (deliveryMode === 'branch') {
+                        // Auto-commit but don't push — branch stays local
+                        console.log(`[executor] Task ${task.id}: branch mode, committing locally`);
+                        result.branchName = prepared.branchName;
+                        keepBranch = true;
+                    }
+                    else if (deliveryMode === 'push') {
+                        // Push branch to remote, but don't create a PR — user creates PR manually
+                        console.log(`[executor] Task ${task.id}: push mode, pushing branch ${prepared.branchName}`);
+                        const prResult = await pushAndCreatePR(prepared.workingDirectory, {
+                            branchName: prepared.branchName,
+                            taskTitle: task.prompt.slice(0, 100),
+                            taskDescription: task.prompt.slice(0, 500),
+                            skipPR: true,
+                        });
+                        result.branchName = prResult.branchName;
+                        if (prResult.pushed) {
+                            keepBranch = true;
+                            console.log(`[executor] Task ${task.id}: branch pushed (${prepared.branchName})`);
+                        }
+                        else {
+                            console.log(`[executor] Task ${task.id}: no changes to push`);
+                        }
+                    }
+                    else {
+                        // 'pr' — push + create PR (existing behavior)
+                        console.log(`[executor] Task ${task.id}: pr mode, attempting PR creation for branch ${prepared.branchName}`);
+                        const prResult = await pushAndCreatePR(prepared.workingDirectory, {
+                            branchName: prepared.branchName,
+                            taskTitle: task.prompt.slice(0, 100),
+                            taskDescription: task.prompt.slice(0, 500),
+                        });
+                        result.branchName = prResult.branchName;
+                        if (prResult.prUrl) {
+                            result.prUrl = prResult.prUrl;
+                            result.prNumber = prResult.prNumber;
+                            keepBranch = true;
+                            console.log(`[executor] Task ${task.id}: PR created at ${prResult.prUrl}`);
+                        }
+                        else if (prResult.pushed) {
+                            keepBranch = true;
+                            console.log(`[executor] Task ${task.id}: branch pushed, no PR created (gh not available?)`);
+                        }
+                        else {
+                            console.log(`[executor] Task ${task.id}: no changes to push`);
+                        }
+                    }
+                }
+                catch (prError) {
+                    const prMsg = prError instanceof Error ? prError.message : String(prError);
+                    console.warn(`[executor] Task ${task.id}: delivery (${deliveryMode}) failed: ${prMsg}`);
+                    // Non-fatal: still report the task result without PR info
+                }
+            }
+            console.log(`[executor] Task ${task.id}: completed with status=${result.status}${result.error ? ` error=${result.error}` : ''}`);
+            // Check if there are tracked Slurm jobs still running for this task.
+            // If so, don't send the final result yet — let the job monitor handle it.
+            const pendingJobs = this.jobMonitor.getJobsForExecution(task.id);
+            if (pendingJobs.length > 0) {
+                console.log(`[executor] Task ${task.id}: ${pendingJobs.length} Slurm job(s) still tracked, deferring completion`);
+                this.wsClient.sendTaskStatus(task.id, 'running', 80, `Waiting for ${pendingJobs.length} Slurm job(s): ${pendingJobs.join(', ')}`);
+                // Don't send final result — the SlurmJobMonitor will send it when jobs finish
+            }
+            else {
+                // Send final result
+                this.wsClient.sendTaskResult(result);
+            }
+        }
+        catch (error) {
+            // Unexpected error during execution
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`[executor] Task ${task.id}: execution error: ${errorMsg}`);
+            this.wsClient.sendTaskResult({
+                taskId: task.id,
+                status: 'failed',
+                error: errorMsg,
+                completedAt: new Date().toISOString(),
+            });
+        }
+        finally {
+            clearTimeout(timeoutId);
+            // Cleanup worktree — but preserve it if a branch was pushed/PR created,
+            // so the worktree remains available for post-execution steering or inspection.
+            // The server will trigger explicit cleanup when the task is fully completed.
+            if (this.preserveWorktrees || keepBranch) {
+                console.log(`[executor] Task ${task.id}: worktree preserved (${this.preserveWorktrees ? 'debug mode' : 'branch pushed'})`);
+            }
+            else {
+                await prepared.cleanup({ keepBranch: false });
+            }
+            // Sandbox: copy back results then cleanup
+            if (sandbox) {
+                try {
+                    console.log(`[executor] Task ${task.id}: copying back sandbox results`);
+                    await sandbox.copyBack();
+                }
+                catch (copyBackErr) {
+                    const msg = copyBackErr instanceof Error ? copyBackErr.message : String(copyBackErr);
+                    console.error(`[executor] Task ${task.id}: sandbox copyBack failed: ${msg}`);
+                }
+                console.log(`[executor] Task ${task.id}: cleaning up sandbox`);
+                await sandbox.cleanup();
+            }
+            // Untrack task from directory
+            this.untrackTaskDirectory(task);
+            this.runningTasks.delete(task.id);
+            this.wsClient.removeActiveTask(task.id);
+            this.processQueue();
+        }
+    }
+    async prepareTaskWorkspace(task, stream) {
+        if (!this.useWorktree) {
+            console.warn(`[executor] Task ${task.id}: worktree disabled, using raw workdir: ${task.workingDirectory}`);
+            return { workingDirectory: task.workingDirectory, cleanup: async () => { } };
+        }
+        // Direct delivery mode: skip worktree, work in-place
+        if (task.deliveryMode === 'direct') {
+            console.log(`[executor] Task ${task.id}: direct delivery mode, using raw workdir: ${task.workingDirectory}`);
+            return { workingDirectory: task.workingDirectory, cleanup: async () => { } };
+        }
+        // Copy delivery mode: copy project to worktree dir (non-git)
+        if (task.deliveryMode === 'copy') {
+            try {
+                const agentDirName = task.agentDir ?? '.astro';
+                if (task.worktreeStrategy === 'reference') {
+                    const { createReferenceWorktree } = await import('./copy-worktree.js');
+                    const ref = await createReferenceWorktree(task.workingDirectory, agentDirName, task.id);
+                    console.log(`[executor] Task ${task.id}: reference worktree at ${ref.worktreePath}`);
+                    return { workingDirectory: ref.worktreePath, cleanup: async () => { await ref.cleanup(); } };
+                }
+                const { createCopyWorktree } = await import('./copy-worktree.js');
+                const copy = await createCopyWorktree(task.workingDirectory, agentDirName, task.id);
+                console.log(`[executor] Task ${task.id}: copy worktree at ${copy.worktreePath}`);
+                return { workingDirectory: copy.worktreePath, cleanup: async () => { await copy.cleanup(); } };
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`[executor] Task ${task.id}: copy worktree failed: ${errorMsg}, using raw workdir`);
+                return { workingDirectory: task.workingDirectory, cleanup: async () => { } };
+            }
+        }
+        try {
+            console.log(`[executor] Task ${task.id}: creating worktree for workdir=${task.workingDirectory}`);
+            const worktree = await createWorktree({
+                workingDirectory: task.workingDirectory,
+                taskId: task.id,
+                rootOverride: this.worktreeRoot,
+                projectId: task.projectId,
+                nodeId: task.planNodeId,
+                agentDir: task.agentDir,
+                stdout: stream.stdout,
+                stderr: stream.stderr,
+            });
+            if (!worktree) {
+                console.warn(`[executor] Task ${task.id}: createWorktree returned null, falling back to raw workdir: ${task.workingDirectory}`);
+                return { workingDirectory: task.workingDirectory, cleanup: async () => { } };
+            }
+            console.log(`[executor] Task ${task.id}: worktree created at ${worktree.workingDirectory} (branch: ${worktree.branchName})`);
+            return worktree;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`[executor] Task ${task.id}: worktree creation FAILED: ${errorMsg} — falling back to raw workdir: ${task.workingDirectory}`);
+            this.wsClient.sendTaskStatus(task.id, 'running', 0, `Worktree setup failed: ${errorMsg}`);
+            return { workingDirectory: task.workingDirectory, cleanup: async () => { } };
+        }
+    }
+    async getAdapter(type) {
+        // Check cache
+        const cached = this.adapters.get(type);
+        if (cached) {
+            return cached;
+        }
+        // Create new adapter
+        const adapter = createProviderAdapter(type);
+        if (!adapter) {
+            return null;
+        }
+        // Wire up job monitor for HPC-aware adapters
+        if (adapter instanceof ClaudeSdkAdapter) {
+            adapter.setJobMonitor(this.jobMonitor);
+        }
+        // Check availability
+        const available = await adapter.isAvailable();
+        if (!available) {
+            return null;
+        }
+        // Cache and return
+        this.adapters.set(type, adapter);
+        return adapter;
+    }
+    processQueue() {
+        while (this.runningTasks.size < this.maxConcurrentTasks && this.taskQueue.length > 0) {
+            const task = this.taskQueue.shift();
+            if (task) {
+                this.executeTask(task).catch((err) => {
+                    console.error(`[executor] Queued task ${task.id} failed unexpectedly: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
+        }
+    }
+}
+/**
+ * Resolve a working directory value.
+ * - Empty/missing → error (must be explicitly set to prevent operating on the agent runner's own repo)
+ * - Git URL → error (repo setup should have resolved this to a local path)
+ * - Otherwise → return as-is
+ */
+function resolveWorkingDirectory(value) {
+    if (!value) {
+        throw new Error('workingDirectory is required but was not provided. ' +
+            'Configure a project directory or repository before dispatching tasks.');
+    }
+    const isGitUrl = value.startsWith('http://') || value.startsWith('https://') || value.startsWith('git@');
+    if (isGitUrl) {
+        throw new Error(`workingDirectory is still a git URL at dispatch time. Run repo setup first.`);
+    }
+    return value;
+}
+//# sourceMappingURL=task-executor.js.map