@amsterdamdatalabs/enact-factory 0.1.1

package/dist/automation/autonomousRunner.js

@@ -0,0 +1,1272 @@
+// EnactFactory - Autonomous Runner
+// Heartbeat → Decision → Execution → Report
+import { Cron } from 'croner';
+import { homedir } from 'node:os';
+import { loadWorkItemState, saveWorkItemState, buildProjectsInfo, appendPipelineHistory, getPipelineHistory, incrementRejection, clearRejection, isRejectionLimitReached, canRetryNow, setRetryTime, clearRetryTime, formatRetryTime, getDailyCompletedCount, getDailyPaceInfo, recordProjectCompletion, canProjectAcceptWorkItem, getProjectWindowCount, } from '../automation/runnerState.js';
+import { getDecisionEngine, } from '../orchestration/decisionEngine.js';
+// ExecutorResult used via execution.reportExecutionResult
+import { checkWorkAllowed } from '../support/timeWindow.js';
+import * as azdo from '../azdo/index.js';
+import { updateProjectAfterWorkItem } from '../azdo/projectUpdater.js';
+import { initScheduler } from '../orchestration/workItemScheduler.js';
+import { formatPipelineResultEmbed, } from '../agents/pairPipeline.js';
+import * as planner from '../support/planner.js';
+import { inferProviderFromModel } from '../support/chatBackend.js';
+import * as execution from '../automation/runnerExecution.js';
+import { getWorkItemSource, reportToDiscord, fetchAzdoWorkItems } from '../automation/runnerExecution.js';
+import { t } from '../locale/index.js';
+import { broadcastEvent } from '../core/eventHub.js';
+import { pruneWorktrees } from '../support/worktreeManager.js';
+import { checkAllMonitors, getActiveMonitors } from '../automation/longRunningMonitor.js';
+import { checkQuotaAllowance } from '../support/quotaTracker.js';
+import { branchNameFor } from '../core/devopsModel.js';
+import { createAssignment, listAssignments } from '../factory/assignment.js';
+import { resolveFactoryRoot } from '../factory/paths.js';
+import { dispatchWorkItemToPaseo } from '../factory/paseoDispatcher.js';
+import { reconcilePaseoAssignments } from '../factory/paseoLifecycle.js';
+import { buildWorkItemStateSyncComment, markWorkItemDispatched } from '../workItemState/store.js';
+// Re-export types and integration setters (used by service.ts)
+export { setDiscordReporter, setAzdoFetcher, setLocalFetcher } from '../automation/runnerExecution.js';
+let runnerInstance = null;
+export class AutonomousRunner {
+    config;
+    engine;
+    scheduler;
+    cronJob = null;
+    state = {
+        isRunning: false,
+        lastHeartbeat: 0,
+        consecutiveErrors: 0,
+    };
+    // Heartbeat concurrency guard
+    _heartbeatRunning = false;
+    // Explicitly enabled project paths (allow-list; empty = nothing runs)
+    enabledProjects = new Set();
+    /**
+     * macOS (APFS default) and Windows have case-insensitive filesystems by
+     * default, so `/Users/x/dev/AnalogModeling` and `/Users/x/dev/analogModeling`
+     * refer to the same directory. Do the enabled-set comparison in a case-
+     * insensitive way on those platforms so UI-captured casing doesn't
+     * mismatch Azdo's project-name casing.
+     */
+    get pathsCaseInsensitive() {
+        return process.platform === 'darwin' || process.platform === 'win32';
+    }
+    normalizePath(p) {
+        return this.pathsCaseInsensitive ? p.toLowerCase() : p;
+    }
+    /** Check if a resolved path is under any enabled project */
+    isProjectEnabled(resolvedPath) {
+        if (this.enabledProjects.size === 0)
+            return false;
+        const needle = this.normalizePath(resolvedPath);
+        for (const enabled of this.enabledProjects) {
+            const hay = this.normalizePath(enabled);
+            if (hay === needle)
+                return true;
+            if (needle.startsWith(hay + '/'))
+                return true;
+        }
+        return false;
+    }
+    // Last fetched Azdo workItems (for dashboard display)
+    lastFetchedWorkItems = [];
+    // Cache: azdoProjectName → resolvedLocalPath (populated during workItem execution)
+    projectPathCache = new Map();
+    // Execution pause: boots paused — user must explicitly resumeExecution() before claims start
+    executionPaused = true;
+    // Turbo mode: faster heartbeat, higher daily cap, no stage skipping
+    turboMode = false;
+    turboExpiresAt = null;
+    static TURBO_DURATION_MS = 4 * 60 * 60 * 1000; // 4 hours auto-expire
+    // Track completed/failed workItem IDs to prevent re-selection (persisted to disk)
+    completedWorkItemIds = new Set();
+    failedWorkItemCounts = new Map();
+    failedWorkItemRetryTimes = new Map(); // workItemId → next retry timestamp (ms)
+    static MAX_RETRY_COUNT = 4; // Increased from 2 to allow more retries with backoff
+    get workItemStateRef() {
+        return {
+            completedWorkItemIds: this.completedWorkItemIds,
+            failedWorkItemCounts: this.failedWorkItemCounts,
+            failedWorkItemRetryTimes: this.failedWorkItemRetryTimes,
+        };
+    }
+    loadWorkItemState() {
+        loadWorkItemState(this.workItemStateRef);
+    }
+    saveWorkItemState() {
+        saveWorkItemState(this.workItemStateRef);
+    }
+    formatWorkItemContext(workItem) {
+        const parts = [];
+        if (workItem.azdoProject?.name)
+            parts.push(`[${workItem.azdoProject.name}]`);
+        if (workItem.workItemIdentifier)
+            parts.push(workItem.workItemIdentifier);
+        else if (workItem.workItemId)
+            parts.push(workItem.workItemId.slice(0, 8));
+        return parts.length > 0 ? parts.join(' ') : '';
+    }
+    constructor(config) {
+        this.config = config;
+        this.loadWorkItemState(); // Restore completed/failed workItem IDs from disk
+        this.engine = getDecisionEngine({
+            allowedProjects: config.allowedProjects,
+            azdoTeamId: config.azdoTeamId,
+            autoExecute: config.autoExecute,
+            maxConsecutiveWorkItems: config.maxConsecutiveWorkItems,
+            cooldownSeconds: config.cooldownSeconds,
+            dryRun: config.dryRun,
+        });
+        // Initialize WorkItemScheduler
+        this.scheduler = initScheduler({
+            maxConcurrent: config.maxConcurrentWorkItems ?? 1,
+            allowSameProjectConcurrent: false,
+            worktreeMode: config.worktreeMode ?? false,
+        });
+        // Set up scheduler event handling
+        this.setupSchedulerEvents();
+    }
+    setupSchedulerEvents() {
+        this.scheduler.on('started', async (running) => {
+            const workItemCtx = this.formatWorkItemContext(running.workItem);
+            console.log(`[Scheduler] WorkItem started: ${workItemCtx} ${running.workItem.title}`);
+            broadcastEvent({ type: 'workItem:started', data: { workItemId: running.workItem.id, title: running.workItem.title, workItemIdentifier: running.workItem.workItemIdentifier } });
+        });
+        this.scheduler.on('completed', async ({ workItem, result }) => {
+            const workItemCtx = this.formatWorkItemContext(workItem);
+            console.log(`[Scheduler] WorkItem completed: ${workItemCtx} ${workItem.title}`);
+            broadcastEvent({ type: 'workItem:completed', data: { workItemId: workItem.id, success: result.success, duration: result.totalDuration } });
+            this.recordPipelineHistory(workItem, result);
+            await reportToDiscord(formatPipelineResultEmbed(result));
+            if (result.finalStatus === 'dispatched') {
+                console.log(`[Scheduler] WorkItem dispatched to Paseo, waiting for external completion: ${workItemCtx} ${workItem.title}`);
+                this.scheduleNextHeartbeat();
+                return;
+            }
+            // Track as completed ONLY on success to prevent re-selection (persist to disk)
+            if (workItem.workItemId && result.success) {
+                this.completedWorkItemIds.add(workItem.workItemId);
+                clearRejection(workItem.workItemId); // Clear rejection count on success
+                clearRetryTime(workItem.workItemId, this.failedWorkItemRetryTimes); // Clear retry backoff time
+                this.saveWorkItemState();
+                // Track project-level pace (5h rolling window)
+                const projectName = workItem.azdoProject?.name ?? 'unknown';
+                recordProjectCompletion(projectName, result.totalCost?.costUsd);
+            }
+            // Skip completion handling for decomposed workItems. Child workItems represent the runnable work.
+            if (result.finalStatus === 'decomposed') {
+                console.log(`[Scheduler] WorkItem decomposed into sub-workItems, skipping Done state`);
+                this.scheduleNextHeartbeat();
+                return;
+            }
+            // On success, update Azdo workItem to Done
+            if (result.success && workItem.workItemId) {
+                try {
+                    await execution.syncSuccessState(workItem);
+                    await azdo.logPairComplete(workItem.workItemId, result.sessionId, {
+                        attempts: result.iterations,
+                        duration: Math.floor(result.totalDuration / 1000),
+                        filesChanged: result.executorResult?.filesChanged || [],
+                        executorSummary: result.executorResult?.summary,
+                        executorCommands: result.executorResult?.commands,
+                        reviewerFeedback: result.reviewResult?.feedback,
+                        reviewerDecision: result.reviewResult?.decision,
+                        testResults: result.testerResult ? {
+                            passed: result.testerResult.testsPassed,
+                            failed: result.testerResult.testsFailed,
+                            coverage: result.testerResult.coverage,
+                            failedTests: result.testerResult.failedTests,
+                        } : undefined,
+                    });
+                    await execution.reconcileCompletionState(workItem);
+                    console.log(`[Scheduler] WorkItem ${workItem.workItemId} marked as Done`);
+                }
+                catch (err) {
+                    console.error(`[Scheduler] Failed to update workItem state:`, err);
+                }
+            }
+            // Azdo project Status Update + Overview refresh (non-blocking)
+            if (workItem.azdoProject) {
+                updateProjectAfterWorkItem(workItem.azdoProject.id, workItem.azdoProject.name, {
+                    title: workItem.title,
+                    success: result.success,
+                    duration: result.totalDuration,
+                    workItemId: workItem.workItemId,
+                    workItemIdentifier: workItem.workItemIdentifier,
+                    cost: result.totalCost?.costUsd,
+                    projectPath: result.workItemContext?.projectPath,
+                }).catch(e => console.warn('[Scheduler] Project update failed:', e));
+            }
+            this.scheduleNextHeartbeat();
+        });
+        this.scheduler.on('failed', async ({ workItem, result }) => {
+            const workItemCtx = this.formatWorkItemContext(workItem);
+            console.log(`[Scheduler] WorkItem failed: ${workItemCtx} ${workItem.title}`);
+            broadcastEvent({ type: 'workItem:completed', data: { workItemId: workItem.id, success: false, duration: result.totalDuration } });
+            this.recordPipelineHistory(workItem, result);
+            await reportToDiscord(formatPipelineResultEmbed(result));
+            // If rejected, track rejection count and block after max attempts
+            if (workItem.workItemId && result.finalStatus === 'rejected') {
+                const feedback = result.reviewResult?.feedback || 'No feedback provided';
+                const rejectionCount = incrementRejection(workItem.workItemId, feedback);
+                console.log(`[Scheduler] WorkItem rejected (${rejectionCount}/3): ${workItemCtx} ${workItem.title}`);
+                console.log(`[Scheduler] Rejection reason: ${feedback}`);
+                if (isRejectionLimitReached(workItem.workItemId)) {
+                    // Max rejections reached - permanently block
+                    this.completedWorkItemIds.add(workItem.workItemId); // Prevent re-selection
+                    clearRetryTime(workItem.workItemId, this.failedWorkItemRetryTimes); // Clear retry time
+                    this.saveWorkItemState();
+                    try {
+                        await execution.syncFailureState(workItem, `Max rejection limit reached (${rejectionCount} attempts): ${feedback}`);
+                        await azdo.logBlocked(workItem.workItemId, 'autonomous-runner', `⚠️ **Max rejection limit reached (${rejectionCount} attempts)**\n\n` +
+                            `This workItem has been rejected ${rejectionCount} times by the reviewer and requires manual intervention.\n\n` +
+                            `**Latest rejection reason:**\n${feedback}\n\n` +
+                            `**Action required:** Please review the workItem requirements and code manually, or adjust the workItem scope.`);
+                        console.log(`[Scheduler] WorkItem ${workItem.workItemId} permanently blocked (max rejections reached)`);
+                    }
+                    catch (err) {
+                        console.error(`[Scheduler] Failed to update workItem state:`, err);
+                    }
+                    return;
+                }
+                else {
+                    // Not max yet - schedule retry with exponential backoff
+                    const nextRetryTime = setRetryTime(workItem.workItemId, rejectionCount, this.failedWorkItemRetryTimes);
+                    const retryIn = formatRetryTime(nextRetryTime);
+                    broadcastEvent({
+                        type: 'log',
+                        data: {
+                            workItemId: workItem.id,
+                            stage: 'retry',
+                            line: `Retry backoff (rejected): ${rejectionCount}/3 — next attempt ${retryIn}`,
+                        },
+                    });
+                    this.saveWorkItemState();
+                    try {
+                        await execution.syncFailureState(workItem, `Review rejected (${rejectionCount}/3): ${feedback}`);
+                        await azdo.logBlocked(workItem.workItemId, 'autonomous-runner', t('runner.reviewRejected', { feedback }) +
+                            `\n\n**Rejection count:** ${rejectionCount}/3 - Will retry automatically ${retryIn}.`);
+                        console.log(`[Scheduler] WorkItem ${workItem.workItemId} marked as Todo (blocked) (rejected ${rejectionCount}/3) — retry ${retryIn}`);
+                    }
+                    catch (err) {
+                        console.error(`[Scheduler] Failed to update workItem state:`, err);
+                    }
+                    return;
+                }
+            }
+            // Track failure count — block after MAX_RETRY_COUNT failures
+            if (workItem.workItemId) {
+                const count = (this.failedWorkItemCounts.get(workItem.workItemId) ?? 0) + 1;
+                this.failedWorkItemCounts.set(workItem.workItemId, count);
+                if (count >= AutonomousRunner.MAX_RETRY_COUNT) {
+                    // Max retries exceeded - permanently block
+                    this.completedWorkItemIds.add(workItem.workItemId); // Prevent re-selection
+                    clearRetryTime(workItem.workItemId, this.failedWorkItemRetryTimes); // Clear retry time
+                    this.saveWorkItemState();
+                    console.log(`[Scheduler] WorkItem failure count: ${count}/${AutonomousRunner.MAX_RETRY_COUNT} for ${workItemCtx} — BLOCKED`);
+                    try {
+                        await execution.syncFailureState(workItem, `Autonomous execution failed ${count} times`);
+                        await azdo.logBlocked(workItem.workItemId, 'autonomous-runner', `Autonomous execution failed ${count} times. Moving to Blocked for manual review.`);
+                        console.log(`[Scheduler] WorkItem ${workItem.workItemId} marked as Todo (blocked) (max retries exceeded)`);
+                    }
+                    catch (err) {
+                        console.error(`[Scheduler] Failed to update workItem state:`, err);
+                    }
+                }
+                else {
+                    // Schedule retry with exponential backoff
+                    const nextRetryTime = setRetryTime(workItem.workItemId, count, this.failedWorkItemRetryTimes);
+                    const retryIn = formatRetryTime(nextRetryTime);
+                    console.log(`[Scheduler] WorkItem failure count: ${count}/${AutonomousRunner.MAX_RETRY_COUNT} for ${workItemCtx} — retry ${retryIn}`);
+                    broadcastEvent({
+                        type: 'log',
+                        data: {
+                            workItemId: workItem.id,
+                            stage: 'retry',
+                            line: `Retry backoff: ${count}/${AutonomousRunner.MAX_RETRY_COUNT} — next attempt ${retryIn}`,
+                        },
+                    });
+                    this.saveWorkItemState();
+                }
+            }
+            // Azdo project Status Update + Overview refresh (non-blocking)
+            if (workItem.azdoProject) {
+                updateProjectAfterWorkItem(workItem.azdoProject.id, workItem.azdoProject.name, {
+                    title: workItem.title,
+                    success: result.success,
+                    duration: result.totalDuration,
+                    workItemIdentifier: workItem.workItemIdentifier,
+                    cost: result.totalCost?.costUsd,
+                    projectPath: result.workItemContext?.projectPath,
+                }).catch(e => console.warn('[Scheduler] Project update failed:', e));
+            }
+            this.scheduleNextHeartbeat();
+        });
+        this.scheduler.on('error', async ({ workItem, error }) => {
+            const workItemCtx = this.formatWorkItemContext(workItem);
+            console.error(`[Scheduler] WorkItem error: ${workItemCtx} ${workItem.title}`, error);
+            await reportToDiscord(t('runner.pipelineError', { title: `${workItemCtx} ${workItem.title}`, error: error.message }));
+        });
+        this.scheduler.on('slotFreed', () => {
+            // Auto-execute next workItem when slot becomes available
+            void this.runAvailableWorkItems();
+        });
+    }
+    filterAlreadyProcessed(workItems) {
+        let recovered = 0;
+        let backoffSkipped = 0;
+        const recoverableStates = new Set(['Todo', 'In Progress', 'In Review']);
+        const filtered = workItems.filter(workItem => {
+            const id = workItem.workItemId || workItem.id;
+            // Check rejection limit first
+            if (isRejectionLimitReached(id)) {
+                return false; // Skip workItems that hit max rejection limit
+            }
+            // Recover workItems in active states from completed/failed list
+            // (user or system intentionally moved back to active, so retry)
+            if (recoverableStates.has(workItem.azdoState || '') && (this.completedWorkItemIds.has(id) || (this.failedWorkItemCounts.get(id) ?? 0) >= AutonomousRunner.MAX_RETRY_COUNT)) {
+                this.completedWorkItemIds.delete(id);
+                this.failedWorkItemCounts.delete(id);
+                clearRejection(id); // Clear rejection count on recovery
+                clearRetryTime(id, this.failedWorkItemRetryTimes); // Clear retry backoff time
+                recovered++;
+                return true;
+            }
+            if (this.completedWorkItemIds.has(id))
+                return false;
+            if ((this.failedWorkItemCounts.get(id) ?? 0) >= AutonomousRunner.MAX_RETRY_COUNT)
+                return false;
+            if (this.hasActivePaseoAssignment(id))
+                return false;
+            // Check if workItem is in exponential backoff period
+            if (!canRetryNow(id, this.failedWorkItemRetryTimes)) {
+                backoffSkipped++;
+                return false; // Skip workItems still in backoff period
+            }
+            return true;
+        });
+        if (recovered > 0) {
+            this.saveWorkItemState();
+            this.syslog(`♻ Recovered ${recovered} Todo workItems from completed/failed/rejected list`);
+        }
+        if (backoffSkipped > 0) {
+            this.syslog(`⏰ Skipped ${backoffSkipped} workItems in exponential backoff period`);
+        }
+        return filtered;
+    }
+    /** Schedule next heartbeat with pace-aware cooldown */
+    _nextHeartbeatTimer = null;
+    scheduleNextHeartbeat() {
+        if (this._nextHeartbeatTimer)
+            return; // already scheduled
+        const isTurbo = this.getTurboMode();
+        // Turbo: 5min flat, no progressive slowdown
+        if (isTurbo) {
+            const turboCooldown = 5 * 60_000; // 5min
+            console.log(`[AutonomousRunner] TURBO: next heartbeat in 5min`);
+            this._nextHeartbeatTimer = setTimeout(() => {
+                this._nextHeartbeatTimer = null;
+                void this.heartbeat();
+            }, turboCooldown);
+            return;
+        }
+        // Normal: progressive slowdown based on 5h window usage
+        const perProjectCap = this.config.dailyWorkItemCap ?? 6;
+        const globalCap = Math.max(this.enabledProjects.size, 3) * perProjectCap;
+        const baseCooldown = this.config.interWorkItemCooldownMs ?? 1_800_000; // 30min default
+        const totalInWindow = getDailyCompletedCount();
+        // Progressive slowdown: ratio² × 3 multiplier
+        const ratio = totalInWindow / globalCap;
+        const multiplier = 1 + (ratio * ratio * 3);
+        const adjustedCooldown = Math.round(baseCooldown * multiplier);
+        const cooldownMin = Math.round(adjustedCooldown / 60_000);
+        console.log(`[AutonomousRunner] Scheduling next heartbeat in ${cooldownMin}min (5h window: ${totalInWindow}/${globalCap}, multiplier: ${multiplier.toFixed(2)}x)`);
+        this._nextHeartbeatTimer = setTimeout(() => {
+            this._nextHeartbeatTimer = null;
+            void this.heartbeat();
+        }, adjustedCooldown);
+    }
+    async runAvailableWorkItems() {
+        if (!this.config.pairMode || !this.config.maxConcurrentWorkItems) {
+            return; // Parallel processing disabled
+        }
+        await this.scheduler.runAvailable(async (workItem, projectPath) => {
+            return this.shouldDispatchWithPaseo()
+                ? this.dispatchWithPaseo(workItem, projectPath)
+                : this.executePipeline(workItem, projectPath);
+        });
+    }
+    shouldDispatchWithPaseo() {
+        return (this.config.dispatchBackend ?? 'paseo') === 'paseo';
+    }
+    hasActivePaseoAssignment(workItemId) {
+        try {
+            return listAssignments(resolveFactoryRoot()).some((assignment) => {
+                return assignment.workItemId === workItemId
+                    && assignment.dispatcher === 'paseo'
+                    && (assignment.status === 'active' || assignment.status === 'stuck');
+            });
+        }
+        catch {
+            return false;
+        }
+    }
+    async dispatchWithPaseo(workItem, projectPath) {
+        const startedAt = Date.now();
+        const workItemId = workItem.workItemId || workItem.id;
+        const workItemRef = workItem.workItemIdentifier || workItemId;
+        const worktreeName = branchNameFor({ workItemId: workItemRef, title: workItem.title }, 'Backlog item');
+        const factoryRoot = resolveFactoryRoot();
+        try {
+            if (this.hasActivePaseoAssignment(workItemId)) {
+                return {
+                    success: true,
+                    sessionId: `paseo-existing-${workItemId}`,
+                    stages: [],
+                    finalStatus: 'dispatched',
+                    totalDuration: Date.now() - startedAt,
+                    iterations: 0,
+                    workItemContext: {
+                        workItemIdentifier: workItem.workItemIdentifier || workItem.workItemId,
+                        projectName: workItem.azdoProject?.name,
+                        projectPath,
+                        workItemTitle: workItem.title,
+                    },
+                };
+            }
+            broadcastEvent({
+                type: 'log',
+                data: { workItemId, stage: 'dispatch', line: `Dispatching to Paseo (${this.config.paseo?.provider ?? 'codex/gpt-5.3-codex-spark'})` },
+            });
+            const dispatch = await dispatchWorkItemToPaseo({
+                workItemId,
+                workItemIdentifier: workItem.workItemIdentifier,
+                title: workItem.title,
+                description: workItem.description,
+                projectName: workItem.azdoProject?.name,
+                projectPath,
+                worktreeName,
+            }, this.config.paseo);
+            createAssignment({
+                workItemId,
+                operatorLane: 'ralph',
+                repoRoot: projectPath,
+                host: 'codex',
+                sessionId: dispatch.agentId,
+                dispatcher: 'paseo',
+                paseoAgentId: dispatch.agentId,
+                paseoProvider: dispatch.provider,
+                paseoMode: dispatch.mode,
+                paseoCwd: dispatch.cwd,
+                paseoWorktree: worktreeName,
+                paseoStatus: 'dispatched',
+                paseoLastCheckedAt: new Date().toISOString(),
+            }, factoryRoot);
+            if (workItem.workItemId) {
+                try {
+                    const state = await markWorkItemDispatched(workItem.workItemId, {
+                        workItemIdentifier: workItem.workItemIdentifier,
+                        title: workItem.title,
+                        projectId: workItem.azdoProject?.id,
+                        projectName: workItem.azdoProject?.name,
+                        azdoState: 'In Progress',
+                        sessionId: dispatch.agentId,
+                        branchName: worktreeName,
+                        worktreePath: dispatch.cwd,
+                    });
+                    await azdo.logPairStart(workItem.workItemId, dispatch.agentId, dispatch.cwd);
+                    await azdo.addComment(workItem.workItemId, buildWorkItemStateSyncComment(state, 'WorkItem dispatched to Paseo'));
+                }
+                catch (err) {
+                    console.warn(`[PaseoDispatch] Failed to persist in-progress state for ${workItemRef}:`, err);
+                }
+            }
+            broadcastEvent({
+                type: 'log',
+                data: { workItemId, stage: 'dispatch', line: `Paseo agent: ${dispatch.agentId}` },
+            });
+            return {
+                success: true,
+                sessionId: dispatch.agentId,
+                stages: [],
+                finalStatus: 'dispatched',
+                totalDuration: Date.now() - startedAt,
+                iterations: 0,
+                workItemContext: {
+                    workItemIdentifier: workItem.workItemIdentifier || workItem.workItemId,
+                    projectName: workItem.azdoProject?.name,
+                    projectPath: dispatch.cwd,
+                    workItemTitle: workItem.title,
+                },
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            broadcastEvent({
+                type: 'log',
+                data: { workItemId, stage: 'dispatch', line: `Paseo dispatch failed: ${message}` },
+            });
+            return {
+                success: false,
+                sessionId: `paseo-dispatch-failed-${Date.now()}`,
+                stages: [],
+                finalStatus: 'failed',
+                totalDuration: Date.now() - startedAt,
+                iterations: 0,
+                workItemContext: {
+                    workItemIdentifier: workItem.workItemIdentifier || workItem.workItemId,
+                    projectName: workItem.azdoProject?.name,
+                    projectPath,
+                    workItemTitle: workItem.title,
+                },
+            };
+        }
+    }
+    getRolesForProject(projectPath) {
+        // Find per-project configuration
+        const projectConfig = this.config.projectAgents?.find(pa => projectPath.includes(pa.path.replace('~', '')));
+        if (!projectConfig?.stages && !this.config.defaultStages) {
+            // Convert from legacy configuration
+            return {
+                coder: {
+                    enabled: true,
+                    model: this.config.executorModel || 'claude-sonnet-4-5-20250929',
+                    timeoutMs: this.config.executorTimeoutMs ?? 0,
+                },
+                critic: {
+                    enabled: true,
+                    model: this.config.reviewerModel || 'claude-haiku-4-5-20251001',
+                    timeoutMs: this.config.reviewerTimeoutMs ?? 0,
+                },
+            };
+        }
+        // Apply per-project overrides
+        const base = this.config.defaultStages || {
+            coder: { enabled: true, model: 'claude-sonnet-4-5-20250929', timeoutMs: 0 },
+            critic: { enabled: true, model: 'claude-haiku-4-5-20251001', timeoutMs: 0 },
+        };
+        if (!projectConfig?.stages) {
+            return base;
+        }
+        // Merge overrides
+        return {
+            coder: { ...base.coder, ...projectConfig.stages.coder },
+            critic: { ...base.critic, ...projectConfig.stages.critic },
+            tester: projectConfig.stages.tester
+                ? { ...base.tester, ...projectConfig.stages.tester }
+                : base.tester,
+            documenter: projectConfig.stages.documenter
+                ? { ...base.documenter, ...projectConfig.stages.documenter }
+                : base.documenter,
+        };
+    }
+    async start() {
+        if (this.state.isRunning) {
+            console.log('[AutonomousRunner] Already running');
+            return;
+        }
+        await this.engine.init();
+        // worktree mode: clean up dangling worktrees at startup
+        if (this.config.worktreeMode) {
+            for (const projectPath of this.config.allowedProjects) {
+                const resolvedPath = projectPath.replace(/^~(?=\/|$)/, homedir());
+                pruneWorktrees(resolvedPath).catch((e) => console.error(`[AutonomousRunner] Worktree prune failed for ${resolvedPath}:`, e));
+            }
+        }
+        // Set up cron job
+        this.cronJob = new Cron(this.config.heartbeatSchedule, async () => {
+            await this.heartbeat();
+        });
+        this.state.isRunning = true;
+        this.state.startedAt = Date.now();
+        console.log(`[AutonomousRunner] Started with schedule: ${this.config.heartbeatSchedule}`);
+        await reportToDiscord(`🤖 ${t('runner.modeStarted')}\n` +
+            `Schedule: \`${this.config.heartbeatSchedule}\`\n` +
+            `Auto-execute: ${this.config.autoExecute ? '✅' : '❌'}\n` +
+            `Projects: ${this.config.allowedProjects.join(', ')}`);
+        // Immediate execution option
+        if (this.config.triggerNow) {
+            console.log('[AutonomousRunner] Triggering immediate heartbeat in 10s...');
+            setTimeout(() => void this.heartbeat(), 10000); // Run after 10s (wait for Discord/Azdo connection)
+        }
+    }
+    stop() {
+        if (this.cronJob) {
+            this.cronJob.stop();
+            this.cronJob = null;
+        }
+        this.state.isRunning = false;
+        console.log('[AutonomousRunner] Stopped');
+    }
+    buildStats() {
+        const stats = this.scheduler.getStats();
+        return {
+            runningWorkItems: stats.running,
+            queuedWorkItems: stats.queued,
+            completedToday: stats.completed,
+            uptime: this.state.startedAt ? Date.now() - this.state.startedAt : 0,
+            schedulerPaused: this.scheduler.isPaused(),
+            executionPaused: this.executionPaused,
+        };
+    }
+    /** Send system message to dashboard LIVE LOG */
+    syslog(line) {
+        console.log(`[HB] ${line}`);
+        broadcastEvent({ type: 'log', data: { workItemId: 'system', stage: 'heartbeat', line } });
+    }
+    async reconcilePaseoLifecycle() {
+        if ((this.config.dispatchBackend ?? 'paseo') !== 'paseo')
+            return;
+        const results = await reconcilePaseoAssignments(resolveFactoryRoot(), this.config.paseo, {
+            addComment: azdo.addComment,
+            updateAzdoState: azdo.updateWorkItemState,
+        });
+        const changed = results.filter((result) => result.action !== 'skipped');
+        if (changed.length > 0) {
+            const summary = changed.map((result) => `${result.workItemId}:${result.status}`).join(', ');
+            this.syslog(`✓ Paseo lifecycle reconciled: ${summary}`);
+            broadcastEvent({ type: 'stats', data: this.buildStats() });
+        }
+    }
+    async heartbeat() {
+        if (this._heartbeatRunning) {
+            console.log('[AutonomousRunner] Heartbeat already running, skipping');
+            return;
+        }
+        this._heartbeatRunning = true;
+        console.log('[AutonomousRunner] Heartbeat triggered');
+        this.state.lastHeartbeat = Date.now();
+        broadcastEvent({ type: 'stats', data: this.buildStats() });
+        broadcastEvent({ type: 'heartbeat' });
+        this.syslog('▶ Heartbeat started');
+        try {
+            // 0.5 Long-running monitor passive check (before time window)
+            const active = getActiveMonitors().filter(m => m.state === 'pending' || m.state === 'running');
+            if (active.length > 0) {
+                const checked = await checkAllMonitors().catch(() => 0);
+                this.syslog(`✓ Monitors: ${checked} checked / ${active.length} active`);
+            }
+            await this.reconcilePaseoLifecycle().catch((error) => {
+                this.syslog(`⚠ Paseo lifecycle reconciliation failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            // 1. Check time window
+            const timeCheck = checkWorkAllowed();
+            if (!timeCheck.allowed) {
+                console.log(`[AutonomousRunner] Blocked: ${timeCheck.reason}`);
+                this.syslog(`⛔ Time window blocked: ${timeCheck.reason}`);
+                return;
+            }
+            this.syslog('✓ Time window: allowed');
+            // 1.4 Execution pause gate — check before quota/pace/fetch
+            if (this.executionPaused) {
+                this.syslog('⏸ Execution paused — skipping claim cycle');
+                return;
+            }
+            // 1.5 Quota gate — skip heartbeat if Claude Max quota is too high
+            const quotaCheck = await checkQuotaAllowance(80);
+            if (!quotaCheck.allowed) {
+                console.log(`[AutonomousRunner] Quota gate: SKIP — ${quotaCheck.reason}`);
+                broadcastEvent({ type: 'log', data: { workItemId: 'system', stage: 'quota', line: `⏸ ${quotaCheck.reason}` } });
+                return;
+            }
+            if (quotaCheck.utilization !== undefined && quotaCheck.utilization > 60) {
+                console.log(`[AutonomousRunner] Quota warning: ${quotaCheck.utilization.toFixed(0)}% utilization`);
+            }
+            // 1.6 Pace gate — per-project 5h rolling window
+            const isTurbo = this.getTurboMode();
+            const perProjectCap = isTurbo ? 20 : (this.config.dailyWorkItemCap ?? 6);
+            const totalInWindow = getDailyCompletedCount();
+            // 전역 상한: 프로젝트 수 × per-project cap (안전장치)
+            const globalCap = Math.max(this.enabledProjects.size, 3) * perProjectCap;
+            if (totalInWindow >= globalCap) {
+                console.log(`[AutonomousRunner] Global pace limit: ${totalInWindow}/${globalCap} workItems in 5h window — skipping`);
+                this.syslog(`⏸ Global pace: ${totalInWindow}/${globalCap} (5h window)`);
+                broadcastEvent({ type: 'log', data: { workItemId: 'system', stage: 'pace', line: `⏸ Global pace: ${totalInWindow}/${globalCap}` } });
+                return;
+            }
+            const modeLabel = isTurbo ? 'TURBO' : 'Normal';
+            this.syslog(`✓ Pace: ${totalInWindow}/${globalCap} global, ${perProjectCap}/project [${modeLabel}]`);
+            // 2. Fetch workItems from configured source
+            const workItemSource = getWorkItemSource();
+            const sourceLabel = workItemSource === 'local' ? 'Local' : workItemSource === 'azdo' ? 'Azdo' : 'Unknown';
+            this.syslog(`⟳ Fetching workItems from ${sourceLabel}...`);
+            const fetchResult = await fetchAzdoWorkItems();
+            if (fetchResult.error) {
+                this.syslog(`✗ ${sourceLabel} fetch error: ${fetchResult.error}`);
+                await reportToDiscord(`⚠️ ${sourceLabel} fetch failed: ${fetchResult.error}`);
+                return;
+            }
+            const workItems = fetchResult.workItems;
+            if (workItems.length === 0) {
+                this.syslog('— No workItems in backlog');
+                return;
+            }
+            this.lastFetchedWorkItems = workItems;
+            this.syslog(`✓ Found ${workItems.length} workItems from ${sourceLabel}`);
+            // Filter out completed and over-retried workItems
+            const filteredWorkItems = this.filterAlreadyProcessed(workItems);
+            if (filteredWorkItems.length === 0) {
+                this.syslog('— All workItems already completed or max retries exceeded');
+                return;
+            }
+            if (filteredWorkItems.length !== workItems.length) {
+                this.syslog(`  Filtered: ${workItems.length} → ${filteredWorkItems.length} (skipped ${workItems.length - filteredWorkItems.length} completed/failed)`);
+            }
+            // Parallel processing mode
+            if (this.config.maxConcurrentWorkItems && this.config.maxConcurrentWorkItems > 1 && this.config.pairMode) {
+                await this.heartbeatParallel(filteredWorkItems);
+                return;
+            }
+            // 3. Run Decision Engine (single workItem)
+            this.syslog('⟳ Running Decision Engine...');
+            const decision = await this.engine.heartbeat(filteredWorkItems);
+            this.syslog(`→ Decision: ${decision.action} — ${decision.reason}`);
+            this.state.lastDecision = decision;
+            // 4. Handle decision
+            if (decision.action === 'execute' && decision.workItem) {
+                await this.executeWorkItemPairMode(decision.workItem);
+            }
+            else if (decision.action === 'defer' && decision.workItem) {
+                this.state.pendingApproval = decision.workItem;
+                await this.requestApproval(decision);
+            }
+            this.state.consecutiveErrors = 0;
+        }
+        catch (error) {
+            this.state.consecutiveErrors++;
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error('[AutonomousRunner] Heartbeat error:', msg);
+            this.syslog(`✗ Heartbeat error: ${msg}`);
+            if (this.state.consecutiveErrors >= 3) {
+                await reportToDiscord(t('runner.consecutiveErrors', { count: this.state.consecutiveErrors, error: msg }));
+            }
+        }
+        finally {
+            this._heartbeatRunning = false;
+        }
+    }
+    async heartbeatParallel(workItems) {
+        const availableSlots = this.scheduler.getAvailableSlots();
+        const runningCount = this.scheduler.getStats().running;
+        this.syslog(`  Parallel mode | slots: ${availableSlots} free / ${this.config.maxConcurrentWorkItems} max | running: ${runningCount}`);
+        if (availableSlots === 0) {
+            this.syslog(`⏳ All slots busy (${runningCount} workItems running), waiting...`);
+            return;
+        }
+        // Fill all available slots (worktree mode isolates each workItem)
+        const maxSlots = availableSlots;
+        // Pre-filter workItems to enabled projects only (before DecisionEngine selection)
+        // This prevents DecisionEngine from wasting its max-slot budget on non-enabled projects.
+        // Only execute active states; Backlog/Blocked are fetched for dashboard visibility.
+        const executableStates = new Set(['Todo', 'In Progress', 'In Review']);
+        const executableWorkItems = workItems.filter(t => executableStates.has(t.azdoState || ''));
+        let workItemsForEngine = executableWorkItems;
+        if (this.enabledProjects.size > 0) {
+            workItemsForEngine = [];
+            for (const workItem of executableWorkItems) {
+                const projName = workItem.azdoProject?.name;
+                if (!projName) {
+                    this.syslog(`  ⚠ Skipping workItem without project mapping: ${workItem.workItemIdentifier}`);
+                    continue;
+                }
+                let cachedPath = this.projectPathCache.get(projName)
+                    ?? this.projectPathCache.get(projName.toLowerCase())
+                    ?? this.projectPathCache.get(projName.replace(/-/g, ' '));
+                if (!cachedPath) {
+                    const lowerProj = projName.toLowerCase().replace(/[^a-z0-9]/g, '');
+                    for (const [key, path] of this.projectPathCache.entries()) {
+                        const lowerKey = key.toLowerCase().replace(/[^a-z0-9]/g, '');
+                        if (lowerKey.length > 3 && (lowerProj.includes(lowerKey) || lowerKey.includes(lowerProj))) {
+                            cachedPath = path;
+                            this.projectPathCache.set(projName, path);
+                            break;
+                        }
+                    }
+                }
+                if (!cachedPath) {
+                    const resolvedPath = await this.resolveProjectPath(workItem);
+                    if (resolvedPath) {
+                        cachedPath = resolvedPath;
+                        if (workItem.azdoProject?.name) {
+                            this.projectPathCache.set(workItem.azdoProject.name, resolvedPath);
+                        }
+                        this.syslog(`  ✓ Mapped project "${projName}" → ${resolvedPath}`);
+                    }
+                    else {
+                        this.syslog(`  ⚠ No path cache for project "${projName}" — skipping ${workItem.workItemIdentifier}`);
+                        continue;
+                    }
+                }
+                const enabled = this.isProjectEnabled(cachedPath);
+                if (!enabled) {
+                    this.syslog(`  ⚠ Project "${projName}" (${cachedPath}) not enabled — skipping ${workItem.workItemIdentifier}`);
+                    continue;
+                }
+                workItemsForEngine.push(workItem);
+            }
+            if (workItemsForEngine.length === 0) {
+                this.syslog(`⚠ No enabled workItems (${executableWorkItems.length} executable, ${workItems.length - executableWorkItems.length} backlog)`);
+                this.syslog(`  Path cache: [${[...this.projectPathCache.entries()].map(([k, v]) => `${k}→${v}`).join(', ')}]`);
+                this.syslog(`  Enabled: [${[...this.enabledProjects].join(', ')}]`);
+                return;
+            }
+            this.syslog(`  WorkItems: ${workItemsForEngine.length} enabled-or-uncached / ${executableWorkItems.length} executable / ${workItems.length} total`);
+        }
+        // Get validated workItem list from DecisionEngine
+        this.syslog('⟳ Decision Engine evaluating workItems...');
+        const decision = await this.engine.heartbeatMultiple(workItemsForEngine, maxSlots, [] // No project exclusion — worktree mode isolates each workItem
+        );
+        console.log(`[AutonomousRunner] Decision: ${decision.action} — ${decision.reason} (${decision.workItems?.length ?? 0} workItems)`);
+        if (decision.action === 'skip' || decision.action === 'defer') {
+            this.syslog(`→ Decision: ${decision.action} — ${decision.reason}`);
+            return;
+        }
+        // Add validated workItems to queue (with conflict detection)
+        let enqueuedCount = 0;
+        // Pre-filter: resolve project paths and skip invalid workItems
+        const candidates = [];
+        for (const { workItem } of decision.workItems) {
+            if (this.scheduler.isWorkItemQueued(workItem.id) || this.scheduler.isWorkItemRunning(workItem.id)) {
+                this.syslog(`  Skip (already queued/running): ${workItem.workItemIdentifier || workItem.id.slice(0, 8)} ${workItem.title}`);
+                continue;
+            }
+            const projectPath = await this.resolveProjectPath(workItem);
+            if (!projectPath) {
+                this.syslog(`✗ Cannot resolve project path for "${workItem.azdoProject?.name || workItem.title}" — skipping`);
+                continue;
+            }
+            if (workItem.azdoProject?.name) {
+                this.projectPathCache.set(workItem.azdoProject.name, projectPath);
+            }
+            if (this.scheduler.isProjectBusy(projectPath)) {
+                this.syslog(`  Project busy: ${projectPath}`);
+                continue;
+            }
+            if (this.enabledProjects.size > 0 && !this.isProjectEnabled(projectPath)) {
+                this.syslog(`  Project not enabled: ${projectPath}`);
+                continue;
+            }
+            // 프로젝트별 5시간 윈도우 cap 체크
+            const projName = workItem.azdoProject?.name ?? 'unknown';
+            const perProjectCap = this.config.dailyWorkItemCap ?? 6;
+            if (!canProjectAcceptWorkItem(projName, perProjectCap)) {
+                const count = getProjectWindowCount(projName);
+                this.syslog(`  ⏸ ${projName}: ${count}/${perProjectCap} workItems in 5h window — throttled`);
+                continue;
+            }
+            candidates.push({ workItem, projectPath });
+        }
+        // Enqueue all validated candidates
+        for (const { workItem, projectPath } of candidates) {
+            this.scheduler.enqueue(workItem, projectPath);
+            broadcastEvent({ type: 'workItem:queued', data: { workItemId: workItem.id, title: workItem.title, projectPath, workItemIdentifier: workItem.workItemIdentifier } });
+            this.syslog(`✓ Queued: ${workItem.workItemIdentifier || ''} ${workItem.title} → ${projectPath.split('/').slice(-2).join('/')}`);
+            enqueuedCount++;
+            // Claim the workItem immediately: set Azdo to 'In Progress' so restarts don't re-queue it
+            if (workItem.workItemId) {
+                azdo.updateWorkItemState(workItem.workItemId, 'In Progress').catch((err) => console.warn(`[AutonomousRunner] Failed to claim workItem ${workItem.workItemIdentifier}:`, err));
+            }
+        }
+        if (enqueuedCount === 0 && decision.skippedCount > 0) {
+            this.syslog(`— No new workItems queued (skipped: ${decision.skippedCount})`);
+        }
+        else {
+            this.syslog(`✓ Enqueued ${enqueuedCount} workItem(s) | skipped: ${decision.skippedCount}`);
+        }
+        // Execute workItems
+        await this.runAvailableWorkItems();
+    }
+    /** Execute workItem in pair mode */
+    async executeWorkItemPairMode(workItem) {
+        // Auto-resolve project path
+        const projectPath = await this.resolveProjectPath(workItem);
+        // Error if project path mapping failed
+        if (!projectPath) {
+            const errorMsg = `Failed to resolve project path for "${workItem.azdoProject?.name || workItem.title}"`;
+            console.error(`[AutonomousRunner] ${errorMsg}`);
+            await reportToDiscord(t('runner.projectMappingFailed', { title: workItem.title, project: workItem.azdoProject?.name || 'unknown' }));
+            return;
+        }
+        // Skip if project is not in enabled list (allow-list; empty = nothing runs)
+        if (this.enabledProjects.size > 0 && !this.isProjectEnabled(projectPath)) {
+            console.log(`[AutonomousRunner] Project not enabled, skipping: ${projectPath}`);
+            return;
+        }
+        // Cache azdoProjectName → resolvedPath for dashboard
+        if (workItem.azdoProject?.name) {
+            this.projectPathCache.set(workItem.azdoProject.name, projectPath);
+        }
+        console.log(`[AutonomousRunner] projectPath: ${projectPath}`);
+        // Check workItem decomposition (when enableDecomposition is set)
+        if (this.config.enableDecomposition) {
+            const threshold = this.config.decompositionThresholdMinutes ?? 30;
+            const needsDecomp = planner.needsDecomposition(workItem, threshold);
+            if (needsDecomp) {
+                console.log(`[AutonomousRunner] WorkItem "${workItem.title}" needs decomposition (>${threshold}min estimated)`);
+                const decomposed = await this.decomposeWorkItem(workItem, projectPath, threshold);
+                if (decomposed) {
+                    // Decomposition succeeded - sub-workItems added to queue, skip original workItem
+                    return;
+                }
+                // Decomposition failed - execute original workItem as-is
+                console.log('[AutonomousRunner] Decomposition failed, executing original workItem');
+            }
+        }
+        if (this.shouldDispatchWithPaseo()) {
+            const result = await this.dispatchWithPaseo(workItem, projectPath);
+            await reportToDiscord(formatPipelineResultEmbed(result));
+            return;
+        }
+        // Use scheduler for parallel processing mode
+        if (this.config.maxConcurrentWorkItems && this.config.maxConcurrentWorkItems > 1) {
+            this.scheduler.enqueue(workItem, projectPath);
+            broadcastEvent({ type: 'workItem:queued', data: { workItemId: workItem.id, title: workItem.title, projectPath, workItemIdentifier: workItem.workItemIdentifier } });
+            await this.runAvailableWorkItems();
+            return;
+        }
+        // Single execution (legacy)
+        const result = await this.executePipeline(workItem, projectPath);
+        await reportToDiscord(formatPipelineResultEmbed(result));
+        // Update Azdo workItem state
+        if (workItem.workItemId) {
+            try {
+                if (result.success) {
+                    // On success, move to Done
+                    await execution.syncSuccessState(workItem);
+                    await azdo.logPairComplete(workItem.workItemId, result.sessionId, {
+                        attempts: result.iterations,
+                        duration: Math.floor(result.totalDuration / 1000),
+                        filesChanged: result.executorResult?.filesChanged || [],
+                        executorSummary: result.executorResult?.summary,
+                        executorCommands: result.executorResult?.commands,
+                        reviewerFeedback: result.reviewResult?.feedback,
+                        reviewerDecision: result.reviewResult?.decision,
+                        testResults: result.testerResult ? {
+                            passed: result.testerResult.testsPassed,
+                            failed: result.testerResult.testsFailed,
+                            coverage: result.testerResult.coverage,
+                            failedTests: result.testerResult.failedTests,
+                        } : undefined,
+                    });
+                    await execution.reconcileCompletionState(workItem);
+                    console.log(`[AutonomousRunner] WorkItem ${workItem.workItemId} marked as Done`);
+                }
+                else if (result.finalStatus === 'rejected') {
+                    // Change to Blocked on review rejection
+                    await execution.syncFailureState(workItem, `Review rejected: ${result.reviewResult?.feedback || t('common.fallback.noDescription')}`);
+                    await azdo.logBlocked(workItem.workItemId, 'autonomous-runner', t('runner.reviewRejected', { feedback: result.reviewResult?.feedback || t('common.fallback.noDescription') }));
+                    console.log(`[AutonomousRunner] WorkItem ${workItem.workItemId} marked as Todo (blocked) (rejected)`);
+                }
+                // If failed, keep In Progress (retry on next heartbeat)
+            }
+            catch (err) {
+                console.error(`[AutonomousRunner] Failed to update workItem state:`, err);
+            }
+        }
+    }
+    getExecCtx() {
+        return {
+            allowedProjects: this.config.allowedProjects,
+            plannerModel: this.config.plannerModel,
+            plannerTimeoutMs: this.config.plannerTimeoutMs,
+            pairMaxAttempts: this.config.pairMaxAttempts,
+            enableDecomposition: this.config.enableDecomposition,
+            decompositionThresholdMinutes: this.config.decompositionThresholdMinutes,
+            decompositionMaxDepth: this.config.decomposition?.maxDepth ?? 2,
+            decompositionMaxChildren: this.config.decomposition?.maxChildrenPerWorkItem ?? 5,
+            decompositionDailyLimit: this.config.decomposition?.dailyLimit ?? 20,
+            decompositionAutoBacklog: this.config.decomposition?.autoBacklog ?? true,
+            jobProfiles: this.config.jobProfiles,
+            getRolesForProject: (p) => this.getRolesForProject(p),
+            reportToDiscord,
+            worktreeMode: this.config.worktreeMode ?? false,
+            scheduleNextHeartbeat: () => this.scheduleNextHeartbeat(),
+            guards: this.config.guards,
+        };
+    }
+    async resolveProjectPath(workItem) {
+        return execution.resolveProjectPath(this.getExecCtx(), workItem);
+    }
+    async decomposeWorkItem(workItem, projectPath, targetMinutes) {
+        return execution.decomposeWorkItem(this.getExecCtx(), workItem, projectPath, targetMinutes);
+    }
+    async executePipeline(workItem, projectPath) {
+        return execution.executePipeline(this.getExecCtx(), workItem, projectPath);
+    }
+    async requestApproval(decision) {
+        return execution.requestApproval(decision, reportToDiscord);
+    }
+    async approve() {
+        if (this.executionPaused) {
+            this.syslog('⏸ Execution paused — approval deferred');
+            return false;
+        }
+        if (!this.state.pendingApproval) {
+            return false;
+        }
+        const workItem = this.state.pendingApproval;
+        this.state.pendingApproval = undefined;
+        // Get workflow from Decision Engine
+        const decision = await this.engine.heartbeat([workItem]);
+        if (decision.workflow && decision.workItem) {
+            await this.executeWorkItemPairMode(decision.workItem);
+            return true;
+        }
+        return false;
+    }
+    reject() {
+        if (!this.state.pendingApproval) {
+            return false;
+        }
+        this.state.pendingApproval = undefined;
+        return true;
+    }
+    async runNow() {
+        await this.heartbeat();
+    }
+    getState() {
+        return { ...this.state };
+    }
+    getAllowedProjects() {
+        return this.config.allowedProjects ?? [];
+    }
+    updateAllowedProjects(paths) {
+        this.config.allowedProjects = paths;
+        this.engine.updateAllowedProjects(paths);
+    }
+    getStats() {
+        return { isRunning: this.state.isRunning, lastHeartbeat: this.state.lastHeartbeat,
+            engineStats: this.engine.getStats(), pendingApproval: !!this.state.pendingApproval,
+            schedulerStats: this.scheduler.getStats(),
+            turboMode: this.turboMode,
+            turboExpiresAt: this.turboExpiresAt,
+            dailyPace: getDailyPaceInfo(),
+        };
+    }
+    // ============================================
+    // Turbo Mode
+    // ============================================
+    getTurboMode() {
+        // Auto-expire turbo
+        if (this.turboMode && this.turboExpiresAt && Date.now() >= this.turboExpiresAt) {
+            this.setTurboMode(false);
+        }
+        return this.turboMode;
+    }
+    setTurboMode(enabled) {
+        this.turboMode = enabled;
+        if (enabled) {
+            this.turboExpiresAt = Date.now() + AutonomousRunner.TURBO_DURATION_MS;
+            const expiresIn = Math.round(AutonomousRunner.TURBO_DURATION_MS / 3_600_000);
+            console.log(`[AutonomousRunner] TURBO MODE ON (auto-expires in ${expiresIn}h)`);
+            broadcastEvent({ type: 'log', data: { workItemId: 'system', stage: 'turbo', line: `TURBO ON — expires in ${expiresIn}h` } });
+        }
+        else {
+            this.turboExpiresAt = null;
+            console.log('[AutonomousRunner] TURBO MODE OFF');
+            broadcastEvent({ type: 'log', data: { workItemId: 'system', stage: 'turbo', line: 'TURBO OFF — normal pace resumed' } });
+        }
+    }
+    pauseExecution(reason) {
+        this.executionPaused = true;
+        const msg = reason ? `⏸ Execution paused — ${reason} (in-flight will drain)` : '⏸ Execution paused — new claims blocked (in-flight will drain)';
+        this.syslog(msg);
+        broadcastEvent({ type: 'stats', data: this.buildStats() });
+    }
+    resumeExecution() {
+        this.executionPaused = false;
+        this.syslog('▶ Execution resumed — claiming new work');
+        broadcastEvent({ type: 'stats', data: this.buildStats() });
+    }
+    isExecutionPaused() {
+        return this.executionPaused;
+    }
+    getAdapterSummary() {
+        const defaultAdapter = this.config.defaultAdapter ?? 'claude';
+        const defaultStages = this.config.defaultStages;
+        const getSummary = (stage, baseModel) => {
+            const stageCfg = defaultStages?.[stage];
+            const model = stageCfg?.model ?? baseModel;
+            let adapter = inferProviderFromModel(model);
+            if ((!model || model === 'auto') && stageCfg?.adapter) {
+                adapter = stageCfg.adapter;
+            }
+            return {
+                adapter,
+                model: model ?? baseModel ?? 'auto',
+                enabled: stageCfg?.enabled !== false,
+            };
+        };
+        return {
+            defaultAdapter,
+            coder: getSummary('coder', this.config.executorModel),
+            critic: getSummary('critic', this.config.reviewerModel),
+            tester: defaultStages?.tester ? getSummary('tester') : undefined,
+            documenter: defaultStages?.documenter ? getSummary('documenter') : undefined,
+        };
+    }
+    switchProvider(adapter) {
+        const mapModelForProvider = (model, role) => {
+            const current = model || '';
+            const isClaudeModel = current.startsWith('claude-');
+            // ChatGPT 계정 Codex에서는 gpt-5.x / gpt-*-codex 계열만 지원
+            // o-series (o3, o4-mini 등)는 사용 불가
+            const isCodexCompatible = current.startsWith('gpt-');
+            if (adapter === 'codex') {
+                if (isCodexCompatible)
+                    return current;
+                // 비호환 모델(o-series 포함) → 모델 플래그 생략 → Codex 기본값 사용
+                return '';
+            }
+            if (adapter === 'cursor' || adapter === 'hermes' || adapter === 'opencode' || adapter === 'responses') {
+                return current || 'auto';
+            }
+            if (isClaudeModel)
+                return current;
+            if (role === 'critic')
+                return 'claude-sonnet-4-20250514';
+            return 'claude-haiku-4-5-20251001';
+        };
+        this.config.defaultAdapter = adapter;
+        if (this.config.defaultStages) {
+            this.config.defaultStages.coder = {
+                ...this.config.defaultStages.coder,
+                adapter,
+                model: mapModelForProvider(this.config.defaultStages.coder.model, 'coder'),
+            };
+            this.config.defaultStages.critic = {
+                ...this.config.defaultStages.critic,
+                adapter,
+                model: mapModelForProvider(this.config.defaultStages.critic.model, 'critic'),
+            };
+            if (this.config.defaultStages.tester) {
+                this.config.defaultStages.tester = {
+                    ...this.config.defaultStages.tester,
+                    adapter,
+                    model: mapModelForProvider(this.config.defaultStages.tester.model, 'tester'),
+                };
+            }
+            if (this.config.defaultStages.documenter) {
+                this.config.defaultStages.documenter = {
+                    ...this.config.defaultStages.documenter,
+                    adapter,
+                    model: mapModelForProvider(this.config.defaultStages.documenter.model, 'documenter'),
+                };
+            }
+            if (this.config.defaultStages.auditor) {
+                this.config.defaultStages.auditor = {
+                    ...this.config.defaultStages.auditor,
+                    adapter,
+                    model: mapModelForProvider(this.config.defaultStages.auditor.model, 'auditor'),
+                };
+            }
+            if (this.config.defaultStages['stage-documenter']) {
+                this.config.defaultStages['stage-documenter'] = {
+                    ...this.config.defaultStages['stage-documenter'],
+                    adapter,
+                    model: mapModelForProvider(this.config.defaultStages['stage-documenter'].model, 'stage-documenter'),
+                };
+            }
+        }
+        if (this.config.executorModel) {
+            this.config.executorModel = mapModelForProvider(this.config.executorModel, 'coder');
+        }
+        if (this.config.reviewerModel) {
+            this.config.reviewerModel = mapModelForProvider(this.config.reviewerModel, 'critic');
+        }
+        console.log(`[AutonomousRunner] Provider switched: ${adapter}`);
+    }
+    pauseScheduler() { this.scheduler.pause(); }
+    resumeScheduler() { this.scheduler.resume(); }
+    getQueuedWorkItems() { return this.scheduler.getQueuedWorkItems(); }
+    getRunningWorkItems() { return this.scheduler.getRunningWorkItems(); }
+    getPipelineHistory(limit = 50) { return getPipelineHistory(limit); }
+    recordPipelineHistory(workItem, result) {
+        appendPipelineHistory({
+            sessionId: result.sessionId, workItemIdentifier: workItem.workItemIdentifier || workItem.workItemId,
+            workItemId: workItem.workItemId, workItemTitle: workItem.title, projectName: workItem.azdoProject?.name,
+            projectPath: result.workItemContext?.projectPath, success: result.success,
+            finalStatus: result.finalStatus, iterations: result.iterations,
+            totalDuration: result.totalDuration,
+            stages: result.stages.map(s => ({ stage: s.stage, success: s.success, duration: s.duration })),
+            cost: result.totalCost ? { costUsd: result.totalCost.costUsd,
+                inputTokens: result.totalCost.inputTokens, outputTokens: result.totalCost.outputTokens } : undefined,
+            prUrl: result.prUrl, reviewerFeedback: result.reviewResult?.feedback,
+            completedAt: new Date().toISOString(),
+        });
+    }
+    disableProject(projectPath) {
+        this.enabledProjects.delete(projectPath);
+        console.log(`[AutonomousRunner] Project disabled: ${projectPath}`);
+    }
+    enableProject(projectPath) {
+        this.enabledProjects.add(projectPath);
+        console.log(`[AutonomousRunner] Project enabled: ${projectPath}`);
+    }
+    /** Get all currently enabled project paths */
+    getEnabledProjects() {
+        return Array.from(this.enabledProjects);
+    }
+    /** Get retry backoff info for a workItem/workItem id (if currently in backoff). */
+    getRetryBackoff(workItemOrWorkItemId) {
+        const retryAt = this.failedWorkItemRetryTimes.get(workItemOrWorkItemId);
+        if (!retryAt)
+            return null;
+        const remainingMs = Math.max(0, retryAt - Date.now());
+        if (remainingMs <= 0)
+            return null;
+        return {
+            retryAt,
+            remainingMs,
+            failedCount: this.failedWorkItemCounts.get(workItemOrWorkItemId) ?? 0,
+        };
+    }
+    /** Pre-register project path in cache (name → path) */
+    registerProjectPath(name, projectPath) {
+        if (!this.projectPathCache.has(name)) {
+            this.projectPathCache.set(name, projectPath);
+        }
+        // Also register capitalized variant to handle "enact-factory" ↔ "EnactFactory" mismatch
+        const capitalized = name.charAt(0).toUpperCase() + name.slice(1);
+        if (capitalized !== name && !this.projectPathCache.has(capitalized)) {
+            this.projectPathCache.set(capitalized, projectPath);
+        }
+    }
+    getProjectsInfo() {
+        const running = this.scheduler.getRunningWorkItems();
+        const queued = this.scheduler.getQueuedWorkItems();
+        // Update path cache from currently running workItems
+        for (const r of running) {
+            if (r.workItem.azdoProject?.name)
+                this.projectPathCache.set(r.workItem.azdoProject.name, r.projectPath);
+        }
+        return buildProjectsInfo(this.lastFetchedWorkItems, running, queued, this.projectPathCache, this.enabledProjects);
+    }
+}
+export function getRunner(config) {
+    if (!runnerInstance && config) {
+        runnerInstance = new AutonomousRunner(config);
+    }
+    if (!runnerInstance) {
+        throw new Error('Runner not initialized. Call getRunner with config first.');
+    }
+    return runnerInstance;
+}
+/**
+ * Start runner (convenience function)
+ */
+export async function startAutonomous(config) {
+    const runner = getRunner(config);
+    await runner.start();
+    return runner;
+}
+/**
+ * Stop runner (convenience function)
+ */
+export function stopAutonomous() {
+    if (runnerInstance) {
+        runnerInstance.stop();
+    }
+}
+//# sourceMappingURL=autonomousRunner.js.map