@astroanywhere/agent 0.2.15 → 0.2.17

package/dist/lib/task-executor.d.ts

@@ -43,6 +43,10 @@ export declare class TaskExecutor {
     private openclawBridge;
     private tasksByDirectory;
     private pendingSafetyChecks;
+    /** Preserved task metadata for worktree recreation on post-completion resume */
+    private completedTaskMeta;
+    /** TTL for completed task metadata (10 minutes, matches adapter session TTL) */
+    private static readonly COMPLETED_TASK_META_TTL_MS;
     constructor(options: TaskExecutorOptions);
     /**
      * Inject the OpenClaw bridge for task execution delegation.
@@ -92,28 +96,20 @@ export declare class TaskExecutor {
         accepted: boolean;
         reason?: string;
     }>;
-    /** Adapter types that support session preservation and resume */
+    /** Check if an adapter supports session persistence and resume */
     private isResumableAdapter;
+    /** Remove completedTaskMeta entries older than TTL */
+    private cleanupExpiredTaskMeta;
     /**
      * Find the adapter that has a preserved session for the given task.
-     * Supports ClaudeSdkAdapter, CodexAdapter, OpenClawAdapter, and OpenCodeAdapter.
      */
     private findAdapterWithSession;
     /**
      * Resume a completed task session for post-completion steering.
-     * Runs in the background, streaming output back through the WebSocket.
+     * Provider-agnostic — works with any adapter that implements resumeTask().
+     * Handles worktree cleanup by falling back to the original project directory.
      */
-    private resumeCompletedTask;
-    /**
-     * Resume a completed Codex task session for post-completion steering.
-     * Uses `codex exec resume <threadId>` for multi-turn conversations.
-     */
-    private resumeCompletedCodexTask;
-    /**
-     * Resume a completed OpenClaw or OpenCode session.
-     * Generic handler that works for any adapter with resumeTask().
-     */
-    private resumeCompletedCliTask;
+    private resumeCompletedSession;
     /**
      * Perform safety check on working directory
      */

package/dist/lib/task-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-executor.d.ts","sourceRoot":"","sources":["../../src/lib/task-executor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"task-executor.d.ts","sourceRoot":"","sources":["../../src/lib/task-executor.ts"],"names":[],"mappings":"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"}

package/dist/lib/task-executor.js

@@ -5,17 +5,16 @@
  * and streaming output back over WebSocket
  */
 import { homedir } from 'node:os';
-import { statSync, realpathSync } from 'node:fs';
+import { statSync, realpathSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createProviderAdapter } from '../providers/index.js';
 import { ClaudeSdkAdapter } from '../providers/claude-sdk-adapter.js';
-import { CodexAdapter } from '../providers/codex-adapter.js';
 import { OpenClawAdapter } from '../providers/openclaw-adapter.js';
-import { OpenCodeAdapter } from '../providers/opencode-adapter.js';
 import { SlurmJobMonitor } from './slurm-job-monitor.js';
 import { createWorktree, syncProjectWorktree } from './worktree.js';
+import { ensureProjectWorkspace } from './workspace-root.js';
 import { BranchLockManager } from './branch-lock.js';
 import { pushAndCreatePR, mergePullRequest, getRemoteBranchSha, isGhAvailable } from './git-pr.js';
 import { localMergeIntoProjectBranch } from './local-merge.js';
@@ -159,6 +158,10 @@ export class TaskExecutor {
     // Safety tracking
     tasksByDirectory = new Map(); // workdir -> taskIds
     pendingSafetyChecks = new Map(); // taskId -> pending check
+    /** Preserved task metadata for worktree recreation on post-completion resume */
+    completedTaskMeta = new Map();
+    /** TTL for completed task metadata (10 minutes, matches adapter session TTL) */
+    static COMPLETED_TASK_META_TTL_MS = 10 * 60 * 1000;
     constructor(options) {
         this.wsClient = options.wsClient;
         this.maxConcurrentTasks = options.maxConcurrentTasks ?? 40;
@@ -200,29 +203,34 @@ export class TaskExecutor {
     async submitTask(task) {
         // Skip workingDirectory resolution for lightweight text-only tasks (no file system access)
         const isTextOnlyTask = task.type === 'summarize' || task.type === 'chat' || task.type === 'plan';
+        // Text-only tasks (plan/chat/summarize) can run without a working directory.
+        // For all others, resolve the directory or auto-provision one.
         let resolvedWorkDir;
-        try {
-            resolvedWorkDir = isTextOnlyTask && !task.workingDirectory
-                ? undefined // Text-only tasks can run without a working directory
-                : resolveWorkingDirectory(task.workingDirectory);
+        if (isTextOnlyTask && !task.workingDirectory) {
+            resolvedWorkDir = undefined;
         }
-        catch (err) {
-            // Fail fast with a clear error instead of entering the execution pipeline.
-            // Without this, tasks with non-existent directories become dead jobs.
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            console.error(`[executor] Task ${task.id}: ${errorMsg}`);
-            this.wsClient.sendTaskResult({
-                taskId: task.id,
-                status: 'failed',
-                error: errorMsg,
-                completedAt: new Date().toISOString(),
-            });
-            this.wsClient.removeActiveTask(task.id);
-            return;
+        else {
+            try {
+                resolvedWorkDir = resolveWorkingDirectory(task.workingDirectory, task.projectId);
+            }
+            catch (err) {
+                // Fail fast with a clear error instead of entering the execution pipeline.
+                // Without this, tasks with non-existent directories become dead jobs.
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                console.error(`[executor] Task ${task.id}: ${errorMsg}`);
+                this.wsClient.sendTaskResult({
+                    taskId: task.id,
+                    status: 'failed',
+                    error: errorMsg,
+                    completedAt: new Date().toISOString(),
+                });
+                this.wsClient.removeActiveTask(task.id);
+                return;
+            }
         }
         const normalizedTask = {
             ...task,
-            workingDirectory: resolvedWorkDir,
+            workingDirectory: resolvedWorkDir ?? '',
         };
         // Determine if worktree isolation will be used for this task.
         // Check git availability early: non-git directories cannot use git worktrees,
@@ -472,8 +480,7 @@ export class TaskExecutor {
         const running = this.runningTasks.get(taskId);
         if (running) {
             // Task is still running — inject message into the live session
-            // Only ClaudeSdkAdapter supports mid-execution steering; Codex does not.
-            if (running.adapter instanceof ClaudeSdkAdapter && typeof running.adapter.injectMessage === 'function') {
+            if (running.adapter.injectMessage) {
                 const injected = await running.adapter.injectMessage(taskId, message, interrupt);
                 if (injected) {
                     return { accepted: true };
@@ -491,33 +498,27 @@ export class TaskExecutor {
                 if (sessionId && context.sessionId !== sessionId) {
                     console.warn(`[task-executor] Session hint mismatch for task ${taskId}: hint=${sessionId}, actual=${context.sessionId}`);
                 }
-                if (resumeAdapter instanceof ClaudeSdkAdapter) {
-                    this.resumeCompletedTask(taskId, message, resumeAdapter, context);
-                    return { accepted: true };
-                }
-                if (resumeAdapter instanceof CodexAdapter) {
-                    this.resumeCompletedCodexTask(taskId, message, resumeAdapter, context);
-                    return { accepted: true };
-                }
-                if (resumeAdapter instanceof OpenClawAdapter || resumeAdapter instanceof OpenCodeAdapter) {
-                    this.resumeCompletedCliTask(taskId, message, resumeAdapter, context);
-                    return { accepted: true };
-                }
-                console.warn(`[task-executor] Adapter has session for task ${taskId} but no resume implementation`);
+                this.resumeCompletedSession(taskId, message, resumeAdapter, context);
+                return { accepted: true };
             }
         }
         return { accepted: false, reason: 'Task not found or session expired' };
     }
-    /** Adapter types that support session preservation and resume */
+    /** Check if an adapter supports session persistence and resume */
     isResumableAdapter(adapter) {
-        return adapter instanceof ClaudeSdkAdapter
-            || adapter instanceof CodexAdapter
-            || adapter instanceof OpenClawAdapter
-            || adapter instanceof OpenCodeAdapter;
+        return typeof adapter.getTaskContext === 'function' && typeof adapter.resumeTask === 'function';
+    }
+    /** Remove completedTaskMeta entries older than TTL */
+    cleanupExpiredTaskMeta() {
+        const now = Date.now();
+        for (const [key, meta] of this.completedTaskMeta) {
+            if (now - meta.storedAt > TaskExecutor.COMPLETED_TASK_META_TTL_MS) {
+                this.completedTaskMeta.delete(key);
+            }
+        }
     }
     /**
      * Find the adapter that has a preserved session for the given task.
-     * Supports ClaudeSdkAdapter, CodexAdapter, OpenClawAdapter, and OpenCodeAdapter.
      */
     findAdapterWithSession(taskId) {
         for (const adapter of this.adapters.values()) {
@@ -531,9 +532,10 @@ export class TaskExecutor {
     }
     /**
      * Resume a completed task session for post-completion steering.
-     * Runs in the background, streaming output back through the WebSocket.
+     * Provider-agnostic — works with any adapter that implements resumeTask().
+     * Handles worktree cleanup by falling back to the original project directory.
      */
-    async resumeCompletedTask(taskId, message, adapter, context) {
+    async resumeCompletedSession(taskId, message, adapter, context) {
         const abortController = new AbortController();
         let textSequence = 0;
         const stream = {
@@ -568,129 +570,49 @@ export class TaskExecutor {
                 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(),
-            });
-        }
-    }
-    /**
-     * Resume a completed Codex task session for post-completion steering.
-     * Uses `codex exec resume <threadId>` for multi-turn conversations.
-     */
-    async resumeCompletedCodexTask(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 Codex 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: `Codex resume failed: ${errorMsg}`,
-                completedAt: new Date().toISOString(),
-            });
+        // Resolve working directory: existing worktree → recreate worktree → project dir → cwd
+        let resumeDir = context.workingDirectory;
+        let resumeWorktreeCleanup;
+        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 {
+                    console.log(`[executor] Task ${taskId}: worktree gone, recreating from project branch at ${meta.originalWorkingDirectory}`);
+                    const worktree = await createWorktree({
+                        workingDirectory: meta.originalWorkingDirectory,
+                        taskId: `resume-${taskId.slice(0, 12)}-${Date.now()}`,
+                        projectId: meta.projectId,
+                        shortProjectId: meta.shortProjectId,
+                        shortNodeId: meta.shortNodeId,
+                        agentDir: meta.agentDir,
+                        baseBranch: meta.baseBranch,
+                        projectBranch: meta.projectBranch,
+                        stdout: stream.stdout,
+                        stderr: stream.stderr,
+                    });
+                    if (worktree) {
+                        resumeDir = worktree.workingDirectory;
+                        resumeWorktreeCleanup = () => worktree.cleanup();
+                        console.log(`[executor] Task ${taskId}: resume worktree created at ${resumeDir}`);
+                    }
+                }
+                catch (err) {
+                    console.warn(`[executor] Task ${taskId}: worktree recreation failed (${err instanceof Error ? err.message : err}), using project dir`);
+                }
+                // If worktree creation failed, fall back to project dir
+                if (!resumeWorktreeCleanup) {
+                    resumeDir = meta.originalWorkingDirectory;
+                }
+            }
+            else {
+                console.warn(`[executor] Task ${taskId}: worktree gone and no project dir available, using process.cwd()`);
+                resumeDir = process.cwd();
+            }
         }
-    }
-    /**
-     * Resume a completed OpenClaw or OpenCode session.
-     * Generic handler that works for any adapter with resumeTask().
-     */
-    async resumeCompletedCliTask(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 ${adapter.name} session...`);
-            const result = await adapter.resumeTask(taskId, message, context.workingDirectory ?? process.cwd(), context.sessionId, stream, abortController.signal);
+            const result = await adapter.resumeTask(taskId, message, resumeDir ?? process.cwd(), context.sessionId, stream, abortController.signal);
             this.wsClient.sendTaskResult({
                 taskId,
                 status: result.success ? 'completed' : 'failed',
@@ -704,10 +626,22 @@ export class TaskExecutor {
             this.wsClient.sendTaskResult({
                 taskId,
                 status: 'failed',
-                error: `${adapter.name} resume failed: ${errorMsg}`,
+                error: `Resume failed: ${errorMsg}`,
                 completedAt: new Date().toISOString(),
             });
         }
+        finally {
+            // Clean up the resume worktree (if one was created)
+            if (resumeWorktreeCleanup) {
+                try {
+                    await resumeWorktreeCleanup();
+                    console.log(`[executor] Task ${taskId}: resume worktree cleaned up`);
+                }
+                catch (err) {
+                    console.warn(`[executor] Task ${taskId}: resume worktree cleanup failed:`, err);
+                }
+            }
+        }
     }
     // ============================================================================
     // Private Methods
@@ -913,7 +847,7 @@ export class TaskExecutor {
             this.processQueue();
             return;
         }
-        console.log(`[executor] Task ${task.id}: adapter ${adapter.name} (${adapter.type}) ready`);
+        console.log(`[executor] Task ${task.id}: adapter ${adapter.name} (${adapter.type}) ready, taskType=${normalizedTask.type ?? 'undefined'}, provider=${normalizedTask.provider}, resumeSessionId=${normalizedTask.resumeSessionId ?? 'none'}`);
         const abortController = new AbortController();
         const outputSequence = { stdout: 0, stderr: 0 };
         // Create stream handlers before workspace prep so setup output is captured
@@ -1025,23 +959,31 @@ export class TaskExecutor {
                 && isTextOnly;
             let result;
             if (canResume) {
-                console.log(`[executor] Task ${task.id}: resuming session ${taskWithWorkspace.resumeSessionId} with ${adapter.name}...`);
+                console.log(`[executor] Task ${task.id}: resuming session ${taskWithWorkspace.resumeSessionId} with ${adapter.name} (type=${adapter.type}, hasMessages=${!!taskWithWorkspace.messages?.length})...`);
                 const resumeStartedAt = new Date().toISOString();
                 try {
                     const resumeResult = await adapter.resumeTask(taskWithWorkspace.id, taskWithWorkspace.prompt, taskWithWorkspace.workingDirectory || process.cwd(), taskWithWorkspace.resumeSessionId, stream, abortController.signal);
-                    result = {
-                        taskId: taskWithWorkspace.id,
-                        status: resumeResult.success ? 'completed' : 'failed',
-                        output: resumeResult.output,
-                        error: resumeResult.error,
-                        startedAt: resumeStartedAt,
-                        completedAt: new Date().toISOString(),
-                    };
+                    if (resumeResult.success) {
+                        result = {
+                            taskId: taskWithWorkspace.id,
+                            status: 'completed',
+                            output: resumeResult.output,
+                            startedAt: resumeStartedAt,
+                            completedAt: new Date().toISOString(),
+                        };
+                    }
+                    else {
+                        // Resume resolved but failed (e.g. Codex session expired, CLI error) —
+                        // fall back to fresh execution. Codex/OpenCode adapters resolve with
+                        // { success: false } instead of throwing, so the catch block won't fire.
+                        console.warn(`[executor] Task ${task.id}: resume returned failure (${resumeResult.error}), falling back to fresh execution`);
+                        result = await adapter.execute(taskWithWorkspace, stream, abortController.signal);
+                    }
                 }
                 catch (resumeErr) {
-                    // Resume failed (session expired, different machine, SDK error) —
+                    // Resume threw (Claude SDK throws on session errors) —
                     // fall back to fresh execution with conversation history in messages
-                    console.warn(`[executor] Task ${task.id}: resume failed (${resumeErr instanceof Error ? resumeErr.message : resumeErr}), falling back to fresh execution`);
+                    console.warn(`[executor] Task ${task.id}: resume threw (${resumeErr instanceof Error ? resumeErr.message : resumeErr}), falling back to fresh execution`);
                     result = await adapter.execute(taskWithWorkspace, stream, abortController.signal);
                 }
             }
@@ -1049,6 +991,23 @@ export class TaskExecutor {
                 console.log(`[executor] Task ${task.id}: executing with ${adapter.name}...`);
                 result = await adapter.execute(taskWithWorkspace, stream, abortController.signal);
             }
+            // Store original working directory on the adapter's session so post-completion
+            // resume can fall back to it when the worktree has been cleaned up.
+            if (normalizedTask.workingDirectory && prepared.workingDirectory !== normalizedTask.workingDirectory) {
+                adapter.setOriginalWorkingDirectory?.(task.id, normalizedTask.workingDirectory);
+                // Preserve task metadata for worktree recreation on resume
+                this.cleanupExpiredTaskMeta();
+                this.completedTaskMeta.set(task.id, {
+                    originalWorkingDirectory: normalizedTask.workingDirectory,
+                    projectBranch: normalizedTask.projectBranch,
+                    baseBranch: normalizedTask.baseBranch,
+                    agentDir: normalizedTask.agentDir,
+                    shortProjectId: normalizedTask.shortProjectId,
+                    shortNodeId: normalizedTask.shortNodeId,
+                    projectId: normalizedTask.projectId,
+                    storedAt: Date.now(),
+                });
+            }
             // Emit accurate file change events via git diff (covers all change methods)
             if (!isTextOnly && prepared.workingDirectory) {
                 await this.emitGitDiffFileChanges(task.id, prepared.workingDirectory, prepared.commitBeforeSha, stream);
@@ -1068,7 +1027,7 @@ export class TaskExecutor {
             if (summary) {
                 console.log(`[executor] Task ${task.id}: summary available — status=${summary.status}, workCompleted=${!!summary.workCompleted}, executiveSummary=${!!summary.executiveSummary}, keyFindings=${summary.keyFindings?.length ?? 0}, filesChanged=${summary.filesChanged?.length ?? 0}`);
             }
-            else {
+            else if (!isTextOnly) {
                 console.warn(`[executor] Task ${task.id}: no summary available for PR body`);
             }
             const rawTitle = summary?.workCompleted || task.title || task.prompt.slice(0, 100);
@@ -1698,12 +1657,19 @@ export class TaskExecutor {
 }
 /**
  * Resolve a working directory value.
- * - Empty/missing → error (must be explicitly set to prevent operating on the agent runner's own repo)
+ * - Empty/missing + projectId → auto-provision workspace under workspace root
+ * - Empty/missing + no projectId → error
  * - Git URL → error (repo setup should have resolved this to a local path)
  * - Otherwise → return as-is
  */
-function resolveWorkingDirectory(value) {
+function resolveWorkingDirectory(value, projectId) {
     if (!value) {
+        if (projectId) {
+            // Auto-provision a temporary workspace for this project (no git init)
+            const dir = ensureProjectWorkspace(projectId);
+            console.log(`[executor] Auto-provisioned workspace for project ${projectId}: ${dir}`);
+            return dir;
+        }
         throw new Error('workingDirectory is required but was not provided. ' +
             'Configure a project directory or repository before dispatching tasks.');
     }