@litmers/cursorflow-orchestrator 0.1.40 → 0.2.2

package/dist/core/lane-state-machine.js

@@ -0,0 +1,890 @@
+"use strict";
+/**
+ * Lane State Machine
+ *
+ * Lane의 생명주기를 세분화된 상태로 관리하는 상태 머신입니다.
+ *
+ * 핵심 원칙:
+ * 1. 명시적 상태 전이 (Explicit State Transitions)
+ * 2. 단일 상태 저장소 (Single Source of Truth)
+ * 3. 상태 전이 검증 (Transition Validation)
+ * 4. 복구/재시도 로직 중앙화 (Centralized Recovery)
+ *
+ * 상태 계층:
+ * - 주 상태 (Primary State): Lane의 기본 상태 (pending, running, completed 등)
+ * - 부 상태 (Sub State): 세부 작업 상태 (preparing_git, executing_task 등)
+ * - 복구 상태 (Recovery State): 복구 진행 상태 (idle, monitoring, recovering 등)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaneStateMachine = exports.StateTransitionTrigger = exports.RecoveryState = exports.LaneSubState = exports.LanePrimaryState = void 0;
+exports.getStateMachine = getStateMachine;
+exports.resetStateMachine = resetStateMachine;
+exports.primaryStateToLaneStatus = primaryStateToLaneStatus;
+const fs = __importStar(require("fs"));
+const events_1 = require("../utils/events");
+const path_1 = require("../utils/path");
+const logger = __importStar(require("../utils/logger"));
+const event_categories_1 = require("../types/event-categories");
+// ============================================================================
+// State Definitions (상태 정의)
+// ============================================================================
+/**
+ * Lane 주 상태 (Primary State)
+ *
+ * 상태 전이 규칙:
+ * - PENDING → INITIALIZING → RUNNING → COMPLETED | FAILED
+ * - RUNNING ↔ WAITING (의존성 대기)
+ * - RUNNING ↔ PAUSED (사용자 요청)
+ * - RUNNING → RECOVERING → RUNNING | FAILED
+ * - * → ABORTED (강제 중단)
+ */
+var LanePrimaryState;
+(function (LanePrimaryState) {
+    /** 대기 중 - 아직 시작되지 않음 */
+    LanePrimaryState["PENDING"] = "pending";
+    /** 초기화 중 - 워크트리/브랜치 준비 */
+    LanePrimaryState["INITIALIZING"] = "initializing";
+    /** 실행 중 */
+    LanePrimaryState["RUNNING"] = "running";
+    /** 의존성 대기 중 */
+    LanePrimaryState["WAITING"] = "waiting";
+    /** 일시 중지 */
+    LanePrimaryState["PAUSED"] = "paused";
+    /** 복구 중 */
+    LanePrimaryState["RECOVERING"] = "recovering";
+    /** 완료 */
+    LanePrimaryState["COMPLETED"] = "completed";
+    /** 실패 */
+    LanePrimaryState["FAILED"] = "failed";
+    /** 강제 중단 */
+    LanePrimaryState["ABORTED"] = "aborted";
+})(LanePrimaryState || (exports.LanePrimaryState = LanePrimaryState = {}));
+/**
+ * Lane 부 상태 (Sub State) - RUNNING 상태의 세부 단계
+ */
+var LaneSubState;
+(function (LaneSubState) {
+    /** 없음 (비실행 상태) */
+    LaneSubState["NONE"] = "none";
+    // --- Git 관련 ---
+    /** Git 워크트리 준비 */
+    LaneSubState["PREPARING_GIT"] = "preparing_git";
+    /** 의존성 브랜치 머지 */
+    LaneSubState["MERGING_DEPENDENCIES"] = "merging_dependencies";
+    /** Task 브랜치 생성 */
+    LaneSubState["CREATING_TASK_BRANCH"] = "creating_task_branch";
+    /** 변경사항 커밋 */
+    LaneSubState["COMMITTING"] = "committing";
+    /** 푸시 */
+    LaneSubState["PUSHING"] = "pushing";
+    /** 머지 */
+    LaneSubState["MERGING"] = "merging";
+    // --- Task 관련 ---
+    /** Task 실행 준비 */
+    LaneSubState["PREPARING_TASK"] = "preparing_task";
+    /** AI 에이전트와 통신 중 */
+    LaneSubState["EXECUTING_AGENT"] = "executing_agent";
+    /** Task 실행 완료 처리 */
+    LaneSubState["FINALIZING_TASK"] = "finalizing_task";
+    // --- 대기 관련 ---
+    /** 의존성 완료 대기 */
+    LaneSubState["WAITING_DEPENDENCY"] = "waiting_dependency";
+    /** 사용자 입력 대기 */
+    LaneSubState["WAITING_USER_INPUT"] = "waiting_user_input";
+    /** Rate limit 대기 */
+    LaneSubState["WAITING_RATE_LIMIT"] = "waiting_rate_limit";
+})(LaneSubState || (exports.LaneSubState = LaneSubState = {}));
+/**
+ * 복구 상태 (Recovery State)
+ */
+var RecoveryState;
+(function (RecoveryState) {
+    /** 복구 필요 없음 */
+    RecoveryState["IDLE"] = "idle";
+    /** 모니터링 중 (Stall 감지) */
+    RecoveryState["MONITORING"] = "monitoring";
+    /** Continue 신호 발송됨 */
+    RecoveryState["CONTINUE_SENT"] = "continue_sent";
+    /** Stronger prompt 발송됨 */
+    RecoveryState["STRONGER_PROMPT_SENT"] = "stronger_prompt_sent";
+    /** 재시작 요청됨 */
+    RecoveryState["RESTART_REQUESTED"] = "restart_requested";
+    /** 진단 실행됨 */
+    RecoveryState["DIAGNOSED"] = "diagnosed";
+    /** 복구 포기 */
+    RecoveryState["EXHAUSTED"] = "exhausted";
+})(RecoveryState || (exports.RecoveryState = RecoveryState = {}));
+// ============================================================================
+// State Transition Triggers (상태 전이 트리거)
+// ============================================================================
+/**
+ * 상태 전이를 발생시키는 트리거
+ */
+var StateTransitionTrigger;
+(function (StateTransitionTrigger) {
+    // --- Lifecycle Triggers ---
+    /** Lane 시작 */
+    StateTransitionTrigger["START"] = "start";
+    /** 초기화 완료 */
+    StateTransitionTrigger["INITIALIZED"] = "initialized";
+    /** Task 완료 */
+    StateTransitionTrigger["TASK_COMPLETED"] = "task_completed";
+    /** 모든 Task 완료 */
+    StateTransitionTrigger["ALL_TASKS_COMPLETED"] = "all_tasks_completed";
+    /** 실패 발생 */
+    StateTransitionTrigger["FAILURE"] = "failure";
+    /** 강제 중단 요청 */
+    StateTransitionTrigger["ABORT"] = "abort";
+    // --- Dependency Triggers ---
+    /** 의존성 대기 시작 */
+    StateTransitionTrigger["WAIT_DEPENDENCY"] = "wait_dependency";
+    /** 의존성 해결됨 */
+    StateTransitionTrigger["DEPENDENCY_RESOLVED"] = "dependency_resolved";
+    /** 의존성 타임아웃 */
+    StateTransitionTrigger["DEPENDENCY_TIMEOUT"] = "dependency_timeout";
+    /** 의존성 실패 */
+    StateTransitionTrigger["DEPENDENCY_FAILED"] = "dependency_failed";
+    // --- Pause/Resume Triggers ---
+    /** 일시 중지 요청 */
+    StateTransitionTrigger["PAUSE"] = "pause";
+    /** 재개 요청 */
+    StateTransitionTrigger["RESUME"] = "resume";
+    // --- Recovery Triggers ---
+    /** 복구 시작 */
+    StateTransitionTrigger["RECOVERY_START"] = "recovery_start";
+    /** 복구 성공 */
+    StateTransitionTrigger["RECOVERY_SUCCESS"] = "recovery_success";
+    /** 복구 실패 */
+    StateTransitionTrigger["RECOVERY_FAILED"] = "recovery_failed";
+    /** Stall 감지 */
+    StateTransitionTrigger["STALL_DETECTED"] = "stall_detected";
+    /** Continue 신호 발송 */
+    StateTransitionTrigger["CONTINUE_SIGNAL_SENT"] = "continue_signal_sent";
+    /** Stronger prompt 발송 */
+    StateTransitionTrigger["STRONGER_PROMPT_SENT"] = "stronger_prompt_sent";
+    /** 재시작 요청 */
+    StateTransitionTrigger["RESTART_REQUESTED"] = "restart_requested";
+    /** 진단 완료 */
+    StateTransitionTrigger["DIAGNOSIS_COMPLETE"] = "diagnosis_complete";
+    // --- Sub-state Triggers ---
+    /** Git 작업 시작 */
+    StateTransitionTrigger["GIT_START"] = "git_start";
+    /** Git 작업 완료 */
+    StateTransitionTrigger["GIT_COMPLETE"] = "git_complete";
+    /** Task 실행 시작 */
+    StateTransitionTrigger["TASK_START"] = "task_start";
+    /** Agent 통신 시작 */
+    StateTransitionTrigger["AGENT_START"] = "agent_start";
+    /** Agent 응답 수신 */
+    StateTransitionTrigger["AGENT_RESPONSE"] = "agent_response";
+})(StateTransitionTrigger || (exports.StateTransitionTrigger = StateTransitionTrigger = {}));
+/**
+ * 상태 전이 규칙 테이블
+ */
+const TRANSITION_RULES = [
+    // --- 시작 및 초기화 ---
+    { from: LanePrimaryState.PENDING, to: LanePrimaryState.INITIALIZING, trigger: StateTransitionTrigger.START },
+    { from: LanePrimaryState.INITIALIZING, to: LanePrimaryState.RUNNING, trigger: StateTransitionTrigger.INITIALIZED },
+    { from: LanePrimaryState.INITIALIZING, to: LanePrimaryState.FAILED, trigger: StateTransitionTrigger.FAILURE },
+    // --- 실행 중 → 완료/실패 ---
+    { from: LanePrimaryState.RUNNING, to: LanePrimaryState.COMPLETED, trigger: StateTransitionTrigger.ALL_TASKS_COMPLETED },
+    { from: LanePrimaryState.RUNNING, to: LanePrimaryState.FAILED, trigger: StateTransitionTrigger.FAILURE },
+    // --- 의존성 대기 ---
+    { from: LanePrimaryState.RUNNING, to: LanePrimaryState.WAITING, trigger: StateTransitionTrigger.WAIT_DEPENDENCY },
+    { from: LanePrimaryState.WAITING, to: LanePrimaryState.RUNNING, trigger: StateTransitionTrigger.DEPENDENCY_RESOLVED },
+    { from: LanePrimaryState.WAITING, to: LanePrimaryState.FAILED, trigger: StateTransitionTrigger.DEPENDENCY_TIMEOUT },
+    { from: LanePrimaryState.WAITING, to: LanePrimaryState.FAILED, trigger: StateTransitionTrigger.DEPENDENCY_FAILED },
+    // --- 일시 중지/재개 ---
+    { from: LanePrimaryState.RUNNING, to: LanePrimaryState.PAUSED, trigger: StateTransitionTrigger.PAUSE },
+    { from: LanePrimaryState.WAITING, to: LanePrimaryState.PAUSED, trigger: StateTransitionTrigger.PAUSE },
+    { from: LanePrimaryState.PAUSED, to: LanePrimaryState.RUNNING, trigger: StateTransitionTrigger.RESUME },
+    // --- 복구 ---
+    { from: LanePrimaryState.RUNNING, to: LanePrimaryState.RECOVERING, trigger: StateTransitionTrigger.RECOVERY_START },
+    { from: LanePrimaryState.RECOVERING, to: LanePrimaryState.RUNNING, trigger: StateTransitionTrigger.RECOVERY_SUCCESS },
+    { from: LanePrimaryState.RECOVERING, to: LanePrimaryState.FAILED, trigger: StateTransitionTrigger.RECOVERY_FAILED },
+    // --- 강제 중단 (모든 상태에서 가능) ---
+    {
+        from: [
+            LanePrimaryState.PENDING,
+            LanePrimaryState.INITIALIZING,
+            LanePrimaryState.RUNNING,
+            LanePrimaryState.WAITING,
+            LanePrimaryState.PAUSED,
+            LanePrimaryState.RECOVERING,
+        ],
+        to: LanePrimaryState.ABORTED,
+        trigger: StateTransitionTrigger.ABORT
+    },
+];
+// ============================================================================
+// Lane State Machine
+// ============================================================================
+/**
+ * Lane 상태 머신
+ *
+ * 사용 예:
+ * ```typescript
+ * const sm = LaneStateMachine.getInstance();
+ *
+ * // Lane 등록
+ * sm.registerLane('lane-1', 'run-123', {
+ *   totalTasks: 5,
+ *   pipelineBranch: 'cursorflow/pipeline/lane-1'
+ * });
+ *
+ * // 상태 전이
+ * sm.transition('lane-1', StateTransitionTrigger.START);
+ * sm.transition('lane-1', StateTransitionTrigger.INITIALIZED);
+ *
+ * // 부 상태 업데이트
+ * sm.setSubState('lane-1', LaneSubState.EXECUTING_AGENT);
+ *
+ * // 상태 조회
+ * const ctx = sm.getContext('lane-1');
+ * console.log(ctx.primaryState, ctx.subState);
+ * ```
+ */
+class LaneStateMachine {
+    static instance = null;
+    /** Lane별 상태 컨텍스트 */
+    contexts = new Map();
+    /** 상태 히스토리 (디버깅/감사용) */
+    history = new Map();
+    /** 상태 변경 콜백 */
+    onTransitionCallbacks = [];
+    /** 디버그 모드 */
+    verbose = false;
+    constructor() {
+        this.verbose = process.env['DEBUG_STATE'] === 'true';
+    }
+    /**
+     * 싱글톤 인스턴스 획득
+     */
+    static getInstance() {
+        if (!LaneStateMachine.instance) {
+            LaneStateMachine.instance = new LaneStateMachine();
+        }
+        return LaneStateMachine.instance;
+    }
+    /**
+     * 인스턴스 리셋 (테스트용)
+     */
+    static resetInstance() {
+        LaneStateMachine.instance = null;
+    }
+    // --------------------------------------------------------------------------
+    // Lane Registration
+    // --------------------------------------------------------------------------
+    /**
+     * Lane 등록
+     */
+    registerLane(laneName, runId, options = {}) {
+        const now = Date.now();
+        const context = {
+            laneName,
+            runId,
+            primaryState: LanePrimaryState.PENDING,
+            subState: LaneSubState.NONE,
+            recoveryState: RecoveryState.IDLE,
+            currentTaskIndex: 0,
+            totalTasks: options.totalTasks || 0,
+            completedTasks: [],
+            restartCount: 0,
+            startTime: now,
+            lastTransitionTime: now,
+            pipelineBranch: options.pipelineBranch,
+            worktreeDir: options.worktreeDir,
+            metadata: options.metadata,
+        };
+        this.contexts.set(laneName, context);
+        this.history.set(laneName, []);
+        this.log(`[${laneName}] Registered (runId: ${runId}, tasks: ${options.totalTasks || 0})`);
+        return context;
+    }
+    /**
+     * Lane 해제
+     */
+    unregisterLane(laneName) {
+        this.contexts.delete(laneName);
+        this.history.delete(laneName);
+        this.log(`[${laneName}] Unregistered`);
+    }
+    /**
+     * Lane 컨텍스트 조회
+     */
+    getContext(laneName) {
+        return this.contexts.get(laneName);
+    }
+    /**
+     * 모든 Lane 컨텍스트 조회
+     */
+    getAllContexts() {
+        return new Map(this.contexts);
+    }
+    // --------------------------------------------------------------------------
+    // State Transitions
+    // --------------------------------------------------------------------------
+    /**
+     * 상태 전이 실행
+     */
+    transition(laneName, trigger, options = {}) {
+        const context = this.contexts.get(laneName);
+        if (!context) {
+            return {
+                success: false,
+                fromState: LanePrimaryState.PENDING,
+                toState: LanePrimaryState.PENDING,
+                trigger,
+                error: `Lane not found: ${laneName}`,
+            };
+        }
+        const currentState = context.primaryState;
+        // 전이 규칙 찾기
+        const rule = this.findTransitionRule(currentState, trigger);
+        if (!rule && !options.force) {
+            const result = {
+                success: false,
+                fromState: currentState,
+                toState: currentState,
+                trigger,
+                error: `Invalid transition: ${currentState} + ${trigger}`,
+            };
+            this.emitTransitionFailed(laneName, context, trigger, result.error);
+            return result;
+        }
+        const targetState = rule?.to || currentState;
+        // Guard 체크
+        if (rule?.guard && !rule.guard(context)) {
+            const result = {
+                success: false,
+                fromState: currentState,
+                toState: currentState,
+                trigger,
+                error: 'Transition guard failed',
+            };
+            this.emitTransitionFailed(laneName, context, trigger, result.error);
+            return result;
+        }
+        // 상태 전이 실행
+        const previousState = context.primaryState;
+        context.primaryState = targetState;
+        context.lastTransitionTime = Date.now();
+        // 오류 정보 업데이트
+        if (options.error) {
+            context.lastError = options.error;
+        }
+        // 종료 상태 처리
+        if (this.isTerminalState(targetState)) {
+            context.endTime = Date.now();
+        }
+        // 부 상태 리셋 (필요한 경우)
+        if (this.shouldResetSubState(previousState, targetState)) {
+            context.subState = LaneSubState.NONE;
+        }
+        // 히스토리 기록
+        const historyEntry = {
+            timestamp: Date.now(),
+            fromState: previousState,
+            toState: targetState,
+            trigger,
+        };
+        this.history.get(laneName)?.push(historyEntry);
+        // 콜백 및 이벤트 발행
+        const result = {
+            success: true,
+            fromState: previousState,
+            toState: targetState,
+            trigger,
+        };
+        rule?.onTransition?.(context);
+        this.notifyTransition(laneName, result);
+        this.emitTransition(laneName, context, previousState, trigger);
+        this.log(`[${laneName}] ${previousState} → ${targetState} (trigger: ${trigger})`);
+        return result;
+    }
+    /**
+     * 전이 규칙 찾기
+     */
+    findTransitionRule(currentState, trigger) {
+        return TRANSITION_RULES.find(rule => {
+            const fromStates = Array.isArray(rule.from) ? rule.from : [rule.from];
+            return fromStates.includes(currentState) && rule.trigger === trigger;
+        });
+    }
+    /**
+     * 종료 상태인지 확인
+     */
+    isTerminalState(state) {
+        return [
+            LanePrimaryState.COMPLETED,
+            LanePrimaryState.FAILED,
+            LanePrimaryState.ABORTED,
+        ].includes(state);
+    }
+    /**
+     * 부 상태 리셋 필요 여부
+     */
+    shouldResetSubState(from, to) {
+        // RUNNING을 벗어날 때 부 상태 리셋
+        return from === LanePrimaryState.RUNNING && to !== LanePrimaryState.RUNNING;
+    }
+    // --------------------------------------------------------------------------
+    // Sub-State Management
+    // --------------------------------------------------------------------------
+    /**
+     * 부 상태 설정
+     */
+    setSubState(laneName, subState) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        const previousSubState = context.subState;
+        context.subState = subState;
+        this.log(`[${laneName}] SubState: ${previousSubState} → ${subState}`);
+        return true;
+    }
+    /**
+     * 부 상태 조회
+     */
+    getSubState(laneName) {
+        return this.contexts.get(laneName)?.subState || LaneSubState.NONE;
+    }
+    // --------------------------------------------------------------------------
+    // Recovery State Management
+    // --------------------------------------------------------------------------
+    /**
+     * 복구 상태 설정
+     */
+    setRecoveryState(laneName, recoveryState) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        const previousState = context.recoveryState;
+        context.recoveryState = recoveryState;
+        this.log(`[${laneName}] RecoveryState: ${previousState} → ${recoveryState}`);
+        return true;
+    }
+    /**
+     * 복구 상태 조회
+     */
+    getRecoveryState(laneName) {
+        return this.contexts.get(laneName)?.recoveryState || RecoveryState.IDLE;
+    }
+    /**
+     * 재시작 횟수 증가
+     */
+    incrementRestartCount(laneName) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return 0;
+        context.restartCount++;
+        return context.restartCount;
+    }
+    // --------------------------------------------------------------------------
+    // Context Updates
+    // --------------------------------------------------------------------------
+    /**
+     * Task 진행 상황 업데이트
+     */
+    updateTaskProgress(laneName, taskIndex, taskName, taskBranch) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        context.currentTaskIndex = taskIndex;
+        if (taskName)
+            context.currentTaskName = taskName;
+        if (taskBranch)
+            context.taskBranch = taskBranch;
+        return true;
+    }
+    /**
+     * Task 완료 기록
+     */
+    recordTaskCompletion(laneName, taskName) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        if (!context.completedTasks.includes(taskName)) {
+            context.completedTasks.push(taskName);
+        }
+        return true;
+    }
+    /**
+     * 대기 중인 의존성 설정
+     */
+    setWaitingFor(laneName, dependencies) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        context.waitingFor = dependencies;
+        return true;
+    }
+    /**
+     * 오류 설정
+     */
+    setError(laneName, error) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        context.lastError = error;
+        return true;
+    }
+    /**
+     * 프로세스 ID 설정
+     */
+    setPid(laneName, pid) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        context.pid = pid;
+        return true;
+    }
+    /**
+     * 채팅 세션 ID 설정
+     */
+    setChatId(laneName, chatId) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        context.chatId = chatId;
+        return true;
+    }
+    /**
+     * 메타데이터 업데이트
+     */
+    updateMetadata(laneName, metadata) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        context.metadata = { ...context.metadata, ...metadata };
+        return true;
+    }
+    // --------------------------------------------------------------------------
+    // State Persistence
+    // --------------------------------------------------------------------------
+    /**
+     * 상태를 파일로 저장
+     */
+    persistState(laneName, stateDir) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return false;
+        const statePath = (0, path_1.safeJoin)(stateDir, 'state.json');
+        // LaneState 형식으로 변환 (기존 호환성)
+        const laneState = this.contextToLaneState(context);
+        try {
+            const stateParent = require('path').dirname(statePath);
+            if (!fs.existsSync(stateParent)) {
+                fs.mkdirSync(stateParent, { recursive: true });
+            }
+            const tempPath = `${statePath}.tmp.${process.pid}`;
+            fs.writeFileSync(tempPath, JSON.stringify(laneState, null, 2), 'utf8');
+            fs.renameSync(tempPath, statePath);
+            events_1.events.emit(event_categories_1.StateEventType.PERSISTED, {
+                laneName,
+                filePath: statePath,
+            });
+            return true;
+        }
+        catch (error) {
+            logger.error(`[StateMachine] Failed to persist state for ${laneName}: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * 파일에서 상태 복구
+     */
+    restoreState(laneName, runId, stateDir) {
+        const statePath = (0, path_1.safeJoin)(stateDir, 'state.json');
+        if (!fs.existsSync(statePath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(statePath, 'utf8');
+            const laneState = JSON.parse(content);
+            // LaneState에서 컨텍스트로 변환
+            const context = this.laneStateToContext(laneName, runId, laneState);
+            this.contexts.set(laneName, context);
+            this.history.set(laneName, []);
+            events_1.events.emit(event_categories_1.StateEventType.RESTORED, {
+                laneName,
+                filePath: statePath,
+                state: laneState,
+            });
+            this.log(`[${laneName}] State restored from ${statePath}`);
+            return context;
+        }
+        catch (error) {
+            logger.error(`[StateMachine] Failed to restore state for ${laneName}: ${error.message}`);
+            events_1.events.emit(event_categories_1.StateEventType.CORRUPTED, {
+                laneName,
+                filePath: statePath,
+                issues: [error.message],
+            });
+            return null;
+        }
+    }
+    /**
+     * 컨텍스트를 기존 LaneState 형식으로 변환
+     */
+    contextToLaneState(context) {
+        return {
+            label: context.laneName,
+            status: context.primaryState,
+            currentTaskIndex: context.currentTaskIndex,
+            totalTasks: context.totalTasks,
+            worktreeDir: context.worktreeDir || null,
+            pipelineBranch: context.pipelineBranch || null,
+            startTime: context.startTime,
+            endTime: context.endTime || null,
+            error: context.lastError || null,
+            dependencyRequest: null,
+            updatedAt: Date.now(),
+            tasksFile: context.metadata?.tasksFile,
+            pid: context.pid,
+            completedTasks: context.completedTasks,
+            waitingFor: context.waitingFor,
+            chatId: context.chatId,
+            // 확장 필드
+            subState: context.subState,
+            recoveryState: context.recoveryState,
+            restartCount: context.restartCount,
+            currentTaskName: context.currentTaskName,
+            taskBranch: context.taskBranch,
+        };
+    }
+    /**
+     * 기존 LaneState에서 컨텍스트로 변환
+     */
+    laneStateToContext(laneName, runId, laneState) {
+        return {
+            laneName,
+            runId,
+            primaryState: laneState.status || LanePrimaryState.PENDING,
+            subState: laneState.subState || LaneSubState.NONE,
+            recoveryState: laneState.recoveryState || RecoveryState.IDLE,
+            currentTaskIndex: laneState.currentTaskIndex || 0,
+            totalTasks: laneState.totalTasks || 0,
+            completedTasks: laneState.completedTasks || [],
+            currentTaskName: laneState.currentTaskName,
+            waitingFor: laneState.waitingFor,
+            lastError: laneState.error,
+            restartCount: laneState.restartCount || 0,
+            startTime: laneState.startTime || Date.now(),
+            endTime: laneState.endTime,
+            lastTransitionTime: laneState.updatedAt || Date.now(),
+            worktreeDir: laneState.worktreeDir,
+            pipelineBranch: laneState.pipelineBranch,
+            taskBranch: laneState.taskBranch,
+            pid: laneState.pid,
+            chatId: laneState.chatId,
+            metadata: {
+                tasksFile: laneState.tasksFile,
+            },
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Event Handling
+    // --------------------------------------------------------------------------
+    /**
+     * 상태 전이 콜백 등록
+     */
+    onTransition(callback) {
+        this.onTransitionCallbacks.push(callback);
+        return () => {
+            const index = this.onTransitionCallbacks.indexOf(callback);
+            if (index > -1) {
+                this.onTransitionCallbacks.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * 전이 콜백 실행
+     */
+    notifyTransition(laneName, result) {
+        for (const callback of this.onTransitionCallbacks) {
+            try {
+                callback(laneName, result);
+            }
+            catch (error) {
+                logger.error(`[StateMachine] Callback error: ${error}`);
+            }
+        }
+    }
+    /**
+     * 전이 이벤트 발행
+     */
+    emitTransition(laneName, context, fromState, trigger) {
+        const payload = {
+            laneName,
+            fromState,
+            toState: context.primaryState,
+            trigger,
+            timestamp: Date.now(),
+        };
+        events_1.events.emit(event_categories_1.StateEventType.TRANSITION, payload);
+    }
+    /**
+     * 전이 실패 이벤트 발행
+     */
+    emitTransitionFailed(laneName, context, trigger, reason) {
+        const payload = {
+            laneName,
+            fromState: context.primaryState,
+            attemptedState: 'unknown',
+            trigger,
+            reason,
+        };
+        events_1.events.emit(event_categories_1.StateEventType.TRANSITION_FAILED, payload);
+    }
+    // --------------------------------------------------------------------------
+    // Query Methods
+    // --------------------------------------------------------------------------
+    /**
+     * 특정 상태의 Lane들 조회
+     */
+    getLanesInState(state) {
+        const result = [];
+        for (const [laneName, context] of this.contexts) {
+            if (context.primaryState === state) {
+                result.push(laneName);
+            }
+        }
+        return result;
+    }
+    /**
+     * 활성 상태 Lane들 조회 (종료되지 않은)
+     */
+    getActiveLanes() {
+        const result = [];
+        for (const [laneName, context] of this.contexts) {
+            if (!this.isTerminalState(context.primaryState)) {
+                result.push(laneName);
+            }
+        }
+        return result;
+    }
+    /**
+     * 전이 히스토리 조회
+     */
+    getHistory(laneName) {
+        return this.history.get(laneName) || [];
+    }
+    /**
+     * 전체 상태 요약 조회
+     */
+    getSummary() {
+        const summary = {};
+        for (const state of Object.values(LanePrimaryState)) {
+            summary[state] = 0;
+        }
+        for (const context of this.contexts.values()) {
+            summary[context.primaryState]++;
+        }
+        return summary;
+    }
+    // --------------------------------------------------------------------------
+    // Utility
+    // --------------------------------------------------------------------------
+    /**
+     * 로깅
+     */
+    log(message) {
+        if (this.verbose) {
+            logger.debug(`[StateMachine] ${message}`);
+        }
+    }
+    /**
+     * 디버그 모드 설정
+     */
+    setVerbose(verbose) {
+        this.verbose = verbose;
+    }
+    /**
+     * 디버그 덤프
+     */
+    dumpState(laneName) {
+        const context = this.contexts.get(laneName);
+        if (!context)
+            return `Lane not found: ${laneName}`;
+        return JSON.stringify({
+            ...context,
+            historyLength: this.history.get(laneName)?.length || 0,
+        }, null, 2);
+    }
+}
+exports.LaneStateMachine = LaneStateMachine;
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * 싱글톤 인스턴스 획득
+ */
+function getStateMachine() {
+    return LaneStateMachine.getInstance();
+}
+/**
+ * 인스턴스 리셋 (테스트용)
+ */
+function resetStateMachine() {
+    LaneStateMachine.resetInstance();
+}
+/**
+ * LanePrimaryState를 기존 LaneStatus로 변환 (호환성)
+ */
+function primaryStateToLaneStatus(state) {
+    switch (state) {
+        case LanePrimaryState.PENDING:
+        case LanePrimaryState.INITIALIZING:
+            return 'pending';
+        case LanePrimaryState.RUNNING:
+            return 'running';
+        case LanePrimaryState.WAITING:
+            return 'waiting';
+        case LanePrimaryState.PAUSED:
+            return 'paused';
+        case LanePrimaryState.RECOVERING:
+            return 'running'; // 복구 중은 running으로 표시
+        case LanePrimaryState.COMPLETED:
+            return 'completed';
+        case LanePrimaryState.FAILED:
+        case LanePrimaryState.ABORTED:
+            return 'failed';
+        default:
+            return 'unknown';
+    }
+}
+//# sourceMappingURL=lane-state-machine.js.map