@plusplusoneplusplus/coc 1.0.2 → 1.0.4

package/node_modules/@plusplusoneplusplus/forge/dist/queue/task-queue-manager.js

@@ -0,0 +1,1059 @@
+"use strict";
+/**
+ * TaskQueueManager
+ *
+ * Manages a queue of tasks with priority-based ordering.
+ * Provides operations for enqueue, dequeue, reorder, and queue control.
+ *
+ * Uses Node.js EventEmitter for cross-platform compatibility.
+ * In-memory storage only - queue resets when process restarts.
+ *
+ * Cross-platform compatible (Linux/Mac/Windows).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskQueueManager = void 0;
+exports.createTaskQueueManager = createTaskQueueManager;
+const events_1 = require("events");
+const types_1 = require("./types");
+// ============================================================================
+// Helpers
+// ============================================================================
+/** Type guard: true when the queue item is a PauseMarker. */
+function isPauseMarker(item) {
+    return item.kind === 'pause-marker';
+}
+/**
+ * Task queue manager for managing AI task execution queue
+ */
+class TaskQueueManager extends events_1.EventEmitter {
+    constructor(options = {}) {
+        super();
+        /** Queue of pending tasks and pause markers (sorted by priority for tasks; markers at absolute positions) */
+        this.queue = [];
+        /** Currently running tasks */
+        this.running = new Map();
+        /** History of completed/failed/cancelled tasks */
+        this.history = [];
+        /** Whether the queue is paused */
+        this.paused = false;
+        /** Whether autopilot is paused */
+        this.autopilotPaused = false;
+        /** Whether the queue is in drain mode (no new tasks accepted) */
+        this.draining = false;
+        /** Callbacks waiting for the queue to become idle */
+        this.idleResolvers = [];
+        /** Set of paused repository IDs */
+        this.pausedRepos = new Set();
+        /** Per-repo pause reason (present when paused due to task failure). */
+        this.pauseReasons = new Map();
+        const { getTaskRepoId, isExclusive, ...rest } = options;
+        this.options = { ...types_1.DEFAULT_QUEUE_MANAGER_OPTIONS, ...rest };
+        this.getTaskRepoId = getTaskRepoId;
+        this.isExclusiveFn = isExclusive;
+    }
+    // ========================================================================
+    // Core Operations
+    // ========================================================================
+    /**
+     * Add a task to the queue
+     * @param input Task input (without auto-generated fields)
+     * @returns The ID of the queued task
+     */
+    enqueue(input) {
+        // Reject new tasks when in drain mode
+        if (this.draining) {
+            throw new Error('Queue is draining — no new tasks accepted');
+        }
+        // Check queue size limit
+        if (this.options.maxQueueSize > 0 && this.size() >= this.options.maxQueueSize) {
+            throw new Error(`Queue is full (max size: ${this.options.maxQueueSize})`);
+        }
+        const task = {
+            ...input,
+            id: (0, types_1.generateTaskId)(),
+            status: 'queued',
+            createdAt: Date.now(),
+            retryCount: 0,
+        };
+        this.insertTask(task);
+        // Emit events
+        this.emitChange('added', task);
+        this.emit('taskAdded', task);
+        return task.id;
+    }
+    /**
+     * Remove and return the next eligible item from the queue.
+     * Pause markers are returned (and consumed) when encountered in order.
+     * Frozen tasks and tasks from paused repos are skipped.
+     * @returns The next item, or undefined if queue is empty
+     */
+    dequeue() {
+        if (this.queue.length === 0) {
+            return undefined;
+        }
+        for (let i = 0; i < this.queue.length; i++) {
+            const item = this.queue[i];
+            if (isPauseMarker(item)) {
+                // Markers are always eligible — return and consume
+                this.queue.splice(i, 1);
+                return item;
+            }
+            const task = item;
+            if (task.frozen)
+                continue;
+            if (this.getTaskRepoId && this.pausedRepos.size > 0) {
+                const repoId = this.getTaskRepoId(task);
+                if (repoId && this.pausedRepos.has(repoId))
+                    continue;
+            }
+            this.queue.splice(i, 1);
+            return task;
+        }
+        return undefined;
+    }
+    /**
+     * Get the next eligible item without removing it.
+     * Pause markers are returned when encountered in order.
+     * Skips frozen tasks, tasks from paused repos, and non-admitted
+     * exclusive tasks when autopilot is paused.
+     * @returns The next eligible item, or undefined if none available
+     */
+    peek() {
+        for (const item of this.queue) {
+            if (isPauseMarker(item)) {
+                return item;
+            }
+            const task = item;
+            if (task.frozen)
+                continue;
+            if (this.getTaskRepoId && this.pausedRepos.size > 0) {
+                const repoId = this.getTaskRepoId(task);
+                if (repoId && this.pausedRepos.has(repoId))
+                    continue;
+            }
+            if (this.autopilotPaused && this.isExclusiveFn?.(task) && !task.admitted)
+                continue;
+            return task;
+        }
+        return undefined;
+    }
+    // ========================================================================
+    // Queue Access
+    // ========================================================================
+    /**
+     * Get all tasks (queued + running + history)
+     */
+    getAll() {
+        return [
+            ...this.queue.filter((item) => !isPauseMarker(item)),
+            ...Array.from(this.running.values()),
+            ...this.history,
+        ];
+    }
+    /**
+     * Get all queue items in order, including pause markers.
+     */
+    getQueueItems() {
+        return [...this.queue];
+    }
+    /**
+     * Get all queued tasks (waiting for execution, excluding pause markers)
+     */
+    getQueued() {
+        return this.queue.filter((item) => !isPauseMarker(item));
+    }
+    /**
+     * Get all running tasks
+     */
+    getRunning() {
+        return Array.from(this.running.values());
+    }
+    /**
+     * Get completed tasks from history
+     */
+    getCompleted() {
+        return this.history.filter(t => t.status === 'completed');
+    }
+    /**
+     * Get failed tasks from history
+     */
+    getFailed() {
+        return this.history.filter(t => t.status === 'failed');
+    }
+    /**
+     * Get cancelled tasks from history
+     */
+    getCancelled() {
+        return this.history.filter(t => t.status === 'cancelled');
+    }
+    /**
+     * Get history (completed + failed + cancelled)
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    /**
+     * Get the number of queued tasks (excludes pause markers)
+     */
+    size() {
+        return this.queue.filter(t => !isPauseMarker(t)).length;
+    }
+    /**
+     * Get queue statistics
+     */
+    getStats() {
+        const taskCount = this.queue.filter(t => !isPauseMarker(t)).length;
+        const stats = {
+            queued: taskCount,
+            running: this.running.size,
+            completed: this.history.filter(t => t.status === 'completed').length,
+            failed: this.history.filter(t => t.status === 'failed').length,
+            cancelled: this.history.filter(t => t.status === 'cancelled').length,
+            total: taskCount + this.running.size + this.history.length,
+            isPaused: this.paused,
+            isDraining: this.draining,
+            pausedRepos: Array.from(this.pausedRepos),
+            isAutopilotPaused: this.autopilotPaused,
+        };
+        // Attach the first available pause reason (single-repo manager → at most one).
+        if (this.pauseReasons.size > 0) {
+            stats.pauseReason = this.pauseReasons.values().next().value;
+        }
+        return stats;
+    }
+    // ========================================================================
+    // Task Operations
+    // ========================================================================
+    /**
+     * Get a task by ID (searches all: queued, running, history)
+     */
+    getTask(id) {
+        // Check queue (exclude pause markers)
+        const queued = this.queue.find(t => !isPauseMarker(t) && t.id === id);
+        if (queued)
+            return queued;
+        // Check running
+        const running = this.running.get(id);
+        if (running)
+            return running;
+        // Check history
+        return this.history.find(t => t.id === id);
+    }
+    /**
+     * Update a task's properties
+     * @param id Task ID
+     * @param updates Partial updates to apply
+     * @returns true if task was found and updated
+     */
+    updateTask(id, updates) {
+        // Try to find in queue
+        const queueIndex = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (queueIndex !== -1) {
+            const task = this.queue[queueIndex];
+            Object.assign(task, updates);
+            // Re-sort if priority changed
+            if (updates.priority !== undefined) {
+                this.queue.splice(queueIndex, 1);
+                this.insertByPriority(task);
+            }
+            this.emitChange('updated', task);
+            this.emit('taskUpdated', task, updates);
+            return true;
+        }
+        // Try to find in running
+        const running = this.running.get(id);
+        if (running) {
+            Object.assign(running, updates);
+            this.emitChange('updated', running);
+            this.emit('taskUpdated', running, updates);
+            return true;
+        }
+        // Try to find in history
+        const historyIndex = this.history.findIndex(t => t.id === id);
+        if (historyIndex !== -1) {
+            const task = this.history[historyIndex];
+            Object.assign(task, updates);
+            this.emitChange('updated', task);
+            this.emit('taskUpdated', task, updates);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Remove a task from the queue (only works for queued tasks)
+     * @param id Task ID
+     * @returns true if task was found and removed
+     */
+    removeTask(id) {
+        const index = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (index === -1) {
+            return false;
+        }
+        const [task] = this.queue.splice(index, 1);
+        this.emitChange('removed', task);
+        this.emit('taskRemoved', task);
+        return true;
+    }
+    /**
+     * Cancel a task (works for queued or running tasks)
+     * @param id Task ID
+     * @returns true if task was found and cancelled
+     */
+    cancelTask(id) {
+        // Try to cancel from queue
+        const queueIndex = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (queueIndex !== -1) {
+            const [item] = this.queue.splice(queueIndex, 1);
+            const task = item;
+            task.status = 'cancelled';
+            task.completedAt = Date.now();
+            this.addToHistory(task);
+            this.emitChange('removed', task);
+            this.emit('taskCancelled', task);
+            return true;
+        }
+        // Try to cancel running task
+        const running = this.running.get(id);
+        if (running) {
+            running.status = 'cancelled';
+            running.completedAt = Date.now();
+            this.running.delete(id);
+            this.addToHistory(running);
+            this.emitChange('updated', running);
+            this.emit('taskCancelled', running);
+            this.checkIdle();
+            return true;
+        }
+        return false;
+    }
+    // ========================================================================
+    // Task State Transitions (used by executor)
+    // ========================================================================
+    /**
+     * Mark a task as started (moves from queue to running)
+     * @param id Task ID
+     * @returns The task if found and started
+     */
+    markStarted(id) {
+        const index = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (index === -1) {
+            return undefined;
+        }
+        const [item] = this.queue.splice(index, 1);
+        const task = item;
+        task.status = 'running';
+        task.startedAt = Date.now();
+        this.running.set(id, task);
+        this.emitChange('updated', task);
+        this.emit('taskStarted', task);
+        return task;
+    }
+    /**
+     * Mark a task as completed (moves from running to history)
+     * @param id Task ID
+     * @param result The result of execution
+     * @returns The task if found and completed
+     */
+    markCompleted(id, result) {
+        const task = this.running.get(id);
+        if (!task) {
+            return undefined;
+        }
+        task.status = 'completed';
+        task.completedAt = Date.now();
+        task.result = result;
+        this.running.delete(id);
+        this.addToHistory(task);
+        this.emitChange('updated', task);
+        this.emit('taskCompleted', task, result);
+        this.checkIdle();
+        return task;
+    }
+    /**
+     * Mark a task as failed (moves from running to history)
+     * @param id Task ID
+     * @param error The error that occurred
+     * @returns The task if found and marked as failed
+     */
+    markFailed(id, error) {
+        const task = this.running.get(id);
+        if (!task) {
+            return undefined;
+        }
+        task.status = 'failed';
+        task.completedAt = Date.now();
+        task.error = typeof error === 'string' ? error : error.message;
+        this.running.delete(id);
+        this.addToHistory(task);
+        this.emitChange('updated', task);
+        this.emit('taskFailed', task, typeof error === 'string' ? new Error(error) : error);
+        this.checkIdle();
+        return task;
+    }
+    /**
+     * Increment retry count and optionally re-queue the task
+     * @param id Task ID
+     * @param requeue Whether to re-queue the task
+     * @returns The task if found
+     */
+    markRetry(id, requeue = true) {
+        const task = this.running.get(id);
+        if (!task) {
+            return undefined;
+        }
+        task.retryCount = (task.retryCount || 0) + 1;
+        if (requeue) {
+            task.status = 'queued';
+            task.startedAt = undefined;
+            this.running.delete(id);
+            this.insertByPriority(task);
+            this.emitChange('reordered', task);
+        }
+        return task;
+    }
+    /**
+     * Move a completed/failed task from history back to the queue.
+     * Used when a follow-up is enqueued for a completed chat task so the
+     * parent task appears under "Queued" while the follow-up waits.
+     *
+     * @param id Task ID to requeue
+     * @returns true if the task was found in history and moved to the queue
+     */
+    requeueFromHistory(id) {
+        const index = this.history.findIndex(t => t.id === id);
+        if (index === -1) {
+            return false;
+        }
+        const [task] = this.history.splice(index, 1);
+        task.status = 'queued';
+        task.startedAt = undefined;
+        task.completedAt = undefined;
+        task.result = undefined;
+        task.error = undefined;
+        this.insertTask(task);
+        this.emitChange('updated', task);
+        this.emit('taskUpdated', task, { status: 'queued' });
+        return true;
+    }
+    /**
+     * Move a queued task back to history as completed.
+     * Reverses requeueFromHistory— used when a follow-up is cancelled
+     * so the parent task returns to the completed section.
+     *
+     * @param id Task ID to return to history
+     * @returns true if the task was found in the queue and moved to history
+     */
+    returnToHistory(id) {
+        const index = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (index === -1) {
+            return false;
+        }
+        const [item] = this.queue.splice(index, 1);
+        const task = item;
+        task.status = 'completed';
+        task.completedAt = Date.now();
+        this.addToHistory(task);
+        this.emitChange('updated', task);
+        this.emit('taskUpdated', task, { status: 'completed' });
+        return true;
+    }
+    /**
+     * Re-activate a task from history (or queue) back to running state.
+     * Used to reuse a completed task (e.g. a chat session receiving follow-ups)
+     * instead of creating a separate task for each interaction.
+     *
+     * @param id Task ID to re-activate
+     * @returns true if the task was found in history/queue and moved to running
+     */
+    reActivate(id) {
+        // Try history first (original path)
+        const histIndex = this.history.findIndex(t => t.id === id);
+        if (histIndex !== -1) {
+            const [task] = this.history.splice(histIndex, 1);
+            task.status = 'running';
+            task.startedAt = Date.now();
+            task.completedAt = undefined;
+            task.result = undefined;
+            task.error = undefined;
+            this.running.set(id, task);
+            this.emitChange('updated', task);
+            this.emit('taskUpdated', task, { status: 'running', startedAt: task.startedAt });
+            return true;
+        }
+        // Fallback: task may have been requeued via requeueFromHistory
+        const queueIndex = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (queueIndex !== -1) {
+            const [item] = this.queue.splice(queueIndex, 1);
+            const task = item;
+            task.status = 'running';
+            task.startedAt = Date.now();
+            this.running.set(id, task);
+            this.emitChange('updated', task);
+            this.emit('taskUpdated', task, { status: 'running', startedAt: task.startedAt });
+            return true;
+        }
+        return false;
+    }
+    // ========================================================================
+    // Freeze / Unfreeze
+    // ========================================================================
+    /**
+     * Freeze a queued task so the executor skips it.
+     * The task remains in its queue position with status 'queued'.
+     * @param id Task ID
+     * @returns true if the task was found in the queue and frozen
+     */
+    freezeTask(id) {
+        const task = this.queue.find(t => !isPauseMarker(t) && t.id === id);
+        if (!task)
+            return false;
+        task.frozen = true;
+        this.emitChange('frozen', task);
+        return true;
+    }
+    /**
+     * Unfreeze a previously frozen task, making it eligible for execution again.
+     * @param id Task ID
+     * @returns true if the task was found in the queue and unfrozen
+     */
+    unfreezeTask(id) {
+        const task = this.queue.find(t => !isPauseMarker(t) && t.id === id);
+        if (!task || !task.frozen)
+            return false;
+        task.frozen = false;
+        this.emitChange('unfrozen', task);
+        return true;
+    }
+    // ========================================================================
+    // Admit / Unadmit (autopilot override)
+    // ========================================================================
+    /**
+     * Admit a held autopilot task so it runs despite autopilot being paused.
+     * @param id Task ID
+     * @returns true if the task was found in the queue and admitted
+     */
+    admitTask(id) {
+        const task = this.queue.find(t => !isPauseMarker(t) && t.id === id);
+        if (!task)
+            return false;
+        task.admitted = true;
+        this.emitChange('admitted', task);
+        return true;
+    }
+    /**
+     * Unadmit a previously admitted task, reverting it to held state.
+     * @param id Task ID
+     * @returns true if the task was found in the queue and unadmitted
+     */
+    unadmitTask(id) {
+        const task = this.queue.find(t => !isPauseMarker(t) && t.id === id);
+        if (!task || !task.admitted)
+            return false;
+        task.admitted = false;
+        this.emitChange('unadmitted', task);
+        return true;
+    }
+    // ========================================================================
+    // Pause Markers
+    // ========================================================================
+    /**
+     * Insert a pause marker at the given position in the queue.
+     * When the executor reaches the marker, it pauses and discards it.
+     *
+     * @param afterIndex 0-based index of the item after which the marker is inserted.
+     *   Pass -1 to insert at the very beginning.
+     *   Values >= queue.length insert at the end.
+     * @returns The id of the newly created marker.
+     */
+    insertPauseMarker(afterIndex) {
+        const marker = {
+            kind: 'pause-marker',
+            id: (0, types_1.generateTaskId)(),
+            createdAt: Date.now(),
+        };
+        // Clamp insertion index
+        const insertAt = Math.max(0, Math.min(afterIndex + 1, this.queue.length));
+        this.queue.splice(insertAt, 0, marker);
+        this.emitChange('pause-marker-added');
+        this.emit('pause-marker-added', marker);
+        return marker.id;
+    }
+    /**
+     * Remove a pause marker by id.
+     * @returns true if the marker was found and removed
+     */
+    removePauseMarker(markerId) {
+        const index = this.queue.findIndex(item => isPauseMarker(item) && item.id === markerId);
+        if (index === -1)
+            return false;
+        this.queue.splice(index, 1);
+        this.emitChange('pause-marker-removed');
+        this.emit('pause-marker-removed', markerId);
+        return true;
+    }
+    // ========================================================================
+    // Reordering
+    // ========================================================================
+    /**
+     * Move a task to the top of the queue (highest priority position)
+     * @param id Task ID
+     * @returns true if task was found and moved
+     */
+    moveToTop(id) {
+        const index = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (index === -1 || index === 0) {
+            return index === 0; // Already at top
+        }
+        const [item] = this.queue.splice(index, 1);
+        const task = item;
+        // Set to high priority and earliest timestamp to ensure it's first
+        task.priority = 'high';
+        task.createdAt = this.queue.length > 0 ? this.queue[0].createdAt - 1 : Date.now();
+        this.queue.unshift(task);
+        this.emitChange('reordered', task);
+        return true;
+    }
+    /**
+     * Move a task up one position in the queue
+     * @param id Task ID
+     * @returns true if task was found and moved
+     */
+    moveUp(id) {
+        const index = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (index <= 0) {
+            return false;
+        }
+        // Swap with previous task
+        [this.queue[index - 1], this.queue[index]] = [this.queue[index], this.queue[index - 1]];
+        this.emitChange('reordered', this.queue[index - 1]);
+        return true;
+    }
+    /**
+     * Move a task down one position in the queue
+     * @param id Task ID
+     * @returns true if task was found and moved
+     */
+    moveDown(id) {
+        const index = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (index === -1 || index >= this.queue.length - 1) {
+            return false;
+        }
+        // Swap with next task
+        [this.queue[index], this.queue[index + 1]] = [this.queue[index + 1], this.queue[index]];
+        this.emitChange('reordered', this.queue[index + 1]);
+        return true;
+    }
+    /**
+     * Move a task to an arbitrary position in the queue (0-based index).
+     * Does not mutate priority (unlike moveToTop).
+     * @param id Task ID
+     * @param targetIndex Desired 0-based index (clamped to valid range)
+     * @returns true if the task was found (even if already at target), false if not found
+     */
+    moveToPosition(id, targetIndex) {
+        const currentIndex = this.queue.findIndex(t => !isPauseMarker(t) && t.id === id);
+        if (currentIndex === -1)
+            return false;
+        const clamped = Math.max(0, Math.min(targetIndex, this.queue.length - 1));
+        if (currentIndex === clamped)
+            return true;
+        const [item] = this.queue.splice(currentIndex, 1);
+        this.queue.splice(clamped, 0, item);
+        this.emitChange('reordered', item);
+        return true;
+    }
+    /**
+     * Get the position of a task in the queue (1-based)
+     * @param id Task ID
+     * @returns Position (1-based) or -1 if not found
+     */
+    getPosition(id) {
+        const index = this.queue.findIndex(t => t.id === id);
+        return index === -1 ? -1 : index + 1;
+    }
+    // ========================================================================
+    // Queue Control
+    // ========================================================================
+    /**
+     * Pause queue processing
+     * Running tasks continue, but no new tasks will be started
+     */
+    pause() {
+        if (!this.paused) {
+            this.paused = true;
+            this.emitChange('paused');
+            this.emit('paused');
+        }
+    }
+    /**
+     * Resume queue processing
+     */
+    resume() {
+        if (this.paused) {
+            this.paused = false;
+            this.emitChange('resumed');
+            this.emit('resumed');
+        }
+    }
+    /**
+     * Check if queue is paused
+     */
+    isPaused() {
+        return this.paused;
+    }
+    // ========================================================================
+    // Autopilot Pause Control
+    // ========================================================================
+    /**
+     * Pause autopilot — prevents new tasks from being enqueued automatically.
+     * Running and already-queued tasks are unaffected.
+     */
+    pauseAutopilot() {
+        if (!this.autopilotPaused) {
+            this.autopilotPaused = true;
+            this.emitChange('autopilot-paused');
+            this.emit('autopilot-paused');
+        }
+    }
+    /**
+     * Resume autopilot — allows automatic enqueuing to proceed again.
+     * Clears any stale admitted flags on queued tasks.
+     */
+    resumeAutopilot() {
+        if (this.autopilotPaused) {
+            this.autopilotPaused = false;
+            for (const item of this.queue) {
+                if (!isPauseMarker(item)) {
+                    item.admitted = false;
+                }
+            }
+            this.emitChange('autopilot-resumed');
+            this.emit('autopilot-resumed');
+        }
+    }
+    /**
+     * Check if autopilot is paused.
+     */
+    isAutopilotPaused() {
+        return this.autopilotPaused;
+    }
+    // ========================================================================
+    // Per-Repo Pause Control
+    // ========================================================================
+    /**
+     * Pause queue processing for a specific repository.
+     * Tasks from this repo will remain in queue but won't be dequeued.
+     */
+    pauseRepo(repoId, reason) {
+        if (!this.pausedRepos.has(repoId)) {
+            this.pausedRepos.add(repoId);
+            if (reason) {
+                this.pauseReasons.set(repoId, reason);
+            }
+            this.emitChange('repo-paused');
+            this.emit('repo-paused', repoId);
+        }
+    }
+    /**
+     * Resume queue processing for a specific repository.
+     */
+    resumeRepo(repoId) {
+        if (this.pausedRepos.delete(repoId)) {
+            this.pauseReasons.delete(repoId);
+            this.emitChange('repo-resumed');
+            this.emit('repo-resumed', repoId);
+        }
+    }
+    /**
+     * Check if a specific repository is paused.
+     */
+    isRepoPaused(repoId) {
+        return this.pausedRepos.has(repoId);
+    }
+    /**
+     * Get all paused repository IDs.
+     */
+    getPausedRepos() {
+        return Array.from(this.pausedRepos);
+    }
+    /**
+     * Get the pause reason for a specific repository (if any).
+     */
+    getPauseReason(repoId) {
+        return this.pauseReasons.get(repoId);
+    }
+    // ========================================================================
+    // Drain Mode
+    // ========================================================================
+    /**
+     * Enter drain mode: stop accepting new tasks.
+     * Existing queued and running tasks continue to completion.
+     */
+    enterDrainMode() {
+        if (!this.draining) {
+            this.draining = true;
+            this.emitChange('drain-started');
+            this.emit('drain-started');
+            // Check if already idle
+            this.checkIdle();
+        }
+    }
+    /**
+     * Exit drain mode: re-enable normal task acceptance.
+     */
+    exitDrainMode() {
+        if (this.draining) {
+            this.draining = false;
+            // Clear any pending idle resolvers
+            this.idleResolvers = [];
+            this.emitChange('drain-cancelled');
+            this.emit('drain-cancelled');
+        }
+    }
+    /**
+     * Check if the queue is in drain mode.
+     */
+    isDraining() {
+        return this.draining;
+    }
+    /**
+     * Wait until the queue is idle (queued=0 and running=0).
+     * Resolves immediately if already idle.
+     */
+    waitUntilIdle() {
+        const taskCount = this.queue.filter(t => !isPauseMarker(t)).length;
+        if (taskCount === 0 && this.running.size === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.idleResolvers.push(resolve);
+        });
+    }
+    /**
+     * Get counts of queued and running tasks.
+     */
+    getTaskCounts() {
+        const taskCount = this.queue.filter(t => !isPauseMarker(t)).length;
+        return {
+            queued: taskCount,
+            running: this.running.size,
+            total: taskCount + this.running.size,
+        };
+    }
+    /**
+     * Clear all queued tasks and markers (does not affect running or history)
+     */
+    clear() {
+        const clearedItems = [...this.queue];
+        this.queue = [];
+        // Move tasks to history as cancelled; discard markers
+        for (const item of clearedItems) {
+            if (isPauseMarker(item))
+                continue;
+            const task = item;
+            task.status = 'cancelled';
+            task.completedAt = Date.now();
+            this.addToHistory(task);
+        }
+        this.emitChange('cleared');
+    }
+    /**
+     * Restore history entries (e.g. from persisted state on startup).
+     * Prepends tasks to history, respecting maxHistorySize.
+     */
+    restoreHistory(tasks) {
+        if (!this.options.keepHistory || tasks.length === 0) {
+            return;
+        }
+        // Prepend restored tasks (older) after current history (newer)
+        this.history = [...this.history, ...tasks];
+        // Trim to max size
+        if (this.history.length > this.options.maxHistorySize) {
+            this.history = this.history.slice(0, this.options.maxHistorySize);
+        }
+    }
+    /**
+     * Clear history
+     */
+    clearHistory() {
+        this.history = [];
+        this.emitChange('cleared');
+    }
+    /**
+     * Remove a single entry from history by task ID.
+     * @returns true if the entry was found and removed, false otherwise.
+     */
+    removeHistoryEntry(taskId) {
+        const index = this.history.findIndex(t => t.id === taskId);
+        if (index === -1) {
+            return false;
+        }
+        const [task] = this.history.splice(index, 1);
+        this.emitChange('removed', task);
+        return true;
+    }
+    /**
+     * Force-fail all running tasks (e.g., stale processes killed externally).
+     * Moves all running tasks to history with a failed status.
+     * @param error Error message to set on the failed tasks
+     * @returns The number of tasks force-failed
+     */
+    forceFailRunning(error = 'Task was force-failed (assumed stale)') {
+        const runningTasks = Array.from(this.running.values());
+        if (runningTasks.length === 0) {
+            return 0;
+        }
+        for (const task of runningTasks) {
+            task.status = 'failed';
+            task.completedAt = Date.now();
+            task.error = error;
+            this.running.delete(task.id);
+            this.addToHistory(task);
+            this.emitChange('updated', task);
+            this.emit('taskFailed', task, new Error(error));
+        }
+        this.checkIdle();
+        return runningTasks.length;
+    }
+    /**
+     * Force-fail a single running task by ID.
+     * @param id Task ID
+     * @param error Error message
+     * @returns true if task was found and force-failed
+     */
+    forceFailTask(id, error = 'Task was force-failed (assumed stale)') {
+        const task = this.running.get(id);
+        if (!task) {
+            return false;
+        }
+        task.status = 'failed';
+        task.completedAt = Date.now();
+        task.error = error;
+        this.running.delete(id);
+        this.addToHistory(task);
+        this.emitChange('updated', task);
+        this.emit('taskFailed', task, new Error(error));
+        this.checkIdle();
+        return true;
+    }
+    /**
+     * Reset the queue manager (clears everything)
+     */
+    reset() {
+        this.queue = [];
+        this.running.clear();
+        this.history = [];
+        this.paused = false;
+        this.autopilotPaused = false;
+        this.draining = false;
+        this.pausedRepos.clear();
+        // Resolve any pending idle waiters since there's nothing left
+        const resolvers = this.idleResolvers;
+        this.idleResolvers = [];
+        for (const resolve of resolvers) {
+            resolve();
+        }
+        this.emitChange('cleared');
+    }
+    // ========================================================================
+    // Private Helpers
+    // ========================================================================
+    /**
+     * Check if queue is idle and resolve pending waiters
+     */
+    checkIdle() {
+        const taskCount = this.queue.filter(t => !isPauseMarker(t)).length;
+        if (taskCount === 0 && this.running.size === 0 && this.idleResolvers.length > 0) {
+            const resolvers = this.idleResolvers;
+            this.idleResolvers = [];
+            for (const resolve of resolvers) {
+                resolve();
+            }
+        }
+    }
+    /**
+     * Route a task to the correct insertion method based on exclusivity.
+     * Non-exclusive tasks jump before the first exclusive task so they are not
+     * blocked behind an exclusive-limiter backlog. Exclusive tasks use standard
+     * priority insertion.
+     */
+    insertTask(task) {
+        if (this.isExclusiveFn && !this.isExclusiveFn(task)) {
+            this.insertBeforeFirstExclusive(task);
+        }
+        else {
+            this.insertByPriority(task);
+        }
+    }
+    /**
+     * Insert a non-exclusive task right before the first exclusive task in the
+     * queue so it is not blocked behind the exclusive-limiter backlog.
+     * Falls back to insertByPriority if there are no exclusive tasks ahead.
+     * Pause markers are treated as transparent (not exclusive).
+     */
+    insertBeforeFirstExclusive(task) {
+        if (!this.isExclusiveFn) {
+            this.insertByPriority(task);
+            return;
+        }
+        const idx = this.queue.findIndex(item => !isPauseMarker(item) && this.isExclusiveFn(item));
+        if (idx === -1) {
+            // No exclusive tasks in queue — standard priority insertion
+            this.insertByPriority(task);
+        }
+        else {
+            this.queue.splice(idx, 0, task);
+        }
+    }
+    /**
+     * Insert a task into the queue maintaining priority order.
+     * Uses a linear scan because pause markers can interrupt the sorted order.
+     * Markers are transparent in priority comparison — the task is inserted before
+     * the first task with strictly lower priority, which may place it before or
+     * after existing markers.
+     */
+    insertByPriority(task) {
+        let insertAt = this.queue.length;
+        for (let i = 0; i < this.queue.length; i++) {
+            const item = this.queue[i];
+            if (!isPauseMarker(item) && (0, types_1.comparePriority)(task, item) < 0) {
+                insertAt = i;
+                break;
+            }
+        }
+        this.queue.splice(insertAt, 0, task);
+    }
+    /**
+     * Add a task to history, respecting max history size
+     */
+    addToHistory(task) {
+        if (!this.options.keepHistory) {
+            return;
+        }
+        this.history.unshift(task);
+        // Trim history if needed
+        if (this.history.length > this.options.maxHistorySize) {
+            this.history = this.history.slice(0, this.options.maxHistorySize);
+        }
+    }
+    /**
+     * Emit a queue change event
+     */
+    emitChange(type, task) {
+        const event = {
+            type,
+            taskId: task?.id,
+            task,
+            timestamp: Date.now(),
+        };
+        this.emit('change', event);
+    }
+}
+exports.TaskQueueManager = TaskQueueManager;
+/**
+ * Create a new TaskQueueManager instance
+ */
+function createTaskQueueManager(options) {
+    return new TaskQueueManager(options);
+}
+//# sourceMappingURL=task-queue-manager.js.map