maestro-flow 0.1.4 → 0.2.1

package/dashboard/dist-server/src/server/execution/execution-scheduler.js

@@ -0,0 +1,1101 @@
+// ---------------------------------------------------------------------------
+// ExecutionScheduler — orchestrates issue execution via agent processes
+// ---------------------------------------------------------------------------
+import { join } from 'node:path';
+import { readIssuesJsonl, writeIssuesJsonl, withIssueWriteLock } from '../utils/issue-store.js';
+import { DEFAULT_SCHEDULER_CONFIG } from '../../shared/execution-types.js';
+import { WorkspaceManager } from './workspace-manager.js';
+import { PromptRegistry } from '../prompt/prompt-registry.js';
+import { PriorityStrategy } from './strategies/priority-strategy.js';
+import { SmartStrategy } from './strategies/smart-strategy.js';
+import { GraphWalkerFactory } from '../coordinator/graph-walker-factory.js';
+import { WalkerEventBridge } from '../coordinator/walker-event-bridge.js';
+// ---------------------------------------------------------------------------
+// Valid agent types for input validation
+// ---------------------------------------------------------------------------
+const VALID_EXECUTORS = new Set([
+    'claude-code', 'codex', 'codex-server', 'gemini', 'gemini-a2a', 'qwen', 'opencode', 'agent-sdk',
+]);
+// ---------------------------------------------------------------------------
+// ExecutionScheduler
+// ---------------------------------------------------------------------------
+export class ExecutionScheduler {
+    agentManager;
+    eventBus;
+    jsonlPath;
+    journal;
+    runningSlots = new Map();
+    queue = [];
+    retryQueue = new Map();
+    claimed = new Set();
+    config;
+    workspaceManager;
+    promptRegistry;
+    tickTimer = null;
+    lastTickAt = null;
+    stats = { totalDispatched: 0, totalCompleted: 0, totalFailed: 0 };
+    tokenUsage = { totalInputTokens: 0, totalOutputTokens: 0 };
+    strategies = new Map();
+    activeStrategy;
+    selfLearningService;
+    isDispatching = false;
+    isCommanderActive = false;
+    // Factory for GraphWalker instances (shared across dispatchViaChain calls)
+    factory;
+    constructor(agentManager, eventBus, jsonlPath, config, promptRegistry, journal, selfLearningService) {
+        this.agentManager = agentManager;
+        this.eventBus = eventBus;
+        this.jsonlPath = jsonlPath;
+        this.journal = journal;
+        this.config = { ...DEFAULT_SCHEDULER_CONFIG, ...config };
+        this.factory = new GraphWalkerFactory();
+        this.promptRegistry = promptRegistry ?? PromptRegistry.createDefault();
+        this.selfLearningService = selfLearningService;
+        // Initialize workspace manager if enabled
+        const ws = this.config.workspace;
+        this.workspaceManager = ws.enabled
+            ? new WorkspaceManager(process.cwd(), {
+                useWorktree: ws.useWorktree,
+                autoCleanup: ws.autoCleanup,
+            })
+            : null;
+        // Register built-in dispatch strategies
+        const priorityStrategy = new PriorityStrategy();
+        const smartStrategy = new SmartStrategy();
+        this.strategies.set(priorityStrategy.name, priorityStrategy);
+        this.strategies.set(smartStrategy.name, smartStrategy);
+        this.activeStrategy = this.strategies.get(this.config.strategy) ?? priorityStrategy;
+        this.subscribeToAgentEvents();
+        // Recover state from persisted issues on startup
+        void this.recoverState();
+    }
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+    /** Dispatch a single issue for execution */
+    async executeIssue(issueId, executor) {
+        if (this.isDispatching) {
+            console.warn(`[Execution] executeIssue(${issueId}) called while tick dispatch in progress, skipping to avoid conflict`);
+            return;
+        }
+        if (!this.claim(issueId))
+            return;
+        if (executor && !VALID_EXECUTORS.has(executor)) {
+            this.claimed.delete(issueId);
+            throw new Error(`Invalid executor: ${executor}`);
+        }
+        const issue = await this.findIssue(issueId);
+        if (!issue) {
+            this.claimed.delete(issueId);
+            throw new Error(`Issue not found: ${issueId}`);
+        }
+        const resolvedExecutor = executor ?? issue.executor ?? this.config.defaultExecutor;
+        await this.dispatch(issue, resolvedExecutor);
+    }
+    /** Enqueue multiple issues for batch execution */
+    async executeBatch(issueIds, executor, maxConcurrency) {
+        if (executor && !VALID_EXECUTORS.has(executor)) {
+            throw new Error(`Invalid executor: ${executor}`);
+        }
+        const concurrency = maxConcurrency ?? this.config.maxConcurrentAgents;
+        const unclaimed = issueIds.filter((id) => this.claim(id));
+        // Fill available slots immediately, rest goes to queue
+        const availableSlots = concurrency - this.runningSlots.size;
+        const immediate = unclaimed.slice(0, Math.max(0, availableSlots));
+        const queued = unclaimed.slice(Math.max(0, availableSlots));
+        this.queue.push(...queued);
+        // Update queued issues' execution state
+        for (const id of queued) {
+            await this.updateIssueFields(id, {
+                execution: { status: 'queued', retryCount: 0 },
+            });
+        }
+        // Dispatch immediate batch
+        for (const id of immediate) {
+            const issue = await this.findIssue(id);
+            if (issue) {
+                const resolvedExecutor = executor ?? issue.executor ?? this.config.defaultExecutor;
+                await this.dispatch(issue, resolvedExecutor);
+            }
+        }
+    }
+    /** Cancel a running or queued issue */
+    async cancelIssue(issueId) {
+        // Remove from queue
+        const queueIdx = this.queue.indexOf(issueId);
+        if (queueIdx >= 0)
+            this.queue.splice(queueIdx, 1);
+        // Remove from retry queue
+        this.retryQueue.delete(issueId);
+        // Stop running agent
+        for (const [processId, slot] of this.runningSlots) {
+            if (slot.issueId === issueId) {
+                await this.agentManager.stop(processId).catch((err) => {
+                    console.warn(`[Execution] Failed to stop agent ${processId}:`, err);
+                });
+                this.runningSlots.delete(processId);
+                break;
+            }
+        }
+        this.claimed.delete(issueId);
+        await this.updateIssueFields(issueId, {
+            execution: { status: 'idle', retryCount: 0 },
+        });
+    }
+    /** Start the automatic dispatch tick loop */
+    enableAutoDispatch() {
+        if (this.tickTimer)
+            return;
+        if (this.isCommanderActive) {
+            console.warn('[Execution] enableAutoDispatch skipped: Commander is managing dispatch');
+            return;
+        }
+        this.config.enabled = true;
+        this.tickTimer = setInterval(() => void this.tick(), this.config.pollIntervalMs);
+        this.emitStatus();
+    }
+    /** @deprecated Use enableAutoDispatch() */
+    startSupervisor() { this.enableAutoDispatch(); }
+    /** Stop automatic dispatch */
+    disableAutoDispatch() {
+        this.config.enabled = false;
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+        this.emitStatus();
+    }
+    /** @deprecated Use disableAutoDispatch() */
+    stopSupervisor() { this.disableAutoDispatch(); }
+    /** Update scheduler config */
+    updateConfig(partial) {
+        const wasEnabled = this.config.enabled;
+        Object.assign(this.config, partial);
+        // Sync active strategy if config.strategy changed
+        if (partial.strategy) {
+            const newStrategy = this.strategies.get(partial.strategy);
+            if (newStrategy) {
+                this.activeStrategy = newStrategy;
+            }
+        }
+        // Restart tick timer if interval changed
+        if (this.config.enabled && this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = setInterval(() => void this.tick(), this.config.pollIntervalMs);
+        }
+        if (this.config.enabled && !wasEnabled) {
+            this.enableAutoDispatch();
+        }
+        else if (!this.config.enabled && wasEnabled) {
+            this.disableAutoDispatch();
+        }
+        this.emitStatus();
+    }
+    /** Get a snapshot of current scheduler state */
+    getStatus() {
+        return {
+            enabled: this.config.enabled,
+            running: Array.from(this.runningSlots.values()),
+            queued: [...this.queue],
+            retrying: Array.from(this.retryQueue.entries()).map(([issueId, r]) => ({
+                issueId,
+                retryAt: new Date(r.retryAt).toISOString(),
+            })),
+            lastTickAt: this.lastTickAt,
+            isCommanderActive: this.isCommanderActive,
+            stats: { ...this.stats },
+            tokenUsage: { ...this.tokenUsage },
+        };
+    }
+    /** Get config */
+    getConfig() {
+        return { ...this.config };
+    }
+    /** Get the execution slot for a given issue */
+    getSlotForIssue(issueId) {
+        for (const slot of this.runningSlots.values()) {
+            if (slot.issueId === issueId)
+                return slot;
+        }
+        return undefined;
+    }
+    /** Register a dispatch strategy (overwrites if name already exists). */
+    registerStrategy(strategy) {
+        this.strategies.set(strategy.name, strategy);
+    }
+    /** Switch the active dispatch strategy by name. Throws if not registered. */
+    setStrategy(name) {
+        const strategy = this.strategies.get(name);
+        if (!strategy) {
+            throw new Error(`Unknown dispatch strategy: ${name}. Registered: ${[...this.strategies.keys()].join(', ')}`);
+        }
+        this.activeStrategy = strategy;
+        this.config.strategy = name;
+        this.emitStatus();
+    }
+    /** Get the name of the active dispatch strategy. */
+    getActiveStrategyName() {
+        return this.activeStrategy.name;
+    }
+    // -------------------------------------------------------------------------
+    // Public: External slot management (e.g., WaveExecutor subtasks)
+    // -------------------------------------------------------------------------
+    /** Acquire a slot for external use (e.g., WaveExecutor subtasks). Returns false if no capacity. */
+    acquireSlot(issueId, processId, executor) {
+        if (this.runningSlots.size >= this.config.maxConcurrentAgents) {
+            return false;
+        }
+        const slot = {
+            issueId,
+            processId,
+            executor,
+            startedAt: new Date().toISOString(),
+            lastActivityAt: new Date().toISOString(),
+            turnNumber: 1,
+            maxTurns: 1,
+        };
+        this.runningSlots.set(processId, slot);
+        this.emitStatus();
+        return true;
+    }
+    /** Release a slot after external use */
+    releaseSlot(processId) {
+        this.runningSlots.delete(processId);
+        this.emitStatus();
+    }
+    /** Wait for a slot to become available, with timeout. Resolves true if acquired, false on timeout. */
+    async waitForSlot(issueId, processId, executor, timeoutMs = 60000) {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            if (this.acquireSlot(issueId, processId, executor))
+                return true;
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+        return false;
+    }
+    /** Clean shutdown */
+    async destroy() {
+        this.disableAutoDispatch();
+        await this.workspaceManager?.destroy();
+    }
+    // -------------------------------------------------------------------------
+    // Private: Atomic claim
+    // -------------------------------------------------------------------------
+    /** Atomically claim an issue. Returns true if successfully claimed. */
+    claim(issueId) {
+        if (this.claimed.has(issueId))
+            return false;
+        this.claimed.add(issueId);
+        return true;
+    }
+    // -------------------------------------------------------------------------
+    // Private: State recovery on startup
+    // -------------------------------------------------------------------------
+    /** Recover in-memory state from persisted JSONL on startup */
+    async recoverState() {
+        const issues = await readIssuesJsonl(this.jsonlPath);
+        for (const issue of issues) {
+            if (!issue.execution)
+                continue;
+            switch (issue.execution.status) {
+                case 'running':
+                    // Agent process is gone after restart — mark as failed for retry
+                    this.claimed.add(issue.id);
+                    await this.updateIssueFields(issue.id, {
+                        execution: {
+                            ...issue.execution,
+                            status: 'retrying',
+                            lastError: 'Server restarted while executing',
+                        },
+                    });
+                    this.retryQueue.set(issue.id, {
+                        retryAt: Date.now() + this.config.retryBackoffMs,
+                        count: (issue.execution.retryCount ?? 0) + 1,
+                    });
+                    break;
+                case 'queued':
+                    // Re-enqueue
+                    this.claimed.add(issue.id);
+                    this.queue.push(issue.id);
+                    break;
+                case 'retrying': {
+                    // Re-add to retry queue
+                    this.claimed.add(issue.id);
+                    const count = issue.execution.retryCount ?? 1;
+                    const backoff = this.config.retryBackoffMs * Math.pow(2, count - 1);
+                    this.retryQueue.set(issue.id, {
+                        retryAt: Date.now() + backoff,
+                        count,
+                    });
+                    break;
+                }
+                // idle, completed, failed — no recovery needed
+            }
+        }
+        // Journal-based recovery: augment state with journal analysis
+        if (this.journal) {
+            try {
+                const recoveryActions = await this.journal.recover();
+                for (const action of recoveryActions) {
+                    if (action.action === 'retry' && !this.claimed.has(action.issueId)) {
+                        // Journal says this was dispatched but never completed — ensure it retries
+                        this.claimed.add(action.issueId);
+                        this.retryQueue.set(action.issueId, {
+                            retryAt: Date.now() + this.config.retryBackoffMs,
+                            count: 1,
+                        });
+                        console.log(`[Execution] Journal recovery: scheduling retry for ${action.issueId} — ${action.reason}`);
+                    }
+                    // resume-wave actions are informational — wave executor handles its own resume
+                }
+            }
+            catch (err) {
+                console.warn('[Execution] Journal recovery failed, continuing with JSONL state:', err);
+            }
+        }
+        if (this.queue.length > 0 || this.retryQueue.size > 0) {
+            console.log(`[Execution] Recovered state: ${this.queue.length} queued, ${this.retryQueue.size} retrying`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Private: Dispatch
+    // -------------------------------------------------------------------------
+    async dispatch(issue, executor) {
+        // Route to chain-based execution when issue has a chain defined
+        if (issue.solution?.chain) {
+            await this.dispatchViaChain(issue, executor);
+            return;
+        }
+        const prompt = await this.buildPrompt(issue);
+        const now = new Date().toISOString();
+        const retryCount = issue.execution?.retryCount ?? 0;
+        // Create isolated workspace if manager is active
+        let workDir = process.cwd();
+        if (this.workspaceManager) {
+            try {
+                const ws = await this.workspaceManager.createForIssue(issue.id);
+                workDir = ws.path;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (this.config.workspace.strict) {
+                    // Strict mode: fail execution rather than running in project root
+                    await this.handleFailure(issue.id, `Workspace creation failed: ${message}`);
+                    return;
+                }
+                console.error(`[Execution] Workspace creation failed for ${issue.id}, falling back to cwd:`, message);
+            }
+        }
+        // Update issue: execution state + status in a single write
+        await this.updateIssueFields(issue.id, {
+            status: 'in_progress',
+            execution: {
+                status: 'running',
+                retryCount,
+                startedAt: now,
+            },
+        });
+        let proc;
+        try {
+            proc = await this.agentManager.spawn(executor, {
+                type: executor,
+                prompt,
+                workDir,
+                approvalMode: 'auto',
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            await this.handleFailure(issue.id, message);
+            return;
+        }
+        const slot = {
+            issueId: issue.id,
+            processId: proc.id,
+            executor,
+            startedAt: now,
+            lastActivityAt: now,
+            turnNumber: 1,
+            maxTurns: this.config.maxTurnsPerIssue ?? 3,
+        };
+        this.runningSlots.set(proc.id, slot);
+        // Update processId on issue
+        await this.updateIssueFields(issue.id, {
+            execution: {
+                status: 'running',
+                processId: proc.id,
+                retryCount,
+                startedAt: now,
+            },
+        });
+        this.stats.totalDispatched++;
+        // Journal: record dispatch event for crash recovery
+        await this.journal?.append({
+            type: 'issue:dispatched',
+            issueId: issue.id,
+            processId: proc.id,
+            executor,
+            timestamp: now,
+        });
+        // Read updated issue for incremental client push
+        const startedIssue = await this.findIssue(issue.id);
+        this.eventBus.emit('execution:started', {
+            issueId: issue.id,
+            processId: proc.id,
+            executor,
+            issue: startedIssue ?? undefined,
+        });
+    }
+    /**
+     * Chain-based dispatch — routes issue execution through a GraphWalker chain.
+     * The chain (e.g., 'issue-lifecycle') defines the multi-step execution flow.
+     */
+    async dispatchViaChain(issue, executor) {
+        const now = new Date().toISOString();
+        const retryCount = issue.execution?.retryCount ?? 0;
+        const chainId = issue.solution.chain;
+        const chainMode = issue.solution?.chainMode ?? 'full';
+        // Workspace isolation
+        let workDir = process.cwd();
+        if (this.workspaceManager) {
+            try {
+                const ws = await this.workspaceManager.createForIssue(issue.id);
+                workDir = ws.path;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (this.config.workspace.strict) {
+                    await this.handleFailure(issue.id, `Workspace creation failed: ${message}`);
+                    return;
+                }
+                console.error(`[Execution] Workspace creation failed for ${issue.id}, falling back to cwd:`, message);
+            }
+        }
+        // Update issue status
+        await this.updateIssueFields(issue.id, {
+            status: 'in_progress',
+            execution: { status: 'running', retryCount, startedAt: now },
+        });
+        this.stats.totalDispatched++;
+        this.eventBus.emit('execution:started', {
+            issueId: issue.id,
+            processId: `chain-${issue.id}`,
+            executor,
+        });
+        // Create GraphWalker via factory
+        try {
+            const bridge = new WalkerEventBridge('coordinate', this.eventBus, `chain-${issue.id}`);
+            const sessionDir = join(workDir, '.workflow', '.maestro-coordinate', `chain-${issue.id}`);
+            const { walker } = await this.factory.create({
+                agentManager: this.agentManager,
+                eventBus: this.eventBus,
+                workDir,
+                emitter: bridge,
+                analyzer: null,
+                sessionDir,
+            });
+            const walkerState = await walker.start(chainId, issue.description, {
+                tool: executor,
+                autoMode: true,
+                workflowRoot: workDir,
+                inputs: {
+                    issue_id: issue.id,
+                    description: issue.description,
+                    mode: chainMode,
+                },
+            });
+            // Determine success from walker state
+            if (walkerState.status === 'completed') {
+                const lastCmd = walkerState.history.filter((h) => h.node_type === 'command').pop();
+                await this.updateIssueFields(issue.id, {
+                    status: 'resolved',
+                    execution: {
+                        status: 'completed',
+                        retryCount,
+                        completedAt: new Date().toISOString(),
+                        result: { summary: lastCmd?.summary ?? 'Chain completed' },
+                    },
+                });
+                this.claimed.delete(issue.id);
+                this.stats.totalCompleted++;
+                const completedIssue = await this.findIssue(issue.id);
+                this.eventBus.emit('execution:completed', {
+                    issueId: issue.id,
+                    processId: `chain-${issue.id}`,
+                    issue: completedIssue ?? undefined,
+                });
+            }
+            else {
+                const failedStep = walkerState.history.filter((h) => h.outcome === 'failure').pop();
+                await this.handleFailure(issue.id, failedStep?.summary ?? 'Chain execution failed');
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            await this.handleFailure(issue.id, `Chain dispatch failed: ${message}`);
+        }
+        // Workspace cleanup
+        if (this.workspaceManager?.getWorkspacePath(issue.id)) {
+            void this.workspaceManager.removeForIssue(issue.id);
+        }
+    }
+    async buildPrompt(issue) {
+        const mode = issue.promptMode ?? this.config.defaultPromptMode;
+        // Check for custom prompt template — routes to 'template' builder
+        if (issue.solution?.promptTemplate) {
+            const builder = this.promptRegistry.get('template');
+            if (builder) {
+                const result = await builder.build({
+                    issue,
+                    config: this.config,
+                    promptMode: 'template',
+                    customTemplate: issue.solution.promptTemplate,
+                });
+                return result.userPrompt;
+            }
+            // Fallback if template builder not registered
+            return this.applyTemplate(issue.solution.promptTemplate, issue);
+        }
+        // Delegate to registered builder
+        const builder = this.promptRegistry.get(mode);
+        if (builder) {
+            const result = await builder.build({
+                issue,
+                config: this.config,
+                promptMode: mode,
+            });
+            return result.userPrompt;
+        }
+        // Fallback: inline logic (kept for safety)
+        return this.buildPromptFallback(issue, mode);
+    }
+    /** Inline fallback — preserves original logic for backward compatibility */
+    buildPromptFallback(issue, mode) {
+        if (mode === 'skill') {
+            return `Execute the following issue:\n\nIssue ID: ${issue.id}\nTitle: ${issue.title}\nType: ${issue.type}\nPriority: ${issue.priority}\n\nDescription:\n${issue.description}`;
+        }
+        const lines = [
+            `You are working on the following ${issue.type} issue:`,
+            '',
+            `## ${issue.title}`,
+            '',
+            issue.description,
+            '',
+            `Priority: ${issue.priority}`,
+        ];
+        if (issue.solution) {
+            lines.push('', '## Solution Plan', '');
+            if (issue.solution.context) {
+                lines.push('### Context', '', issue.solution.context, '');
+            }
+            if (issue.solution.steps.length > 0) {
+                lines.push('### Steps', '');
+                for (let i = 0; i < issue.solution.steps.length; i++) {
+                    const step = issue.solution.steps[i];
+                    lines.push(`${i + 1}. ${step.description}`);
+                    if (step.target)
+                        lines.push(`   - Target: ${step.target}`);
+                    if (step.verification)
+                        lines.push(`   - Verify: ${step.verification}`);
+                }
+            }
+            lines.push('', 'Follow the solution plan above. Execute each step in order.', 'After completing all steps, verify each step\'s criteria.', 'When done, provide a summary of the changes made.');
+        }
+        else {
+            lines.push('', 'Please implement this issue. Follow existing code patterns and conventions.', 'When done, provide a summary of the changes made.');
+        }
+        return lines.join('\n');
+    }
+    /** Simple variable substitution for custom prompt templates */
+    applyTemplate(template, issue) {
+        return template
+            .replace(/\{\{\s*issue\.id\s*\}\}/g, issue.id)
+            .replace(/\{\{\s*issue\.title\s*\}\}/g, issue.title)
+            .replace(/\{\{\s*issue\.description\s*\}\}/g, issue.description)
+            .replace(/\{\{\s*issue\.type\s*\}\}/g, issue.type)
+            .replace(/\{\{\s*issue\.priority\s*\}\}/g, issue.priority)
+            .replace(/\{\{\s*issue\.status\s*\}\}/g, issue.status);
+    }
+    // -------------------------------------------------------------------------
+    // Private: Agent event handling
+    // -------------------------------------------------------------------------
+    subscribeToAgentEvents() {
+        this.eventBus.on('agent:stopped', (event) => {
+            const payload = event.data;
+            void this.handleAgentStopped(payload.processId, payload.reason);
+        });
+        // Multi-turn continuation: triggered by turn/completed notification in
+        // codex app-server mode. The process stays alive between turns.
+        this.eventBus.on('agent:turnCompleted', (event) => {
+            const payload = event.data;
+            void this.handleTurnCompleted(payload.processId);
+        });
+        // Track activity for stall detection + accumulate token usage
+        this.eventBus.on('agent:entry', (event) => {
+            const entry = event.data;
+            const slot = this.runningSlots.get(entry.processId);
+            if (slot) {
+                slot.lastActivityAt = new Date().toISOString();
+            }
+            // Accumulate token usage from token_usage entries
+            if (entry.type === 'token_usage') {
+                this.tokenUsage.totalInputTokens += entry.inputTokens ?? 0;
+                this.tokenUsage.totalOutputTokens += entry.outputTokens ?? 0;
+            }
+        });
+    }
+    async handleAgentStopped(processId, reason) {
+        const slot = this.runningSlots.get(processId);
+        if (!slot)
+            return;
+        // Check entries for success/failure
+        const entries = this.agentManager.getEntries(processId);
+        const lastEntries = entries.slice(-5);
+        const hasError = lastEntries.some((e) => e.type === 'error' || (e.type === 'status_change' && e.status === 'error'));
+        if (hasError || reason === 'error') {
+            this.runningSlots.delete(processId);
+            const errorMsg = reason ?? 'Agent stopped with error';
+            await this.handleFailure(slot.issueId, errorMsg);
+            await this.dispatchNext();
+            return;
+        }
+        // Process exited normally — treat as completion.
+        // Multi-turn continuation is handled by handleTurnCompleted (triggered by
+        // turn/completed notification while the process is still alive).
+        this.runningSlots.delete(processId);
+        await this.handleCompletion(slot.issueId, processId);
+        await this.dispatchNext();
+    }
+    /**
+     * Handle turn/completed notification from a codex-server agent.
+     * The process is still alive — attempt continuation or complete.
+     */
+    async handleTurnCompleted(processId) {
+        const slot = this.runningSlots.get(processId);
+        if (!slot)
+            return;
+        if (await this.attemptContinuation(slot, processId)) {
+            return; // Continuation started, slot stays in runningSlots
+        }
+        // No more turns — complete the execution.
+        // Stop the still-alive process since we're done with it.
+        await this.agentManager.stop(processId).catch((err) => {
+            console.warn(`[Execution] Failed to stop completed agent ${processId}:`, err);
+        });
+        this.runningSlots.delete(processId);
+        await this.handleCompletion(slot.issueId, processId);
+        await this.dispatchNext();
+    }
+    async handleCompletion(issueId, processId) {
+        // Extract result from agent entries
+        const result = this.extractResult(processId);
+        // Journal: record completion event
+        await this.journal?.append({
+            type: 'issue:completed',
+            issueId,
+            processId,
+            timestamp: new Date().toISOString(),
+            result: result ? {
+                summary: result.summary,
+                commitHash: result.commitHash,
+                filesChanged: result.filesChanged,
+            } : undefined,
+        });
+        await this.updateIssueFields(issueId, {
+            status: 'resolved',
+            execution: {
+                status: 'completed',
+                retryCount: 0,
+                completedAt: new Date().toISOString(),
+                result,
+            },
+        });
+        this.claimed.delete(issueId);
+        this.stats.totalCompleted++;
+        // Clean up workspace if auto-cleanup is enabled
+        if (this.workspaceManager?.getWorkspacePath(issueId)) {
+            void this.workspaceManager.removeForIssue(issueId);
+        }
+        // Read updated issue for incremental client push
+        const completedIssue = await this.findIssue(issueId);
+        this.eventBus.emit('execution:completed', { issueId, processId, issue: completedIssue ?? undefined });
+    }
+    /** Extract structured result from agent entry history */
+    extractResult(processId) {
+        const entries = this.agentManager.getEntries(processId);
+        if (entries.length === 0)
+            return undefined;
+        const result = {};
+        // Count file changes
+        const fileChanges = entries.filter((e) => e.type === 'file_change');
+        if (fileChanges.length > 0) {
+            result.filesChanged = fileChanges.length;
+        }
+        // Extract last assistant message as summary
+        const assistantMessages = entries.filter((e) => e.type === 'assistant_message' && !e.partial);
+        if (assistantMessages.length > 0) {
+            const lastMsg = assistantMessages[assistantMessages.length - 1];
+            const text = lastMsg.content ?? '';
+            // Truncate to reasonable length for storage
+            result.summary = text.slice(0, 2000);
+        }
+        // Look for commit hash or PR URL in command outputs
+        const commandOutputs = entries.filter((e) => e.type === 'command_exec');
+        for (const entry of commandOutputs) {
+            const output = entry.output ?? '';
+            // Match git commit hash
+            const commitMatch = output.match(/\b([a-f0-9]{7,40})\b.*(?:commit|created)/i)
+                ?? output.match(/(?:commit|created).*\b([a-f0-9]{7,40})\b/i);
+            if (commitMatch && !result.commitHash) {
+                result.commitHash = commitMatch[1];
+            }
+            // Match PR URL
+            const prMatch = output.match(/(https:\/\/github\.com\/[^\s]+\/pull\/\d+)/);
+            if (prMatch && !result.prUrl) {
+                result.prUrl = prMatch[1];
+            }
+        }
+        return Object.keys(result).length > 0 ? result : undefined;
+    }
+    async handleFailure(issueId, error) {
+        const issue = await this.findIssue(issueId);
+        const currentRetry = issue?.execution?.retryCount ?? 0;
+        // Journal: record failure event
+        await this.journal?.append({
+            type: 'issue:failed',
+            issueId,
+            processId: issue?.execution?.processId ?? '',
+            error,
+            retryCount: currentRetry + 1,
+            timestamp: new Date().toISOString(),
+        });
+        if (currentRetry < this.config.maxRetries) {
+            // Schedule retry with exponential backoff
+            const backoff = this.config.retryBackoffMs * Math.pow(2, currentRetry);
+            this.retryQueue.set(issueId, {
+                retryAt: Date.now() + backoff,
+                count: currentRetry + 1,
+            });
+            await this.updateIssueFields(issueId, {
+                execution: {
+                    status: 'retrying',
+                    retryCount: currentRetry + 1,
+                    lastError: error,
+                },
+            });
+        }
+        else {
+            await this.updateIssueFields(issueId, {
+                execution: {
+                    status: 'failed',
+                    retryCount: currentRetry,
+                    lastError: error,
+                },
+            });
+            this.claimed.delete(issueId);
+            this.stats.totalFailed++;
+        }
+        // Find processId for the failed issue (may already be removed from runningSlots)
+        let processId = '';
+        for (const [pid, slot] of this.runningSlots) {
+            if (slot.issueId === issueId) {
+                processId = pid;
+                this.runningSlots.delete(pid);
+                break;
+            }
+        }
+        // Read updated issue for incremental client push
+        const failedIssue = await this.findIssue(issueId);
+        this.eventBus.emit('execution:failed', { issueId, processId, error, issue: failedIssue ?? undefined });
+    }
+    // -------------------------------------------------------------------------
+    // Private: Multi-turn continuation (codex-server only)
+    // -------------------------------------------------------------------------
+    /**
+     * Attempt to continue a codex-server agent for another turn.
+     * Returns true if continuation was initiated; false if normal completion should proceed.
+     */
+    async attemptContinuation(slot, processId) {
+        // Only codex-server supports interactive follow-up messages
+        if (slot.executor !== 'codex-server')
+            return false;
+        // Check turn budget
+        if (slot.turnNumber >= slot.maxTurns)
+            return false;
+        // Re-read issue from JSONL to check current status
+        let issue;
+        try {
+            issue = await this.findIssue(slot.issueId);
+        }
+        catch {
+            // IO failure — don't continue, fall through to normal completion
+            return false;
+        }
+        if (!issue)
+            return false;
+        // If issue is already resolved or closed, no need to continue
+        if (issue.status === 'resolved' || issue.status === 'closed')
+            return false;
+        // Check that the agent process is still registered in agentManager
+        // (sendMessage will throw if process is gone)
+        const continuationPrompt = this.buildContinuationPrompt(slot.turnNumber + 1, slot.maxTurns);
+        try {
+            await this.agentManager.sendMessage(processId, continuationPrompt);
+        }
+        catch {
+            // Process already exited — fall through to normal completion
+            return false;
+        }
+        // Update slot for next turn
+        slot.turnNumber++;
+        slot.lastActivityAt = new Date().toISOString();
+        // Slot remains in runningSlots (not deleted)
+        console.log(`[Execution] Continuation turn ${slot.turnNumber}/${slot.maxTurns} for issue ${slot.issueId} (process ${processId})`);
+        return true;
+    }
+    /** Build a continuation prompt for multi-turn execution */
+    buildContinuationPrompt(turnNumber, maxTurns) {
+        return [
+            `Continuation turn #${turnNumber} of ${maxTurns}.`,
+            '',
+            'Continuation guidance:',
+            '- The previous turn completed normally, but the issue is still in an active state.',
+            '- Resume from the current workspace and workpad state instead of restarting from scratch.',
+            '- Review what was accomplished in the previous turn and continue from where it left off.',
+        ].join('\n');
+    }
+    // -------------------------------------------------------------------------
+    // Private: Supervisor tick
+    // -------------------------------------------------------------------------
+    async tick() {
+        this.lastTickAt = new Date().toISOString();
+        // 1. Reconcile running issues (detect externally resolved/closed)
+        await this.reconcileRunningIssues();
+        // 2. Stall detection
+        await this.detectStalls();
+        // 3. Process retry queue
+        this.processRetries();
+        // 4. Dispatch queued issues first
+        await this.dispatchNext();
+        // 5. Auto-dispatch via active strategy
+        await this.dispatchViaStrategy();
+        // 6. Emit status
+        this.emitStatus();
+    }
+    /** Delegate issue selection to the active strategy and execute returned decisions. */
+    async dispatchViaStrategy() {
+        if (this.isDispatching)
+            return;
+        this.isDispatching = true;
+        try {
+            const availableSlots = this.config.maxConcurrentAgents - this.runningSlots.size;
+            if (availableSlots <= 0)
+                return;
+            const issues = await readIssuesJsonl(this.jsonlPath);
+            const context = {
+                issues,
+                runningSlots: this.runningSlots,
+                claimed: this.claimed,
+                config: this.config,
+                availableSlots,
+                learningSuggestions: this.selfLearningService?.getStats().suggestions ?? [],
+            };
+            const decisions = await this.activeStrategy.selectIssues(context);
+            for (const decision of decisions) {
+                // Re-check capacity (previous dispatches in this batch may have filled slots)
+                if (this.runningSlots.size >= this.config.maxConcurrentAgents)
+                    break;
+                if (!this.claim(decision.issueId))
+                    continue;
+                const issue = issues.find((i) => i.id === decision.issueId);
+                if (!issue) {
+                    this.claimed.delete(decision.issueId);
+                    continue;
+                }
+                const executor = (decision.executor ?? issue.executor ?? this.config.defaultExecutor);
+                await this.dispatch(issue, executor);
+            }
+        }
+        finally {
+            this.isDispatching = false;
+        }
+    }
+    /**
+     * Reconcile running slots against persisted issue state.
+     * If an issue was externally resolved or closed, stop its agent.
+     */
+    async reconcileRunningIssues() {
+        for (const [processId, slot] of this.runningSlots) {
+            const issue = await this.findIssue(slot.issueId);
+            if (!issue)
+                continue;
+            if (issue.status === 'resolved' || issue.status === 'closed') {
+                console.log(`[Execution] Reconcile: issue ${slot.issueId} is ${issue.status}, stopping agent ${processId}`);
+                await this.agentManager.stop(processId).catch((err) => {
+                    console.warn(`[Execution] Failed to stop reconciled agent ${processId}:`, err);
+                });
+                // Update JSONL status before removing the slot
+                await this.updateIssueFields(slot.issueId, {
+                    status: 'resolved',
+                    execution: {
+                        status: 'completed',
+                        completedAt: new Date().toISOString(),
+                    },
+                });
+                this.runningSlots.delete(processId);
+                this.claimed.delete(slot.issueId);
+                this.stats.totalCompleted++;
+                // Read updated issue for incremental client push
+                const reconciledIssue = await this.findIssue(slot.issueId);
+                this.eventBus.emit('execution:completed', {
+                    issueId: slot.issueId,
+                    processId,
+                    issue: reconciledIssue ?? undefined,
+                });
+            }
+        }
+    }
+    async detectStalls() {
+        const now = Date.now();
+        for (const [processId, slot] of this.runningSlots) {
+            const lastActivity = new Date(slot.lastActivityAt).getTime();
+            if (now - lastActivity > this.config.stallTimeoutMs) {
+                console.warn(`[Execution] Stall detected for issue ${slot.issueId} (process ${processId})`);
+                await this.agentManager.stop(processId).catch((err) => {
+                    console.warn(`[Execution] Failed to stop stalled agent ${processId}:`, err);
+                });
+                // handleAgentStopped will clean up
+            }
+        }
+    }
+    processRetries() {
+        const now = Date.now();
+        for (const [issueId, retry] of this.retryQueue) {
+            if (now >= retry.retryAt) {
+                this.retryQueue.delete(issueId);
+                this.queue.unshift(issueId); // Priority position
+            }
+        }
+    }
+    /** @deprecated Superseded by PriorityStrategy via dispatchViaStrategy(). Kept for reference. */
+    async autoDispatchByPriority() {
+        if (this.queue.length === 0) {
+            // Check for unqueued open issues to auto-enqueue
+            const issues = await readIssuesJsonl(this.jsonlPath);
+            const priorityOrder = {
+                urgent: 0,
+                high: 1,
+                medium: 2,
+                low: 3,
+            };
+            const candidates = issues
+                .filter((i) => (i.status === 'open') &&
+                (!i.execution || i.execution.status === 'idle') &&
+                !this.claimed.has(i.id))
+                .sort((a, b) => (priorityOrder[a.priority] ?? 3) - (priorityOrder[b.priority] ?? 3));
+            for (const issue of candidates) {
+                if (this.claim(issue.id)) {
+                    this.queue.push(issue.id);
+                    await this.updateIssueFields(issue.id, {
+                        execution: { status: 'queued', retryCount: 0 },
+                    });
+                }
+            }
+        }
+        await this.dispatchNext();
+    }
+    /**
+     * @deprecated Superseded by SmartStrategy via dispatchViaStrategy(). Kept for reference.
+     *
+     * Smart strategy: priority + executor affinity + failure avoidance.
+     * - Prioritize issues matching idle executor types (spread load across agents)
+     * - Deprioritize issue types that have recently failed
+     */
+    async autoDispatchSmart() {
+        if (this.queue.length === 0) {
+            const issues = await readIssuesJsonl(this.jsonlPath);
+            const priorityOrder = {
+                urgent: 0, high: 1, medium: 2, low: 3,
+            };
+            // Determine which executor types are currently in use
+            const busyExecutors = new Map();
+            for (const slot of this.runningSlots.values()) {
+                busyExecutors.set(slot.executor, (busyExecutors.get(slot.executor) ?? 0) + 1);
+            }
+            const candidates = issues
+                .filter((i) => i.status === 'open' &&
+                (!i.execution || i.execution.status === 'idle') &&
+                !this.claimed.has(i.id))
+                .map((issue) => {
+                const executor = issue.executor ?? this.config.defaultExecutor;
+                const priorityScore = priorityOrder[issue.priority] ?? 3;
+                // Prefer executors with fewer running slots (load balancing)
+                const affinityScore = busyExecutors.get(executor) ?? 0;
+                // Penalize if previous execution failed (avoid re-failing)
+                const failurePenalty = issue.execution?.lastError ? 2 : 0;
+                return {
+                    issue,
+                    score: priorityScore + affinityScore + failurePenalty,
+                };
+            })
+                .sort((a, b) => a.score - b.score);
+            for (const { issue } of candidates) {
+                if (this.claim(issue.id)) {
+                    this.queue.push(issue.id);
+                    await this.updateIssueFields(issue.id, {
+                        execution: { status: 'queued', retryCount: 0 },
+                    });
+                }
+            }
+        }
+        await this.dispatchNext();
+    }
+    async dispatchNext() {
+        while (this.queue.length > 0 &&
+            this.runningSlots.size < this.config.maxConcurrentAgents) {
+            const issueId = this.queue.shift();
+            const issue = await this.findIssue(issueId);
+            if (!issue) {
+                this.claimed.delete(issueId);
+                continue;
+            }
+            const executor = issue.executor ?? this.config.defaultExecutor;
+            await this.dispatch(issue, executor);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Private: JSONL operations (all serialized via writeLock)
+    // -------------------------------------------------------------------------
+    async findIssue(issueId) {
+        const issues = await readIssuesJsonl(this.jsonlPath);
+        return issues.find((i) => i.id === issueId) ?? null;
+    }
+    /** Atomically update multiple fields on an issue in a single read-modify-write */
+    async updateIssueFields(issueId, fields) {
+        await withIssueWriteLock(async () => {
+            const issues = await readIssuesJsonl(this.jsonlPath);
+            const idx = issues.findIndex((i) => i.id === issueId);
+            if (idx === -1)
+                return;
+            const issue = issues[idx];
+            if (fields.status !== undefined) {
+                issue.status = fields.status;
+            }
+            if (fields.execution !== undefined) {
+                issue.execution = {
+                    status: 'idle',
+                    retryCount: 0,
+                    ...issue.execution,
+                    ...fields.execution,
+                };
+            }
+            issue.updated_at = new Date().toISOString();
+            issues[idx] = issue;
+            await writeIssuesJsonl(this.jsonlPath, issues);
+        });
+    }
+    emitStatus() {
+        this.eventBus.emit('supervisor:status', this.getStatus());
+    }
+}
+//# sourceMappingURL=execution-scheduler.js.map