@amsterdamdatalabs/enact-factory 0.1.1

package/dist/automation/runnerExecution.js

@@ -0,0 +1,701 @@
+// ============================================
+// Enact Factory - Runner Execution Helpers
+// Execution/reporting/integration logic extracted from AutonomousRunner
+// ============================================
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { createPipelineFromConfig, buildWorkItemPrefix } from '../agents/pairPipeline.js';
+import { formatParsedWorkItemSummary, loadParsedWorkItem } from '../orchestration/workItemParser.js';
+import * as executorAgent from '../agents/executor.js';
+import * as reviewerAgent from '../agents/reviewer.js';
+import * as projectMapper from '../support/projectMapper.js';
+import * as azdo from '../azdo/index.js';
+import * as planner from '../support/planner.js';
+import { runDraftAnalysis } from '../agents/draftAnalyzer.js';
+import { t } from '../locale/index.js';
+import { broadcastEvent } from '../core/eventHub.js';
+import { branchNameFor, shouldTeardown } from '../core/devopsModel.js';
+import { createWorktree, commitAndCreatePR, removeWorktree, } from '../support/worktreeManager.js';
+import { getWorkItemStore } from '../workItems/index.js';
+import { getDecompositionDepth, getChildrenCount, getDailyCreationCount, canCreateMoreWorkItems, registerDecomposition, } from '../automation/runnerState.js';
+import { buildWorkItemStateSyncComment, completeParentIfChildrenDone, markWorkItemBlocked, markWorkItemDecomposed, markWorkItemDone, markWorkItemInProgress, releaseDependentWorkItems, upsertWorkItemState, } from '../workItemState/store.js';
+let notificationSend = null;
+/** @deprecated Discord removed — registers an optional notification sink */
+export function setDiscordReporter(sendFn) {
+    notificationSend = sendFn;
+    console.log('[AutonomousRunner] Notification reporter registered');
+}
+export async function reportToDiscord(message) {
+    if (notificationSend) {
+        try {
+            await notificationSend(message);
+            return;
+        }
+        catch (error) {
+            console.error('[AutonomousRunner] Notification report failed:', error);
+        }
+    }
+    console.log('[AutonomousRunner]', message);
+}
+let workItemFetch = null;
+let workItemSource = null;
+export function setAzdoFetcher(fetchFn) {
+    workItemFetch = fetchFn;
+    workItemSource = 'azdo';
+    console.log('[AutonomousRunner] Azdo fetcher registered');
+}
+export function setLocalFetcher(fetchFn) {
+    workItemFetch = fetchFn;
+    workItemSource = 'local';
+    console.log('[AutonomousRunner] Local fetcher registered');
+}
+// Track consecutive fetch failures for visibility
+let fetchFailureCount = 0;
+export async function fetchAzdoWorkItems() {
+    if (!workItemFetch) {
+        console.log('[AutonomousRunner] No workItem fetcher registered');
+        return { workItems: [], error: 'No workItem fetcher registered' };
+    }
+    try {
+        const workItems = await workItemFetch();
+        if (fetchFailureCount > 0) {
+            console.log(`[AutonomousRunner] WorkItem fetch recovered after ${fetchFailureCount} failures`);
+        }
+        fetchFailureCount = 0;
+        return { workItems };
+    }
+    catch (error) {
+        fetchFailureCount++;
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[AutonomousRunner] WorkItem fetch failed (${fetchFailureCount}x consecutive): ${msg}`);
+        return { workItems: [], error: msg };
+    }
+}
+/**
+ * Get current workItem source type
+ */
+export function getWorkItemSource() {
+    return workItemSource;
+}
+// Project Path Resolution
+export async function resolveProjectPath(ctx, workItem) {
+    // For local workItems, projectPath is already resolved
+    if (workItem.source === 'local' && workItem.projectPath) {
+        // Verify the path exists
+        if (!existsSync(workItem.projectPath)) {
+            console.error(`[AutonomousRunner] Local workItem "${workItem.title}" project path does not exist: ${workItem.projectPath}`);
+            return null;
+        }
+        return workItem.projectPath;
+    }
+    // For Azdo workItems, resolve via project mapping
+    const projectName = workItem.azdoProject?.name;
+    const projectId = workItem.azdoProject?.id;
+    if (!projectId || !projectName) {
+        console.error(`[AutonomousRunner] WorkItem "${workItem.title}" has no project info - SKIP`);
+        return null;
+    }
+    // 1순위: allowedProjects에서 정확한 basename 매칭 (fuzzy보다 신뢰도 높음)
+    for (const allowed of ctx.allowedProjects) {
+        const expanded = allowed.replace(/^~(?=\/|$)/, homedir());
+        const dirName = expanded.split('/').pop();
+        if (dirName === projectName || dirName?.toLowerCase() === projectName.toLowerCase()) {
+            if (await isValidProjectPath(expanded)) {
+                console.log(`[AutonomousRunner] AllowedProjects match: ${projectName} → ${expanded}`);
+                return expanded;
+            }
+        }
+    }
+    // 2순위: ~/dev/{name} 직접 경로
+    const directPath = `${homedir()}/dev/${projectName}`;
+    if (await isValidProjectPath(directPath)) {
+        console.log(`[AutonomousRunner] Direct path found: ${projectName} → ${directPath}`);
+        return directPath;
+    }
+    const lowerPath = `${homedir()}/dev/${projectName.toLowerCase()}`;
+    if (await isValidProjectPath(lowerPath)) {
+        console.log(`[AutonomousRunner] Lowercase path found: ${projectName} → ${lowerPath}`);
+        return lowerPath;
+    }
+    // 3순위: ~/dev/tools/ 서브디렉토리
+    const toolsPath = `${homedir()}/dev/tools/${projectName}`;
+    if (await isValidProjectPath(toolsPath)) {
+        console.log(`[AutonomousRunner] Tools path found: ${projectName} → ${toolsPath}`);
+        return toolsPath;
+    }
+    // 4순위: fuzzy match (스캔 기반, 오탐 가능성 있음)
+    const mappedPath = await projectMapper.mapAzdoProject(projectId, projectName, ctx.allowedProjects);
+    if (mappedPath) {
+        console.log(`[AutonomousRunner] Fuzzy mapped: ${projectName} → ${mappedPath}`);
+        return mappedPath;
+    }
+    console.error(`[AutonomousRunner] Failed to resolve project path for "${projectName}" - SKIP`);
+    console.error(`[AutonomousRunner] Tried: allowedProjects, ${directPath}, ${lowerPath}, ${toolsPath}, fuzzy mapper`);
+    return null;
+}
+export async function isValidProjectPath(path) {
+    try {
+        const fs = await import('fs/promises');
+        const stats = await fs.stat(path);
+        if (!stats.isDirectory())
+            return false;
+        const checks = ['.git', 'package.json', 'pyproject.toml'];
+        for (const check of checks) {
+            try {
+                await fs.stat(`${path}/${check}`);
+                return true;
+            }
+            catch {
+                // continue
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+// WorkItem Decomposition
+export async function decomposeWorkItem(ctx, workItem, projectPath, targetMinutes, draftAnalysis) {
+    console.log(`[AutonomousRunner] Decomposing workItem: ${workItem.title}`);
+    const workItemId = workItem.workItemId || workItem.id;
+    const maxDepth = ctx.decompositionMaxDepth ?? 2;
+    const maxChildren = ctx.decompositionMaxChildren ?? 5;
+    const dailyLimit = ctx.decompositionDailyLimit ?? 20;
+    const autoBacklog = ctx.decompositionAutoBacklog ?? true;
+    // ============================================
+    // Pre-checks: Depth, Children, Daily Limit
+    // ============================================
+    // Check decomposition depth limit
+    if (workItem.workItemId) {
+        const currentDepth = getDecompositionDepth(workItem.workItemId);
+        if (currentDepth >= maxDepth) {
+            console.log(`[AutonomousRunner] Decomposition depth limit reached: ${currentDepth}/${maxDepth}`);
+            if (autoBacklog && workItem.workItemId) {
+                try {
+                    await azdo.updateWorkItemState(workItem.workItemId, 'Backlog');
+                    await azdo.addComment(workItem.workItemId, `⚠️ **Auto-moved to Backlog**\n\n` +
+                        `Reason: Decomposition depth limit reached (${currentDepth}/${maxDepth})\n\n` +
+                        `This workItem has been nested too deeply. Please review and simplify the workItem structure, ` +
+                        `or handle it manually.`);
+                    console.log(`[AutonomousRunner] WorkItem moved to backlog (depth limit)`);
+                }
+                catch (err) {
+                    console.error(`[AutonomousRunner] Failed to move to backlog:`, err);
+                }
+            }
+            return false;
+        }
+        // Check children count limit
+        const childrenCount = getChildrenCount(workItem.workItemId);
+        if (childrenCount >= maxChildren) {
+            console.log(`[AutonomousRunner] Children count limit reached: ${childrenCount}/${maxChildren}`);
+            if (autoBacklog) {
+                try {
+                    await azdo.updateWorkItemState(workItem.workItemId, 'Backlog');
+                    await azdo.addComment(workItem.workItemId, `⚠️ **Auto-moved to Backlog**\n\n` +
+                        `Reason: Too many sub-workItems already created (${childrenCount}/${maxChildren})\n\n` +
+                        `This workItem has generated too many sub-workItems. Please review the decomposition strategy, ` +
+                        `or handle it manually.`);
+                    console.log(`[AutonomousRunner] WorkItem moved to backlog (children limit)`);
+                }
+                catch (err) {
+                    console.error(`[AutonomousRunner] Failed to move to backlog:`, err);
+                }
+            }
+            return false;
+        }
+    }
+    // Check daily creation limit
+    // NOTE: Don't move to Backlog on daily limit — it resets tomorrow.
+    // Moving to Backlog would permanently exclude the workItem from future heartbeats.
+    // Instead, skip decomposition and fall through to direct execution.
+    if (!canCreateMoreWorkItems(dailyLimit)) {
+        const currentCount = getDailyCreationCount();
+        console.log(`[AutonomousRunner] Daily workItem creation limit reached: ${currentCount}/${dailyLimit} — skipping decomposition (will retry tomorrow)`);
+        return false;
+    }
+    broadcastEvent({ type: 'pipeline:stage', data: { workItemId, stage: 'decompose', status: 'start' } });
+    await ctx.reportToDiscord(t('runner.decomposition.starting', {
+        title: workItem.title,
+        estimated: String(planner.estimateWorkItemDuration(workItem)),
+        threshold: String(targetMinutes),
+    }));
+    // Periodic progress log while planner runs (fallback if stdout isn't streaming)
+    let elapsed = 0;
+    const progressTimer = setInterval(() => {
+        elapsed += 30;
+        broadcastEvent({ type: 'log', data: { workItemId, stage: 'decompose', line: `⏱ Planner running... ${elapsed}s` } });
+    }, 30000);
+    let result;
+    try {
+        result = await planner.runPlanner({
+            workItemTitle: workItem.title,
+            workItemDescription: workItem.description || '',
+            projectPath,
+            projectName: workItem.azdoProject?.name,
+            targetMinutes,
+            model: ctx.plannerModel ?? 'claude-sonnet-4-5-20250929',
+            timeoutMs: ctx.plannerTimeoutMs ?? 600000,
+            onLog: (line) => broadcastEvent({ type: 'log', data: { workItemId, stage: 'decompose', line } }),
+            draftAnalysis: draftAnalysis ? {
+                workItemType: draftAnalysis.workItemType,
+                intentSummary: draftAnalysis.intentSummary,
+                relevantFiles: draftAnalysis.relevantFiles,
+                suggestedApproach: draftAnalysis.suggestedApproach,
+                projectStats: draftAnalysis.projectStats,
+            } : undefined,
+        });
+    }
+    finally {
+        clearInterval(progressTimer);
+    }
+    await ctx.reportToDiscord(planner.formatPlannerResult(result));
+    if (!result.success) {
+        console.error(`[AutonomousRunner] Planner failed: ${result.error}`);
+        broadcastEvent({ type: 'pipeline:stage', data: { workItemId, stage: 'decompose', status: 'fail' } });
+        return false;
+    }
+    if (!result.needsDecomposition || result.subWorkItems.length === 0) {
+        console.log('[AutonomousRunner] Planner determined no decomposition needed');
+        return 'no-decomp';
+    }
+    if (!workItem.workItemId) {
+        console.error('[AutonomousRunner] Cannot create sub-workItems: no parent workItemId');
+        return false;
+    }
+    const createdSubWorkItems = [];
+    for (const [index, subWorkItem] of result.subWorkItems.entries()) {
+        const depsStr = subWorkItem.dependencies?.length
+            ? `\n\n${t('runner.decomposition.prerequisite', { deps: subWorkItem.dependencies.join(', ') })}`
+            : '';
+        const subDescription = `${subWorkItem.description}\n\n` +
+            `${t('runner.decomposition.estimatedTime', { n: String(subWorkItem.estimatedMinutes) })}${depsStr}\n\n` +
+            t('runner.decomposition.autoDecomposed', { parentTitle: workItem.title });
+        const subResult = await azdo.createSubWorkItem(workItem.workItemId, subWorkItem.title, subDescription, {
+            priority: subWorkItem.priority,
+            projectId: workItem.azdoProject?.id,
+            estimatedMinutes: subWorkItem.estimatedMinutes,
+        });
+        if ('error' in subResult) {
+            console.error(`[AutonomousRunner] Failed to create sub-workItem: ${subResult.error}`);
+            continue;
+        }
+        createdSubWorkItems.push({
+            id: subResult.id,
+            identifier: subResult.identifier,
+            title: subResult.title,
+            dependencies: subWorkItem.dependencies || [],
+            topoRank: index,
+            estimatedMinutes: subWorkItem.estimatedMinutes,
+        });
+        console.log(`[AutonomousRunner] Created sub-workItem: ${subResult.identifier}`);
+    }
+    if (createdSubWorkItems.length === 0) {
+        console.error('[AutonomousRunner] No sub-workItems created');
+        broadcastEvent({ type: 'pipeline:stage', data: { workItemId, stage: 'decompose', status: 'fail' } });
+        return false;
+    }
+    // Register decomposition in tracking (for limits)
+    registerDecomposition(workItem.workItemId, workItem.parentId, // Parent ID if this workItem is also a sub-workItem
+    createdSubWorkItems.map(s => s.id));
+    console.log(`[AutonomousRunner] Registered decomposition: parent=${workItem.workItemId}, children=${createdSubWorkItems.length}, daily=${getDailyCreationCount()}/${dailyLimit}`);
+    await azdo.markAsDecomposed(workItem.workItemId, createdSubWorkItems.length, result.totalEstimatedMinutes);
+    const childIdByTitle = new Map(createdSubWorkItems.map((subWorkItem) => [subWorkItem.title, subWorkItem.id]));
+    const parentState = markWorkItemDecomposed(workItem.workItemId, {
+        workItemIdentifier: workItem.workItemIdentifier,
+        title: workItem.title,
+        projectId: workItem.azdoProject?.id,
+        projectName: workItem.azdoProject?.name,
+        parentWorkItemId: workItem.parentId,
+        childWorkItemIds: createdSubWorkItems.map((subWorkItem) => subWorkItem.id),
+    });
+    await azdo.addComment(workItem.workItemId, buildWorkItemStateSyncComment(parentState, 'Parent workItem decomposed'));
+    const subWorkItemList = createdSubWorkItems
+        .map((s, i) => `${i + 1}. ${s.identifier}: ${s.title}`)
+        .join('\n');
+    await ctx.reportToDiscord(t('runner.decomposition.completed', {
+        original: workItem.workItemIdentifier || workItem.workItemId || '',
+        count: String(createdSubWorkItems.length),
+        list: subWorkItemList,
+        totalMinutes: String(result.totalEstimatedMinutes),
+    }));
+    broadcastEvent({ type: 'pipeline:stage', data: { workItemId, stage: 'decompose', status: 'complete' } });
+    // Log each sub-workItem as a log line for the dashboard
+    for (const s of createdSubWorkItems) {
+        broadcastEvent({ type: 'log', data: { workItemId, stage: 'decompose', line: `↳ ${s.identifier}: ${s.title}` } });
+    }
+    console.log(`[AutonomousRunner] Decomposition complete: ${createdSubWorkItems.length} sub-workItems created`);
+    for (const subWorkItem of createdSubWorkItems) {
+        const dependencyWorkItemIds = subWorkItem.dependencies
+            .map((title) => childIdByTitle.get(title))
+            .filter((value) => Boolean(value));
+        const isReady = dependencyWorkItemIds.length === 0;
+        const childState = upsertWorkItemState(subWorkItem.id, {
+            workItemIdentifier: subWorkItem.identifier,
+            title: subWorkItem.title,
+            projectId: workItem.azdoProject?.id,
+            projectName: workItem.azdoProject?.name,
+            parentWorkItemId: workItem.workItemId,
+            dependencyWorkItemIds,
+            dependencyTitles: subWorkItem.dependencies,
+            topoRank: subWorkItem.topoRank,
+            execution: {
+                status: isReady ? 'todo' : 'blocked',
+                blockedReason: isReady ? undefined : `Waiting on dependencies: ${dependencyWorkItemIds.join(', ')}`,
+                retryCount: 0,
+            },
+            azdoState: isReady ? 'Todo' : 'Backlog',
+        });
+        try {
+            if (isReady) {
+                await azdo.updateWorkItemState(subWorkItem.id, 'Todo');
+                console.log(`[AutonomousRunner] Moved ${subWorkItem.identifier} to Todo`);
+            }
+            else {
+                console.log(`[AutonomousRunner] Keeping ${subWorkItem.identifier} in Backlog until dependencies resolve`);
+            }
+            await azdo.addComment(subWorkItem.id, buildWorkItemStateSyncComment(childState, isReady ? 'WorkItem ready after decomposition' : 'WorkItem blocked by decomposition dependency'));
+        }
+        catch (err) {
+            console.warn(`[AutonomousRunner] Failed to initialize ${subWorkItem.identifier} state:`, err);
+        }
+    }
+    // Trigger immediate heartbeat to pick up newly created sub-workItems
+    if (ctx.scheduleNextHeartbeat) {
+        console.log('[AutonomousRunner] Scheduling immediate heartbeat to process sub-workItems...');
+        ctx.scheduleNextHeartbeat();
+    }
+    return true;
+}
+// Pipeline Execution
+export async function executePipeline(ctx, workItem, projectPath) {
+    console.log(`[AutonomousRunner] executePipeline: ${workItem.title}`);
+    // ============================================
+    // Draft Analysis (Haiku 사전 분석 — ~3초)
+    // Planner + Executor에 enriched context 제공
+    // ============================================
+    let draftResult;
+    if (ctx.enableDraftAnalysis !== false) {
+        try {
+            // Use stable internal workItem id so dashboard can map draft stage rows
+            // back to project/workItem metadata populated from workItem:queued events.
+            const workItemId = workItem.id;
+            broadcastEvent({ type: 'pipeline:stage', data: { workItemId, stage: 'draft', status: 'start' } });
+            draftResult = await runDraftAnalysis({
+                workItemTitle: workItem.title,
+                workItemDescription: workItem.description || '',
+                projectPath,
+                model: ctx.draftModel,
+                timeoutMs: 30000,
+                onLog: (line) => broadcastEvent({ type: 'log', data: { workItemId, stage: 'draft', line } }),
+            });
+            broadcastEvent({ type: 'pipeline:stage', data: { workItemId, stage: 'draft', status: 'complete' } });
+            console.log(`[AutonomousRunner] Draft: type=${draftResult.workItemType}, files=${draftResult.relevantFiles.length}, ${draftResult.durationMs}ms`);
+        }
+        catch (err) {
+            console.warn('[AutonomousRunner] Draft analysis failed (non-blocking):', err);
+        }
+    }
+    if (ctx.enableDecomposition) {
+        const threshold = ctx.decompositionThresholdMinutes ?? 30;
+        const needsDecomp = planner.needsDecomposition(workItem, threshold, true); // heuristic pre-filter
+        if (needsDecomp) {
+            const estimated = planner.estimateWorkItemDuration(workItem);
+            console.log(`[AutonomousRunner] WorkItem "${workItem.title}" may need decomposition (estimated ${estimated}min > ${threshold}min)`);
+            const decomposed = await decomposeWorkItem(ctx, workItem, projectPath, threshold, draftResult);
+            if (decomposed === true) {
+                // Successfully decomposed into sub-workItems
+                return {
+                    success: true,
+                    sessionId: `decomposed-${Date.now()}`,
+                    iterations: 0,
+                    totalDuration: 0,
+                    finalStatus: 'decomposed',
+                    stages: [],
+                };
+            }
+            if (decomposed === 'no-decomp') {
+                // Planner says workItem is smaller than threshold — proceed with direct execution
+                console.log('[AutonomousRunner] Planner says workItem fits in threshold, executing directly');
+            }
+            else {
+                // Decomposition failed (limit reached, planner error, API error, etc.)
+                // Fall through to direct execution instead of aborting entirely
+                console.log('[AutonomousRunner] Decomposition failed, falling back to direct execution');
+            }
+        }
+    }
+    // ============================================
+    // Git Worktree: work in an isolated branch per workItem
+    // ============================================
+    let worktreeInfo = null;
+    let actualPath = projectPath;
+    let teardownLifecycle = null;
+    if (ctx.worktreeMode && workItem.workItemId && workItem.workItemIdentifier) {
+        const workItemKind = workItem.workItemId
+            ? (await (await getWorkItemStore()).getWorkItem(workItem.workItemId))?.kind ?? 'Backlog item'
+            : 'Backlog item';
+        const branchName = branchNameFor({ workItemId: workItem.workItemIdentifier, title: workItem.title }, workItemKind);
+        try {
+            worktreeInfo = await createWorktree(projectPath, workItem.workItemId, branchName);
+            actualPath = worktreeInfo.worktreePath;
+            broadcastEvent({
+                type: 'log',
+                data: {
+                    workItemId: workItem.workItemId,
+                    stage: 'worktree',
+                    line: `Worktree: ${actualPath} (branch: ${branchName})`,
+                },
+            });
+        }
+        catch (err) {
+            console.warn('[Worktree] Failed to create worktree, falling back to main repo:', err);
+        }
+    }
+    try {
+        const roles = ctx.getRolesForProject(projectPath); // look up config using original path
+        const pipeline = createPipelineFromConfig(roles, ctx.pairMaxAttempts ?? 3, ctx.guards, ctx.jobProfiles, draftResult ? {
+            workItemType: draftResult.workItemType,
+            intentSummary: draftResult.intentSummary,
+            relevantFiles: draftResult.relevantFiles,
+            suggestedApproach: draftResult.suggestedApproach,
+            projectStats: draftResult.projectStats,
+            registrySnapshot: draftResult.registrySnapshot,
+        } : undefined);
+        const workItemPrefix = buildWorkItemPrefix(workItem, actualPath);
+        pipeline.on('stage:start', ({ stage }) => {
+            console.log(`[${workItemPrefix}] Stage started: ${stage}`);
+        });
+        const workItemReportCtx = {
+            workItemIdentifier: workItem.workItemIdentifier || workItem.workItemId,
+            projectName: workItem.azdoProject?.name,
+            projectPath: actualPath,
+        };
+        pipeline.on('stage:complete', async ({ stage, result }) => {
+            console.log(`[${workItemPrefix}] Stage completed: ${stage}, success=${result.success}`);
+            await reportStageResult(stage, result, ctx.reportToDiscord, workItemReportCtx);
+        });
+        pipeline.on('revision:start', ({ stage }) => {
+            void ctx.reportToDiscord(t('runner.pipeline.revisionNeeded', { stage }));
+        });
+        // HALT event: low confidence → report to Azdo + Discord
+        pipeline.on('halt', async ({ confidence, haltReason, sessionId, iteration }) => {
+            console.warn(`[${workItemPrefix}] HALT event: confidence=${confidence}%, reason=${haltReason}`);
+            // Report to Azdo
+            if (workItem.workItemId && ctx.guards?.haltToAzdo) {
+                try {
+                    await azdo.logHalt(workItem.workItemId, sessionId, confidence, iteration, haltReason);
+                }
+                catch (err) {
+                    console.error(`[${workItemPrefix}] Azdo logHalt failed:`, err);
+                }
+            }
+            // Report to Discord
+            await ctx.reportToDiscord(`⚠️ HALT - Low Confidence\nWorkItem: ${workItem.title}\nConfidence: ${confidence}%\nIteration: #${iteration}\nReason: ${haltReason || 'Low confidence score'}`);
+        });
+        const stages = getEnabledStages(roles);
+        const workItemRef = workItem.workItemIdentifier || workItem.workItemId || '';
+        const projectDisplay = workItem.azdoProject?.name
+            ? `📁 ${workItem.azdoProject.name} (${actualPath.split('/').slice(-2).join('/')})`
+            : actualPath.split('/').slice(-2).join('/');
+        await ctx.reportToDiscord(`${t('runner.pipeline.starting')}\n${t('runner.result.workItemLabel')}: ${workItem.title}\nProject: ${projectDisplay}` +
+            (workItemRef ? `\nWorkItem: ${workItemRef}` : '') +
+            `\nStages: ${stages.join(' → ')}` +
+            (worktreeInfo ? `\nBranch: ${worktreeInfo.branchName}` : ''));
+        if (workItem.workItemId) {
+            try {
+                const sessionId = `pipeline-${Date.now()}`;
+                const inProgressState = await markWorkItemInProgress(workItem.workItemId, {
+                    workItemIdentifier: workItem.workItemIdentifier,
+                    title: workItem.title,
+                    projectId: workItem.azdoProject?.id,
+                    projectName: workItem.azdoProject?.name,
+                    azdoState: 'In Progress',
+                    sessionId,
+                    branchName: worktreeInfo?.branchName,
+                    worktreePath: actualPath,
+                });
+                await azdo.logPairStart(workItem.workItemId, sessionId, projectPath);
+                await azdo.addComment(workItem.workItemId, buildWorkItemStateSyncComment(inProgressState, 'WorkItem execution started'));
+            }
+            catch (err) {
+                console.error(`[${workItemPrefix}] Azdo logPairStart failed:`, err);
+                // Continue pipeline even if this fails
+                await azdo.updateWorkItemState(workItem.workItemId, 'In Progress');
+            }
+        }
+        // Run pipeline in worktree path
+        const result = await pipeline.run(workItem, actualPath);
+        // Create PR (worktree mode + pipeline success = finalStatus 'approved')
+        if (worktreeInfo && result.success && result.finalStatus === 'approved') {
+            try {
+                const prUrl = await commitAndCreatePR(worktreeInfo, workItem.title, workItem.workItemIdentifier || '', workItem.description || '');
+                result.prUrl = prUrl;
+                broadcastEvent({
+                    type: 'log',
+                    data: {
+                        workItemId: workItem.workItemId || workItem.id,
+                        stage: 'pr',
+                        line: `PR created: ${prUrl}`,
+                    },
+                });
+                console.log(`[Runner] PR created for ${workItem.workItemIdentifier}: ${prUrl}`);
+                teardownLifecycle = { phase: 'done', status: 'merging' };
+            }
+            catch (err) {
+                console.error('[Worktree] PR creation failed:', err);
+                broadcastEvent({
+                    type: 'log',
+                    data: {
+                        workItemId: workItem.workItemId || workItem.id,
+                        stage: 'pr',
+                        line: `PR creation failed: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                });
+                teardownLifecycle = { phase: 'failed', status: 'active' };
+            }
+        }
+        else if (worktreeInfo) {
+            // Log why PR was not created
+            const reason = !result.success
+                ? `Pipeline failed (${result.finalStatus})`
+                : `Unexpected state (success=${result.success}, finalStatus=${result.finalStatus})`;
+            console.log(`[Runner] PR not created for ${workItem.workItemIdentifier}: ${reason}`);
+            teardownLifecycle = {
+                phase: result.success ? 'done' : 'failed',
+                status: result.success ? 'active' : 'active',
+            };
+        }
+        return result;
+    }
+    finally {
+        if (worktreeInfo && teardownLifecycle && shouldTeardown(teardownLifecycle)) {
+            await removeWorktree(worktreeInfo).catch((err) => console.warn('[Worktree] Cleanup failed:', err));
+        }
+        else if (worktreeInfo) {
+            console.log(`[Worktree] Preserving ${worktreeInfo.worktreePath} until merge/teardown policy is satisfied`);
+        }
+    }
+}
+function getEnabledStages(stages) {
+    const enabledStages = [];
+    if (stages?.coder?.enabled !== false)
+        enabledStages.push('coder');
+    if (stages?.critic?.enabled !== false)
+        enabledStages.push('critic');
+    if (stages?.tester?.enabled)
+        enabledStages.push('tester');
+    if (stages?.documenter?.enabled)
+        enabledStages.push('documenter');
+    return enabledStages;
+}
+// Reporting
+async function reportStageResult(stage, result, reportFn, workItemCtx) {
+    switch (stage) {
+        case 'coder':
+            await reportFn(executorAgent.formatWorkReport(result.result, workItemCtx));
+            break;
+        case 'critic':
+            await reportFn(reviewerAgent.formatReviewFeedback(result.result));
+            break;
+        case 'tester': {
+            const { formatTestReport } = await import('../agents/tester.js');
+            await reportFn(formatTestReport(result.result));
+            break;
+        }
+        case 'documenter': {
+            const { formatDocReport } = await import('../agents/documenter.js');
+            await reportFn(formatDocReport(result.result));
+            break;
+        }
+    }
+}
+export async function requestApproval(decision, reportFn) {
+    if (!decision.workItem)
+        return;
+    const projectInfo = decision.workItem.azdoProject?.name
+        ? `📁 **${decision.workItem.azdoProject.name}**\n`
+        : '';
+    const workItemRef = decision.workItem.workItemIdentifier || decision.workItem.workItemId || 'N/A';
+    await reportFn(`${t('runner.approval.title')}\n${t('runner.approval.question', { project: projectInfo, title: decision.workItem.title })}\n` +
+        `WorkItem: ${workItemRef}\nPriority: P${decision.workItem.priority}\n${t('runner.approval.reason')}: ${decision.reason}\n${t('runner.approval.footer')}`);
+    if (decision.workItem.workItemId) {
+        const parsed = await loadParsedWorkItem(decision.workItem.workItemId);
+        if (parsed) {
+            const summary = formatParsedWorkItemSummary(parsed);
+            await reportFn(`\`\`\`\n${summary.slice(0, 1800)}\n\`\`\``);
+        }
+    }
+}
+export async function reportExecutionResult(workItem, result, reportFn) {
+    const duration = (result.duration / 1000).toFixed(1);
+    const stepCount = Object.keys(result.execution.stepResults).length;
+    const completedCount = Object.values(result.execution.stepResults)
+        .filter(r => r.status === 'completed').length;
+    const projectPrefix = workItem.azdoProject?.name ? `[${workItem.azdoProject.name}] ` : '';
+    const workItemDisplay = `${projectPrefix}${workItem.title}`;
+    if (result.success) {
+        await reportFn(`${t('runner.result.workItemCompleted')}\n${t('runner.result.workItemLabel')}: ${workItemDisplay}\n` +
+            `${t('runner.result.duration')}: ${duration}s\n${t('runner.result.completedSteps')}: ${completedCount}/${stepCount}`);
+    }
+    else {
+        await reportFn(`${t('runner.result.workItemFailed')}\n${t('runner.result.workItemLabel')}: ${workItemDisplay}\n` +
+            `${t('runner.result.failedStep')}: ${result.failedStep || 'Unknown'}\n${t('runner.result.rollback')}: ${result.rollbackPerformed ? '✅' : '❌'}`);
+        const failedStepResult = result.execution.stepResults[result.failedStep || ''];
+        if (failedStepResult?.error) {
+            await reportFn(`\`\`\`\n${failedStepResult.error.slice(0, 1500)}\n\`\`\``);
+        }
+    }
+}
+export async function reconcileCompletionState(workItem) {
+    if (!workItem.workItemId)
+        return;
+    const released = releaseDependentWorkItems(workItem.workItemId);
+    for (const child of released) {
+        try {
+            await azdo.updateWorkItemState(child.workItemId, 'Todo');
+            await azdo.addComment(child.workItemId, buildWorkItemStateSyncComment(child, 'WorkItem unblocked and ready'));
+        }
+        catch (err) {
+            console.warn(`[AutonomousRunner] Failed to release dependent workItem ${child.workItemId}:`, err);
+        }
+    }
+    const parent = completeParentIfChildrenDone(workItem.workItemId);
+    if (!parent)
+        return;
+    try {
+        await azdo.updateWorkItemState(parent.workItemId, 'Done');
+        await azdo.addComment(parent.workItemId, buildWorkItemStateSyncComment(parent, 'All child workItems completed'));
+    }
+    catch (err) {
+        console.warn(`[AutonomousRunner] Failed to complete parent workItem ${parent.workItemId}:`, err);
+    }
+}
+export async function syncFailureState(workItem, reason) {
+    if (!workItem.workItemId)
+        return;
+    const state = await markWorkItemBlocked(workItem.workItemId, reason, workItem.blockedBy || [], workItem.azdoState);
+    try {
+        await azdo.addComment(workItem.workItemId, buildWorkItemStateSyncComment(state, 'WorkItem blocked'));
+    }
+    catch (err) {
+        console.warn(`[AutonomousRunner] Failed to sync blocked state for ${workItem.workItemId}:`, err);
+    }
+}
+export async function syncSuccessState(workItem, confidence) {
+    if (!workItem.workItemId)
+        return;
+    const state = await markWorkItemDone(workItem.workItemId, {
+        workItemIdentifier: workItem.workItemIdentifier,
+        title: workItem.title,
+        confidence,
+    });
+    try {
+        await azdo.addComment(workItem.workItemId, buildWorkItemStateSyncComment(state, 'WorkItem completed'));
+    }
+    catch (err) {
+        console.warn(`[AutonomousRunner] Failed to sync success state for ${workItem.workItemId}:`, err);
+    }
+}
+//# sourceMappingURL=runnerExecution.js.map