@plusplusoneplusplus/coc 1.0.0 → 1.0.1

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

@@ -1,1059 +0,0 @@
-"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