@aws/lsp-codewhisperer 0.0.113 → 0.0.115

package/out/language-server/netTransform/atxTransformHandler.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ATXTransformHandler = void 0;
+const fs = require("fs");
+const archiver = require("archiver");
+const got_1 = require("got");
 const path = require("path");
+const AdmZip = require("adm-zip");
 const artifactManager_1 = require("./artifactManager");
 const elastic_gumby_frontend_client_1 = require("@amazon/elastic-gumby-frontend-client");
 const AtxTokenServiceManager_1 = require("../../shared/amazonQServiceManager/AtxTokenServiceManager");
 const constants_1 = require("../../shared/constants");
+const atxModels_1 = require("./atxModels");
 const uuid_1 = require("uuid");
 const utils_1 = require("./utils");
 /**
@@ -19,6 +24,10 @@ class ATXTransformHandler {
     runtime;
     atxClient = null;
     cachedHitl = null;
+    cachedStepHitl = null;
+    cachedInteractiveMode = null;
+    _applyingCheckpoints = false;
+    _currentDiffContext = null;
     constructor(serviceManager, workspace, logging, runtime) {
         this.serviceManager = serviceManager;
         this.workspace = workspace;
@@ -133,6 +142,15 @@ class ATXTransformHandler {
     onProfileUpdate() {
         this.atxClient = null;
     }
+    /**
+     * Clear cached job state (for terminal job statuses)
+     */
+    clearJobCache() {
+        this.cachedHitl = null;
+        this.cachedStepHitl = null;
+        this.cachedInteractiveMode = null;
+        this.logging.log('ATX: Cleared job cache');
+    }
     /**
      * Verify session (internal LSP method called before each ATX API)
      */
@@ -171,19 +189,25 @@ class ATXTransformHandler {
             const workspaces = (response.items || []).map(workspace => ({
                 Id: workspace.id,
                 Name: workspace.name,
+                Description: workspace.description,
                 CreatedDate: new Date().toISOString(), // Use current date since createdDate not available
             }));
-            return workspaces;
+            const applicationUrl = this.serviceManager.getActiveApplicationUrl();
+            this.logging.log(`ATX: ApplicationUrl: ${applicationUrl}`);
+            return {
+                workspaces,
+                applicationUrl,
+            };
         }
         catch (error) {
             this.logging.error(`ATX: ListWorkspaces error: ${String(error)}`);
-            return [];
+            return { workspaces: [], applicationUrl: null };
         }
     }
     /**
      * Create a new workspace
      */
-    async createWorkspace(workspaceName) {
+    async createWorkspace(workspaceName, workspaceDescription) {
         try {
             this.logging.log(`ATX: Starting CreateWorkspace with name: ${workspaceName || 'auto-generated'}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
@@ -192,7 +216,8 @@ class ATXTransformHandler {
             const { CreateWorkspaceCommand } = await Promise.resolve().then(() => require('@amazon/elastic-gumby-frontend-client'));
             const command = new CreateWorkspaceCommand({
                 name: workspaceName || undefined,
-                description: workspaceName ? `Workspace: ${workspaceName}` : 'Auto-generated workspace',
+                description: workspaceDescription ||
+                    (workspaceName ? `Workspace: ${workspaceName}` : 'Auto-generated workspace'),
             });
             await this.addAuthToCommand(command);
             const response = await this.atxClient.send(command);
@@ -213,26 +238,67 @@ class ATXTransformHandler {
             return null;
         }
     }
+    /**
+     * List jobs in a workspace
+     */
+    async listJobs(workspaceId) {
+        try {
+            this.logging.log(`ATX: ========== ListJobs called for workspace: ${workspaceId} ==========`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const { ListJobsCommand } = await Promise.resolve().then(() => require('@amazon/elastic-gumby-frontend-client'));
+            const allJobs = [];
+            let nextToken;
+            // Paginate through all jobs
+            do {
+                const command = new ListJobsCommand({ workspaceId, nextToken });
+                await this.addAuthToCommand(command);
+                const response = await this.atxClient.send(command);
+                if (response.jobList) {
+                    allJobs.push(...response.jobList);
+                }
+                nextToken = response.nextToken;
+            } while (nextToken);
+            this.logging.log(`ATX: ListJobs completed - found ${allJobs.length} jobs`);
+            const jobs = allJobs.map(entry => ({
+                JobId: entry.jobInfo?.jobId || '',
+                JobName: entry.jobInfo?.jobName,
+                Status: entry.jobInfo?.statusDetails?.status || 'UNKNOWN',
+                CreationTime: entry.jobInfo?.creationTime?.toISOString(),
+                StartExecutionTime: entry.jobInfo?.startExecutionTime?.toISOString(),
+                EndExecutionTime: entry.jobInfo?.endExecutionTime?.toISOString(),
+                ClientSource: entry.jobInfo?.clientSource,
+            }));
+            return { Jobs: jobs };
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListJobs error: ${String(error)}`);
+            return null;
+        }
+    }
     /**
      * List workspaces and optionally create new workspace (CONSOLIDATED API)
      */
     async listOrCreateWorkspace(request) {
         try {
             this.logging.log('ATX: Starting ListOrCreateWorkspace operation');
+            this.logging.log(`ATX: Request received: ${JSON.stringify(request)}`);
             // Call verifySession ONCE at the beginning
             if (!(await this.verifySession())) {
                 this.logging.error('ATX: Session verification failed for listOrCreateWorkspace');
                 return null;
             }
             // Always get list of existing workspaces
-            const workspaces = await this.listWorkspaces();
+            const listResult = await this.listWorkspaces();
             const response = {
-                AvailableWorkspaces: workspaces,
+                AvailableWorkspaces: listResult.workspaces || [],
                 CreatedWorkspace: undefined,
             };
             // Optionally create new workspace
+            this.logging.log(`ATX: CreateWorkspaceName = ${request.CreateWorkspaceName}`);
             if (request.CreateWorkspaceName !== undefined) {
-                const newWorkspace = await this.createWorkspace(request.CreateWorkspaceName);
+                const newWorkspace = await this.createWorkspace(request.CreateWorkspaceName, request.CreateWorkspaceDescription);
                 if (newWorkspace) {
                     response.CreatedWorkspace = {
                         WorkspaceId: newWorkspace.workspaceId,
@@ -242,6 +308,7 @@ class ATXTransformHandler {
                     response.AvailableWorkspaces.push({
                         Id: newWorkspace.workspaceId,
                         Name: newWorkspace.workspaceName,
+                        Description: request.CreateWorkspaceDescription,
                         CreatedDate: new Date().toISOString(),
                     });
                 }
@@ -264,10 +331,27 @@ class ATXTransformHandler {
             if (!this.atxClient && !(await this.initializeAtxClient())) {
                 throw new Error('ATX FES client not initialized');
             }
+            // Map InteractiveMode enum to backend format (all strings)
+            // Autonomous -> "auto", Interactive -> "interactive"
+            let interactiveModeValue = 'auto';
+            if (request.interactiveMode === 'Interactive') {
+                interactiveModeValue = 'interactive';
+            }
+            // Build objective object with target_framework and interactive_mode
+            const objective = {
+                target_framework: request.targetFramework || 'net10.0',
+                interactive_mode: interactiveModeValue,
+            };
+            const orchestratorAgent = (0, constants_1.getAtxOrchestratorAgent)();
+            if (process.env.ATX_ORCHESTRATOR_AGENT) {
+                this.logging.log(`ATX: CreateJob using override orchestratorAgent='${orchestratorAgent}' (from ATX_ORCHESTRATOR_AGENT env var)`);
+            }
+            this.logging.log(`ATX: CreateJob objective: ${JSON.stringify(objective)}`);
             const command = new elastic_gumby_frontend_client_1.CreateJobCommand({
                 workspaceId: request.workspaceId,
-                objective: JSON.stringify({ target_framework: request.targetFramework || 'net10.0' }),
-                jobType: 'DOTNET_IDE',
+                objective: JSON.stringify(objective),
+                // jobType: 'DOTNET_IDE' as any,
+                orchestratorAgent: orchestratorAgent,
                 jobName: request.jobName || `transform-job-${Date.now()}`,
                 intent: 'LANGUAGE_UPGRADE',
                 idempotencyToken: (0, uuid_1.v4)(),
@@ -406,11 +490,14 @@ class ATXTransformHandler {
     async startTransform(request) {
         try {
             this.logging.log(`ATX: Starting transform workflow for workspace: ${request.workspaceId}`);
+            // Cache the interactive mode setting
+            this.cachedInteractiveMode = request.interactiveMode || 'Autonomous';
             // Step 1: Create transformation job
             const createJobResponse = await this.createJob({
                 workspaceId: request.workspaceId,
                 jobName: request.jobName || 'Transform Job',
                 targetFramework: request.startTransformRequest.TargetFramework,
+                interactiveMode: request.interactiveMode,
             });
             if (!createJobResponse?.jobId) {
                 throw new Error('Failed to create ATX transformation job');
@@ -440,6 +527,11 @@ class ATXTransformHandler {
             if (!startJobResponse?.success) {
                 throw new Error('Failed to start ATX transformation job');
             }
+            // Step 7: Write source files list to checkpoints folder for tracking (only in interactive mode)
+            if (request.interactiveMode && request.interactiveMode !== 'Autonomous') {
+                const startTransformReq = request.startTransformRequest;
+                this.writeSourceFilesManifest(startTransformReq.SolutionRootPath, createJobResponse.jobId, startTransformReq);
+            }
             this.logging.log('ATX: Transform workflow completed successfully');
             return {
                 TransformationJobId: createJobResponse.jobId,
@@ -452,7 +544,7 @@ class ATXTransformHandler {
             return null;
         }
     }
-    async getJob(workspaceId, jobId) {
+    async getJob(workspaceId, jobId, includeObjective = false) {
         try {
             this.logging.log(`ATX: Getting job: ${jobId} in workspace: ${workspaceId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
@@ -462,7 +554,7 @@ class ATXTransformHandler {
             const command = new elastic_gumby_frontend_client_1.GetJobCommand({
                 workspaceId: workspaceId,
                 jobId: jobId,
-                includeObjective: false,
+                includeObjective: includeObjective,
             });
             await this.addAuthToCommand(command);
             const response = await this.atxClient.send(command);
@@ -561,6 +653,73 @@ class ATXTransformHandler {
             return null;
         }
     }
+    async updateHitl(workspaceId, jobId, taskId, humanArtifactId) {
+        try {
+            this.logging.log(`ATX: Starting UpdateHitl for task: ${taskId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for UpdateHitl');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.UpdateHitlTaskCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                taskId: taskId,
+                humanArtifact: {
+                    artifactId: humanArtifactId,
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: UpdateHitl completed successfully with status ${result.status}`);
+            return result;
+        }
+        catch (error) {
+            this.logging.error(`ATX: UpdateHitl error: ${String(error)}`);
+            return null;
+        }
+    }
+    async completeHitlWithBuildResults(workspaceId, jobId, taskId, buildOutput, solutionRootPath) {
+        try {
+            this.logging.log(`ATX: Completing HITL ${taskId} with build results`);
+            // Write build output to temp file
+            const tempDir = path.join(solutionRootPath, 'artifactWorkspace', jobId);
+            await utils_1.Utils.directoryExists(tempDir);
+            const buildResultsPath = path.join(tempDir, 'build-results.txt');
+            fs.writeFileSync(buildResultsPath, buildOutput);
+            // Upload as artifact. The artifact must be categorized as HITL_FROM_USER
+            // so the platform associates it with the HITL task; the subsequent submit
+            // call will fail with ResourceNotFoundException if any other category is
+            // used. The existing upload flows (plan, packages, generic completion)
+            // all follow this pattern.
+            const uploadResponse = await this.createArtifactUploadUrl(workspaceId, jobId, buildResultsPath, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.OTHER);
+            if (!uploadResponse?.uploadUrl) {
+                return { Success: false, Error: 'Failed to create artifact upload URL' };
+            }
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadResponse.uploadUrl, buildResultsPath, uploadResponse.requestHeaders, this.logging);
+            if (!uploadSuccess) {
+                return { Success: false, Error: 'Failed to upload build results' };
+            }
+            const completeResponse = await this.completeArtifactUpload(workspaceId, jobId, uploadResponse.uploadId);
+            if (!completeResponse?.success) {
+                return { Success: false, Error: 'Failed to complete artifact upload' };
+            }
+            // Submit the HITL with the uploaded artifact via SubmitCriticalHitlTaskCommand.
+            // The backend creates the local-build-verification HITL with severity=CRITICAL
+            // (matching the missing-packages HITL flow), so the Critical submit path
+            // routes correctly and transitions the task directly to SUBMITTED — no
+            // intermediate updateHitl call is required.
+            const submitResult = await this.submitHitl(workspaceId, jobId, taskId, uploadResponse.uploadId);
+            if (!submitResult) {
+                return { Success: false, Error: 'Failed to submit HITL task' };
+            }
+            this.logging.log('ATX: HITL completed with build results successfully');
+            return { Success: true };
+        }
+        catch (error) {
+            this.logging.error(`ATX: completeHitlWithBuildResults error: ${String(error)}`);
+            return { Success: false, Error: String(error) };
+        }
+    }
     async getHitl(workspaceId, jobId, taskId) {
         try {
             this.logging.log(`ATX: Getting Hitl task: ${taskId}`);
@@ -613,6 +772,7 @@ class ATXTransformHandler {
         }
     }
     async getHitlAgentArtifact(workspaceId, jobId, solutionRootPath) {
+        let hitl = null;
         try {
             this.logging.log(`ATX: Getting Hitl Agent Artifact for job: ${jobId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
@@ -627,18 +787,63 @@ class ATXTransformHandler {
             if (hitls.length != 1) {
                 this.logging.log(`ATX: Found ${hitls.length} hitls (expected 1)`);
             }
-            const hitl = hitls[0];
+            hitl =
+                hitls.find(h => h.tag === 'local-build-verification') ||
+                    hitls.find(h => h.tag === 'missing-packages' || h.tag === 'handle_missing_packages_hitl') ||
+                    hitls[0];
+            this.logging.log(`ATX: getHitlAgentArtifact picked hitl tag: ${hitl.tag}, all tags: ${hitls.map(h => h.tag).join(',')}`);
+            this.logging.log(`ATX: getHitlAgentArtifact - selected tag: ${hitl.tag}, artifactId: ${hitl.agentArtifact?.artifactId}, allTags: ${hitls.map((h) => h.tag)}`);
             this.cachedHitl = hitl.taskId;
             const hitlTag = hitl.tag || null;
+            // local-build-verification: IDE handles the build, no artifact download needed
+            if (hitlTag === 'local-build-verification') {
+                this.logging.log('ATX: local-build-verification HITL — returning tag for IDE to handle');
+                return { HitlTag: hitlTag, TaskId: hitl.taskId };
+            }
+            // If no agent artifact, return tag and taskId without downloading
+            if (!hitl.agentArtifact?.artifactId) {
+                this.logging.log(`ATX: HITL has no agent artifact (tag=${hitlTag}) — returning tag only`);
+                return { HitlTag: hitlTag, TaskId: hitl.taskId };
+            }
             const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, hitl.agentArtifact.artifactId);
             if (!downloadInfo) {
                 throw new Error('Failed to get ATX FES download URL');
             }
             const pathToDownload = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId);
-            await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'transformation-plan-download.zip', this.logging);
             const fs = require('fs');
+            await utils_1.Utils.directoryExists(pathToDownload);
+            // Missing-packages artifact is raw JSON, not a zip
+            if (hitlTag === 'missing-packages' || hitlTag === 'handle_missing_packages_hitl') {
+                const response = await got_1.default.get(downloadInfo.s3PresignedUrl, {
+                    headers: downloadInfo.requestHeaders || {},
+                    responseType: 'buffer',
+                });
+                const rawPath = path.join(pathToDownload, 'missing-packages.json');
+                fs.writeFileSync(rawPath, response.body);
+                this.logging.log(`ATX: Missing packages artifact saved as JSON: ${rawPath} (${response.body.length} bytes)`);
+            }
+            else {
+                try {
+                    await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'transformation-plan-download.zip', this.logging);
+                }
+                catch (extractError) {
+                    this.logging.error(`ATX: Zip extraction failed (${String(extractError)}), saving raw artifact`);
+                    try {
+                        const response = await got_1.default.get(downloadInfo.s3PresignedUrl, {
+                            headers: downloadInfo.requestHeaders || {},
+                            responseType: 'buffer',
+                        });
+                        const rawPath = path.join(pathToDownload, `hitl-artifact-${hitlTag || 'unknown'}`);
+                        fs.writeFileSync(rawPath, response.body);
+                        this.logging.log(`ATX: Raw artifact saved to ${rawPath} (${response.body.length} bytes)`);
+                    }
+                    catch (downloadError) {
+                        this.logging.error(`ATX: Raw artifact save also failed: ${String(downloadError)}`);
+                    }
+                }
+            }
             const extractedFiles = fs.readdirSync(pathToDownload);
-            this.logging.log(`ATX: Extracted files in ${pathToDownload}: ${JSON.stringify(extractedFiles)}`);
+            this.logging.log(`ATX: Files in ${pathToDownload}: ${JSON.stringify(extractedFiles)}`);
             const planPath = path.join(pathToDownload, 'transformation-plan.md');
             const reportPath = path.join(pathToDownload, 'assessment-report.md');
             const missingPackageJsonPath = path.join(pathToDownload, 'missing-packages.json');
@@ -648,26 +853,72 @@ class ATXTransformHandler {
                 ReportPath: fs.existsSync(reportPath) ? reportPath : undefined,
                 MissingPackageJsonPath: fs.existsSync(missingPackageJsonPath) ? missingPackageJsonPath : undefined,
                 HitlTag: hitlTag,
+                TaskId: hitl.taskId,
             };
         }
         catch (error) {
             this.logging.error(`ATX: GetHitlAgentArtifact error: ${String(error)}`);
+            // Guardrail: return tag/taskId even on download failure so IDE can still handle the HITL
+            if (hitl) {
+                return { HitlTag: hitl.tag || null, TaskId: hitl.taskId };
+            }
             return null;
         }
     }
     /**
-     * Get transform info - dummy implementation
+     * Get transform info
      */
     async getTransformInfo(request) {
+        const diffContext = { failed: false, failedStepIds: [] };
+        this._currentDiffContext = diffContext;
+        try {
+            const result = await this._getTransformInfoInternal(request, diffContext);
+            if (result && diffContext.failed) {
+                result.DiffApplyFailed = true;
+                result.DiffApplyFailedStepIds = diffContext.failedStepIds;
+            }
+            return result;
+        }
+        finally {
+            this._currentDiffContext = null;
+        }
+    }
+    async _getTransformInfoInternal(request, _diffContext) {
         try {
             this.logging.log(`ATX: Getting transform info for job: ${request.TransformationJobId}`);
-            const job = await this.getJob(request.WorkspaceId, request.TransformationJobId);
+            // Check if we need to determine interactive mode from the job objective
+            const needObjective = this.cachedInteractiveMode === null;
+            const job = await this.getJob(request.WorkspaceId, request.TransformationJobId, needObjective);
             if (!job) {
                 this.logging.error(`ATX: Job not found: ${request.TransformationJobId}`);
-                return null;
+                return {
+                    TransformationJob: null,
+                    ErrorString: 'JOB_NOT_FOUND',
+                };
+            }
+            // If interactive mode is not cached, try to get it from the job objective
+            if (this.cachedInteractiveMode === null && job.objective) {
+                try {
+                    const objective = JSON.parse(job.objective);
+                    // Map backend string format to InteractiveMode enum
+                    // "interactive" -> Interactive, "auto" -> Autonomous
+                    if (objective.interactive_mode === 'interactive') {
+                        this.cachedInteractiveMode = 'Interactive';
+                    }
+                    else {
+                        this.cachedInteractiveMode = 'Autonomous';
+                    }
+                    this.logging.log(`ATX: Determined interactive mode from job objective: ${this.cachedInteractiveMode}`);
+                }
+                catch (e) {
+                    this.logging.log('ATX: Could not parse job objective for interactive mode');
+                    this.cachedInteractiveMode = 'Autonomous';
+                }
             }
             const jobStatus = job.statusDetails?.status;
             if (jobStatus === 'COMPLETED') {
+                // Clear cached state for terminal job status
+                this.clearJobCache();
                 const pathToArtifact = await this.downloadFinalArtifact(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
                 const plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
                 return {
@@ -681,6 +932,8 @@ class ATXTransformHandler {
                 };
             }
             else if (jobStatus === 'FAILED') {
+                // Clear cached state for terminal job status
+                this.clearJobCache();
                 this.logging.error(`ATX: Job failed - Reason: ${job?.statusDetails?.failureReason ?? 'Unknown'}`);
                 return {
                     TransformationJob: {
@@ -693,6 +946,8 @@ class ATXTransformHandler {
                 };
             }
             else if (jobStatus === 'STOPPING' || jobStatus === 'STOPPED') {
+                // Clear cached state for terminal job status
+                this.clearJobCache();
                 return {
                     TransformationJob: {
                         WorkspaceId: request.WorkspaceId,
@@ -702,8 +957,38 @@ class ATXTransformHandler {
                     ErrorString: 'Transformation job stopped',
                 };
             }
-            else if (jobStatus === 'PLANNED') {
+            else if (jobStatus === 'EXECUTING') {
                 const plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+                // If GetCheckpoints is requested, populate HasCheckpoint field on steps
+                if (request.GetCheckpoints) {
+                    this.populateCheckpointsOnPlan(plan, request.TransformationJobId, request.SolutionRootPath);
+                }
+                // HITLs can be raised at task level while the job-level status remains
+                // EXECUTING (the local-build-verification flow being the primary case).
+                // Probe listHitls here so the IDE is notified of pending human input
+                // without waiting for the job-level status to transition.
+                const execHitls = await this.listHitls(request.WorkspaceId, request.TransformationJobId);
+                const hitlTagSummary = execHitls && execHitls.length > 0 ? execHitls.map(h => String(h.tag)).join(', ') : '<none>';
+                this.logging.log(`ATX: EXECUTING HITL probe for job ${request.TransformationJobId}: ${execHitls ? execHitls.length : 0} task(s) [${hitlTagSummary}]`);
+                // Filter out the mode-selection checkpoint HITL — it's always present and
+                // doesn't require user action. Only surface truly blocking HITLs.
+                const blockingHitls = execHitls ? execHitls.filter(h => !String(h.tag).endsWith('-checkpoint')) : [];
+                if (blockingHitls.length > 0) {
+                    const execHitl = blockingHitls.find(h => h.tag === 'local-build-verification') ||
+                        blockingHitls.find(h => h.tag === 'missing-packages' || h.tag === 'handle_missing_packages_hitl') ||
+                        blockingHitls[0];
+                    this.logging.log(`ATX: EXECUTING job has pending HITL — tag=${execHitl.tag} taskId=${execHitl.taskId}; surfacing AWAITING_HUMAN_INPUT to IDE`);
+                    return {
+                        TransformationJob: {
+                            WorkspaceId: request.WorkspaceId,
+                            JobId: request.TransformationJobId,
+                            Status: 'AWAITING_HUMAN_INPUT',
+                        },
+                        HitlTag: execHitl.tag,
+                        HitlTaskId: execHitl.taskId,
+                        TransformationPlan: plan,
+                    };
+                }
                 return {
                     TransformationJob: {
                         WorkspaceId: request.WorkspaceId,
@@ -714,29 +999,60 @@ class ATXTransformHandler {
                 };
             }
             else if (jobStatus === 'AWAITING_HUMAN_INPUT') {
-                const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
-                this.logging.log(`ATX: HITL full response: ${JSON.stringify(response)}`);
-                this.logging.log(`ATX: HITL response - HitlTag: ${response?.HitlTag}, MissingPackageJsonPath: ${response?.MissingPackageJsonPath}`);
-                return {
-                    TransformationJob: {
-                        WorkspaceId: request.WorkspaceId,
-                        JobId: request.TransformationJobId,
-                        Status: jobStatus,
-                    },
-                    PlanPath: response?.PlanPath,
-                    ReportPath: response?.ReportPath,
-                    MissingPackageJsonPath: response?.MissingPackageJsonPath,
-                    HitlTag: response?.HitlTag,
-                };
+                return await this.handleAwaitingHumanInput(request);
             }
             else {
+                this.logging.log(`ATX: Job status is ${jobStatus} - checking for pending HITL tasks`);
                 await this.listWorklogs(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+                // Try to get plan regardless of status
+                let plan = undefined;
+                try {
+                    plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+                }
+                catch (e) {
+                    // Plan not available yet
+                }
+                // Check for pending HITL tasks (e.g. missing packages) - job stays in PLANNING while HITL is pending
+                const hitls = await this.listHitls(request.WorkspaceId, request.TransformationJobId);
+                if (hitls && hitls.length > 0) {
+                    const hitl = hitls.find(h => h.tag === 'local-build-verification') ||
+                        hitls.find(h => h.tag === 'missing-packages' || h.tag === 'handle_missing_packages_hitl') ||
+                        hitls[0];
+                    this.logging.log(`ATX: Found HITL task - tag: ${hitl.tag}, hasArtifact: ${!!hitl.agentArtifact}`);
+                    // For missing packages HITL, try to download artifact if available
+                    if (hitl.tag === 'handle_missing_packages_hitl' || hitl.tag === 'missing-packages') {
+                        this.cachedHitl = hitl.taskId;
+                        let missingPkgPath;
+                        if (hitl.agentArtifact?.artifactId) {
+                            try {
+                                const result = await this.handlePlanningPhaseHitl(request);
+                                missingPkgPath = result?.MissingPackageJsonPath ?? undefined;
+                                this.logging.log(`ATX: Missing packages artifact downloaded: ${missingPkgPath}`);
+                            }
+                            catch (e) {
+                                this.logging.log(`ATX: Missing packages artifact download failed: ${e}`);
+                            }
+                        }
+                        return {
+                            TransformationJob: {
+                                WorkspaceId: request.WorkspaceId,
+                                JobId: request.TransformationJobId,
+                                Status: 'AWAITING_HUMAN_INPUT',
+                            },
+                            HitlTag: hitl.tag,
+                            HitlTaskId: hitl.taskId,
+                            MissingPackageJsonPath: missingPkgPath,
+                            TransformationPlan: plan,
+                        };
+                    }
+                }
                 return {
                     TransformationJob: {
                         WorkspaceId: request.WorkspaceId,
                         JobId: request.TransformationJobId,
                         Status: jobStatus,
                     },
+                    TransformationPlan: plan,
                 };
             }
         }
@@ -745,462 +1061,1813 @@ class ATXTransformHandler {
             return null;
         }
     }
-    async uploadPlan(request) {
-        this.logging.log('ATX: Starting upload plan');
-        if (!this.cachedHitl) {
-            this.logging.error('ATX: UploadPlan error: No cached hitl');
-            return null;
+    /**
+     * Handles AWAITING_HUMAN_INPUT status.
+     * Two scenarios:
+     * 1. Planning phase: No plan exists yet, need to get HITL artifacts (plan.md, report.md)
+     * 2. Execution phase: Plan exists, HITL raised for a specific step
+     */
+    async handleAwaitingHumanInput(request) {
+        // Check for local-build-verification HITL first — it can happen with or without a plan
+        const hitlResponse = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+        if (hitlResponse?.HitlTag === 'local-build-verification') {
+            this.logging.log('ATX: local-build-verification HITL — returning directly to IDE');
+            const plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+            return {
+                TransformationJob: {
+                    WorkspaceId: request.WorkspaceId,
+                    JobId: request.TransformationJobId,
+                    Status: 'AWAITING_HUMAN_INPUT',
+                },
+                TransformationPlan: plan,
+                HitlTag: 'local-build-verification',
+                HitlTaskId: hitlResponse.TaskId,
+            };
         }
-        try {
-            const pathToZip = path.join(path.dirname(request.PlanPath), 'transformation-plan-upload.zip');
-            await utils_1.Utils.zipFile(request.PlanPath, pathToZip);
-            const uploadInfo = await this.createArtifactUploadUrl(request.WorkspaceId, request.TransformationJobId, pathToZip, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.ZIP);
-            if (!uploadInfo) {
-                this.logging.error('ATX: UploadPlan error: Failed to get upload URL');
-                return null;
-            }
-            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, pathToZip, uploadInfo.requestHeaders, this.logging);
-            if (!uploadSuccess) {
-                throw new Error('Failed to upload ZIP file to S3');
-            }
-            const completeResponse = await this.completeArtifactUpload(request.WorkspaceId, request.TransformationJobId, uploadInfo.uploadId);
-            if (!completeResponse?.success) {
-                throw new Error('Failed to complete artifact upload');
-            }
-            this.logging.log('ATX: Plan uploaded, submitting hitl');
-            const submitHitl = await this.submitHitl(request.WorkspaceId, request.TransformationJobId, this.cachedHitl, uploadInfo.uploadId);
-            if (!submitHitl) {
-                throw new Error('Failed to submit hitl');
-            }
-            this.logging.log('ATX: Hitl submitted, polling for status');
-            const validation = await this.pollHitlTask(request.WorkspaceId, request.TransformationJobId, this.cachedHitl);
-            if (!validation) {
-                throw new Error('Failed to poll hitl task');
-            }
-            if (validation === 'Submitted plan did not pass validation, please check the plan for details....') {
-                const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, path.dirname(path.dirname(path.dirname(request.PlanPath))));
-                return {
-                    VerificationStatus: false,
-                    Message: validation,
-                    PlanPath: response?.PlanPath,
-                    ReportPath: response?.ReportPath,
-                };
-            }
-            else {
-                return {
-                    VerificationStatus: true,
-                    Message: validation,
-                };
-            }
+        // Try to get the transformation plan first
+        const plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+        const hasPlan = plan.Root.Children.length > 0 && plan.Root.Children[0].Children.length > 0;
+        if (hasPlan) {
+            // Execution phase: Plan exists, HITL raised during transformation
+            return await this.handleExecutionPhaseHitl(request, plan);
         }
-        catch (error) {
-            this.logging.error(`ATX: UploadPlan error: ${String(error)}`);
-            return null;
+        else {
+            // Planning phase: No plan yet, get HITL artifacts for plan review
+            return await this.handlePlanningPhaseHitl(request);
         }
     }
-    // Upload Missing package dependencies
-    async uploadPackages(request) {
-        this.logging.log('ATX: Starting upload packages');
-        if (!this.cachedHitl) {
-            this.logging.error('ATX: UploadPackages error: No cached hitl');
-            return { Success: false, Message: 'No cached HITL task' };
+    /**
+     * Handles HITL during planning phase - downloads plan.md and report.md for user review.
+     */
+    async handlePlanningPhaseHitl(request) {
+        const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
+        this.logging.log(`ATX: Planning phase HITL - HitlTag: ${response?.HitlTag}, MissingPackageJsonPath: ${response?.MissingPackageJsonPath}, PlanPath: ${response?.PlanPath}`);
+        return {
+            TransformationJob: {
+                WorkspaceId: request.WorkspaceId,
+                JobId: request.TransformationJobId,
+                Status: 'AWAITING_HUMAN_INPUT',
+            },
+            PlanPath: response?.PlanPath,
+            ReportPath: response?.ReportPath,
+            MissingPackageJsonPath: response?.MissingPackageJsonPath,
+            HitlTag: response?.HitlTag,
+            HitlTaskId: response?.TaskId,
+        };
+    }
+    /**
+     * Handles HITL during execution phase - plan exists, step-level HITL raised.
+     */
+    async handleExecutionPhaseHitl(request, plan) {
+        this.logging.log(`ATX: Execution phase HITL - plan has ${plan.Root.Children.length} steps`);
+        // If GetCheckpoints is requested, populate HasCheckpoint field on steps
+        if (request.GetCheckpoints) {
+            this.populateCheckpointsOnPlan(plan, request.TransformationJobId, request.SolutionRootPath);
         }
         try {
-            if (!request.PackagesZipPath) {
-                this.logging.log('ATX: No packages to upload, submitting HITL without artifact');
-                return { Success: false, Message: "No Package xip path found. Can't proceed with HITL" };
-            }
-            var humanArtifactId = await this.uploadArtifactAndComplete(request.WorkspaceId, request.TransformationJobId, request.PackagesZipPath);
-            if (!humanArtifactId) {
-                return { Success: false, Message: 'Failed to upload packages' };
+            // Find the step with PENDING_HUMAN_INPUT status in the plan
+            const pendingStep = this.findPendingHumanInputStep(plan.Root);
+            if (!pendingStep) {
+                this.logging.log('ATX: No step with PENDING_HUMAN_INPUT status found in plan');
+                return {
+                    TransformationJob: {
+                        WorkspaceId: request.WorkspaceId,
+                        JobId: request.TransformationJobId,
+                        Status: 'AWAITING_HUMAN_INPUT',
+                    },
+                    TransformationPlan: plan,
+                };
             }
-            this.logging.log('ATX: Packages uploaded successfully');
-            // Submit HITL (with or without artifact)
-            const submitHitl = await this.submitHitl(request.WorkspaceId, request.TransformationJobId, this.cachedHitl, humanArtifactId);
-            if (!submitHitl) {
-                throw new Error('Failed to submit hitl');
+            this.logging.log(`ATX: Found pending step: ${pendingStep.StepId}`);
+            // Find the step-level HITL using tag: {stepId}-review
+            const stepHitl = await this.findStepLevelHitl(request.WorkspaceId, request.TransformationJobId, pendingStep.StepId);
+            if (!stepHitl) {
+                this.logging.log('ATX: No step-level HITL found, returning plan only');
+                return {
+                    TransformationJob: {
+                        WorkspaceId: request.WorkspaceId,
+                        JobId: request.TransformationJobId,
+                        Status: 'AWAITING_HUMAN_INPUT',
+                    },
+                    TransformationPlan: plan,
+                };
             }
-            this.logging.log('ATX: HITL submitted successfully');
+            // Download and parse the agent artifact JSON
+            const stepInformation = await this.downloadAndParseStepHitlArtifact(request.WorkspaceId, request.TransformationJobId, stepHitl, pendingStep.StepId, request.SolutionRootPath);
             return {
-                Success: true,
-                Message: 'Packages uploaded and HITL submitted successfully',
+                TransformationJob: {
+                    WorkspaceId: request.WorkspaceId,
+                    JobId: request.TransformationJobId,
+                    Status: 'AWAITING_HUMAN_INPUT',
+                },
+                TransformationPlan: plan,
+                StepInformation: stepInformation,
             };
         }
         catch (error) {
-            this.logging.error(`ATX: UploadPackages error: ${String(error)}`);
-            return { Success: false, Message: String(error) };
+            this.logging.error(`ATX: handleExecutionPhaseHitl error: ${String(error)}`);
+            return {
+                TransformationJob: {
+                    WorkspaceId: request.WorkspaceId,
+                    JobId: request.TransformationJobId,
+                    Status: 'AWAITING_HUMAN_INPUT',
+                },
+                TransformationPlan: plan,
+            };
         }
     }
-    async uploadArtifactAndComplete(workspaceId, jobId, filePath) {
-        const uploadInfo = await this.createArtifactUploadUrl(workspaceId, jobId, filePath, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.ZIP);
-        if (!uploadInfo) {
-            this.logging.error('ATX: Failed to get upload URL');
-            return null;
-        }
-        const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, filePath, uploadInfo.requestHeaders, this.logging);
-        if (!uploadSuccess) {
-            this.logging.error('ATX: Failed to upload to S3');
-            return null;
+    /**
+     * Recursively finds a step with PENDING_HUMAN_INPUT status in the plan tree.
+     */
+    findPendingHumanInputStep(step) {
+        if (step.Status === 'PENDING_HUMAN_INPUT') {
+            return step;
         }
-        const completeResponse = await this.completeArtifactUpload(workspaceId, jobId, uploadInfo.uploadId);
-        if (!completeResponse?.success) {
-            this.logging.error('ATX: Failed to complete artifact upload');
-            return null;
+        for (const child of step.Children) {
+            const found = this.findPendingHumanInputStep(child);
+            if (found) {
+                return found;
+            }
         }
-        return uploadInfo.uploadId;
+        return null;
     }
     /**
-     * Stop ATX transformation job
+     * Finds the step-level HITL task by filtering for the "{stepId}-review" tag.
      */
-    async stopJob(workspaceId, jobId) {
+    async findStepLevelHitl(workspaceId, jobId, stepId) {
         try {
-            this.logging.log(`ATX: StopJob operation started for job: ${jobId}`);
+            this.logging.log(`ATX: Finding step-level HITL for job: ${jobId}, step: ${stepId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                throw new Error('ATX FES client not initialized');
+                this.logging.error('ATX: Failed to initialize client for findStepLevelHitl');
+                return null;
             }
-            const command = new elastic_gumby_frontend_client_1.StopJobCommand({
+            // List HITLs with "{stepId}-review" tag
+            const command = new elastic_gumby_frontend_client_1.ListHitlTasksCommand({
                 workspaceId: workspaceId,
                 jobId: jobId,
+                taskType: 'NORMAL',
+                taskFilter: {
+                    taskStatuses: ['AWAITING_HUMAN_INPUT', 'IN_PROGRESS'],
+                    tag: `${stepId}-review`,
+                },
             });
             await this.addAuthToCommand(command);
-            const response = await this.atxClient.send(command);
-            this.logging.log(`ATX: StopJob SUCCESS - Status: ${response.status}`);
-            this.logging.log(`ATX: StopJob RequestId: ${response.$metadata?.requestId}`);
-            return response.status || 'STOPPED';
+            const result = await this.atxClient.send(command);
+            if (!result.hitlTasks || result.hitlTasks.length === 0) {
+                this.logging.log(`ATX: No step-level HITL found with tag ${stepId}-review`);
+                return null;
+            }
+            const stepHitl = result.hitlTasks[0];
+            this.logging.log(`ATX: Found step-level HITL: ${stepHitl.taskId}`);
+            // Cache the step HITL task ID for later use in checkpointAction
+            this.cachedStepHitl = stepHitl.taskId || null;
+            return stepHitl;
         }
         catch (error) {
-            this.logging.error(`ATX: StopJob error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            return 'FAILED';
+            this.logging.error(`ATX: findStepLevelHitl error: ${String(error)}`);
+            return null;
         }
     }
-    async downloadFinalArtifact(workspaceId, jobId, solutionRootPath) {
+    /**
+     * Downloads and parses the step HITL agent artifact JSON, and extracts the diff artifact.
+     */
+    async downloadAndParseStepHitlArtifact(workspaceId, jobId, hitlTask, stepId, solutionRootPath) {
         try {
-            this.logging.log(`ATX: Starting download final artifact for job: ${jobId}`);
-            const artifacts = await this.listArtifacts(workspaceId, jobId);
-            if (!artifacts || artifacts.length === 0) {
-                throw new Error('No CUSTOMER_OUTPUT artifacts available for download');
+            const taskId = hitlTask.taskId;
+            const agentArtifactId = hitlTask.agentArtifact?.artifactId;
+            if (!agentArtifactId) {
+                this.logging.error('ATX: Step HITL has no agent artifact');
+                return null;
             }
-            const artifact = artifacts[0];
-            const artifactId = artifact.artifactId;
-            this.logging.log(`ATX: Found artifact: ${artifactId}, size: ${artifact.sizeInBytes} bytes`);
+            this.logging.log(`ATX: Downloading step HITL artifact: ${agentArtifactId}`);
+            // Download the agent artifact JSON
+            const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, agentArtifactId);
+            if (!downloadInfo) {
+                throw new Error('Failed to get download URL for step HITL artifact');
+            }
+            // Download the JSON content
+            const response = await got_1.default.get(downloadInfo.s3PresignedUrl, {
+                headers: downloadInfo.requestHeaders || {},
+                responseType: 'text',
+            });
+            const artifactJson = JSON.parse(response.body);
+            this.logging.log(`ATX: Parsed step HITL artifact JSON`);
+            // Extract diff artifact if present
+            let diffArtifactPath = '';
+            if (artifactJson.diffArtifactId) {
+                diffArtifactPath = await this.downloadDiffArtifact(workspaceId, jobId, artifactJson.diffArtifactId, solutionRootPath, stepId);
+            }
+            const diffApplyFailed = !!(artifactJson.diffArtifactId && diffArtifactPath === '');
+            if (diffApplyFailed && this._currentDiffContext) {
+                this._currentDiffContext.failed = true;
+                this._currentDiffContext.failedStepIds.push(stepId);
+            }
+            return {
+                StepId: stepId,
+                DiffArtifactPath: diffArtifactPath,
+                DiffApplyFailed: diffApplyFailed,
+                // Use retryInstruction if available, otherwise fall back to originalInstruction
+                RetryInstruction: artifactJson.retryInstruction || artifactJson.originalInstruction,
+                ...(artifactJson.isInvalid !== undefined && { IsInvalid: artifactJson.isInvalid }),
+                ...(artifactJson.invalidInstruction && { InvalidInstruction: artifactJson.invalidInstruction }),
+                ...(artifactJson.invalidReason && { InvalidReason: artifactJson.invalidReason }),
+                ...(artifactJson.expiryTimestampUTC && { ExpiryTimestampUTC: artifactJson.expiryTimestampUTC }),
+            };
+        }
+        catch (error) {
+            this.logging.error(`ATX: downloadAndParseStepHitlArtifact error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Downloads and extracts the diff artifact ZIP, then immediately applies changes.
+     * Retries up to 3 times on failure before giving up.
+     */
+    async downloadDiffArtifact(workspaceId, jobId, diffArtifactId, solutionRootPath, stepId) {
+        const maxRetries = 3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                this.logging.log(`ATX: Downloading diff artifact: ${diffArtifactId} (attempt ${attempt}/${maxRetries})`);
+                const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, diffArtifactId);
+                if (!downloadInfo) {
+                    throw new Error('Failed to get download URL for diff artifact');
+                }
+                const pathToDownload = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints', stepId);
+                await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, `${stepId}.zip`, this.logging);
+                this.logging.log(`ATX: Diff artifact extracted to: ${pathToDownload}`);
+                // Immediately apply changes after extraction
+                const result = await this.applyChanges(pathToDownload, solutionRootPath);
+                if (result.success) {
+                    this.logging.log(`ATX: Changes applied immediately for step: ${stepId}`);
+                    // Update source files manifest with newly added files
+                    if (result.addedFiles && result.addedFiles.length > 0) {
+                        this.updateSourceFilesManifest(solutionRootPath, jobId, result.addedFiles);
+                    }
+                    // Mark this step as applied
+                    this.saveAppliedCheckpoint(solutionRootPath, jobId, stepId);
+                    // Save timestamp after changes are applied for tracking user modifications
+                    this.saveLastAppliedTimestamp(solutionRootPath, jobId, stepId);
+                    return pathToDownload;
+                }
+                else {
+                    throw new Error(`Failed to apply changes: ${result.error}`);
+                }
+            }
+            catch (error) {
+                this.logging.error(`ATX: downloadDiffArtifact attempt ${attempt}/${maxRetries} failed: ${String(error)}`);
+                if (attempt < maxRetries) {
+                    const delayMs = utils_1.Utils.getExpDelayForApiRetryMs(attempt);
+                    this.logging.log(`ATX: Retrying in ${delayMs}ms...`);
+                    await utils_1.Utils.sleep(delayMs);
+                }
+            }
+        }
+        // All retries exhausted
+        this.logging.error(`ATX: downloadDiffArtifact failed after ${maxRetries} attempts for step ${stepId}`);
+        return '';
+    }
+    /**
+     * Populates HasCheckpoint field on plan steps based on checkpoint-settings.json or defaults to true.
+     */
+    populateCheckpointsOnPlan(plan, jobId, solutionRootPath) {
+        try {
+            const checkpointSettingsPath = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints', 'checkpoint-settings.json');
+            let checkpointSettings = null;
+            // Check if checkpoint-settings.json exists
+            if (fs.existsSync(checkpointSettingsPath)) {
+                try {
+                    const fileContent = fs.readFileSync(checkpointSettingsPath, 'utf-8');
+                    checkpointSettings = JSON.parse(fileContent);
+                    this.logging.log(`ATX: Loaded checkpoint settings from ${checkpointSettingsPath}`);
+                }
+                catch (e) {
+                    this.logging.error(`ATX: Failed to parse checkpoint-settings.json: ${String(e)}`);
+                }
+            }
+            else {
+                this.logging.log('ATX: No checkpoint-settings.json found, defaulting all steps to HasCheckpoint=true');
+            }
+            // Recursively set HasCheckpoint on all steps
+            this.setCheckpointsOnSteps(plan.Root, checkpointSettings);
+        }
+        catch (error) {
+            this.logging.error(`ATX: populateCheckpointsOnPlan error: ${String(error)}`);
+        }
+    }
+    /**
+     * Recursively sets HasCheckpoint on steps based on settings or defaults to true.
+     */
+    setCheckpointsOnSteps(step, settings) {
+        // Skip the root node
+        if (step.StepId !== 'root') {
+            if (settings && settings[step.StepId] !== undefined) {
+                step.HasCheckpoint = settings[step.StepId];
+            }
+            else {
+                // Default to true if no settings file or step not in settings
+                step.HasCheckpoint = true;
+            }
+        }
+        // Recursively process children
+        for (const child of step.Children) {
+            this.setCheckpointsOnSteps(child, settings);
+        }
+    }
+    /**
+     * Writes a manifest of source files to the checkpoints folder for tracking changes.
+     * Creates source-files.json containing all source code file paths from the transformation request.
+     */
+    writeSourceFilesManifest(solutionRootPath, jobId, request) {
+        try {
+            const checkpointsDir = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints');
+            if (!fs.existsSync(checkpointsDir)) {
+                fs.mkdirSync(checkpointsDir, { recursive: true });
+            }
+            const sourceFiles = [];
+            // Extract source file paths from project metadata
+            if (request.ProjectMetadata) {
+                for (const project of request.ProjectMetadata) {
+                    if (project.SourceCodeFilePaths) {
+                        for (const filePath of project.SourceCodeFilePaths) {
+                            if (filePath) {
+                                sourceFiles.push(filePath);
+                            }
+                        }
+                    }
+                    // Include project file itself
+                    if (project.ProjectPath) {
+                        sourceFiles.push(project.ProjectPath);
+                    }
+                }
+            }
+            // Include solution file
+            if (request.SolutionFilePath) {
+                sourceFiles.push(request.SolutionFilePath);
+            }
+            // Include solution config files
+            if (request.SolutionConfigPaths) {
+                for (const configPath of request.SolutionConfigPaths) {
+                    if (configPath) {
+                        sourceFiles.push(configPath);
+                    }
+                }
+            }
+            const manifest = {
+                jobId: jobId,
+                solutionRootPath: solutionRootPath,
+                createdAt: new Date().toISOString(),
+                sourceFiles: sourceFiles,
+            };
+            const manifestPath = path.join(checkpointsDir, 'source-files.json');
+            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+            this.logging.log(`ATX: Source files manifest written to ${manifestPath} with ${sourceFiles.length} files`);
+        }
+        catch (error) {
+            this.logging.error(`ATX: Failed to write source files manifest: ${String(error)}`);
+        }
+    }
+    /**
+     * Updates the source files manifest with newly added files from HITL checkpoints.
+     * Adds new file paths to the existing manifest, avoiding duplicates.
+     */
+    updateSourceFilesManifest(solutionRootPath, jobId, newFiles) {
+        try {
+            if (!newFiles || newFiles.length === 0) {
+                return;
+            }
+            const checkpointsDir = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints');
+            const manifestPath = path.join(checkpointsDir, 'source-files.json');
+            if (!fs.existsSync(manifestPath)) {
+                this.logging.log('ATX: Source files manifest not found, skipping update');
+                return;
+            }
+            const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+            const manifest = JSON.parse(manifestContent);
+            // Convert new relative paths to absolute paths and add to manifest
+            const existingFiles = new Set(manifest.sourceFiles || []);
+            let addedCount = 0;
+            for (const relativePath of newFiles) {
+                const absolutePath = path.join(solutionRootPath, relativePath);
+                if (!existingFiles.has(absolutePath)) {
+                    manifest.sourceFiles.push(absolutePath);
+                    existingFiles.add(absolutePath);
+                    addedCount++;
+                }
+            }
+            if (addedCount > 0) {
+                manifest.lastUpdated = new Date().toISOString();
+                fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+                this.logging.log(`ATX: Updated source files manifest with ${addedCount} new files`);
+            }
+        }
+        catch (error) {
+            this.logging.error(`ATX: Failed to update source files manifest: ${String(error)}`);
+        }
+    }
+    /**
+     * Saves the timestamp when changes were applied for a step.
+     * Used to detect user modifications after checkpoint application.
+     */
+    saveLastAppliedTimestamp(solutionRootPath, jobId, stepId) {
+        try {
+            const checkpointsDir = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints');
+            const manifestPath = path.join(checkpointsDir, 'source-files.json');
+            if (!fs.existsSync(manifestPath)) {
+                this.logging.log('ATX: Source files manifest not found, skipping timestamp save');
+                return;
+            }
+            const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+            const manifest = JSON.parse(manifestContent);
+            manifest.lastAppliedTimestamp = Date.now();
+            manifest.lastAppliedStepId = stepId;
+            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+            this.logging.log(`ATX: Saved last applied timestamp for step: ${stepId}`);
+        }
+        catch (error) {
+            this.logging.error(`ATX: Failed to save last applied timestamp: ${String(error)}`);
+        }
+    }
+    /**
+     * Gets the list of files that have been modified since the last checkpoint was applied.
+     * Returns absolute paths of modified files.
+     */
+    getModifiedFilesSinceCheckpoint(solutionRootPath, jobId) {
+        try {
+            const checkpointsDir = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints');
+            const manifestPath = path.join(checkpointsDir, 'source-files.json');
+            if (!fs.existsSync(manifestPath)) {
+                this.logging.log('ATX: Source files manifest not found');
+                return [];
+            }
+            const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+            const manifest = JSON.parse(manifestContent);
+            const lastAppliedTimestamp = manifest.lastAppliedTimestamp;
+            if (!lastAppliedTimestamp) {
+                this.logging.log('ATX: No last applied timestamp found');
+                return [];
+            }
+            const sourceFiles = manifest.sourceFiles || [];
+            const modifiedFiles = [];
+            for (const filePath of sourceFiles) {
+                try {
+                    if (fs.existsSync(filePath)) {
+                        const stats = fs.statSync(filePath);
+                        if (stats.mtimeMs > lastAppliedTimestamp) {
+                            modifiedFiles.push(filePath);
+                        }
+                    }
+                }
+                catch (e) {
+                    this.logging.error(`ATX: Failed to check file modification time for ${filePath}: ${String(e)}`);
+                }
+            }
+            this.logging.log(`ATX: Found ${modifiedFiles.length} modified files since last checkpoint`);
+            return modifiedFiles;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Failed to get modified files: ${String(error)}`);
+            return [];
+        }
+    }
+    /**
+     * Creates a zip file containing the modified files for checkpoint action.
+     * Returns the path to the created zip file, or empty string if no files or error.
+     */
+    async createModifiedFilesZip(solutionRootPath, jobId, modifiedFiles) {
+        try {
+            if (modifiedFiles.length === 0) {
+                return '';
+            }
+            const checkpointsDir = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints');
+            const zipPath = path.join(checkpointsDir, 'user-modifications.zip');
+            const archive = archiver('zip', { zlib: { level: 9 } });
+            const stream = fs.createWriteStream(zipPath);
+            await new Promise((resolve, reject) => {
+                archive.on('error', err => reject(err));
+                stream.on('close', () => resolve());
+                archive.pipe(stream);
+                for (const filePath of modifiedFiles) {
+                    // Calculate relative path from solution root
+                    const relativePath = path.relative(solutionRootPath, filePath);
+                    archive.file(filePath, { name: relativePath });
+                }
+                void archive.finalize();
+            });
+            this.logging.log(`ATX: Created modified files zip with ${modifiedFiles.length} files at ${zipPath}`);
+            return zipPath;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Failed to create modified files zip: ${String(error)}`);
+            return '';
+        }
+    }
+    async uploadCustomPlan(request) {
+        this.logging.log('ATX: Starting upload file');
+        try {
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const fileName = path.basename(request.FilePath);
+            const artifactStorePath = request.ArtifactStorePath
+                ? `${request.ArtifactStorePath.replace(/\/+$/, '')}/${fileName}`
+                : fileName;
+            const ext = path.extname(request.FilePath).toLowerCase();
+            const fileTypeMap = {
+                '.json': 'JSON',
+                '.zip': 'ZIP',
+                '.pdf': 'PDF',
+                '.html': 'HTML',
+                '.htm': 'HTML',
+                '.txt': 'TXT',
+                '.md': 'MARKDOWN',
+                '.csv': 'CSV',
+                '.pptx': 'PPTX',
+                '.xlsx': 'XLSX',
+            };
+            const fileType = (fileTypeMap[ext] || 'OTHER');
+            const sha256 = await utils_1.Utils.getSha256Async(request.FilePath);
+            const command = new elastic_gumby_frontend_client_1.CreateArtifactUploadUrlCommand({
+                workspaceId: request.WorkspaceId,
+                jobId: request.TransformationJobId,
+                contentDigest: { Sha256: sha256 },
+                artifactReference: {
+                    artifactType: {
+                        categoryType: elastic_gumby_frontend_client_1.CategoryType.CUSTOMER_INPUT,
+                        fileType: fileType,
+                    },
+                },
+                fileMetadata: {
+                    path: artifactStorePath,
+                    description: request.Description,
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = (await this.atxClient.send(command));
+            if (!result?.artifactId || !result?.s3PreSignedUrl) {
+                throw new Error('Failed to get upload URL from service');
+            }
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(result.s3PreSignedUrl, request.FilePath, result.requestHeaders, this.logging);
+            if (!uploadSuccess) {
+                throw new Error('Failed to upload file to S3');
+            }
+            const completeResponse = await this.completeArtifactUpload(request.WorkspaceId, request.TransformationJobId, result.artifactId);
+            if (!completeResponse?.success) {
+                throw new Error('Failed to complete artifact upload');
+            }
+            this.logging.log(`ATX: File uploaded successfully - artifactId: ${result.artifactId}`);
+            return { Success: true, ArtifactId: result.artifactId };
+        }
+        catch (error) {
+            this.logging.error(`ATX: UploadCustomPlan error: ${String(error)}`);
+            return { Success: false, Error: String(error) };
+        }
+    }
+    async uploadPlan(request) {
+        this.logging.log('ATX: Starting upload plan');
+        if (!this.cachedHitl) {
+            this.logging.error('ATX: UploadPlan error: No cached hitl');
+            return null;
+        }
+        try {
+            const pathToZip = path.join(path.dirname(request.PlanPath), 'transformation-plan-upload.zip');
+            await utils_1.Utils.zipFile(request.PlanPath, pathToZip);
+            const uploadInfo = await this.createArtifactUploadUrl(request.WorkspaceId, request.TransformationJobId, pathToZip, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.ZIP);
+            if (!uploadInfo) {
+                this.logging.error('ATX: UploadPlan error: Failed to get upload URL');
+                return null;
+            }
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, pathToZip, uploadInfo.requestHeaders, this.logging);
+            if (!uploadSuccess) {
+                throw new Error('Failed to upload ZIP file to S3');
+            }
+            const completeResponse = await this.completeArtifactUpload(request.WorkspaceId, request.TransformationJobId, uploadInfo.uploadId);
+            if (!completeResponse?.success) {
+                throw new Error('Failed to complete artifact upload');
+            }
+            this.logging.log('ATX: Plan uploaded, submitting hitl');
+            const submitHitl = await this.submitHitl(request.WorkspaceId, request.TransformationJobId, this.cachedHitl, uploadInfo.uploadId);
+            if (!submitHitl) {
+                throw new Error('Failed to submit hitl');
+            }
+            this.logging.log('ATX: Hitl submitted, polling for status');
+            const validation = await this.pollHitlTask(request.WorkspaceId, request.TransformationJobId, this.cachedHitl);
+            if (!validation) {
+                throw new Error('Failed to poll hitl task');
+            }
+            if (validation === 'Submitted plan did not pass validation, please check the plan for details....') {
+                const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, path.dirname(path.dirname(path.dirname(request.PlanPath))));
+                return {
+                    VerificationStatus: false,
+                    Message: validation,
+                    PlanPath: response?.PlanPath,
+                    ReportPath: response?.ReportPath,
+                };
+            }
+            else {
+                return {
+                    VerificationStatus: true,
+                    Message: validation,
+                };
+            }
+        }
+        catch (error) {
+            this.logging.error(`ATX: UploadPlan error: ${String(error)}`);
+            return null;
+        }
+    }
+    // Upload Missing package dependencies
+    async uploadPackages(request) {
+        this.logging.log('ATX: Starting upload packages');
+        if (!this.cachedHitl) {
+            this.logging.error('ATX: UploadPackages error: No cached hitl');
+            return { Success: false, Message: 'No cached HITL task' };
+        }
+        try {
+            if (!request.PackagesZipPath) {
+                this.logging.log('ATX: No packages to upload, submitting HITL without artifact');
+                return { Success: false, Message: "No Package xip path found. Can't proceed with HITL" };
+            }
+            var humanArtifactId = await this.uploadArtifactAndComplete(request.WorkspaceId, request.TransformationJobId, request.PackagesZipPath);
+            if (!humanArtifactId) {
+                return { Success: false, Message: 'Failed to upload packages' };
+            }
+            this.logging.log('ATX: Packages uploaded successfully');
+            // Submit HITL (with or without artifact)
+            const submitHitl = await this.submitHitl(request.WorkspaceId, request.TransformationJobId, this.cachedHitl, humanArtifactId);
+            if (!submitHitl) {
+                throw new Error('Failed to submit hitl');
+            }
+            this.logging.log('ATX: HITL submitted successfully');
+            return {
+                Success: true,
+                Message: 'Packages uploaded and HITL submitted successfully',
+            };
+        }
+        catch (error) {
+            this.logging.error(`ATX: UploadPackages error: ${String(error)}`);
+            return { Success: false, Message: String(error) };
+        }
+    }
+    async uploadArtifactAndComplete(workspaceId, jobId, filePath) {
+        const uploadInfo = await this.createArtifactUploadUrl(workspaceId, jobId, filePath, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.ZIP);
+        if (!uploadInfo) {
+            this.logging.error('ATX: Failed to get upload URL');
+            return null;
+        }
+        const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, filePath, uploadInfo.requestHeaders, this.logging);
+        if (!uploadSuccess) {
+            this.logging.error('ATX: Failed to upload to S3');
+            return null;
+        }
+        const completeResponse = await this.completeArtifactUpload(workspaceId, jobId, uploadInfo.uploadId);
+        if (!completeResponse?.success) {
+            this.logging.error('ATX: Failed to complete artifact upload');
+            return null;
+        }
+        return uploadInfo.uploadId;
+    }
+    /**
+     * Stop ATX transformation job
+     */
+    async stopJob(workspaceId, jobId) {
+        try {
+            this.logging.log(`ATX: StopJob operation started for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const command = new elastic_gumby_frontend_client_1.StopJobCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+            });
+            await this.addAuthToCommand(command);
+            const response = await this.atxClient.send(command);
+            // Clear cached state when user initiates stop
+            this.clearJobCache();
+            this.logging.log(`ATX: StopJob SUCCESS - Status: ${response.status}`);
+            this.logging.log(`ATX: StopJob RequestId: ${response.$metadata?.requestId}`);
+            return response.status || 'STOPPED';
+        }
+        catch (error) {
+            this.logging.error(`ATX: StopJob error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return 'FAILED';
+        }
+    }
+    async downloadFinalArtifact(workspaceId, jobId, solutionRootPath) {
+        try {
+            this.logging.log(`ATX: Starting download final artifact for job: ${jobId}`);
+            const artifacts = await this.listArtifacts(workspaceId, jobId);
+            if (!artifacts || artifacts.length === 0) {
+                throw new Error('No CUSTOMER_OUTPUT artifacts available for download');
+            }
+            const artifact = artifacts[0];
+            const artifactId = artifact.artifactId;
+            this.logging.log(`ATX: Found artifact: ${artifactId}, size: ${artifact.sizeInBytes} bytes`);
             const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, artifactId);
             if (!downloadInfo) {
                 throw new Error('Failed to get ATX FES download URL');
             }
-            const pathToDownload = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId);
-            await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'ExportResultsArchive.zip', this.logging);
-            this.logging.log(`ATX: Download final artifact completed successfully`);
-            return pathToDownload;
+            const pathToDownload = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId);
+            await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'ExportResultsArchive.zip', this.logging);
+            this.logging.log(`ATX: Download final artifact completed successfully`);
+            return pathToDownload;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Download final artifact failed: ${String(error)}`);
+            return null;
+        }
+    }
+    async getTransformationPlan(workspaceId, jobId, solutionRootPath) {
+        try {
+            const plan = await this.fetchPlanTree(workspaceId, jobId);
+            // Fetch worklogs in parallel (fire and forget, don't block plan return)
+            this.fetchWorklogs(workspaceId, jobId, solutionRootPath).catch(e => {
+                this.logging.log(`ATX: Could not get worklogs for workspace: ${workspaceId}, job: ${jobId}`);
+            });
+            // Download completed step artifacts if not already present (all modes)
+            const anyFailed = await this.downloadCompletedStepArtifacts(workspaceId, jobId, solutionRootPath, plan);
+            if (anyFailed && this._currentDiffContext) {
+                this._currentDiffContext.failed = true;
+            }
+            this.logging.log(`ATX: Successfully built plan tree with ${plan.Root.Children.length} root steps`);
+            return plan;
+        }
+        catch (error) {
+            this.logging.error(`ATX: getTransformationPlan error: ${String(error)}`);
+            return { Root: (0, atxModels_1.createEmptyRootNode)() };
+        }
+    }
+    /**
+     * Downloads artifacts for completed steps in interactive mode if they don't already exist,
+     * then applies the changes in order, tracking progress in checkpoints-applied.json.
+     */
+    async downloadCompletedStepArtifacts(workspaceId, jobId, solutionRootPath, plan) {
+        let anyFailed = false;
+        // Prevent concurrent execution
+        if (this._applyingCheckpoints) {
+            this.logging.log('ATX: downloadCompletedStepArtifacts already in progress, skipping');
+            return false;
+        }
+        this._applyingCheckpoints = true;
+        try {
+            const completedSteps = this.findCompletedSteps(plan.Root);
+            // Sort by score to ensure correct application order
+            completedSteps.sort((a, b) => (a.score || 0) - (b.score || 0));
+            this.logging.log(`ATX: Found ${completedSteps.length} completed steps to check for artifacts`);
+            // Load the list of already applied steps
+            const appliedSteps = this.loadAppliedCheckpoints(solutionRootPath, jobId);
+            for (const step of completedSteps) {
+                const stepCheckpointPath = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints', step.StepId);
+                // Check if the checkpoint folder already exists
+                if (!fs.existsSync(stepCheckpointPath)) {
+                    // Download the artifact for this completed step
+                    await this.downloadCompletedStepArtifact(workspaceId, jobId, step.StepId, solutionRootPath);
+                }
+                // Apply changes if not already applied
+                if (!appliedSteps.includes(step.StepId)) {
+                    // Check if checkpoint folder exists after download attempt
+                    if (fs.existsSync(stepCheckpointPath)) {
+                        const result = await this.applyChanges(stepCheckpointPath, solutionRootPath);
+                        if (result.success) {
+                            // Mark this step as applied
+                            this.saveAppliedCheckpoint(solutionRootPath, jobId, step.StepId);
+                            this.logging.log(`ATX: Applied changes for step: ${step.StepId}`);
+                            // Update source files manifest with newly added files
+                            if (result.addedFiles && result.addedFiles.length > 0) {
+                                this.updateSourceFilesManifest(solutionRootPath, jobId, result.addedFiles);
+                            }
+                        }
+                        else {
+                            this.logging.error(`ATX: Failed to apply changes for step ${step.StepId}: ${result.error}`);
+                            anyFailed = true;
+                            if (this._currentDiffContext) {
+                                this._currentDiffContext.failedStepIds.push(step.StepId);
+                            }
+                        }
+                    }
+                    else {
+                        this.logging.error(`ATX: Checkpoint folder not available for step: ${step.StepId}, skipping apply`);
+                        anyFailed = true;
+                        if (this._currentDiffContext) {
+                            this._currentDiffContext.failedStepIds.push(step.StepId);
+                        }
+                    }
+                }
+                else {
+                    this.logging.log(`ATX: Changes already applied for step: ${step.StepId}`);
+                }
+            }
+        }
+        catch (error) {
+            this.logging.error(`ATX: downloadCompletedStepArtifacts error: ${String(error)}`);
+            anyFailed = true;
+        }
+        finally {
+            this._applyingCheckpoints = false;
+        }
+        return anyFailed;
+    }
+    /**
+     * Loads the list of step IDs that have already had their changes applied.
+     */
+    loadAppliedCheckpoints(solutionRootPath, jobId) {
+        try {
+            const appliedPath = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints', 'checkpoints-applied.json');
+            if (fs.existsSync(appliedPath)) {
+                const content = fs.readFileSync(appliedPath, 'utf-8');
+                const data = JSON.parse(content);
+                return data.appliedSteps || [];
+            }
+            return [];
+        }
+        catch (error) {
+            this.logging.error(`ATX: loadAppliedCheckpoints error: ${String(error)}`);
+            return [];
+        }
+    }
+    /**
+     * Saves a step ID to the list of applied checkpoints.
+     */
+    saveAppliedCheckpoint(solutionRootPath, jobId, stepId) {
+        try {
+            const checkpointsDir = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints');
+            const appliedPath = path.join(checkpointsDir, 'checkpoints-applied.json');
+            // Ensure directory exists
+            if (!fs.existsSync(checkpointsDir)) {
+                fs.mkdirSync(checkpointsDir, { recursive: true });
+            }
+            // Load existing data or create new
+            let data = { appliedSteps: [] };
+            if (fs.existsSync(appliedPath)) {
+                const content = fs.readFileSync(appliedPath, 'utf-8');
+                data = JSON.parse(content);
+            }
+            // Add step if not already present
+            if (!data.appliedSteps.includes(stepId)) {
+                data.appliedSteps.push(stepId);
+            }
+            // Save back to file
+            fs.writeFileSync(appliedPath, JSON.stringify(data, null, 2));
+            this.logging.log(`ATX: Saved applied checkpoint: ${stepId}`);
+        }
+        catch (error) {
+            this.logging.error(`ATX: saveAppliedCheckpoint error: ${String(error)}`);
+        }
+    }
+    /**
+     * Recursively finds all level 2 steps with SUCCEEDED status in the plan tree.
+     * Level 2 steps are grandchildren of root (e.g., ClassLibrary1 under Transform Projects).
+     * Returns steps sorted by their score to ensure correct application order.
+     */
+    findCompletedSteps(step, depth = 0) {
+        const completedSteps = [];
+        // Only count SUCCEEDED steps at depth 2 (grandchildren of root)
+        if (depth === 2 && step.Status === 'SUCCEEDED') {
+            completedSteps.push(step);
+        }
+        // Process children
+        for (const child of step.Children) {
+            completedSteps.push(...this.findCompletedSteps(child, depth + 1));
+        }
+        return completedSteps;
+    }
+    /**
+     * Downloads and extracts the artifact for a completed step.
+     */
+    async downloadCompletedStepArtifact(workspaceId, jobId, stepId, solutionRootPath) {
+        try {
+            this.logging.log(`ATX: Downloading artifact for completed step: ${stepId}`);
+            // List artifacts filtered by stepId and CUSTOMER_OUTPUT category
+            const artifacts = await this.listArtifactsForStep(workspaceId, jobId, stepId);
+            if (!artifacts || artifacts.length === 0) {
+                this.logging.log(`ATX: No CUSTOMER_OUTPUT artifact found for step: ${stepId}`);
+                return;
+            }
+            // There should be only one artifact that matches
+            const artifact = artifacts[0];
+            this.logging.log(`ATX: Found artifact ${artifact.artifactId} for step: ${stepId}`);
+            // Download and extract the artifact
+            await this.downloadDiffArtifact(workspaceId, jobId, artifact.artifactId, solutionRootPath, stepId);
+        }
+        catch (error) {
+            this.logging.error(`ATX: downloadCompletedStepArtifact error for step ${stepId}: ${String(error)}`);
+        }
+    }
+    /**
+     * Lists artifacts filtered by stepId and CUSTOMER_OUTPUT category.
+     */
+    async listArtifactsForStep(workspaceId, jobId, stepId) {
+        try {
+            this.logging.log(`ATX: Listing artifacts for step: ${stepId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for listArtifactsForStep');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.ListArtifactsCommand({
+                workspaceId: workspaceId,
+                jobFilter: {
+                    jobId: jobId,
+                    categoryType: 'CUSTOMER_OUTPUT',
+                    planStepId: stepId,
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: Found ${result.artifacts?.length || 0} artifacts for step: ${stepId}`);
+            return result.artifacts || [];
+        }
+        catch (error) {
+            this.logging.error(`ATX: listArtifactsForStep error: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Fetches all plan steps in a single API call and builds the tree locally.
+     */
+    async fetchPlanTree(workspaceId, jobId) {
+        const root = (0, atxModels_1.createEmptyRootNode)();
+        if (!this.atxClient && !(await this.initializeAtxClient())) {
+            this.logging.error('ATX: Failed to initialize client for fetchPlanTree');
+            return { Root: root };
+        }
+        // Fetch ALL steps in a single call (no parentStepId = returns all steps)
+        const allSteps = await this.fetchAllSteps(workspaceId, jobId);
+        if (!allSteps || allSteps.length === 0) {
+            this.logging.log('ATX: No plan steps available yet');
+            return { Root: root };
+        }
+        // Build tree from flat list
+        root.Children = this.buildTreeFromFlatList(allSteps);
+        // Log step labels including sub-steps for diagnostic visibility
+        // during the build/fix loop polling cycle.
+        const allLabels = allSteps.map((s) => s.stepLabel || s.stepName || s.stepId || '?');
+        const errorFixRounds = allLabels.filter((l) => l.includes('error-fix-round'));
+        this.logging.log(`ATX: fetchPlanTree completed - Built tree with ${root.Children.length} root steps from ${allSteps.length} total steps` +
+            (errorFixRounds.length > 0
+                ? ` (includes ${errorFixRounds.length} error-fix-round sub-steps: ${errorFixRounds.join(', ')})`
+                : ''));
+        return { Root: root };
+    }
+    /**
+     * Fetches all steps in a single API call (no parentStepId filter).
+     */
+    async fetchAllSteps(workspaceId, jobId) {
+        const allSteps = [];
+        let nextToken;
+        try {
+            do {
+                const command = new elastic_gumby_frontend_client_1.ListJobPlanStepsCommand({
+                    workspaceId: workspaceId,
+                    jobId: jobId,
+                    maxResults: 100,
+                    ...(nextToken && { nextToken }),
+                });
+                await this.addAuthToCommand(command);
+                const result = await this.atxClient.send(command);
+                if (result?.steps) {
+                    allSteps.push(...result.steps);
+                }
+                nextToken = result?.nextToken;
+            } while (nextToken);
+            this.logging.log(`ATX: Fetched ${allSteps.length} total steps`);
+            return allSteps;
+        }
+        catch (error) {
+            this.logging.error(`ATX: Error fetching all steps: ${String(error)}`);
+            return [];
+        }
+    }
+    /**
+     * Builds a tree structure from a flat list of steps using ParentStepId relationships.
+     */
+    buildTreeFromFlatList(flatSteps) {
+        // Create a map of StepId -> AtxPlanStep for quick lookup
+        const stepMap = new Map();
+        // First pass: convert all API steps to AtxPlanStep objects
+        for (const apiStep of flatSteps) {
+            const step = this.mapApiStepToNode(apiStep);
+            if (step.StepId) {
+                stepMap.set(step.StepId, step);
+            }
+        }
+        // Second pass: build parent-child relationships
+        const rootChildren = [];
+        for (const step of stepMap.values()) {
+            if (step.ParentStepId === 'root' || !step.ParentStepId) {
+                rootChildren.push(step);
+            }
+            else {
+                const parent = stepMap.get(step.ParentStepId);
+                if (parent) {
+                    parent.Children.push(step);
+                }
+                else {
+                    // Orphan step - treat as root level
+                    rootChildren.push(step);
+                }
+            }
+        }
+        // Sort all children arrays by score
+        this.sortStepsByScore(rootChildren);
+        for (const step of stepMap.values()) {
+            if (step.Children.length > 0) {
+                this.sortStepsByScore(step.Children);
+            }
+        }
+        return rootChildren;
+    }
+    /**
+     * Maps an API step response to AtxPlanStep.
+     * Converts from FES camelCase to C#-compatible PascalCase.
+     */
+    mapApiStepToNode(apiStep) {
+        return {
+            StepId: apiStep.stepId || '',
+            ParentStepId: apiStep.parentStepId === 'root' ? null : apiStep.parentStepId || null,
+            StepName: apiStep.stepName || '',
+            Description: apiStep.description || '',
+            Status: this.mapApiStatus(apiStep.status),
+            Children: [],
+            // Keep score for sorting (not sent to C#)
+            score: apiStep.score || 0,
+        };
+    }
+    /**
+     * Maps API status string to PlanStepStatus.
+     * Returns the status directly if valid, otherwise defaults to NOT_STARTED.
+     */
+    mapApiStatus(status) {
+        if (!status)
+            return 'NOT_STARTED';
+        // The API returns valid PlanStepStatus values directly
+        return status;
+    }
+    /**
+     * Sorts steps by score (primary).
+     */
+    sortStepsByScore(steps) {
+        steps.sort((a, b) => (a.score || 0) - (b.score || 0));
+    }
+    /**
+     * Fetches worklogs for a job and saves them to disk.
+     */
+    async fetchWorklogs(workspaceId, jobId, solutionRootPath) {
+        await this.listWorklogs(workspaceId, jobId, solutionRootPath);
+    }
+    /**
+     * Lists artifacts using FES client with filtering - default to CUSTOMER_OUTPUT
+     */
+    async listArtifacts(workspaceId, jobId, filter = 'CUSTOMER_OUTPUT') {
+        try {
+            this.logging.log(`ATX: Starting ListArtifacts for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for ListArtifacts');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.ListArtifactsCommand({
+                workspaceId: workspaceId,
+                jobFilter: {
+                    jobId: jobId,
+                    categoryType: filter, // Server-side filtering for customer output artifacts
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: ListArtifacts completed - Found ${result.artifacts?.length || 0} artifacts`);
+            return result.artifacts || [];
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListArtifacts error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return null;
+        }
+    }
+    /**
+     * Lists worklogs for a job and saves them to disk grouped by step ID.
+     */
+    async listWorklogs(workspaceId, jobId, solutionRootPath, stepId) {
+        try {
+            this.logging.log(`ATX: Starting ListWorklogs for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for ListWorklogs');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.ListWorklogsCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                ...(stepId && {
+                    worklogFilter: {
+                        stepIdFilter: {
+                            stepId: stepId,
+                        },
+                    },
+                }),
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: ListWorklogs completed - Found ${result.worklogs?.length || 0} entries`);
+            for (const value of result.worklogs || []) {
+                const currentStepId = value.attributeMap?.STEP_ID || stepId || 'Progress';
+                await utils_1.Utils.saveWorklogsToJson(jobId, currentStepId, value.description || '', solutionRootPath, value.timestamp);
+            }
+            return result.worklogs || [];
         }
         catch (error) {
-            this.logging.error(`ATX: Download final artifact failed: ${String(error)}`);
+            this.logging.error(`ATX: ListWorklogs error: ${String(error)}`);
             return null;
         }
     }
-    async getTransformationPlan(workspaceId, jobId, solutionRootPath) {
+    /**
+     * Set checkpoints for interactive mode transformation.
+     * Lists HITLs with "checkpoint-settings" tag, uploads checkpoints as JSON artifact,
+     * and updates the HITL task with the new artifact ID.
+     */
+    async setCheckpoints(workspaceId, jobId, solutionRootPath, checkpoints, interactiveMode) {
         try {
-            // Get real plan steps from ATX FES (only if job status >= PLANNED)
-            const planSteps = await this.getATXFESJobPlanSteps(workspaceId, jobId);
-            if (planSteps) {
-                this.logging.log(`ATX FES: Found ${planSteps.length} transformation steps`);
-                // Sort steps by score (primary) and startTime (tiebreaker) to match RTS ordering
-                planSteps.sort((a, b) => {
-                    const scoreDiff = (a.score || 0) - (b.score || 0);
-                    if (scoreDiff !== 0)
-                        return scoreDiff;
-                    // Tiebreaker for identical scores: sort by startTime
-                    const timeA = a.startTime ? new Date(a.startTime).getTime() : 0;
-                    const timeB = b.startTime ? new Date(b.startTime).getTime() : 0;
-                    return timeA - timeB;
-                });
-                // Return in exact same format as RTS with all required fields
-                const transformationPlan = {
-                    transformationSteps: planSteps.map((step, index) => {
-                        try {
-                            // Map substeps to ProgressUpdates for IDE display
-                            const progressUpdates = (step.substeps || []).map((substep) => {
-                                // Map ATX substep status to IDE TransformationProgressUpdateStatus enum values
-                                let substepStatus = 'IN_PROGRESS'; // Default - no NOT_STARTED in this enum
-                                switch (substep.status) {
-                                    case 'SUCCEEDED':
-                                    case 'COMPLETED':
-                                        substepStatus = 'COMPLETED';
-                                        break;
-                                    case 'IN_PROGRESS':
-                                    case 'RUNNING':
-                                        substepStatus = 'IN_PROGRESS';
-                                        break;
-                                    case 'FAILED':
-                                        substepStatus = 'FAILED';
-                                        break;
-                                    case 'SKIPPED':
-                                        substepStatus = 'SKIPPED';
-                                        break;
-                                    case 'NOT_STARTED':
-                                    case 'CREATED':
-                                    default:
-                                        substepStatus = 'IN_PROGRESS'; // No NOT_STARTED option in ProgressUpdate enum
-                                        break;
-                                }
-                                // Map nested progress updates (3rd level)
-                                const nestedProgressUpdates = (substep.substeps || []).map((nestedUpdate) => {
-                                    let nestedStatus = 'IN_PROGRESS';
-                                    switch (nestedUpdate.status) {
-                                        case 'SUCCEEDED':
-                                        case 'COMPLETED':
-                                            nestedStatus = 'COMPLETED';
-                                            break;
-                                        case 'IN_PROGRESS':
-                                        case 'RUNNING':
-                                            nestedStatus = 'IN_PROGRESS';
-                                            break;
-                                        case 'FAILED':
-                                            nestedStatus = 'FAILED';
-                                            break;
-                                        case 'SKIPPED':
-                                            nestedStatus = 'SKIPPED';
-                                            break;
-                                        default:
-                                            nestedStatus = 'IN_PROGRESS';
-                                            break;
-                                    }
-                                    return {
-                                        name: nestedUpdate.stepName || 'Unknown Nested Update',
-                                        description: nestedUpdate.description || '',
-                                        status: nestedStatus,
-                                        stepId: nestedUpdate.stepId ?? undefined,
-                                    };
-                                });
-                                return {
-                                    name: substep.stepName || 'Unknown Substep',
-                                    description: substep.description || '',
-                                    status: substepStatus,
-                                    startTime: substep.startTime ? new Date(substep.startTime) : undefined,
-                                    endTime: substep.endTime ? new Date(substep.endTime) : undefined,
-                                    stepId: substep.stepId ?? undefined,
-                                    progressUpdates: nestedProgressUpdates,
-                                };
-                            });
-                            // Use ATX status directly - IDE supports most values, minimal mapping needed
-                            let mappedStatus = step.status || 'NOT_STARTED';
-                            // Only map the few values IDE doesn't have
-                            if (mappedStatus === 'SUCCEEDED') {
-                                mappedStatus = 'COMPLETED';
-                            }
-                            else if (mappedStatus === 'RUNNING') {
-                                mappedStatus = 'IN_PROGRESS';
-                            }
-                            else if (mappedStatus === 'CREATED') {
-                                mappedStatus = 'NOT_STARTED';
-                            }
-                            // Use ATX step data directly without hardcoded ordering
-                            const stepNumber = index + 1;
-                            const stepName = `Step ${stepNumber} - ${step.stepName || 'Unknown Step'}`;
-                            return {
-                                id: step.stepId || `step-${stepNumber}`,
-                                name: stepName,
-                                description: step.description || '',
-                                status: mappedStatus,
-                                progressUpdates: progressUpdates,
-                                startTime: step.startTime ? new Date(step.startTime) : undefined,
-                                endTime: step.endTime ? new Date(step.endTime) : undefined,
-                            };
-                        }
-                        catch (error) {
-                            this.logging.error(`ATX FES: Error mapping step ${index}: ${String(error)}`);
-                            // Return a safe fallback step
-                            const stepNumber = index + 1;
-                            return {
-                                id: step.stepId || `fallback-${stepNumber}`,
-                                name: `Step ${stepNumber} - ${step.stepName || `Step ${stepNumber}`}`,
-                                description: step.description || '',
-                                status: 'NOT_STARTED',
-                                progressUpdates: [],
-                                startTime: undefined,
-                                endTime: undefined,
-                            };
-                        }
-                    }),
-                };
-                try {
-                    await this.listWorklogs(workspaceId, jobId, solutionRootPath);
-                }
-                catch (e) {
-                    this.logging.log(`ATX FES: Could not get worklog for workspaces: ${workspaceId}, job id: ${jobId}`);
-                }
-                this.logging.log(`ATX FES: Successfully mapped ${transformationPlan.transformationSteps?.length || 0} steps`);
-                return transformationPlan;
+            this.logging.log(`ATX: Starting setCheckpoints for job: ${jobId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                return { Success: false, Error: 'ATX FES client not initialized' };
+            }
+            // Step 1: List HITLs with "checkpoint-settings" tag
+            const hitlTask = await this.findCheckpointSettingsHitl(workspaceId, jobId);
+            if (!hitlTask) {
+                return { Success: false, Error: 'No HITL task found with checkpoint-settings tag' };
+            }
+            this.logging.log(`ATX: Found checkpoint-settings HITL task: ${hitlTask.taskId}`);
+            // Step 2: Create JSON file with checkpoints mapping in checkpoints folder
+            const artifactDir = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints');
+            if (!fs.existsSync(artifactDir)) {
+                fs.mkdirSync(artifactDir, { recursive: true });
+            }
+            // Build JSON content with optional interactiveMode
+            const jsonContent = { ...checkpoints };
+            if (interactiveMode) {
+                // Map PascalCase to backend format: Interactive->interactive, Autonomous->auto
+                let mappedMode = 'auto';
+                if (interactiveMode === 'Interactive')
+                    mappedMode = 'interactive';
+                jsonContent.interactive_mode = mappedMode;
+                this.logging.log(`ATX: setCheckpoints interactive_mode=${mappedMode}`);
+            }
+            const jsonFilePath = path.join(artifactDir, 'checkpoint-settings.json');
+            this.logging.log(`ATX: Writing checkpoint-settings.json to ${jsonFilePath}`);
+            fs.writeFileSync(jsonFilePath, JSON.stringify(jsonContent, null, 2));
+            // Step 3: Upload the JSON artifact
+            const uploadInfo = await this.createArtifactUploadUrl(workspaceId, jobId, jsonFilePath, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.JSON);
+            if (!uploadInfo) {
+                return { Success: false, Error: 'Failed to create artifact upload URL' };
             }
-            else {
-                this.logging.log('ATX FES: No plan steps available yet - returning empty plan');
-                return {
-                    transformationSteps: [],
-                };
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, jsonFilePath, uploadInfo.requestHeaders, this.logging);
+            if (!uploadSuccess) {
+                return { Success: false, Error: 'Failed to upload checkpoints artifact to S3' };
+            }
+            // Step 4: Complete artifact upload
+            const completeResponse = await this.completeArtifactUpload(workspaceId, jobId, uploadInfo.uploadId);
+            if (!completeResponse?.success) {
+                return { Success: false, Error: 'Failed to complete artifact upload' };
+            }
+            // Step 5: Update HITL task with the new artifact ID
+            const updateResult = await this.updateHitl(workspaceId, jobId, hitlTask.taskId, uploadInfo.uploadId);
+            if (!updateResult) {
+                return { Success: false, Error: 'Failed to update HITL task with checkpoints artifact' };
             }
+            this.logging.log(`ATX: setCheckpoints completed successfully`);
+            return { Success: true };
         }
         catch (error) {
-            this.logging.error(`ATX FES getTransformationPlan error: ${String(error)}`);
-            // Return empty plan on error
-            return {
-                transformationSteps: [],
-            };
+            this.logging.error(`ATX: setCheckpoints error: ${String(error)}`);
+            return { Success: false, Error: String(error) };
         }
     }
-    async getATXFESJobPlanSteps(workspaceId, jobId) {
+    /**
+     * Find HITL task with "checkpoint-settings" tag
+     */
+    async findCheckpointSettingsHitl(workspaceId, jobId) {
         try {
-            this.logging.log(`ATX FES: getting plan steps with substeps...`);
-            const result = await this.listJobPlanSteps(workspaceId, jobId);
-            if (result) {
-                const steps = result || [];
-                this.logging.log(`ListJobPlanSteps: SUCCESS - Found ${steps.length} plan steps with substeps`);
-                return steps;
+            this.logging.log(`ATX: Looking for HITL task with checkpoint-settings tag`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                this.logging.error('ATX: Failed to initialize client for findCheckpointSettingsHitl');
+                return null;
+            }
+            const command = new elastic_gumby_frontend_client_1.ListHitlTasksCommand({
+                workspaceId: workspaceId,
+                jobId: jobId,
+                taskType: 'NORMAL',
+                taskFilter: {
+                    taskStatuses: ['AWAITING_HUMAN_INPUT', 'IN_PROGRESS'],
+                    tag: `${jobId}-checkpoint`,
+                },
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            if (result.hitlTasks && result.hitlTasks.length > 0) {
+                this.logging.log(`ATX: Found ${result.hitlTasks.length} HITL task(s) with checkpoint-settings tag`);
+                return result.hitlTasks[0];
             }
+            this.logging.log('ATX: No HITL task found with checkpoint-settings tag');
             return null;
         }
         catch (error) {
-            this.logging.error(`ListJobPlanSteps error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.logging.error(`ATX: findCheckpointSettingsHitl error: ${String(error)}`);
             return null;
         }
     }
     /**
-     * Lists job plan steps using FES client with recursive substep fetching
+     * Update workspace by detecting modified files and submitting them to the step HITL.
+     * Goes through source-files.json to find files with last modified date > recorded timestamp,
+     * creates a zip with modified files and metadata.json containing filesUpdated with relative paths.
      */
-    async listJobPlanSteps(workspaceId, jobId) {
+    async updateWorkspace(workspaceId, jobId, solutionRootPath, stepId) {
         try {
-            this.logging.log(`ATX: Starting ListJobPlanSteps for job: ${jobId}`);
+            this.logging.log(`ATX: Starting updateWorkspace for job: ${jobId}, step: ${stepId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('ATX: Failed to initialize client for ListJobPlanSteps');
-                return null;
-            }
-            // Get root steps first
-            const rootSteps = await this.getStepsRecursive(workspaceId, jobId, 'root');
-            if (rootSteps && rootSteps.length > 0) {
-                // For each root step, get its substeps
-                for (const step of rootSteps) {
-                    const substeps = await this.getStepsRecursive(workspaceId, jobId, step.stepId);
-                    step.substeps = substeps || [];
-                    // Sort substeps by score (primary) and startTime (tiebreaker) to match RTS ordering
-                    if (step.substeps.length > 0) {
-                        step.substeps.sort((a, b) => {
-                            const scoreDiff = (a.score || 0) - (b.score || 0);
-                            if (scoreDiff !== 0)
-                                return scoreDiff;
-                            // Tiebreaker for identical scores: sort by startTime
-                            const timeA = a.startTime ? new Date(a.startTime).getTime() : 0;
-                            const timeB = b.startTime ? new Date(b.startTime).getTime() : 0;
-                            return timeA - timeB;
-                        });
-                        for (const substep of step.substeps) {
-                            const superSubsteps = await this.getStepsRecursive(workspaceId, jobId, substep.stepId);
-                            substep.substeps = superSubsteps || [];
-                            // Sort substeps by score (primary) and startTime (tiebreaker) to match RTS ordering
-                            if (substep.substeps.length > 0) {
-                                substep.substeps.sort((a, b) => {
-                                    const scoreDiff = (a.score || 0) - (b.score || 0);
-                                    if (scoreDiff !== 0)
-                                        return scoreDiff;
-                                    // Tiebreaker for identical scores: sort by startTime
-                                    const timeA = a.startTime ? new Date(a.startTime).getTime() : 0;
-                                    const timeB = b.startTime ? new Date(b.startTime).getTime() : 0;
-                                    return timeA - timeB;
-                                });
-                            }
-                        }
-                    }
+                return { Success: false, Error: 'ATX FES client not initialized' };
+            }
+            // Get the cached step HITL task ID, or query for it if not cached
+            let taskId = this.cachedStepHitl;
+            if (!taskId) {
+                this.logging.log('ATX: No cached step HITL, querying for active step HITL');
+                const stepHitl = await this.findStepLevelHitl(workspaceId, jobId, stepId);
+                if (!stepHitl || !stepHitl.taskId) {
+                    return { Success: false, Error: 'No active step HITL found' };
                 }
-                this.logging.log(`ATX: ListJobPlanSteps completed - Found ${rootSteps.length} steps with substeps`);
-                return rootSteps;
+                taskId = stepHitl.taskId;
+            }
+            const validTaskId = taskId;
+            // Check for user-modified files since last checkpoint
+            const modifiedFiles = this.getModifiedFilesSinceCheckpoint(solutionRootPath, jobId);
+            this.logging.log(`ATX: Found ${modifiedFiles.length} user-modified files, creating zip with metadata`);
+            // Create zip with modified files and metadata.json (even if empty)
+            const zipPath = await this.createUpdateWorkspaceZip(solutionRootPath, jobId, modifiedFiles);
+            if (!zipPath) {
+                return { Success: false, Error: 'Failed to create update workspace zip' };
+            }
+            // Upload the zip
+            const uploadInfo = await this.createArtifactUploadUrl(workspaceId, jobId, zipPath, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.ZIP);
+            if (!uploadInfo) {
+                return { Success: false, Error: 'Failed to create artifact upload URL' };
             }
-            this.logging.log('ATX: ListJobPlanSteps - No root steps found');
-            return null;
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, zipPath, uploadInfo.requestHeaders, this.logging);
+            if (!uploadSuccess) {
+                return { Success: false, Error: 'Failed to upload update workspace zip to S3' };
+            }
+            // Complete artifact upload
+            const completeResponse = await this.completeArtifactUpload(workspaceId, jobId, uploadInfo.uploadId);
+            if (!completeResponse?.success) {
+                return { Success: false, Error: 'Failed to complete artifact upload' };
+            }
+            // Update the HITL task with the human artifact
+            const updateResult = await this.updateHitl(workspaceId, jobId, validTaskId, uploadInfo.uploadId);
+            if (!updateResult) {
+                return { Success: false, Error: 'Failed to update workspace HITL' };
+            }
+            // Clear the cached step HITL after successful update
+            this.cachedStepHitl = null;
+            this.logging.log(`ATX: updateWorkspace completed successfully`);
+            return { Success: true };
         }
         catch (error) {
-            this.logging.error(`ATX: ListJobPlanSteps error: ${String(error)}`);
-            return null;
+            this.logging.error(`ATX: updateWorkspace error: ${String(error)}`);
+            return { Success: false, Error: String(error) };
         }
     }
     /**
-     * Recursively gets steps for a given parent step ID
+     * Creates a zip file containing modified files and a metadata.json with filesUpdated list.
+     * If no files are modified, creates a zip with just an empty metadata.json.
+     * Returns the path to the created zip file, or empty string if error.
      */
-    async getStepsRecursive(workspaceId, jobId, parentStepId) {
+    async createUpdateWorkspaceZip(solutionRootPath, jobId, modifiedFiles) {
         try {
-            const command = new elastic_gumby_frontend_client_1.ListJobPlanStepsCommand({
-                workspaceId: workspaceId,
-                jobId: jobId,
-                parentStepId: parentStepId,
-                maxResults: 100,
+            const checkpointsDir = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId, 'checkpoints');
+            if (!fs.existsSync(checkpointsDir)) {
+                fs.mkdirSync(checkpointsDir, { recursive: true });
+            }
+            const zipPath = path.join(checkpointsDir, 'update-workspace.zip');
+            // Calculate relative paths for metadata
+            const filesUpdated = modifiedFiles.map(filePath => path.relative(solutionRootPath, filePath));
+            // Create metadata.json content (empty array if no files modified)
+            const metadata = {
+                filesUpdated: filesUpdated,
+            };
+            const archive = archiver('zip', { zlib: { level: 9 } });
+            const stream = fs.createWriteStream(zipPath);
+            await new Promise((resolve, reject) => {
+                archive.on('error', err => reject(err));
+                stream.on('close', () => resolve());
+                archive.pipe(stream);
+                // Add metadata.json
+                archive.append(JSON.stringify(metadata, null, 2), { name: 'metadata.json' });
+                // Add modified files with relative paths
+                for (const filePath of modifiedFiles) {
+                    const relativePath = path.relative(solutionRootPath, filePath);
+                    archive.file(filePath, { name: relativePath });
+                }
+                void archive.finalize();
             });
-            await this.addAuthToCommand(command);
-            const result = await this.atxClient.send(command);
-            if (result && result.steps && result.steps.length > 0) {
-                return result.steps;
-            }
-            return null;
+            this.logging.log(`ATX: Created update workspace zip with ${modifiedFiles.length} files at ${zipPath}`);
+            return zipPath;
         }
         catch (error) {
-            this.logging.error(`Error getting steps for parent ${parentStepId}: ${String(error)}`);
-            return null;
+            this.logging.error(`ATX: Failed to create update workspace zip: ${String(error)}`);
+            return '';
         }
     }
     /**
-     * Lists artifacts using FES client with filtering - default to CUSTOMER_OUTPUT
+     * Submit a standard HITL task with a human artifact.
      */
-    async listArtifacts(workspaceId, jobId, filter = 'CUSTOMER_OUTPUT') {
+    async submitStandardHitl(workspaceId, jobId, taskId, humanArtifactId) {
         try {
-            this.logging.log(`ATX: Starting ListArtifacts for job: ${jobId}`);
+            this.logging.log(`ATX: Starting SubmitStandardHitl for task: ${taskId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('ATX: Failed to initialize client for ListArtifacts');
+                this.logging.error('ATX: Failed to initialize client for SubmitStandardHitl');
                 return null;
             }
-            const command = new elastic_gumby_frontend_client_1.ListArtifactsCommand({
+            const command = new elastic_gumby_frontend_client_1.SubmitStandardHitlTaskCommand({
                 workspaceId: workspaceId,
-                jobFilter: {
-                    jobId: jobId,
-                    categoryType: filter, // Server-side filtering for customer output artifacts
+                jobId: jobId,
+                taskId: taskId,
+                action: 'APPROVE',
+                humanArtifact: {
+                    artifactId: humanArtifactId,
                 },
             });
             await this.addAuthToCommand(command);
             const result = await this.atxClient.send(command);
-            this.logging.log(`ATX: ListArtifacts completed - Found ${result.artifacts?.length || 0} artifacts`);
-            return result.artifacts || [];
+            this.logging.log(`ATX: SubmitStandardHitl completed - task status: ${result.status || 'UNKNOWN'}`);
+            return result;
         }
         catch (error) {
-            this.logging.error(`ATX: ListArtifacts error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.logging.error(`ATX: SubmitStandardHitl error: ${String(error)}`);
             return null;
         }
     }
     /**
-     * Lists artifacts using FES client with CUSTOMER_OUTPUT filtering
+     * Apply changes from a checkpoint folder to the solution root.
+     * Reads metadata.json and applies file additions, removals, updates, and moves.
      */
-    async listWorklogs(workspaceId, jobId, solutionRootPath, stepId) {
+    async applyChanges(checkpointFolderPath, solutionRootPath) {
         try {
-            this.logging.log(`ATX: Starting ListWorklogs for job: ${jobId}`);
+            this.logging.log(`ATX: Starting applyChanges from ${checkpointFolderPath} to ${solutionRootPath}`);
+            // Read metadata.json from checkpoint folder
+            const metadataPath = path.join(checkpointFolderPath, 'metadata.json');
+            if (!fs.existsSync(metadataPath)) {
+                return { success: false, error: `metadata.json not found at ${metadataPath}` };
+            }
+            const metadataContent = fs.readFileSync(metadataPath, 'utf-8');
+            const metadata = JSON.parse(metadataContent);
+            const filesAdded = metadata.filesAdded || [];
+            const filesRemoved = metadata.filesRemoved || [];
+            const filesUpdated = metadata.filesUpdated || [];
+            const movedFilesMap = metadata.movedFilesMap || [];
+            let addedCount = 0;
+            let removedCount = 0;
+            let updatedCount = 0;
+            let movedCount = 0;
+            const successfullyAddedFiles = [];
+            // Handle filesAdded: Copy from {checkpointFolder}/after/{relativePath} to {solutionRootPath}/{relativePath}
+            for (const relativePath of filesAdded) {
+                try {
+                    const sourcePath = path.join(checkpointFolderPath, 'after', relativePath);
+                    const destPath = path.join(solutionRootPath, relativePath);
+                    // Ensure destination directory exists
+                    const destDir = path.dirname(destPath);
+                    if (!fs.existsSync(destDir)) {
+                        fs.mkdirSync(destDir, { recursive: true });
+                    }
+                    fs.copyFileSync(sourcePath, destPath);
+                    addedCount++;
+                    successfullyAddedFiles.push(relativePath);
+                    this.logging.log(`ATX: Added file: ${relativePath}`);
+                }
+                catch (e) {
+                    this.logging.error(`ATX: Failed to add file ${relativePath}: ${String(e)}`);
+                }
+            }
+            // Handle filesRemoved: Delete file at {solutionRootPath}/{relativePath}
+            for (const relativePath of filesRemoved) {
+                try {
+                    const filePath = path.join(solutionRootPath, relativePath);
+                    if (fs.existsSync(filePath)) {
+                        fs.unlinkSync(filePath);
+                        removedCount++;
+                        this.logging.log(`ATX: Removed file: ${relativePath}`);
+                    }
+                }
+                catch (e) {
+                    this.logging.error(`ATX: Failed to remove file ${relativePath}: ${String(e)}`);
+                }
+            }
+            // Handle filesUpdated: Copy from {checkpointFolder}/after/{relativePath} to {solutionRootPath}/{relativePath}
+            for (const relativePath of filesUpdated) {
+                try {
+                    const sourcePath = path.join(checkpointFolderPath, 'after', relativePath);
+                    const destPath = path.join(solutionRootPath, relativePath);
+                    // Ensure destination directory exists
+                    const destDir = path.dirname(destPath);
+                    if (!fs.existsSync(destDir)) {
+                        fs.mkdirSync(destDir, { recursive: true });
+                    }
+                    fs.copyFileSync(sourcePath, destPath);
+                    updatedCount++;
+                    this.logging.log(`ATX: Updated file: ${relativePath}`);
+                }
+                catch (e) {
+                    this.logging.error(`ATX: Failed to update file ${relativePath}: ${String(e)}`);
+                }
+            }
+            // Handle filesMoved: Use movedFilesMap to copy content from before to after location, delete before file
+            for (const mapping of movedFilesMap) {
+                try {
+                    const beforePath = path.join(solutionRootPath, mapping.before);
+                    const afterPath = path.join(solutionRootPath, mapping.after);
+                    // Ensure destination directory exists
+                    const afterDir = path.dirname(afterPath);
+                    if (!fs.existsSync(afterDir)) {
+                        fs.mkdirSync(afterDir, { recursive: true });
+                    }
+                    // Copy content from before to after
+                    if (fs.existsSync(beforePath)) {
+                        fs.copyFileSync(beforePath, afterPath);
+                        // Delete the before file
+                        fs.unlinkSync(beforePath);
+                        movedCount++;
+                        this.logging.log(`ATX: Moved file: ${mapping.before} -> ${mapping.after}`);
+                    }
+                }
+                catch (e) {
+                    this.logging.error(`ATX: Failed to move file ${mapping.before} -> ${mapping.after}: ${String(e)}`);
+                }
+            }
+            this.logging.log(`ATX: applyChanges completed - Added: ${addedCount}, Removed: ${removedCount}, Updated: ${updatedCount}, Moved: ${movedCount}`);
+            return {
+                success: true,
+                filesAdded: addedCount,
+                filesRemoved: removedCount,
+                filesUpdated: updatedCount,
+                filesMoved: movedCount,
+                addedFiles: successfullyAddedFiles,
+            };
+        }
+        catch (error) {
+            this.logging.error(`ATX: applyChanges error: ${String(error)}`);
+            return { success: false, error: String(error) };
+        }
+    }
+    /**
+     * Send chat message to Transform service
+     */
+    async sendMessage(request) {
+        try {
+            this.logging.log(`ATX: Sending chat message for workspace: ${request.workspaceId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('ATX: Failed to initialize client for ListWorklogs');
-                return null;
+                throw new Error('ATX FES client not initialized');
             }
-            const command = new elastic_gumby_frontend_client_1.ListWorklogsCommand({
-                workspaceId: workspaceId,
-                jobId: jobId,
-                ...(stepId && {
-                    worklogFilter: {
-                        stepIdFilter: {
-                            stepId: stepId,
+            const command = new elastic_gumby_frontend_client_1.SendMessageCommand({
+                text: request.text,
+                idempotencyToken: (0, uuid_1.v4)(),
+                metadata: {
+                    resourcesOnScreen: {
+                        workspace: {
+                            workspaceId: request.workspaceId,
+                            ...(request.jobId ? { jobs: [{ jobId: request.jobId, focusState: 'ACTIVE' }] } : {}),
                         },
                     },
-                }),
+                },
+            });
+            await this.addAuthToCommand(command);
+            const sendResult = (await this.atxClient.send(command));
+            const sentMessageId = sendResult?.message?.messageId;
+            if (!sentMessageId || request.skipPolling) {
+                return { success: true, data: sendResult };
+            }
+            // Poll for response (180 attempts * 5s = 15 minutes max)
+            for (let attempt = 0; attempt < 180; attempt++) {
+                await new Promise(resolve => setTimeout(resolve, 5000));
+                const listResult = await this.listMessages({
+                    workspaceId: request.workspaceId,
+                    jobId: request.jobId,
+                    maxResults: 10,
+                });
+                const messageIds = listResult?.messageIds ?? [];
+                if (!messageIds.length)
+                    continue;
+                const batchResult = await this.batchGetMessages({
+                    workspaceId: request.workspaceId,
+                    messageIds,
+                });
+                const responses = (batchResult?.messages ?? []).filter((m) => m.parentMessageId === sentMessageId && m.messageOrigin === 'SYSTEM');
+                const finalResponse = responses.find((m) => m.processingInfo?.messageType === 'FINAL_RESPONSE');
+                if (finalResponse) {
+                    return {
+                        success: true,
+                        data: {
+                            sentMessage: sendResult.message,
+                            response: {
+                                messageId: finalResponse.messageId,
+                                text: finalResponse.text,
+                                messageType: 'FINAL_RESPONSE',
+                                interactions: finalResponse.interactions,
+                                createdAt: finalResponse.createdAt,
+                            },
+                        },
+                    };
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    sentMessage: sendResult.message,
+                    response: null,
+                    note: 'No final response within 15 minutes. Use listMessages + batchGetMessages to check later.',
+                },
+            };
+        }
+        catch (error) {
+            this.logging.error(`ATX: SendMessage error: ${String(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * List chat messages
+     */
+    async listMessages(request) {
+        try {
+            this.logging.log(`ATX: Listing messages for workspace: ${request.workspaceId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
+            }
+            const workspace = { workspaceId: request.workspaceId };
+            if (request.jobId) {
+                workspace.jobs = [{ jobId: request.jobId, focusState: 'ACTIVE' }];
+            }
+            const command = new elastic_gumby_frontend_client_1.ListMessagesCommand({
+                metadata: { resourcesOnScreen: { workspace } },
+                ...(request.maxResults && { maxResults: request.maxResults }),
+                ...(request.nextToken && { nextToken: request.nextToken }),
+                ...(request.startTimestamp && { startTimestamp: request.startTimestamp }),
             });
             await this.addAuthToCommand(command);
             const result = await this.atxClient.send(command);
-            this.logging.log(`ATX: ListWorklogs completed - Found ${result.worklogs?.length || 0} entries`);
-            for (const value of result.worklogs || []) {
-                const currentStepId = value.attributeMap?.STEP_ID || stepId || 'Progress';
-                await utils_1.Utils.saveWorklogsToJson(jobId, currentStepId, value.description || '', solutionRootPath);
+            this.logging.log(`ATX: ListMessages completed - Found ${result.messageIds?.length || 0} messages`);
+            return result;
+        }
+        catch (error) {
+            this.logging.error(`ATX: ListMessages error: ${String(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * Batch get messages by IDs
+     */
+    async batchGetMessages(request) {
+        try {
+            this.logging.log(`ATX: Batch getting ${request.messageIds.length} messages`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
             }
-            return result.worklogs || [];
+            const command = new elastic_gumby_frontend_client_1.BatchGetMessageCommand({
+                messageIds: request.messageIds,
+                workspaceId: request.workspaceId,
+            });
+            await this.addAuthToCommand(command);
+            const result = await this.atxClient.send(command);
+            this.logging.log(`ATX: BatchGetMessages completed`);
+            return result;
         }
         catch (error) {
-            this.logging.error(`ATX: ListWorklogs error: ${String(error)}`);
+            this.logging.error(`ATX: BatchGetMessages error: ${String(error)}`);
+            throw error;
+        }
+    }
+    async listArtifactsForDownload(workspaceId, jobId) {
+        try {
+            const artifacts = await this.listArtifacts(workspaceId, jobId);
+            if (!artifacts) {
+                return { Artifacts: [], Error: 'Failed to list artifacts' };
+            }
+            this.logging.log(`ATX: listArtifactsForDownload raw artifacts: ${JSON.stringify(artifacts.map((a) => ({ id: a.artifactId, path: a.fileMetadata?.path, category: a.categoryType })))}`);
+            const mapped = artifacts
+                .filter((a) => a.fileMetadata?.path)
+                .map((a) => ({
+                ArtifactId: a.artifactId,
+                Name: a.fileMetadata.path,
+                Description: a.fileMetadata.description || '',
+                SizeInBytes: a.sizeInBytes || 0,
+                CreatedTimestamp: a.artifactCreatedTimestamp || 0,
+            }));
+            return { Artifacts: mapped };
+        }
+        catch (error) {
+            this.logging.error(`ATX: listArtifactsForDownload error: ${error}`);
+            return { Artifacts: [], Error: String(error) };
+        }
+    }
+    async downloadArtifactToPath(workspaceId, jobId, artifactId, savePath, artifactName) {
+        try {
+            const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, artifactId);
+            if (!downloadInfo) {
+                return { Success: false, Error: 'Failed to get download URL' };
+            }
+            const response = await got_1.default.get(downloadInfo.s3PresignedUrl, {
+                headers: downloadInfo.requestHeaders || {},
+                responseType: 'buffer',
+            });
+            await utils_1.Utils.directoryExists(savePath);
+            const fileName = artifactName ? path.basename(artifactName) : 'artifact.zip';
+            const filePath = path.join(savePath, fileName);
+            fs.writeFileSync(filePath, Buffer.from(response.body));
+            return { Success: true, FilePath: savePath };
+        }
+        catch (error) {
+            return { Success: false, Error: String(error) };
+        }
+    }
+    /**
+     * Get job dashboard data — fetches dashboard HITL task, downloads artifact, parses repo/branch info
+     */
+    async getJobDashboard(workspaceId, jobId) {
+        try {
+            this.logging.log(`getJobDashboard START - job: ${jobId}, workspace: ${workspaceId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX client not initialized');
+            }
+            // Step 1: List DASHBOARD HITL tasks
+            this.logging.log(`Step 1: ListHitlTasks taskType=DASHBOARD`);
+            const command = new elastic_gumby_frontend_client_1.ListHitlTasksCommand({
+                workspaceId,
+                jobId,
+                taskType: 'DASHBOARD',
+            });
+            await this.addAuthToCommand(command);
+            const hitlResult = await this.atxClient.send(command);
+            this.logging.log(`Step 1: Found ${hitlResult.hitlTasks?.length || 0} DASHBOARD tasks`);
+            const dashboardTask = hitlResult.hitlTasks?.[0];
+            if (!dashboardTask?.agentArtifact?.artifactId) {
+                this.logging.error(`No artifact. Task: ${JSON.stringify(dashboardTask)}`);
+                return null;
+            }
+            this.logging.log(`Step 1: artifactId=${dashboardTask.agentArtifact.artifactId}`);
+            // Step 2: Download artifact
+            this.logging.log(`Step 2: Getting download URL`);
+            const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, dashboardTask.agentArtifact.artifactId);
+            if (!downloadInfo) {
+                throw new Error('Failed to get dashboard artifact download URL');
+            }
+            this.logging.log(`Step 2: Downloading...`);
+            const response = await (0, got_1.default)(downloadInfo.s3PresignedUrl, {
+                headers: downloadInfo.requestHeaders,
+                responseType: 'buffer',
+            });
+            // Step 3: Parse
+            this.logging.log(`Step 3: Downloaded ${response.body.length} bytes`);
+            this.logging.log(`Step 3: First 300 chars: ${response.body.toString('utf8').substring(0, 300)}`);
+            let dashboardData = null;
+            try {
+                dashboardData = JSON.parse(response.body.toString('utf8'));
+                this.logging.log(`Step 3: Parsed as raw JSON OK`);
+            }
+            catch (jsonErr) {
+                this.logging.log(`Step 3: JSON parse failed: ${jsonErr}, trying zip`);
+                const zip = new AdmZip(response.body);
+                for (const entry of zip.getEntries()) {
+                    this.logging.log(`Step 3: Zip entry: ${entry.entryName}`);
+                    if (entry.entryName.endsWith('.json') || entry.entryName.includes('dashboard')) {
+                        dashboardData = JSON.parse(entry.getData().toString('utf8'));
+                        break;
+                    }
+                }
+            }
+            if (!dashboardData) {
+                throw new Error('Could not parse dashboard artifact');
+            }
+            this.logging.log(`Step 3: Keys: ${Object.keys(dashboardData).join(', ')}`);
+            this.logging.log(`Step 3: previousDashboards: ${JSON.stringify(dashboardData.previousDashboards)?.substring(0, 500)}`);
+            // Step 4: Extract repos
+            const projectDetail = dashboardData.projectDetail || {};
+            const resources = dashboardData.resources || [];
+            this.logging.log(`Step 4: targetBranch=${projectDetail.targetBranch}, targetVersion=${projectDetail.targetVersion}, resources=${resources.length}`);
+            const repos = resources.map((r, i) => {
+                this.logging.log(`Step 4: repo[${i}] name=${r.repositoryName} url=${r.repositoryLocation?.url} status=${r.status} loc=${r.totalLoc}`);
+                // Get solution paths from solutionSummaryFailureReasons keys, or project names as fallback
+                let solutions = [];
+                if (r.solutionSummaryFailureReasons && Object.keys(r.solutionSummaryFailureReasons).length > 0) {
+                    solutions = Object.keys(r.solutionSummaryFailureReasons);
+                }
+                else if (r.projects && r.projects.length > 0) {
+                    // Extract unique project names
+                    solutions = r.projects.map((p) => p.name || '').filter((n) => n);
+                }
+                this.logging.log(`Step 4: repo[${i}] solutions=${solutions.join(', ')}`);
+                return {
+                    repositoryName: r.repositoryName || '',
+                    cloneUrl: r.repositoryLocation?.url || '',
+                    targetBranch: projectDetail.targetBranch || '',
+                    sourceBranch: r.sourceBranch || '',
+                    status: r.status || '',
+                    totalLoc: r.totalLoc,
+                    totalProjects: r.totalProjects,
+                    solutions,
+                };
+            });
+            // Get report artifact IDs
+            const reportArtifactId = dashboardData.jobTransformationSummaryArtifact || '';
+            this.logging.log(`Step 4: reportArtifactId=${reportArtifactId}`);
+            // Step 5: Get assessment report artifact IDs from DotnetCrossRepoSelector HITL
+            let jobAssessmentReportArtifactId = '';
+            const repoAssessmentMap = {}; // repoName -> artifactId
+            try {
+                const normalHitlCmd = new elastic_gumby_frontend_client_1.ListHitlTasksCommand({ workspaceId, jobId, taskType: 'NORMAL' });
+                await this.addAuthToCommand(normalHitlCmd);
+                const normalHitlResult = await this.atxClient.send(normalHitlCmd);
+                const tasks = normalHitlResult.hitlTasks || [];
+                this.logging.log(`Step 5: ${tasks.length} NORMAL HITL tasks`);
+                const selectorTask = tasks.find(t => t.uxComponentId === 'DotnetCrossRepoSelector');
+                if (selectorTask?.agentArtifact?.artifactId) {
+                    this.logging.log(`Step 5: Downloading DotnetCrossRepoSelector artifact: ${selectorTask.agentArtifact.artifactId}`);
+                    const dlInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, selectorTask.agentArtifact.artifactId);
+                    if (dlInfo) {
+                        const resp = await (0, got_1.default)(dlInfo.s3PresignedUrl, {
+                            headers: dlInfo.requestHeaders,
+                            responseType: 'text',
+                        });
+                        const selectorProps = JSON.parse(typeof resp.body === 'string' ? resp.body : String(resp.body));
+                        // Job-level assessment report
+                        const jobReports = selectorProps.properties?.jobAssessmentReports || [];
+                        jobAssessmentReportArtifactId = jobReports[0]?.artifactId || '';
+                        this.logging.log(`Step 5: jobAssessmentReportArtifactId=${jobAssessmentReportArtifactId}`);
+                        // Per-repo assessment reports
+                        const discoveredResources = selectorProps.properties?.discoveredResources || [];
+                        for (const r of discoveredResources) {
+                            const repoReports = r.repoAssessmentReports || [];
+                            if (repoReports.length > 0 && r.name) {
+                                repoAssessmentMap[r.name] = repoReports[0].artifactId;
+                                this.logging.log(`Step 5: repo ${r.name} assessmentArtifactId=${repoReports[0].artifactId}`);
+                            }
+                        }
+                    }
+                }
+                else {
+                    this.logging.log(`Step 5: DotnetCrossRepoSelector task not found`);
+                }
+            }
+            catch (e) {
+                this.logging.log(`Step 5: Failed to get assessment reports: ${e}`);
+            }
+            // Attach assessment + transformation report artifact IDs to repos
+            // repoTransformationSummaryArtifacts is an array of {repoName: artifactId} objects
+            const repoTransformationArtifactsRaw = dashboardData.repoTransformationSummaryArtifacts || [];
+            const repoTransformationMap = {};
+            if (Array.isArray(repoTransformationArtifactsRaw)) {
+                for (const entry of repoTransformationArtifactsRaw) {
+                    for (const [name, id] of Object.entries(entry)) {
+                        repoTransformationMap[name] = id;
+                    }
+                }
+            }
+            this.logging.log(`Step 5: repoTransformationMap keys: ${Object.keys(repoTransformationMap).join(', ')}`);
+            for (const repo of repos) {
+                repo.assessmentReportArtifactId = repoAssessmentMap[repo.repositoryName] || '';
+                repo.transformationReportArtifactId = repoTransformationMap[repo.repositoryName] || '';
+                this.logging.log(`Step 5: repo ${repo.repositoryName} assessment=${repo.assessmentReportArtifactId} transformation=${repo.transformationReportArtifactId}`);
+            }
+            this.logging.log(`getJobDashboard DONE - ${repos.length} repos`);
+            return {
+                targetBranch: projectDetail.targetBranch,
+                targetVersion: projectDetail.targetVersion,
+                repos,
+                reportArtifactId,
+                jobAssessmentReportArtifactId,
+            };
+        }
+        catch (error) {
+            this.logging.error(`getJobDashboard ERROR: ${String(error)}`);
+            return null;
+        }
+    }
+    /**
+     * Find and download the assessment report XLSX for a completed job
+     */
+    async getJobReport(workspaceId, jobId, artifactId) {
+        try {
+            this.logging.log(`getJobReport START - job: ${jobId}, artifact: ${artifactId}`);
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX client not initialized');
+            }
+            if (!artifactId)
+                throw new Error('ArtifactId is required');
+            const reportDl = await this.createArtifactDownloadUrl(workspaceId, jobId, artifactId);
+            if (!reportDl)
+                throw new Error('Failed to get report download URL');
+            const reportResp = await (0, got_1.default)(reportDl.s3PresignedUrl, {
+                headers: reportDl.requestHeaders,
+                responseType: 'buffer',
+            });
+            this.logging.log(`getJobReport DONE - ${reportResp.body.length} bytes`);
+            return {
+                reportBase64: reportResp.body.toString('base64'),
+                fileName: `report_${jobId.substring(0, 8)}_${artifactId.substring(0, 8)}.xlsx`,
+            };
+        }
+        catch (error) {
+            this.logging.error(`getJobReport ERROR: ${String(error)}`);
             return null;
         }
     }