agent-pipeline 0.1.0 → 0.1.2

package/dist/core/pipeline-runner.js

@@ -6,11 +6,12 @@ import { DAGPlanner } from './dag-planner.js';
 import { PipelineInitializer } from './pipeline-initializer.js';
 import { GroupExecutionOrchestrator } from './group-execution-orchestrator.js';
 import { PipelineFinalizer } from './pipeline-finalizer.js';
+import { InstructionLoader } from './instruction-loader.js';
 import { NotificationManager } from '../notifications/notification-manager.js';
-import { ProjectConfigLoader } from '../config/project-config-loader.js';
 import { PipelineLoader } from '../config/pipeline-loader.js';
 import { LoopStateManager } from './loop-state-manager.js';
 import { AgentRuntimeRegistry } from './agent-runtime-registry.js';
+import { PipelineAbortError } from './abort-controller.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 export class PipelineRunner {
@@ -27,8 +28,9 @@ export class PipelineRunner {
     repoPath;
     runtime;
     stateUpdateCallbacks = [];
-    projectConfigLoader;
     loopStateManager;
+    loopExecutionDirs;
+    loopMainDirs;
     constructor(repoPath, dryRun = false) {
         this.repoPath = repoPath;
         this.dryRun = dryRun;
@@ -37,55 +39,71 @@ export class PipelineRunner {
         this.prCreator = new PRCreator();
         this.stateManager = new StateManager(repoPath);
         this.dagPlanner = new DAGPlanner();
-        this.projectConfigLoader = new ProjectConfigLoader(repoPath);
         this.loopStateManager = new LoopStateManager(repoPath);
-        this.runtime = AgentRuntimeRegistry.getRuntime('claude-sdk');
-        this.initializer = new PipelineInitializer(this.gitManager, this.branchManager, this.repoPath, this.dryRun, this.runtime);
-        this.groupOrchestrator = new GroupExecutionOrchestrator(this.gitManager, this.stateManager, this.repoPath, this.dryRun, this.runtime, this.shouldLog.bind(this), this.notifyStateChange.bind(this), this.notifyStageResults.bind(this));
+        this.runtime = AgentRuntimeRegistry.getRuntime('claude-code-headless');
+        this.initializer = new PipelineInitializer(this.gitManager, this.repoPath, this.dryRun, this.runtime);
+        this.groupOrchestrator = new GroupExecutionOrchestrator(this.stateManager, this.shouldLog.bind(this), this.notifyStateChange.bind(this), this.notifyStageResults.bind(this));
         this.finalizer = new PipelineFinalizer(this.gitManager, this.branchManager, this.prCreator, this.stateManager, this.repoPath, this.dryRun, this.shouldLog.bind(this));
     }
     shouldLog(interactive) {
         return !interactive;
     }
     async notifyStageResults(executions, state) {
+        const notificationContexts = [];
         for (const execution of executions) {
             if (execution.status === 'success') {
-                await this.notify({
+                notificationContexts.push({
                     event: 'stage.completed',
                     pipelineState: state,
                     stage: execution
                 });
             }
             else if (execution.status === 'failed') {
-                await this.notify({
+                notificationContexts.push({
                     event: 'stage.failed',
                     pipelineState: state,
                     stage: execution
                 });
             }
         }
+        if (notificationContexts.length > 0) {
+            await Promise.all(notificationContexts.map(context => this.notify(context)));
+        }
     }
     async runPipeline(config, options = {}) {
         const interactive = options.interactive || false;
+        const verbose = options.verbose || false;
         const notificationManager = config.notifications
             ? new NotificationManager(config.notifications)
             : undefined;
-        const loopingConfig = await this.projectConfigLoader.loadLoopingConfig();
-        let loopEnabled = options.loop || false;
-        if (loopEnabled && !loopingConfig.enabled) {
-            console.warn('⚠️  Loop mode requested but looping is disabled in config');
+        this.loopExecutionDirs = undefined;
+        this.loopMainDirs = undefined;
+        let loopSession;
+        let loopEnabled;
+        let loopingConfig;
+        if (options.loop === false) {
             loopEnabled = false;
+            loopingConfig = this.getDefaultLoopingConfig();
+        }
+        else {
+            loopEnabled = config.looping?.enabled ?? false;
+            if (loopEnabled) {
+                loopSession = await this.loopStateManager.startSession(options.maxLoopIterations ?? config.looping?.maxIterations ?? 100);
+                loopingConfig = config.looping;
+            }
+            else {
+                loopingConfig = this.getDefaultLoopingConfig();
+            }
         }
-        const maxIterations = options.maxLoopIterations ?? loopingConfig.maxIterations ?? 100;
+        const maxIterations = options.maxLoopIterations ?? loopingConfig.maxIterations;
         let iterationCount = 0;
         let lastState;
         let currentConfig = config;
         let currentMetadata = options.loopMetadata;
         let loopTerminationReason = 'natural';
-        let loopSession;
-        if (loopEnabled) {
-            loopSession = this.loopStateManager.startSession(maxIterations);
-        }
+        let loopDirCreated = false;
+        let loopDirs = loopingConfig.directories;
+        const loopIterationHistory = [];
         while (true) {
             iterationCount++;
             if (iterationCount > maxIterations) {
@@ -99,20 +117,65 @@ export class PipelineRunner {
                     : currentConfig.name;
                 console.log(`🔁 Loop iteration ${iterationCount}: Running pipeline '${pipelineName}'...`);
             }
+            if (loopEnabled && loopSession) {
+                const pipelineName = this.getPipelineName(currentConfig, currentMetadata);
+                await this.loopStateManager.appendIteration(loopSession.sessionId, {
+                    iterationNumber: iterationCount,
+                    pipelineName,
+                    status: 'in-progress'
+                });
+            }
             const loopContext = loopEnabled && loopingConfig.enabled
                 ? {
                     enabled: true,
-                    directories: loopingConfig.directories,
+                    directories: loopDirs,
                     currentIteration: iterationCount,
-                    maxIterations
+                    maxIterations,
+                    sessionId: loopSession?.sessionId
                 }
                 : undefined;
             lastState = await this._executeSinglePipeline(currentConfig, currentMetadata, {
                 interactive,
+                verbose,
                 notificationManager,
                 loopContext,
-                loopSessionId: loopSession?.sessionId
+                loopSessionId: loopSession?.sessionId,
+                abortController: options.abortController,
+                isFirstLoopIteration: loopEnabled && !loopDirCreated,
+                suppressCompletionNotification: loopEnabled
             });
+            if (loopEnabled && !loopDirCreated && loopContext) {
+                loopDirCreated = true;
+                loopDirs = loopContext.directories;
+            }
+            if (loopEnabled && lastState) {
+                let totalInput = 0;
+                let totalOutput = 0;
+                let totalCacheRead = 0;
+                for (const stage of lastState.stages) {
+                    if (stage.tokenUsage) {
+                        totalInput += stage.tokenUsage.actual_input || 0;
+                        totalOutput += stage.tokenUsage.output || 0;
+                        totalCacheRead += stage.tokenUsage.cache_read || 0;
+                    }
+                }
+                const historyEntry = {
+                    iterationNumber: iterationCount,
+                    pipelineName: currentMetadata?.sourcePath
+                        ? path.basename(currentMetadata.sourcePath, '.yml')
+                        : currentConfig.name,
+                    status: lastState.status === 'completed' ? 'completed'
+                        : lastState.status === 'aborted' ? 'aborted' : 'failed',
+                    duration: lastState.artifacts.totalDuration,
+                    commitCount: lastState.stages.filter(s => s.commitSha).length,
+                    stageCount: lastState.stages.length,
+                    successfulStages: lastState.stages.filter(s => s.status === 'success').length,
+                    failedStages: lastState.stages.filter(s => s.status === 'failed').length,
+                    tokenUsage: totalInput > 0 ? { totalInput, totalOutput, totalCacheRead } : undefined
+                };
+                loopIterationHistory.push(historyEntry);
+                lastState.loopIterationHistory = [...loopIterationHistory];
+            }
             this.notifyStateChange(lastState);
             if (this.shouldLog(interactive) && loopEnabled && lastState.status === 'completed') {
                 console.log(`✅ Completed iteration ${iterationCount}`);
@@ -120,8 +183,8 @@ export class PipelineRunner {
             if (currentMetadata?.sourceType === 'loop-pending') {
                 try {
                     const destDir = lastState.status === 'completed'
-                        ? loopingConfig.directories.finished
-                        : loopingConfig.directories.failed;
+                        ? loopDirs.finished
+                        : loopDirs.failed;
                     const fileName = path.basename(currentMetadata.sourcePath);
                     await this._moveFile(currentMetadata.sourcePath, destDir, fileName);
                     if (this.shouldLog(interactive)) {
@@ -133,26 +196,38 @@ export class PipelineRunner {
                     console.error(`⚠️  Failed to move pipeline file: ${error}`);
                 }
             }
-            if (lastState.status === 'failed') {
+            if (lastState.status === 'aborted') {
                 if (loopEnabled && loopSession) {
                     await this.recordIteration(loopSession.sessionId, lastState, currentMetadata, false);
                 }
-                loopTerminationReason = 'failure';
-                const pipelineName = currentMetadata?.sourcePath
-                    ? path.basename(currentMetadata.sourcePath, '.yml')
-                    : currentConfig.name;
                 if (this.shouldLog(interactive)) {
-                    console.log(`Loop: terminating after failure of ${pipelineName}`);
+                    console.log('Loop: terminating due to abort');
                 }
                 break;
             }
+            if (lastState.status === 'failed') {
+                if (loopEnabled && loopSession) {
+                    await this.recordIteration(loopSession.sessionId, lastState, currentMetadata, false);
+                }
+                const failureStrategy = currentConfig.execution?.failureStrategy ?? 'stop';
+                if (failureStrategy === 'stop') {
+                    loopTerminationReason = 'failure';
+                    const pipelineName = currentMetadata?.sourcePath
+                        ? path.basename(currentMetadata.sourcePath, '.yml')
+                        : currentConfig.name;
+                    if (this.shouldLog(interactive)) {
+                        console.log(`Loop: terminating after failure of ${pipelineName}`);
+                    }
+                    break;
+                }
+            }
             if (!loopEnabled) {
                 if (loopSession) {
                     await this.recordIteration(loopSession.sessionId, lastState, currentMetadata, false);
                 }
                 break;
             }
-            const nextFile = await this._findNextPipelineFile(loopingConfig);
+            const nextFile = await this._findNextPipelineFile(loopDirs);
             const triggeredNext = nextFile !== undefined;
             if (loopSession) {
                 await this.recordIteration(loopSession.sessionId, lastState, currentMetadata, triggeredNext);
@@ -166,7 +241,7 @@ export class PipelineRunner {
             const fileName = path.basename(nextFile);
             let runningPath;
             try {
-                runningPath = await this._moveFile(nextFile, loopingConfig.directories.running, fileName);
+                runningPath = await this._moveFile(nextFile, loopDirs.running, fileName);
             }
             catch (error) {
                 console.error(`❌ Failed to move ${fileName} to running directory: ${error}`);
@@ -181,7 +256,7 @@ export class PipelineRunner {
             catch (error) {
                 console.error(`❌ Failed to load pipeline ${fileName}: ${error}`);
                 try {
-                    await this._moveFile(runningPath, loopingConfig.directories.failed, fileName);
+                    await this._moveFile(runningPath, loopDirs.failed, fileName);
                 }
                 catch (moveError) {
                     console.error(`⚠️  Failed to move ${fileName} to failed directory: ${moveError}`);
@@ -194,18 +269,55 @@ export class PipelineRunner {
         }
         if (lastState.loopContext) {
             lastState.loopContext.terminationReason = loopTerminationReason;
+            this.notifyStateChange(lastState);
+        }
+        if (loopEnabled &&
+            lastState.artifacts.worktreePath &&
+            this.loopExecutionDirs &&
+            this.loopMainDirs) {
+            try {
+                await this.copyLoopDirectories(this.loopExecutionDirs, this.loopMainDirs);
+                if (this.shouldLog(interactive)) {
+                    console.log('📋 Copied loop directories to main repo');
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Could not copy loop directories: ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
         if (loopEnabled && loopSession) {
-            const sessionStatus = loopTerminationReason === 'natural' ? 'completed' :
-                loopTerminationReason === 'limit-reached' ? 'limit-reached' :
-                    'failed';
+            const sessionStatus = lastState.status === 'aborted' ? 'aborted' :
+                loopTerminationReason === 'natural' ? 'completed' :
+                    loopTerminationReason === 'limit-reached' ? 'limit-reached' :
+                        'failed';
             await this.loopStateManager.completeSession(loopSession.sessionId, sessionStatus);
         }
+        if (loopEnabled) {
+            const event = lastState.status === 'aborted'
+                ? 'pipeline.aborted'
+                : loopTerminationReason === 'natural'
+                    ? 'pipeline.completed'
+                    : 'pipeline.failed';
+            await this.notify({
+                event,
+                pipelineState: lastState,
+                metadata: {
+                    loopCompleted: loopTerminationReason === 'natural',
+                    terminationReason: loopTerminationReason,
+                    totalIterations: iterationCount
+                }
+            });
+        }
         return lastState;
     }
     notifyStateChange(state) {
+        const clonedState = {
+            ...state,
+            stages: [...state.stages],
+            artifacts: { ...state.artifacts }
+        };
         for (const callback of this.stateUpdateCallbacks) {
-            callback(state);
+            callback(clonedState);
         }
     }
     async notify(context) {
@@ -227,9 +339,85 @@ export class PipelineRunner {
     onStateChange(callback) {
         this.stateUpdateCallbacks.push(callback);
     }
-    async _findNextPipelineFile(loopingConfig) {
+    getDefaultLoopingConfig(sessionId) {
+        const baseDir = sessionId
+            ? `.agent-pipeline/loops/${sessionId}`
+            : '.agent-pipeline/loops/default';
+        return {
+            enabled: true,
+            maxIterations: 100,
+            directories: this.getSessionLoopDirs(this.repoPath, baseDir),
+        };
+    }
+    getSessionLoopDirs(basePath, sessionBaseDir) {
+        return {
+            pending: path.resolve(basePath, `${sessionBaseDir}/pending`),
+            running: path.resolve(basePath, `${sessionBaseDir}/running`),
+            finished: path.resolve(basePath, `${sessionBaseDir}/finished`),
+            failed: path.resolve(basePath, `${sessionBaseDir}/failed`),
+        };
+    }
+    resolveLoopDirectories(loopContext, executionRepoPath, worktreePath) {
+        const sessionId = loopContext.sessionId ?? 'default';
+        const sessionBaseDir = `.agent-pipeline/loops/${sessionId}`;
+        const sessionMainDirs = this.getSessionLoopDirs(this.repoPath, sessionBaseDir);
+        const sessionExecutionDirs = this.getSessionLoopDirs(executionRepoPath, sessionBaseDir);
+        const providedDirs = loopContext.directories;
+        const mainDirs = {
+            pending: providedDirs.pending || sessionMainDirs.pending,
+            running: providedDirs.running || sessionMainDirs.running,
+            finished: providedDirs.finished || sessionMainDirs.finished,
+            failed: providedDirs.failed || sessionMainDirs.failed,
+        };
+        if (!worktreePath) {
+            return { executionDirs: mainDirs, mainDirs, sessionExecutionDirs };
+        }
+        const executionDirs = {
+            pending: this.mapToExecutionDir(mainDirs.pending, executionRepoPath, sessionExecutionDirs.pending),
+            running: this.mapToExecutionDir(mainDirs.running, executionRepoPath, sessionExecutionDirs.running),
+            finished: this.mapToExecutionDir(mainDirs.finished, executionRepoPath, sessionExecutionDirs.finished),
+            failed: this.mapToExecutionDir(mainDirs.failed, executionRepoPath, sessionExecutionDirs.failed),
+        };
+        return { executionDirs, mainDirs, sessionExecutionDirs };
+    }
+    mapToExecutionDir(mainDir, executionRepoPath, fallbackDir) {
+        const relativePath = path.relative(this.repoPath, mainDir);
+        const isInsideRepo = relativePath && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
+        if (!isInsideRepo) {
+            return fallbackDir;
+        }
+        return path.resolve(executionRepoPath, relativePath);
+    }
+    areSameLoopDirs(left, right) {
+        return left.pending === right.pending &&
+            left.running === right.running &&
+            left.finished === right.finished &&
+            left.failed === right.failed;
+    }
+    async ensureLoopDirectoriesExist(directories) {
+        const dirs = [
+            directories.pending,
+            directories.running,
+            directories.finished,
+            directories.failed,
+        ];
+        await Promise.all(dirs.map(dir => fs.mkdir(dir, { recursive: true })));
+    }
+    async copyLoopDirectories(executionDirs, mainDirs) {
+        const dirPairs = [
+            { source: executionDirs.pending, dest: mainDirs.pending },
+            { source: executionDirs.running, dest: mainDirs.running },
+            { source: executionDirs.finished, dest: mainDirs.finished },
+            { source: executionDirs.failed, dest: mainDirs.failed },
+        ];
+        for (const { source, dest } of dirPairs) {
+            await fs.mkdir(path.dirname(dest), { recursive: true });
+            await fs.cp(source, dest, { recursive: true, force: true });
+        }
+    }
+    async _findNextPipelineFile(loopDirs) {
         try {
-            const pendingDir = loopingConfig.directories.pending;
+            const pendingDir = loopDirs.pending;
             const files = await fs.readdir(pendingDir);
             const yamlFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
             if (yamlFiles.length === 0) {
@@ -267,19 +455,94 @@ export class PipelineRunner {
         return destPath;
     }
     async _executeSinglePipeline(config, metadata, options) {
-        const { interactive, loopContext, loopSessionId } = options;
-        this.notificationManager = options.notificationManager;
-        const initResult = await this.initializer.initialize(config, {
-            interactive,
-            notificationManager: this.notificationManager,
-            loopContext,
-            loopSessionId,
-            metadata
-        }, this.notify.bind(this), this.notifyStateChange.bind(this));
-        let { state, parallelExecutor, pipelineBranch, originalBranch, startTime } = initResult;
+        const { interactive, verbose, loopContext, loopSessionId, abortController, isFirstLoopIteration, suppressCompletionNotification } = options;
+        this.notificationManager = options.notificationManager ||
+            (config.notifications ? new NotificationManager(config.notifications) : undefined);
+        let initResult;
+        try {
+            initResult = await this.initializer.initialize(config, {
+                interactive,
+                verbose,
+                notificationManager: this.notificationManager,
+                loopContext,
+                loopSessionId,
+                metadata,
+                abortController
+            }, this.notify.bind(this), this.notifyStateChange.bind(this));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const now = new Date().toISOString();
+            if (this.shouldLog(interactive)) {
+                console.error(`\n❌ Pipeline initialization failed: ${errorMessage}\n`);
+            }
+            const failedState = {
+                runId: 'init-failed',
+                pipelineConfig: config,
+                trigger: {
+                    type: config.trigger,
+                    commitSha: '',
+                    timestamp: now
+                },
+                stages: [
+                    {
+                        stageName: 'pipeline-initialization',
+                        status: 'failed',
+                        startTime: now,
+                        endTime: now,
+                        duration: 0,
+                        error: {
+                            message: errorMessage,
+                            timestamp: now
+                        }
+                    }
+                ],
+                status: 'failed',
+                artifacts: {
+                    initialCommit: '',
+                    changedFiles: [],
+                    totalDuration: 0,
+                    handoverDir: ''
+                }
+            };
+            await this.notify({
+                event: 'pipeline.failed',
+                pipelineState: failedState,
+                metadata: { error: errorMessage }
+            });
+            return failedState;
+        }
+        let { state, parallelExecutor, pipelineBranch, worktreePath, executionRepoPath, startTime, pipelineLogger } = initResult;
         this.notificationManager = initResult.notificationManager;
+        if (isFirstLoopIteration && loopContext?.sessionId) {
+            const { executionDirs, mainDirs, sessionExecutionDirs } = this.resolveLoopDirectories(loopContext, executionRepoPath, worktreePath);
+            const usesSessionDirs = this.areSameLoopDirs(executionDirs, sessionExecutionDirs);
+            if (usesSessionDirs) {
+                await this.loopStateManager.createSessionDirectories(loopContext.sessionId, executionRepoPath);
+            }
+            else {
+                await this.ensureLoopDirectoriesExist(executionDirs);
+            }
+            loopContext.directories = executionDirs;
+            this.loopExecutionDirs = executionDirs;
+            this.loopMainDirs = mainDirs;
+            if (this.shouldLog(interactive)) {
+                const baseDir = usesSessionDirs
+                    ? this.loopStateManager.getSessionQueueDir(loopContext.sessionId, executionRepoPath)
+                    : executionRepoPath;
+                console.log(`📁 Created loop directories under: ${baseDir}`);
+            }
+        }
         try {
-            const executionGraph = this.dagPlanner.buildExecutionPlan(config);
+            let effectiveConfig = config;
+            let loopStageName;
+            if (loopContext?.enabled) {
+                const injected = this.injectLoopStageIntoConfig(config, state);
+                effectiveConfig = injected.modifiedConfig;
+                loopStageName = injected.loopStageName;
+                state.pipelineConfig = effectiveConfig;
+            }
+            const executionGraph = this.dagPlanner.buildExecutionPlan(effectiveConfig);
             if (this.shouldLog(interactive) && executionGraph.plan.groups.length > 0) {
                 console.log(`📊 Execution plan: ${executionGraph.plan.groups.length} groups, ` +
                     `max parallelism: ${executionGraph.plan.maxParallelism}`);
@@ -288,39 +551,146 @@ export class PipelineRunner {
                 }
                 console.log('');
             }
-            for (const group of executionGraph.plan.groups) {
-                const result = await this.groupOrchestrator.processGroup(group, state, config, executionGraph, parallelExecutor, interactive);
-                state = result.state;
-                if (result.shouldStopPipeline) {
-                    state.status = 'failed';
+            const totalGroups = executionGraph.plan.groups.length;
+            let abortedAtGroup;
+            for (let groupIndex = 0; groupIndex < totalGroups; groupIndex++) {
+                if (abortController?.aborted) {
+                    state.status = 'aborted';
+                    abortedAtGroup = groupIndex + 1;
                     break;
                 }
+                const group = executionGraph.plan.groups[groupIndex];
+                const isLoopGroup = loopStageName && group.stages.some(s => s.name === loopStageName);
+                if (isLoopGroup) {
+                    if (state.status === 'failed' || state.status === 'aborted') {
+                        break;
+                    }
+                    try {
+                        const instructionLoader = new InstructionLoader(this.repoPath);
+                        const loopInstructionsPath = config.looping?.instructions;
+                        const loopTemplateContext = {
+                            pendingDir: loopContext.directories.pending,
+                            currentIteration: loopContext.currentIteration,
+                            maxIterations: loopContext.maxIterations,
+                            pipelineName: config.name
+                        };
+                        const loopSystemPrompt = await instructionLoader.loadLoopInstructions(loopInstructionsPath, loopTemplateContext);
+                        if (this.shouldLog(interactive)) {
+                            console.log('🔁 Running loop agent...');
+                        }
+                        const result = await this.groupOrchestrator.processGroup(group, state, effectiveConfig, parallelExecutor, interactive, initResult.handoverManager, verbose, { [loopStageName]: loopSystemPrompt });
+                        state = result.state;
+                        if (this.shouldLog(interactive)) {
+                            const loopExecution = state.stages.find((stage) => stage.stageName === loopStageName);
+                            if (loopExecution?.status === 'success') {
+                                console.log(`✅ ${loopStageName} (${loopExecution.duration?.toFixed(0) ?? 0}s)`);
+                            }
+                            else if (loopExecution) {
+                                console.log(`⚠️  ${loopStageName} failed (non-fatal): ${loopExecution.error?.message ?? 'unknown'}`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        if (this.shouldLog(interactive)) {
+                            console.warn(`⚠️  Loop agent error (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                }
+                else {
+                    const result = await this.groupOrchestrator.processGroup(group, state, effectiveConfig, parallelExecutor, interactive, initResult.handoverManager, verbose);
+                    state = result.state;
+                    if (abortController?.aborted) {
+                        state.status = 'aborted';
+                        abortedAtGroup = groupIndex + 1;
+                        break;
+                    }
+                    if (result.shouldStopPipeline) {
+                        state.status = 'failed';
+                        break;
+                    }
+                }
             }
-            if (state.status === 'running') {
+            if (abortedAtGroup !== undefined && this.shouldLog(interactive)) {
+                console.log(`\n⚠️  Pipeline aborted at group ${abortedAtGroup}/${totalGroups}\n`);
+            }
+            if (state.status === 'running' && !abortController?.aborted) {
                 state.status = 'completed';
             }
         }
         catch (error) {
-            state.status = 'failed';
-            if (this.shouldLog(interactive)) {
-                console.error(`\n❌ Pipeline failed: ${error}\n`);
+            if (error instanceof PipelineAbortError || abortController?.aborted) {
+                state.status = 'aborted';
+                if (this.shouldLog(interactive)) {
+                    console.log(`\n⚠️  Pipeline aborted\n`);
+                }
+            }
+            else {
+                state.status = 'failed';
+                if (this.shouldLog(interactive)) {
+                    console.error(`\n❌ Pipeline failed: ${error}\n`);
+                }
             }
         }
-        state = await this.finalizer.finalize(state, config, pipelineBranch, originalBranch, startTime, interactive, this.notify.bind(this), this.notifyStateChange.bind(this));
+        state = await this.finalizer.finalize(state, config, pipelineBranch, worktreePath, executionRepoPath, startTime, interactive, verbose, this.notify.bind(this), this.notifyStateChange.bind(this), { suppressCompletionNotification, pipelineLogger });
         return state;
     }
     async recordIteration(sessionId, state, metadata, triggeredNext) {
-        const pipelineName = metadata?.sourcePath
-            ? path.basename(metadata.sourcePath, '.yml')
-            : state.pipelineConfig.name;
-        await this.loopStateManager.appendIteration(sessionId, {
-            iterationNumber: state.loopContext?.currentIteration ?? 1,
+        const pipelineName = this.getPipelineName(state.pipelineConfig, metadata);
+        const iterationNumber = state.loopContext?.currentIteration ?? 1;
+        const updated = await this.loopStateManager.updateIteration(sessionId, iterationNumber, {
             pipelineName,
             runId: state.runId,
-            status: state.status === 'completed' ? 'completed' : 'failed',
+            status: state.status === 'completed' ? 'completed' : state.status === 'aborted' ? 'aborted' : 'failed',
             duration: state.artifacts.totalDuration,
             triggeredNext
         });
+        if (!updated) {
+            await this.loopStateManager.appendIteration(sessionId, {
+                iterationNumber,
+                pipelineName,
+                runId: state.runId,
+                status: state.status === 'completed' ? 'completed' : state.status === 'aborted' ? 'aborted' : 'failed',
+                duration: state.artifacts.totalDuration,
+                triggeredNext
+            });
+        }
+    }
+    injectLoopStageIntoConfig(config, state) {
+        const loopStageName = this.getUniqueLoopStageName(config, state);
+        const loopStage = {
+            name: loopStageName,
+            agent: '__inline__',
+            onFail: 'warn',
+            dependsOn: config.agents.map(a => a.name)
+        };
+        const modifiedConfig = {
+            ...config,
+            agents: [...config.agents, loopStage]
+        };
+        return { modifiedConfig, loopStageName };
+    }
+    getUniqueLoopStageName(config, state) {
+        const baseName = 'loop-agent';
+        const usedNames = new Set([
+            ...config.agents.map((agent) => agent.name),
+            ...state.stages.map((stage) => stage.stageName)
+        ]);
+        if (!usedNames.has(baseName)) {
+            return baseName;
+        }
+        const runIdSuffix = state.runId?.slice(0, 8) ?? 'run';
+        let counter = 1;
+        let candidate = `${baseName}-${runIdSuffix}`;
+        while (usedNames.has(candidate)) {
+            candidate = `${baseName}-${runIdSuffix}-${counter}`;
+            counter += 1;
+        }
+        return candidate;
+    }
+    getPipelineName(config, metadata) {
+        return metadata?.sourcePath
+            ? path.basename(metadata.sourcePath, '.yml')
+            : config.name;
     }
 }
 //# sourceMappingURL=pipeline-runner.js.map