agentic-qe 3.14.2 → 3.14.4

package/dist/shared/llm/translation/message-formatter.js

@@ -8,6 +8,7 @@
  * - Message role mapping
  */
 import { isBuiltinExtendedProviderType } from '../router/types.js';
+import { resolveModelPricing } from '../cost-tracker.js';
 // ============================================================================
 // System Prompt Handling
 // ============================================================================
@@ -220,31 +221,11 @@ export function formatResponse(response, sourceProvider, latencyMs, cached = fal
 }
 /**
  * Calculate cost based on model pricing
- * Note: This is a simplified version - real implementation should use model-mapping pricing
  */
 function calculateCost(inputTokens, outputTokens, model) {
-    // Simplified pricing per 1M tokens (should be loaded from model-mapping)
-    const pricing = {
-        'claude-opus-4-7': { input: 15, output: 75 },
-        'claude-sonnet-4-6': { input: 3, output: 15 },
-        'claude-haiku-4-5-20251001': { input: 0.8, output: 4 },
-        'gpt-4o': { input: 2.5, output: 10 },
-        'gpt-4o-mini': { input: 0.15, output: 0.6 },
-        'gemini-pro': { input: 1.25, output: 5 },
-        'gemini-2.0-pro': { input: 1.25, output: 5 },
-    };
-    // Find matching pricing or use default
-    let modelPricing = pricing[model];
-    if (!modelPricing) {
-        // Try prefix matching
-        for (const [key, value] of Object.entries(pricing)) {
-            if (model.includes(key) || key.includes(model.split('-')[0])) {
-                modelPricing = value;
-                break;
-            }
-        }
-    }
-    modelPricing = modelPricing || { input: 1, output: 2 }; // Default fallback
+    // Shared pricing (cost tracker table, then model registry); unknown models
+    // keep the historical conservative fallback rather than being treated as free.
+    const modelPricing = resolveModelPricing(model) ?? { input: 1, output: 2 };
     const inputCost = (inputTokens / 1_000_000) * modelPricing.input;
     const outputCost = (outputTokens / 1_000_000) * modelPricing.output;
     return {

package/dist/shared/test-runner-verdict.d.ts

@@ -0,0 +1,29 @@
+/** A runner or suite error is not an assertion result. */
+export declare class TestRunnerExecutionError extends Error {
+    constructor(message: string);
+}
+interface RunnerCounts {
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+interface RunnerReport {
+    success?: boolean;
+    numFailedTestSuites?: number;
+    numRuntimeErrorTestSuites?: number;
+    testResults?: Array<{
+        status?: string;
+        message?: string;
+        assertionResults?: Array<{
+            status?: string;
+        }>;
+    }>;
+}
+/**
+ * Preserve ordinary assertion failures, but reject incomplete/failed execution
+ * that assertion counts cannot represent. Process status is authoritative even
+ * when a runner emits success=true (for example, Vitest unhandled rejections).
+ */
+export declare function getTestRunnerExecutionError(runner: string, files: string, exitCode: number | null, counts: RunnerCounts, output: string, report?: RunnerReport): TestRunnerExecutionError | undefined;
+export {};
+//# sourceMappingURL=test-runner-verdict.d.ts.map

package/dist/shared/test-runner-verdict.js

@@ -0,0 +1,43 @@
+/** A runner or suite error is not an assertion result. */
+export class TestRunnerExecutionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TestRunnerExecutionError';
+    }
+}
+/**
+ * Preserve ordinary assertion failures, but reject incomplete/failed execution
+ * that assertion counts cannot represent. Process status is authoritative even
+ * when a runner emits success=true (for example, Vitest unhandled rejections).
+ */
+export function getTestRunnerExecutionError(runner, files, exitCode, counts, output, report) {
+    const suites = report?.testResults ?? [];
+    const suiteErrors = suites.filter(suite => suite.status === 'failed' && (
+    // Jest also uses message for ordinary assertion failures; Vitest reserves
+    // it for suite errors such as collection and afterAll failures.
+    (runner === 'vitest' && suite.message)
+        || !suite.assertionResults?.some(assertion => assertion.status === 'failed')));
+    let reason;
+    if (exitCode === null) {
+        reason = 'terminated without an exit code';
+    }
+    else if (counts.passed + counts.failed + counts.skipped === 0) {
+        reason = 'reported zero tests';
+    }
+    else if (suiteErrors.length > 0 || (report?.numRuntimeErrorTestSuites ?? 0) > 0
+        || ((report?.numFailedTestSuites ?? 0) > 0 && counts.failed === 0)) {
+        reason = 'reported a suite execution error';
+    }
+    else if ((exitCode !== 0 || report?.success === false) && counts.failed === 0) {
+        reason = 'failed without a failed assertion';
+    }
+    if (!reason)
+        return undefined;
+    const diagnostics = [
+        ...suiteErrors.map(suite => suite.message).filter(Boolean),
+        output.trim(),
+    ].filter(Boolean).join('\n').slice(0, 4000);
+    return new TestRunnerExecutionError(`${runner} ${reason} for ${files} (exit code ${exitCode ?? 'unknown'}).` +
+        (diagnostics ? `\n${diagnostics}` : ''));
+}
+//# sourceMappingURL=test-runner-verdict.js.map

package/dist/shared/vitest-json-report.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Vitest JSON report handling that works on Vitest 4 and 5.
+ *
+ * Vitest 5 no longer prints the `--reporter=json` document to stdout; it
+ * writes `.vitest/json/output.json` and prints only
+ * `JSON report written to <path>`. Vitest 4 prints the document to stdout
+ * unless `--outputFile` is given, in which case it behaves like Vitest 5.
+ *
+ * Passing an explicit `--outputFile` therefore gives one contract on both
+ * majors: the report is always in a file we own. Every runner integration
+ * that spawns `vitest run --reporter=json` must go through this module
+ * instead of parsing stdout directly.
+ */
+export interface VitestJsonReport {
+    /** Absolute path the report will be written to. */
+    readonly path: string;
+    /** CLI arguments to append to `vitest run --reporter=json`. */
+    readonly args: readonly string[];
+    /**
+     * Read this invocation's report. Missing reports return undefined so callers
+     * can distinguish them from a completed run; malformed reports throw.
+     * Stdout is diagnostic text, never a substitute for the requested report.
+     */
+    read(stdout: string): string | undefined;
+    /** Remove the temporary report directory. Safe to call more than once. */
+    cleanup(): void;
+}
+/**
+ * Read the report owned by a finished Vitest run. The stdout parameter stays
+ * for existing callers but is never treated as result evidence.
+ */
+export declare function resolveVitestJsonOutput(_stdout: string, reportPath: string | undefined): string | undefined;
+/**
+ * Create a per-run report location. The directory is unique per call so
+ * concurrent runs never read each other's output.
+ */
+export declare function createVitestJsonReport(): VitestJsonReport;
+/**
+ * True when a command vector (runner command plus arguments) is a
+ * `vitest ... --reporter=json` invocation that has not already been given an
+ * output file. Pass the runner command as the first element when the caller
+ * configures it separately (for example `testRunner: 'vitest'`).
+ */
+export declare function needsVitestJsonReportFile(args: readonly string[]): boolean;
+//# sourceMappingURL=vitest-json-report.d.ts.map

package/dist/shared/vitest-json-report.js

@@ -0,0 +1,80 @@
+/**
+ * Vitest JSON report handling that works on Vitest 4 and 5.
+ *
+ * Vitest 5 no longer prints the `--reporter=json` document to stdout; it
+ * writes `.vitest/json/output.json` and prints only
+ * `JSON report written to <path>`. Vitest 4 prints the document to stdout
+ * unless `--outputFile` is given, in which case it behaves like Vitest 5.
+ *
+ * Passing an explicit `--outputFile` therefore gives one contract on both
+ * majors: the report is always in a file we own. Every runner integration
+ * that spawns `vitest run --reporter=json` must go through this module
+ * instead of parsing stdout directly.
+ */
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Read the report owned by a finished Vitest run. The stdout parameter stays
+ * for existing callers but is never treated as result evidence.
+ */
+export function resolveVitestJsonOutput(_stdout, reportPath) {
+    if (!reportPath)
+        return undefined;
+    let content;
+    try {
+        content = readFileSync(reportPath, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw new Error('Could not read the current Vitest JSON report.');
+    }
+    try {
+        const parsed = JSON.parse(content);
+        if (!parsed || !Array.isArray(parsed.testResults))
+            throw new Error('Invalid report');
+    }
+    catch {
+        throw new Error('The current Vitest JSON report is malformed.');
+    }
+    return content;
+}
+/**
+ * Create a per-run report location. The directory is unique per call so
+ * concurrent runs never read each other's output.
+ */
+export function createVitestJsonReport() {
+    const dir = mkdtempSync(join(tmpdir(), 'aqe-vitest-report-'));
+    const path = join(dir, 'report.json');
+    let cleaned = false;
+    return {
+        path,
+        args: [`--outputFile=${path}`],
+        read: (stdout) => resolveVitestJsonOutput(stdout, path),
+        cleanup: () => {
+            if (cleaned)
+                return;
+            cleaned = true;
+            try {
+                rmSync(dir, { recursive: true, force: true });
+            }
+            catch {
+                // Best effort: a leftover temp dir is not worth failing a test run over.
+            }
+        },
+    };
+}
+/**
+ * True when a command vector (runner command plus arguments) is a
+ * `vitest ... --reporter=json` invocation that has not already been given an
+ * output file. Pass the runner command as the first element when the caller
+ * configures it separately (for example `testRunner: 'vitest'`).
+ */
+export function needsVitestJsonReportFile(args) {
+    const isVitest = args.some(arg => /(^|[\\/])vitest(\.cmd|\.js|\.mjs)?$/i.test(arg));
+    const jsonReporter = args.some((arg, i) => arg === '--reporter=json' || (arg === '--reporter' && args[i + 1] === 'json'));
+    const hasOutputFile = args.some(arg => arg.startsWith('--outputFile'));
+    return isVitest && jsonReporter && !hasOutputFile;
+}
+//# sourceMappingURL=vitest-json-report.js.map

package/dist/test-scheduling/executors/vitest-executor.d.ts

@@ -25,11 +25,12 @@ export interface VitestConfig {
      * is detected historically by tracking pass/fail patterns over time.
      */
     flakyTracker?: FlakyTestTracker;
+    /** Grace period before forcefully stopping a test process tree. */
+    terminationGraceMs?: number;
 }
 export declare class VitestPhaseExecutor implements PhaseExecutor {
     private readonly config;
-    private currentProcess;
-    private isAborted;
+    private currentCommand;
     constructor(config?: VitestConfig);
     execute(phase: TestPhase, testFiles?: string[]): Promise<PhaseResult>;
     isReady(): Promise<boolean>;
@@ -38,6 +39,10 @@ export declare class VitestPhaseExecutor implements PhaseExecutor {
     private buildArgs;
     private runVitest;
     private runCommand;
+    private terminateProcessTree;
+    private signalGroup;
+    private waitForGroupExit;
+    private waitForClose;
     private parseResult;
     private getCoverageFromReport;
     private createErrorResult;

package/dist/test-scheduling/executors/vitest-executor.js

@@ -4,15 +4,16 @@
  * A REAL test executor that actually runs tests using Vitest.
  * No simulation. No fake data. Real test execution.
  */
-import { spawn } from 'child_process';
+import { execFile, spawn } from 'child_process';
 import { safeJsonParse } from '../../shared/safe-json.js';
+import { getTestRunnerExecutionError } from '../../shared/test-runner-verdict.js';
+import { createVitestJsonReport } from '../../shared/vitest-json-report.js';
 // ============================================================================
 // Vitest Executor Implementation
 // ============================================================================
 export class VitestPhaseExecutor {
     config;
-    currentProcess = null;
-    isAborted = false;
+    currentCommand = null;
     constructor(config = {}) {
         this.config = config;
     }
@@ -20,7 +21,6 @@ export class VitestPhaseExecutor {
     // PhaseExecutor Interface
     // --------------------------------------------------------------------------
     async execute(phase, testFiles) {
-        this.isAborted = false;
         const startTime = Date.now();
         try {
             const args = this.buildArgs(phase, testFiles);
@@ -47,11 +47,7 @@ export class VitestPhaseExecutor {
         return 'vitest-executor';
     }
     async abort() {
-        this.isAborted = true;
-        if (this.currentProcess) {
-            this.currentProcess.kill('SIGTERM');
-            this.currentProcess = null;
-        }
+        await this.currentCommand?.terminate(new Error('Test execution aborted'));
     }
     // --------------------------------------------------------------------------
     // Private Methods
@@ -95,19 +91,37 @@ export class VitestPhaseExecutor {
         return args;
     }
     async runVitest(args, timeoutMs) {
-        const { stdout, exitCode } = await this.runCommand(this.config.vitestPath || 'npx', args, timeoutMs);
-        // Parse JSON output from Vitest
+        // Vitest 5 writes --reporter=json output to a file instead of stdout; an
+        // explicit --outputFile gives Vitest 4 and 5 the same contract.
+        const report = createVitestJsonReport();
+        let document;
+        let exitCode;
+        let stderr;
+        try {
+            const run = await this.runCommand(this.config.vitestPath || 'npx', [...args, ...report.args], timeoutMs);
+            exitCode = run.exitCode;
+            stderr = run.stderr;
+            const currentReport = report.read(run.stdout);
+            if (currentReport === undefined) {
+                throw new Error('The current Vitest JSON report is missing for this phase.');
+            }
+            document = currentReport;
+        }
+        finally {
+            report.cleanup();
+        }
+        // Parse JSON report from Vitest
+        let result;
         try {
-            // Vitest outputs JSON to stdout when using --reporter=json
-            const jsonStart = stdout.indexOf('{');
-            const jsonEnd = stdout.lastIndexOf('}');
+            const jsonStart = document.indexOf('{');
+            const jsonEnd = document.lastIndexOf('}');
             if (jsonStart === -1 || jsonEnd === -1) {
                 throw new Error('No JSON output from Vitest');
             }
-            const jsonStr = stdout.slice(jsonStart, jsonEnd + 1);
-            return safeJsonParse(jsonStr);
+            const jsonStr = document.slice(jsonStart, jsonEnd + 1);
+            result = safeJsonParse(jsonStr);
         }
-        catch (parseError) {
+        catch {
             // If JSON parsing fails, create a basic result from exit code
             return {
                 numTotalTestSuites: 0,
@@ -122,46 +136,154 @@ export class VitestPhaseExecutor {
                 testResults: [],
             };
         }
+        const executionError = getTestRunnerExecutionError('vitest', 'phase', exitCode, {
+            passed: result.numPassedTests,
+            failed: result.numFailedTests,
+            skipped: result.numPendingTests,
+        }, stderr, result);
+        if (executionError)
+            throw executionError;
+        return result;
     }
     runCommand(command, args, timeoutMs) {
-        return new Promise((resolve, reject) => {
-            let stdout = '';
-            let stderr = '';
-            // Security: shell: false prevents command injection through arguments
-            // Cross-platform: Use .cmd extension on Windows for npm scripts
-            const executable = process.platform === 'win32' && command === 'npx'
-                ? 'npx.cmd'
-                : command;
-            this.currentProcess = spawn(executable, args, {
-                cwd: this.config.cwd || process.cwd(),
-                env: { ...process.env, ...this.config.env },
-                shell: false,
-            });
-            const timeout = setTimeout(() => {
-                this.currentProcess?.kill('SIGTERM');
-                reject(new Error(`Test execution timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-            this.currentProcess.stdout?.on('data', (data) => {
-                stdout += data.toString();
-            });
-            this.currentProcess.stderr?.on('data', (data) => {
-                stderr += data.toString();
-            });
-            this.currentProcess.on('close', (code) => {
-                clearTimeout(timeout);
-                this.currentProcess = null;
-                if (this.isAborted) {
-                    reject(new Error('Test execution aborted'));
-                }
-                else {
-                    resolve({ stdout, stderr, exitCode: code ?? 1 });
+        if (this.currentCommand) {
+            return Promise.reject(new Error('Test executor already has an active process'));
+        }
+        // shell: false prevents argument injection. A fresh POSIX process group
+        // lets cancellation reach npx, Vitest, and the workers it started.
+        const executable = process.platform === 'win32' && command === 'npx' ? 'npx.cmd' : command;
+        const child = spawn(executable, args, {
+            cwd: this.config.cwd || process.cwd(),
+            env: { ...process.env, ...this.config.env },
+            shell: false,
+            detached: process.platform !== 'win32',
+        });
+        // Detached workers do not receive the terminal's SIGINT. The CLI may
+        // exit synchronously from its signal handler, so kill this owned group
+        // synchronously while the command is active.
+        const stopOnExit = () => {
+            if (child.pid) {
+                try {
+                    process.kill(-child.pid, 'SIGKILL');
                 }
-            });
-            this.currentProcess.on('error', (error) => {
+                catch { /* already exited */ }
+            }
+        };
+        if (process.platform !== 'win32')
+            process.once('exit', stopOnExit);
+        let stdout = '';
+        let stderr = '';
+        let exitCode = 1;
+        let terminalError;
+        let terminationError;
+        let termination;
+        let rejectTermination;
+        const terminationFailed = new Promise((_, reject) => { rejectTermination = reject; });
+        child.stdout?.on('data', data => { stdout += data.toString(); });
+        child.stderr?.on('data', data => { stderr += data.toString(); });
+        const closed = new Promise((resolve, reject) => {
+            child.once('close', code => { exitCode = code ?? 1; resolve(); });
+            child.once('error', reject);
+        });
+        const active = {
+            terminate: (reason) => {
+                terminalError ??= reason;
+                termination ??= this.terminateProcessTree(child, closed).catch(error => {
+                    terminationError = error;
+                    rejectTermination(error);
+                    throw error;
+                });
+                return termination;
+            },
+        };
+        this.currentCommand = active;
+        const timeout = setTimeout(() => {
+            void active.terminate(new Error(`Test execution timed out after ${timeoutMs}ms`)).catch(() => { });
+        }, timeoutMs);
+        return (async () => {
+            try {
+                // A failed kill must settle the phase even if the child never closes.
+                await Promise.race([closed, terminationFailed]);
+                if (termination)
+                    await termination;
+                if (terminalError)
+                    throw terminalError;
+                return { stdout, stderr, exitCode };
+            }
+            finally {
                 clearTimeout(timeout);
-                this.currentProcess = null;
-                reject(error);
+                if (process.platform !== 'win32')
+                    process.removeListener('exit', stopOnExit);
+                // A failed kill leaves an unknown survivor. Keep this executor closed
+                // to new work rather than replacing the only handle to that tree.
+                if (this.currentCommand === active && !terminationError)
+                    this.currentCommand = null;
+            }
+        })();
+    }
+    async terminateProcessTree(child, closed) {
+        const pid = child.pid;
+        if (!pid) {
+            await closed;
+            return;
+        }
+        if (process.platform === 'win32') {
+            // taskkill /T follows the descendant tree; killing only npx.cmd leaves
+            // its Vitest child running. There is no POSIX-style process group here.
+            await new Promise((resolve, reject) => {
+                execFile('taskkill', ['/PID', String(pid), '/T', '/F'], { timeout: 2000 }, error => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                });
             });
+            await this.waitForClose(closed, 2000);
+            return;
+        }
+        this.signalGroup(pid, 'SIGTERM');
+        const requestedGrace = this.config.terminationGraceMs;
+        const graceMs = requestedGrace !== undefined && Number.isFinite(requestedGrace)
+            ? Math.max(0, Math.min(requestedGrace, 30_000))
+            : 1000;
+        if (!await this.waitForGroupExit(pid, graceMs)) {
+            this.signalGroup(pid, 'SIGKILL');
+            if (!await this.waitForGroupExit(pid, 2000)) {
+                throw new Error(`Test process group ${pid} survived SIGKILL`);
+            }
+        }
+        await this.waitForClose(closed, 2000);
+    }
+    signalGroup(pid, signal) {
+        try {
+            if (!process.kill(-pid, signal))
+                throw new Error(`Failed to send ${signal} to test process group ${pid}`);
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH')
+                throw error;
+        }
+    }
+    async waitForGroupExit(pid, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            try {
+                process.kill(-pid, 0);
+            }
+            catch (error) {
+                if (error.code === 'ESRCH')
+                    return true;
+                throw error;
+            }
+            if (Date.now() >= deadline)
+                return false;
+            await new Promise(resolve => setTimeout(resolve, 25));
+        }
+    }
+    async waitForClose(closed, timeoutMs) {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error('Test process did not close after termination')), timeoutMs);
+            closed.then(() => { clearTimeout(timer); resolve(); }, error => { clearTimeout(timer); reject(error); });
         });
     }
     async parseResult(phase, vitestResult, durationMs) {

package/dist/test-scheduling/git-aware/test-selector.js

@@ -12,6 +12,7 @@
  */
 import { spawn } from 'child_process';
 import { resolve, dirname, basename } from 'path';
+import { assertSafeGitRef } from '../../shared/git/ref-validation.js';
 // ============================================================================
 // Default Mapping Rules
 // ============================================================================
@@ -72,6 +73,7 @@ export class GitAwareTestSelector {
         }
         this.cwd = config.cwd || process.cwd();
         this.baseRef = config.baseRef || 'HEAD~1';
+        assertSafeGitRef(this.baseRef, 'base ref');
         this.mappingRules = config.mappingRules || DEFAULT_MAPPING_RULES;
         this.impactAnalyzer = config.impactAnalyzer;
     }
@@ -175,6 +177,7 @@ export class GitAwareTestSelector {
      * Get the merge base between current branch and main
      */
     async getMergeBase(targetBranch = 'main') {
+        assertSafeGitRef(targetBranch, 'target branch');
         try {
             const output = await this.git(['merge-base', 'HEAD', targetBranch]);
             return output.trim();

package/dist/test-scheduling/phase-scheduler.d.ts

@@ -46,6 +46,7 @@ export declare class PhaseScheduler {
     private startTime?;
     private endTime?;
     private abortController?;
+    private abortRequested;
     constructor(executor: PhaseExecutor, config?: SchedulerConfig);
     /**
      * Run all test phases sequentially

package/dist/test-scheduling/phase-scheduler.js

@@ -21,6 +21,7 @@ export class PhaseScheduler {
     startTime;
     endTime;
     abortController;
+    abortRequested = false;
     constructor(executor, config = {
         phases: DEFAULT_TEST_PHASES,
         failFast: true,
@@ -45,6 +46,7 @@ export class PhaseScheduler {
         this.results = [];
         this.startTime = new Date();
         this.abortController = new AbortController();
+        this.abortRequested = false;
         try {
             for (const phase of this.config.phases) {
                 // Check if paused (pause() can be called externally during execution)
@@ -56,6 +58,9 @@ export class PhaseScheduler {
                     break;
                 }
                 const result = await this.executePhaseWithRetry(phase);
+                if (this.abortRequested) {
+                    throw new Error('Phase aborted');
+                }
                 this.results.push(result);
                 this.currentPhaseIndex++;
                 this.config.onPhaseComplete?.(result);
@@ -64,13 +69,19 @@ export class PhaseScheduler {
                     break;
                 }
             }
+            if (this.abortRequested) {
+                throw new Error('Phase aborted');
+            }
             this.endTime = new Date();
             this.state = this.results.every((r) => r.success) ? 'completed' : 'failed';
             this.config.onAllComplete?.(this.results);
             return this.results;
         }
         catch (error) {
-            this.state = 'failed';
+            // abort() owns the final state after its executor has actually stopped.
+            // Until then, do not report a successful or quiesced scheduler run.
+            if (!this.abortRequested)
+                this.state = 'failed';
             this.endTime = new Date();
             throw error;
         }
@@ -83,6 +94,7 @@ export class PhaseScheduler {
         if (!phase) {
             throw new Error(`Phase not found: ${phaseId}`);
         }
+        this.abortRequested = false;
         return this.executePhaseWithRetry(phase);
     }
     /**
@@ -105,6 +117,7 @@ export class PhaseScheduler {
      * Abort execution immediately
      */
     async abort() {
+        this.abortRequested = true;
         this.abortController?.abort();
         await this.executor.abort();
         this.state = 'idle';
@@ -143,13 +156,22 @@ export class PhaseScheduler {
         let lastResult;
         const maxAttempts = this.config.retryFailedPhases ? this.config.maxRetries : 1;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            if (this.abortRequested) {
+                throw new Error('Phase aborted');
+            }
             try {
                 lastResult = await this.executor.execute(phase);
+                if (this.abortRequested) {
+                    throw new Error('Phase aborted');
+                }
                 if (lastResult.success || !this.config.retryFailedPhases) {
                     return lastResult;
                 }
             }
             catch (error) {
+                if (this.abortRequested) {
+                    throw new Error('Phase aborted');
+                }
                 this.config.onError?.(error, phase);
                 if (attempt === maxAttempts) {
                     return this.createErrorResult(phase, error);