@bloomreach/brxm-upgrade 0.1.1

package/dist/guide/phases/ExecutionPhase.d.ts

@@ -0,0 +1,80 @@
+import type { GuidePhase, GuideContext, PhaseResult } from '../types.js';
+/**
+ * Execution phase: iterates through plan steps with AI coaching,
+ * prompts the user for actions, and delegates to executors for
+ * prepare/apply operations.
+ *
+ * This phase wraps the lower-level executor infrastructure with
+ * StepCoach interactions, providing briefings, Q&A, and a ChatLoop
+ * for each step.
+ */
+export declare class ExecutionPhase implements GuidePhase {
+    readonly name = "Execution";
+    readonly phaseNumber = 3;
+    readonly totalPhases = 3;
+    readonly canChat = true;
+    private static readonly MAX_SPINNER_LABEL_LENGTH;
+    run(context: GuideContext): Promise<PhaseResult>;
+    /**
+     * Execute a single step in a prompt loop, handling user actions
+     * like show_diff, ask_question, and ask_ai_help before the final
+     * apply or skip decision.
+     */
+    private executeStepLoop;
+    /**
+     * Prompt the user for an action.
+     * Always interactive — AI options are shown but disabled when no coach is available.
+     */
+    private promptStepAction;
+    /**
+     * Prepares steps that need instructions shown before the user chooses an action.
+     */
+    private prepareForDisplay;
+    /**
+     * Show step-specific instructions or guidance before the prompt.
+     */
+    private showPreparedGuidance;
+    private getSpinnerStepLabel;
+    private formatStepBriefingOutput;
+    private showLabeledText;
+    /**
+     * Build step-specific action choices for the execution prompt.
+     */
+    private getStepActionChoices;
+    /**
+     * Prompt the user when step preparation fails validation.
+     */
+    private promptValidationError;
+    /**
+     * Prompt for revision instructions for an AI-assisted proposal.
+     */
+    private promptRevisionRequest;
+    /**
+     * Create all executor instances.
+     */
+    private createExecutors;
+    /**
+     * Select the appropriate executor for a step based on its type and
+     * automation level.
+     */
+    private getExecutorForStep;
+    /**
+     * Initialize or resume execution state from context.
+     */
+    private initializeState;
+    /**
+     * Determine the starting index in the steps array for resume support.
+     * Skips steps that are already completed or skipped in the execution state.
+     */
+    private getStartIndex;
+    /**
+     * Verification and manual steps are completed by the user after reviewing
+     * guidance rather than by writing prepared changes here.
+     */
+    private completesWithoutAutomaticApply;
+    /**
+     * Narrow an executor to the AI-assisted executor when revision support is available.
+     */
+    private isAIAssistedExecutor;
+}
+//# sourceMappingURL=ExecutionPhase.d.ts.map

package/dist/guide/phases/ExecutionPhase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionPhase.d.ts","sourceRoot":"","sources":["../../../src/guide/phases/ExecutionPhase.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAC;AAQvF;;;;;;;;GAQG;AACH,qBAAa,cAAe,YAAW,UAAU;IAC/C,QAAQ,CAAC,IAAI,eAAe;IAC5B,QAAQ,CAAC,WAAW,KAAK;IACzB,QAAQ,CAAC,WAAW,KAAK;IACzB,QAAQ,CAAC,OAAO,QAAQ;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAAM;IAEhD,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAuJtD;;;;OAIG;YACW,eAAe;IA8M7B;;;OAGG;YACW,gBAAgB;IAoB9B;;OAEG;YACW,iBAAiB;IAyC/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAmB5B,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,wBAAwB;IAiBhC,OAAO,CAAC,eAAe;IAMvB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAqD5B;;OAEG;YACW,qBAAqB;IAsBnC;;OAEG;YACW,qBAAqB;IAYnC;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;OAEG;IACH,OAAO,CAAC,eAAe;IAmBvB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAUrB;;;OAGG;IACH,OAAO,CAAC,8BAA8B;IAItC;;OAEG;IACH,OAAO,CAAC,oBAAoB;CAG7B"}

package/dist/guide/phases/ExecutionPhase.js

@@ -0,0 +1,574 @@
+/* eslint-disable no-console */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { AutomatedExecutor, AIAssistedExecutor, ManualExecutor, VersionBumpExecutor, CVGateExecutor, } from '../../execution/executors/index.js';
+import { StateManager } from '../../execution/state-manager.js';
+import { DiffPresenter } from '../../execution/diff-presenter.js';
+import { createSpinner } from '../../utils/spinner.js';
+import { StepCoach } from '../chat/StepCoach.js';
+import { ChatLoop } from '../chat/ChatLoop.js';
+import { ChatContextBuilder } from '../chat/ChatContextBuilder.js';
+import { formatPhaseHeader, formatPhaseIntro, formatStepBriefing, formatOutro, wrapIndentedText, } from '../rendering/formatters.js';
+import { formatPlatformChangesSummary } from '../rendering/platform-changes.js';
+/**
+ * Execution phase: iterates through plan steps with AI coaching,
+ * prompts the user for actions, and delegates to executors for
+ * prepare/apply operations.
+ *
+ * This phase wraps the lower-level executor infrastructure with
+ * StepCoach interactions, providing briefings, Q&A, and a ChatLoop
+ * for each step.
+ */
+export class ExecutionPhase {
+    name = 'Execution';
+    phaseNumber = 3;
+    totalPhases = 3;
+    canChat = true;
+    static MAX_SPINNER_LABEL_LENGTH = 40;
+    async run(context) {
+        console.log(formatPhaseHeader(this.phaseNumber, this.totalPhases, this.name));
+        console.log(formatPhaseIntro('Execute'));
+        if (!context.plan) {
+            return {
+                success: false,
+                summary: 'Execution failed — missing prerequisites',
+                error: 'No plan available. Run the planning phase first.',
+            };
+        }
+        const plan = context.plan;
+        const steps = plan.steps;
+        const totalSteps = steps.length;
+        // Initialize executors
+        const executors = this.createExecutors(context.ai);
+        const stateManager = new StateManager(context.projectRoot);
+        const diffPresenter = new DiffPresenter();
+        const coach = context.ai ? new StepCoach(context.ai) : undefined;
+        const contextBuilder = new ChatContextBuilder();
+        // Initialize or resume execution state
+        const state = this.initializeState(context, plan.generatedAt);
+        context.executionState = state;
+        // Determine the starting step index (for resume support)
+        const processedSteps = new Set([...state.completedSteps, ...state.skippedSteps]);
+        const startIndex = this.getStartIndex(state, steps);
+        const results = [];
+        for (let i = startIndex; i < steps.length; i++) {
+            const step = steps[i];
+            // Skip steps already processed in a prior partial run (handles failed→completed gaps)
+            if (processedSteps.has(step.stepNumber)) {
+                continue;
+            }
+            state.currentStep = step.stepNumber;
+            // Step action loop: prompt, handle action, re-prompt if needed
+            const result = await this.executeStepLoop(step, totalSteps, context, executors, diffPresenter, coach, contextBuilder);
+            results.push(result);
+            // Update execution state
+            if (result.success) {
+                if (result.decision === 'accept') {
+                    state.completedSteps.push(step.stepNumber);
+                }
+                else if (result.decision === 'skip') {
+                    state.skippedSteps.push(step.stepNumber);
+                }
+            }
+            else {
+                state.failedSteps.push(step.stepNumber);
+                // "Abort upgrade" should stop the entire execution loop, not just the current step
+                if (result.decision === 'reject') {
+                    state.updatedAt = new Date().toISOString();
+                    await stateManager.saveState(state);
+                    break;
+                }
+            }
+            state.updatedAt = new Date().toISOString();
+            await stateManager.saveState(state);
+        }
+        // Store results in context
+        context.executionResults = results;
+        // Mark complete when all steps have been processed (accounts for resumed partial runs)
+        const allProcessed = new Set([...state.completedSteps, ...state.skippedSteps]);
+        if (allProcessed.size >= totalSteps) {
+            state.isComplete = true;
+            await stateManager.saveState(state);
+        }
+        // Use cumulative state counts so resumed runs report total progress
+        const applied = state.completedSteps.length;
+        const skipped = state.skippedSteps.length;
+        const failed = state.failedSteps.length;
+        // -- Build final summary --
+        const allResults = context.executionResults ?? [];
+        const completedStepNumbers = new Set(state.completedSteps);
+        const skippedStepNumbers = new Set(state.skippedSteps);
+        const manualStepsRemaining = plan.steps.filter((s) => !completedStepNumbers.has(s.stepNumber)
+            && (s.automatable === 'false'
+                || skippedStepNumbers.has(s.stepNumber)));
+        const totalDuration = allResults.reduce((sum, r) => sum + r.duration, 0);
+        console.log(formatOutro({
+            fromVersion: context.currentVersion ?? 'unknown',
+            toVersion: context.targetVersion ?? 'unknown',
+            applied,
+            skipped,
+            failed,
+            duration: totalDuration,
+            manualStepsRemaining: manualStepsRemaining.map(s => ({
+                stepNumber: s.stepNumber,
+                description: s.description,
+                manualSteps: s.manualSteps,
+            })),
+        }));
+        // Show Platform Changes Summary if there are informational entries
+        if (plan.informationalEntries && plan.informationalEntries.length > 0) {
+            console.log(formatPlatformChangesSummary(plan.informationalEntries, plan.fromVersion, plan.toVersion));
+        }
+        const guideSummary = {
+            fromVersion: context.currentVersion ?? 'unknown',
+            toVersion: context.targetVersion ?? 'unknown',
+            completedSteps: applied,
+            skippedSteps: skipped,
+            manualStepsRemaining,
+            duration: totalDuration,
+        };
+        const summaryText = failed > 0
+            ? `Upgrade completed with errors: ${String(applied)} applied, ${String(skipped)} skipped, ${String(failed)} failed`
+            : `Execution complete: ${String(applied)} applied, ${String(skipped)} skipped, ${String(failed)} failed`;
+        return {
+            success: true,
+            summary: summaryText,
+            data: guideSummary,
+        };
+    }
+    /**
+     * Execute a single step in a prompt loop, handling user actions
+     * like show_diff, ask_question, and ask_ai_help before the final
+     * apply or skip decision.
+     */
+    async executeStepLoop(step, totalSteps, context, executors, diffPresenter, coach, contextBuilder) {
+        const startTime = Date.now();
+        const executor = this.getExecutorForStep(step, executors);
+        const suppressStepBriefingLeadingBlankLine = step.automatable === 'partial' && this.isAIAssistedExecutor(executor);
+        let preparedChanges = await this.prepareForDisplay(step, executor, context.projectRoot);
+        console.log(this.formatStepBriefingOutput(step, totalSteps, suppressStepBriefingLeadingBlankLine));
+        if (coach) {
+            const briefingSpinner = createSpinner({ text: 'Generating context...', color: 'cyan' });
+            briefingSpinner.start();
+            try {
+                const aiBriefing = await coach.generateBriefing(step, context.discovery);
+                briefingSpinner.stop();
+                this.showLabeledText('Context', aiBriefing);
+            }
+            catch {
+                briefingSpinner.stop();
+                // Context is nice-to-have — continue without it
+            }
+        }
+        this.showPreparedGuidance(step, preparedChanges);
+        while (true) {
+            const action = await this.promptStepAction(step, !!coach, preparedChanges);
+            switch (action) {
+                case 'apply': {
+                    const executor = this.getExecutorForStep(step, executors);
+                    // Prepare if not already prepared (from show_diff)
+                    if (!preparedChanges) {
+                        preparedChanges = await executor.prepare(step, context.projectRoot);
+                    }
+                    if (!preparedChanges.isValid) {
+                        const errorAction = await this.promptValidationError(preparedChanges.validationErrors ?? ['Unknown validation error']);
+                        switch (errorAction) {
+                            case 'skip':
+                                return {
+                                    stepNumber: step.stepNumber,
+                                    entryId: step.entryId,
+                                    success: true,
+                                    decision: 'skip',
+                                    modifiedFiles: [],
+                                    modifiedFileCount: 0,
+                                    duration: Date.now() - startTime,
+                                };
+                            case 'mark_done':
+                                return {
+                                    stepNumber: step.stepNumber,
+                                    entryId: step.entryId,
+                                    success: true,
+                                    decision: 'accept',
+                                    modifiedFiles: [],
+                                    modifiedFileCount: 0,
+                                    duration: Date.now() - startTime,
+                                };
+                            case 'abort':
+                                return {
+                                    stepNumber: step.stepNumber,
+                                    entryId: step.entryId,
+                                    success: false,
+                                    decision: 'reject',
+                                    modifiedFiles: [],
+                                    modifiedFileCount: 0,
+                                    error: preparedChanges.validationErrors?.join(', '),
+                                    duration: Date.now() - startTime,
+                                };
+                        }
+                    }
+                    if (step.automatable === 'partial' && preparedChanges.changes.length === 0) {
+                        return {
+                            stepNumber: step.stepNumber,
+                            entryId: step.entryId,
+                            success: true,
+                            decision: 'accept',
+                            modifiedFiles: [],
+                            modifiedFileCount: 0,
+                            duration: Date.now() - startTime,
+                        };
+                    }
+                    if (this.completesWithoutAutomaticApply(step)) {
+                        return {
+                            stepNumber: step.stepNumber,
+                            entryId: step.entryId,
+                            success: true,
+                            decision: 'accept',
+                            modifiedFiles: [],
+                            modifiedFileCount: 0,
+                            duration: Date.now() - startTime,
+                        };
+                    }
+                    try {
+                        const modifiedFiles = await executor.apply(preparedChanges, context.projectRoot);
+                        return {
+                            stepNumber: step.stepNumber,
+                            entryId: step.entryId,
+                            success: true,
+                            decision: 'accept',
+                            modifiedFiles: modifiedFiles.map((f) => f.filePath),
+                            modifiedFileCount: modifiedFiles.length,
+                            duration: Date.now() - startTime,
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            stepNumber: step.stepNumber,
+                            entryId: step.entryId,
+                            success: false,
+                            decision: 'reject',
+                            modifiedFiles: [],
+                            modifiedFileCount: 0,
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                            duration: Date.now() - startTime,
+                        };
+                    }
+                }
+                case 'show_diff': {
+                    // Prepare changes if not yet prepared
+                    if (!preparedChanges) {
+                        preparedChanges = await executor.prepare(step, context.projectRoot);
+                    }
+                    diffPresenter.showFullDiff(preparedChanges);
+                    // Re-prompt
+                    break;
+                }
+                case 'ask_ai_help': {
+                    if (context.ai) {
+                        const chatContext = contextBuilder.buildStepContext(step, context.discovery);
+                        const chatLoop = new ChatLoop(context.ai);
+                        await chatLoop.run(chatContext, contextBuilder.buildSystemPrompt());
+                    }
+                    // Re-prompt
+                    break;
+                }
+                case 'revise_ai': {
+                    if (this.isAIAssistedExecutor(executor)) {
+                        const revisionRequest = await this.promptRevisionRequest();
+                        console.log('');
+                        const spinnerLabel = this.getSpinnerStepLabel(step);
+                        const spinner = createSpinner({
+                            text: `Revising AI proposal for ${spinnerLabel}...`,
+                            color: 'cyan',
+                        });
+                        spinner.start();
+                        try {
+                            preparedChanges = await executor.revise(step, context.projectRoot, preparedChanges ?? {
+                                step,
+                                changes: [],
+                                totalFiles: 0,
+                                isValid: true,
+                            }, revisionRequest);
+                            spinner.stop();
+                            this.showPreparedGuidance(step, preparedChanges);
+                        }
+                        catch (error) {
+                            spinner.fail('Failed to revise AI proposal');
+                            console.log(chalk.yellow(`  ${error instanceof Error ? error.message : 'Unable to revise AI proposal.'}`));
+                        }
+                    }
+                    // Re-prompt
+                    break;
+                }
+                case 'skip': {
+                    return {
+                        stepNumber: step.stepNumber,
+                        entryId: step.entryId,
+                        success: true,
+                        decision: 'skip',
+                        modifiedFiles: [],
+                        modifiedFileCount: 0,
+                        duration: Date.now() - startTime,
+                    };
+                }
+            }
+        }
+    }
+    /**
+     * Prompt the user for an action.
+     * Always interactive — AI options are shown but disabled when no coach is available.
+     */
+    async promptStepAction(step, hasAI, preparedChanges) {
+        const choices = this.getStepActionChoices(step, hasAI, preparedChanges);
+        console.log('');
+        const { action } = (await inquirer.prompt([
+            {
+                type: 'select',
+                name: 'action',
+                message: chalk.cyan('What would you like to do?'),
+                choices,
+            },
+        ]));
+        return action;
+    }
+    /**
+     * Prepares steps that need instructions shown before the user chooses an action.
+     */
+    async prepareForDisplay(step, executor, projectRoot) {
+        if (step.type === 'verification_gate') {
+            return executor.prepare(step, projectRoot);
+        }
+        if (step.automatable === 'partial') {
+            if (!this.isAIAssistedExecutor(executor)) {
+                return {
+                    step,
+                    changes: [],
+                    totalFiles: 0,
+                    aiAnalysis: step.aiGuidance ??
+                        step.analysis ??
+                        'AI assistance is unavailable for this step. Review it manually and mark it as done when finished.',
+                    isValid: true,
+                };
+            }
+            console.log('');
+            const spinnerLabel = this.getSpinnerStepLabel(step);
+            const spinner = createSpinner({
+                text: `Preparing AI guidance for ${spinnerLabel}...`,
+                color: 'cyan',
+            });
+            spinner.start();
+            try {
+                const prepared = await executor.prepare(step, projectRoot);
+                spinner.stop();
+                return prepared;
+            }
+            catch (error) {
+                spinner.fail('Failed to prepare AI guidance');
+                throw error;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Show step-specific instructions or guidance before the prompt.
+     */
+    showPreparedGuidance(step, preparedChanges) {
+        if (step.manualSteps && step.manualSteps.length > 0) {
+            this.showLabeledText('Instructions', step.manualSteps.map((manualStep, index) => `${index + 1}. ${manualStep}`).join('\n'));
+            return;
+        }
+        if (preparedChanges?.aiAnalysis) {
+            this.showLabeledText('AI Guidance', preparedChanges.aiAnalysis);
+            return;
+        }
+        if (preparedChanges?.message) {
+            this.showLabeledText('Instructions', preparedChanges.message);
+        }
+    }
+    getSpinnerStepLabel(step) {
+        const description = step.description.trim();
+        if (description.length > 0
+            && description.length <= ExecutionPhase.MAX_SPINNER_LABEL_LENGTH
+            && !description.includes('\n')) {
+            return description;
+        }
+        return `step ${step.stepNumber}`;
+    }
+    formatStepBriefingOutput(step, totalSteps, suppressLeadingBlankLine = false) {
+        const briefing = formatStepBriefing({
+            stepNumber: step.stepNumber,
+            totalSteps,
+            description: step.description,
+            type: step.type,
+            automatable: step.automatable,
+            riskLevel: step.riskLevel,
+            affectedFileCount: step.affectedFileCount,
+        });
+        return suppressLeadingBlankLine ? briefing.replace(/^\n/, '') : briefing;
+    }
+    showLabeledText(label, text) {
+        console.log('');
+        console.log(chalk.bold(`${label}:`));
+        console.log(wrapIndentedText(text));
+    }
+    /**
+     * Build step-specific action choices for the execution prompt.
+     */
+    getStepActionChoices(step, hasAI, preparedChanges) {
+        const aiDisabledHint = '(requires AI key)';
+        const askAIChoice = {
+            name: `${step.automatable === 'partial' ? 'Ask AI for help first' : 'Ask AI for help'}${hasAI ? '' : ` ${aiDisabledHint}`}`,
+            value: 'ask_ai_help',
+            disabled: !hasAI,
+        };
+        if (step.type === 'verification_gate') {
+            return [
+                { name: 'Mark this check as done', value: 'apply' },
+                askAIChoice,
+                { name: 'Skip this step', value: 'skip' },
+            ];
+        }
+        if (step.automatable === 'false') {
+            return [
+                { name: 'Mark this step as done', value: 'apply' },
+                askAIChoice,
+                { name: 'Skip this step', value: 'skip' },
+            ];
+        }
+        if (step.automatable === 'partial') {
+            if (preparedChanges && preparedChanges.changes.length > 0) {
+                return [
+                    { name: 'Show diff first', value: 'show_diff' },
+                    { name: 'Apply proposed change', value: 'apply' },
+                    { name: `Ask AI to revise${hasAI ? '' : ` ${aiDisabledHint}`}`, value: 'revise_ai', disabled: !hasAI },
+                    { name: 'Skip this step', value: 'skip' },
+                ];
+            }
+            return [
+                { name: 'Mark this step as done', value: 'apply' },
+                { name: `Ask AI to revise${hasAI ? '' : ` ${aiDisabledHint}`}`, value: 'revise_ai', disabled: !hasAI },
+                askAIChoice,
+                { name: 'Skip this step', value: 'skip' },
+            ];
+        }
+        return [
+            { name: 'Apply this change', value: 'apply' },
+            { name: 'Show the diff first', value: 'show_diff' },
+            askAIChoice,
+            { name: 'Skip this step', value: 'skip' },
+        ];
+    }
+    /**
+     * Prompt the user when step preparation fails validation.
+     */
+    async promptValidationError(errors) {
+        console.log('');
+        console.log(chalk.yellow('  ⚠ Step validation issue: ') + errors.join(', '));
+        const { action } = (await inquirer.prompt([
+            {
+                type: 'select',
+                name: 'action',
+                message: chalk.cyan('What would you like to do?'),
+                choices: [
+                    { name: 'Skip this step', value: 'skip' },
+                    { name: 'Mark as done (I handled it myself)', value: 'mark_done' },
+                    { name: 'Abort upgrade', value: 'abort' },
+                ],
+            },
+        ]));
+        return action;
+    }
+    /**
+     * Prompt for revision instructions for an AI-assisted proposal.
+     */
+    async promptRevisionRequest() {
+        const { revisionRequest } = (await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'revisionRequest',
+                message: chalk.cyan('What should the AI change about the proposal?'),
+            },
+        ]));
+        return revisionRequest.trim();
+    }
+    /**
+     * Create all executor instances.
+     */
+    createExecutors(ai) {
+        return {
+            automated: new AutomatedExecutor(),
+            aiAssisted: ai ? new AIAssistedExecutor(ai) : undefined,
+            manual: new ManualExecutor(),
+            versionBump: new VersionBumpExecutor(),
+            cvGate: new CVGateExecutor(),
+        };
+    }
+    /**
+     * Select the appropriate executor for a step based on its type and
+     * automation level.
+     */
+    getExecutorForStep(step, executors) {
+        if (step.type === 'verification_gate') {
+            return executors.cvGate;
+        }
+        if (step.type === 'version_bump') {
+            return executors.versionBump;
+        }
+        switch (step.automatable) {
+            case 'true':
+                return executors.automated;
+            case 'partial':
+                return executors.aiAssisted ?? executors.manual;
+            case 'false':
+                return executors.manual;
+            default:
+                return executors.manual;
+        }
+    }
+    /**
+     * Initialize or resume execution state from context.
+     */
+    initializeState(context, planGeneratedAt) {
+        if (context.executionState && context.executionState.planGeneratedAt === planGeneratedAt) {
+            return context.executionState;
+        }
+        const now = new Date().toISOString();
+        return {
+            planFile: '.brxm-upgrade/plan.json',
+            planGeneratedAt,
+            currentStep: 1,
+            completedSteps: [],
+            skippedSteps: [],
+            failedSteps: [],
+            startedAt: now,
+            updatedAt: now,
+            isComplete: false,
+        };
+    }
+    /**
+     * Determine the starting index in the steps array for resume support.
+     * Skips steps that are already completed or skipped in the execution state.
+     */
+    getStartIndex(state, steps) {
+        const processedSteps = new Set([...state.completedSteps, ...state.skippedSteps]);
+        for (let i = 0; i < steps.length; i++) {
+            if (!processedSteps.has(steps[i].stepNumber)) {
+                return i;
+            }
+        }
+        return steps.length;
+    }
+    /**
+     * Verification and manual steps are completed by the user after reviewing
+     * guidance rather than by writing prepared changes here.
+     */
+    completesWithoutAutomaticApply(step) {
+        return step.type === 'verification_gate' || step.automatable === 'false';
+    }
+    /**
+     * Narrow an executor to the AI-assisted executor when revision support is available.
+     */
+    isAIAssistedExecutor(executor) {
+        return executor instanceof AIAssistedExecutor;
+    }
+}
+//# sourceMappingURL=ExecutionPhase.js.map