kantban-cli 0.1.8 → 0.1.10

package/dist/lib/orchestrator.js

@@ -1,1636 +0,0 @@
-import { resolveToolRestrictions } from './tool-profiles.js';
-import { generateWorktreeName } from './worktree.js';
-import { evaluateConstraints } from './constraint-evaluator.js';
-import { classifyTrajectory } from './stuck-detector.js';
-import { readCheckpoint } from './checkpoint.js';
-import { parseVerdict, resolveVerdictAction } from './evaluator.js';
-import { shouldFireReplanner } from './replanner.js';
-export function classifyTier(input) {
-    if (input.invocationTier === 'light')
-        return 'light';
-    if (input.invocationTier === 'heavy')
-        return 'heavy';
-    if (!input.hasPromptDocument)
-        return 'light';
-    return 'heavy';
-}
-/**
- * PipelineOrchestrator — coordination layer for Ralph Loops.
- *
- * Discovers pipeline columns (has_prompt=true, type !== 'done'),
- * spawns loops for tickets with concurrency limits per column,
- * and handles WebSocket events for dynamic ticket arrivals.
- */
-export class PipelineOrchestrator {
-    boardId;
-    projectId;
-    deps;
-    /** Column ID -> column configuration */
-    pipelineColumns = new Map();
-    /** Column ID -> cached column scope (from initialize) */
-    columnScopes = new Map();
-    /** Ticket ID -> active loop tracking */
-    activeLoops = new Map();
-    /** Column ID -> queued ticket IDs (FIFO) */
-    loopQueues = new Map();
-    /** Ticket IDs that have been spawned or queued (prevents re-processing) */
-    knownTickets = new Set();
-    /** Tickets deferred because they have unresolved blockers. Re-queued when a blocker reaches Done. */
-    deferredTickets = new Map(); // ticketId → columnId
-    /** Ticket IDs currently in the spawning process (prevents double-spawn race) */
-    spawning = new Set();
-    /** Ticket IDs currently in onLoopComplete (prevents double-spawn during async advisor recovery) */
-    completing = new Set();
-    /** Per-column reservation count for in-flight spawns (prevents concurrency overshoot) */
-    columnReservations = new Map();
-    /** Cached board scope for constraint evaluation — refreshed each scan cycle */
-    cachedBoardScope = null;
-    /** Last time a loop was spawned per column — for column.last_fired_at subject */
-    lastFiredAt = new Map();
-    /** Column IDs currently blocked by firing constraints (prevents redundant re-evaluation within a scan) */
-    blockedColumns = new Set();
-    /** Per-ticket advisor invocation count for the current column transit */
-    advisorBudget = new Map();
-    /** Per-ticket model override (set by RETRY_DIFFERENT_MODEL, consumed by startTrackedLoop) */
-    ticketModelOverrides = new Map();
-    /** Stable session ID for this orchestrator instance (pipeline run) */
-    sessionId;
-    /** Replanner invocation count for the current pipeline run */
-    replannerInvocations = 0;
-    /** Maximum replanner invocations before auto-pause */
-    replannerMaxInvocations = 3;
-    /** When true, pipeline is paused — scanAndSpawn and spawnOrQueue will skip */
-    pipelinePaused = false;
-    /** Per-column consecutive scope refresh failure counts — auto-pauses after 3 for any column */
-    columnScopeRefreshFailures = new Map();
-    /** Consecutive board scope refresh failure count — auto-pauses after 3 */
-    boardScopeRefreshFailures = 0;
-    /** Timestamp when the pipeline started (for duration-based replanner triggers) */
-    pipelineStartTime = Date.now();
-    constructor(boardId, projectId, deps) {
-        this.boardId = boardId;
-        this.projectId = projectId;
-        this.deps = deps;
-        this.sessionId = crypto.randomUUID();
-    }
-    /**
-     * Execute an async action with logged error handling.
-     * Returns true if the action succeeded, false if it threw.
-     * Non-blocking — callers can ignore the return value for fire-and-forget.
-     */
-    async safeAction(ticketId, label, fn) {
-        try {
-            await fn();
-            return true;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`  [error] ${label} failed for ${ticketId}: ${msg}`);
-            return false;
-        }
-    }
-    /** Returns the IDs of all discovered pipeline columns. */
-    get pipelineColumnIds() {
-        return Array.from(this.pipelineColumns.keys());
-    }
-    /** Returns the total number of active loops. */
-    get activeLoopCount() {
-        return this.activeLoops.size;
-    }
-    /** Returns true if any tickets are queued or deferred (waiting for a slot). */
-    get hasQueuedWork() {
-        for (const [, queue] of this.loopQueues) {
-            if (queue.length > 0)
-                return true;
-        }
-        return this.deferredTickets.size > 0 || this.spawning.size > 0;
-    }
-    /** Returns true if any tickets are queued (waiting for a slot) or spawning — excludes deferred tickets. */
-    get hasActiveQueuedWork() {
-        for (const [, queue] of this.loopQueues) {
-            if (queue.length > 0)
-                return true;
-        }
-        return this.spawning.size > 0;
-    }
-    /** Returns the number of queued (waiting) tickets for a column. */
-    queuedCount(columnId) {
-        return this.loopQueues.get(columnId)?.length ?? 0;
-    }
-    /**
-     * Initialize the orchestrator: fetch board scope, identify pipeline columns,
-     * and fetch column-level agent configs.
-     */
-    async initialize() {
-        const boardScope = await this.deps.fetchBoardScope(this.boardId);
-        this.cachedBoardScope = boardScope;
-        // Identify pipeline columns: (has_prompt=true OR type=evaluator) AND type !== 'done'
-        const pipelineCols = boardScope.columns.filter((col) => (col.has_prompt || col.type === 'evaluator') && col.type !== 'done');
-        // Fetch column scope for each pipeline column to get agent_config and tickets
-        await Promise.all(pipelineCols.map(async (col) => {
-            const colScope = await this.deps.fetchColumnScope(col.id);
-            const cfg = colScope.agent_config;
-            this.pipelineColumns.set(col.id, {
-                columnId: col.id,
-                name: col.name,
-                columnType: col.type,
-                concurrency: cfg?.concurrency ?? 1,
-                maxIterations: cfg?.max_iterations ?? 10,
-                gutterThreshold: cfg?.gutter_threshold ?? 3,
-                modelPreference: cfg?.model_preference,
-                maxBudgetUsd: cfg?.max_budget_usd,
-                worktreeEnabled: cfg?.worktree?.enabled,
-                worktreeOnMove: cfg?.worktree?.on_move,
-                worktreeOnDone: cfg?.worktree?.on_done,
-                invocationTier: cfg?.invocation_tier,
-                lookaheadColumnId: cfg?.lookahead_column_id,
-                runMemory: cfg?.run_memory,
-                advisorEnabled: cfg?.advisor?.enabled,
-                advisorMaxInvocations: cfg?.advisor?.max_invocations ?? 2,
-                advisorModel: cfg?.advisor?.model ?? 'haiku',
-                checkpointEnabled: cfg?.checkpoint,
-                modelRouting: cfg?.model_routing ? {
-                    initial: cfg.model_routing.initial,
-                    escalation: cfg.model_routing.escalation,
-                    escalateAfter: cfg.model_routing.escalate_after ?? 2,
-                } : undefined,
-                stuckDetection: cfg?.stuck_detection?.enabled ? {
-                    enabled: true,
-                    firstCheck: cfg.stuck_detection.first_check ?? 3,
-                    interval: cfg.stuck_detection.interval ?? 2,
-                } : undefined,
-                builtinTools: cfg?.builtin_tools,
-                allowedTools: cfg?.allowed_tools,
-                disallowedTools: cfg?.disallowed_tools,
-            });
-            // Cache column scope for scanAndSpawn
-            this.columnScopes.set(col.id, colScope);
-            // Initialize the queue for this column
-            this.loopQueues.set(col.id, []);
-        }));
-    }
-    /**
-     * Refresh the cached column scope for a single column.
-     * Keeps stale scope on error rather than crashing.
-     */
-    async refreshColumnScope(columnId) {
-        try {
-            const colScope = await this.deps.fetchColumnScope(columnId);
-            this.columnScopes.set(columnId, colScope);
-            this.columnScopeRefreshFailures.delete(columnId);
-        }
-        catch (err) {
-            const count = (this.columnScopeRefreshFailures.get(columnId) ?? 0) + 1;
-            this.columnScopeRefreshFailures.set(columnId, count);
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`  [warn] refreshColumnScope failed for ${columnId} (attempt ${count}, keeping stale): ${msg}`);
-            if (count >= 3) {
-                console.error(`  [error] 3 consecutive scope refresh failures for column ${columnId} — pausing pipeline`);
-                this.pipelinePaused = true;
-            }
-        }
-    }
-    /**
-     * Refresh the cached board scope. Called at the start of each scan cycle
-     * to get fresh ticket counts for constraint evaluation.
-     */
-    async refreshBoardScope() {
-        try {
-            this.cachedBoardScope = await this.deps.fetchBoardScope(this.boardId);
-            this.boardScopeRefreshFailures = 0;
-            // Auto-unpause if pipeline was paused due to scope refresh failures
-            if (this.pipelinePaused) {
-                const anyColumnFailing = Array.from(this.columnScopeRefreshFailures.values()).some(c => c >= 3);
-                if (!anyColumnFailing) {
-                    console.error('  [info] Scope refresh succeeded — unpausing pipeline');
-                    this.pipelinePaused = false;
-                }
-            }
-        }
-        catch (err) {
-            this.boardScopeRefreshFailures++;
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`  [warn] refreshBoardScope failed (attempt ${this.boardScopeRefreshFailures}, keeping stale): ${msg}`);
-            if (this.boardScopeRefreshFailures >= 3) {
-                console.error('  [error] 3 consecutive scope refresh failures — pausing pipeline');
-                this.pipelinePaused = true;
-            }
-        }
-    }
-    /**
-     * Public method to invalidate constraint caches when WS events arrive
-     * (firing_constraint:created/updated/deleted). Forces re-fetch on next access.
-     */
-    async refreshConstraints() {
-        // Re-fetch column scopes to get updated firing_constraints arrays
-        await Promise.all(Array.from(this.pipelineColumns.keys()).map((colId) => this.refreshColumnScope(colId)));
-        this.blockedColumns.clear();
-    }
-    /**
-     * Build the BoardState required by the constraint evaluator from current
-     * orchestrator state + cached board scope.
-     */
-    buildBoardState() {
-        const bs = this.cachedBoardScope;
-        if (!bs) {
-            return {
-                columns: [],
-                active_loops: new Map(),
-                last_fired_at: new Map(),
-                circuit_breaker_count: 0,
-                backlog_ticket_count: 0,
-            };
-        }
-        // Compute active loops per column
-        const activeLoopsPerColumn = new Map();
-        for (const [, loop] of this.activeLoops) {
-            activeLoopsPerColumn.set(loop.columnId, (activeLoopsPerColumn.get(loop.columnId) ?? 0) + 1);
-        }
-        // Compute seconds since last fire per column
-        const now = Date.now();
-        const lastFiredSeconds = new Map();
-        for (const [colId, firedAt] of this.lastFiredAt) {
-            lastFiredSeconds.set(colId, Math.floor((now - firedAt.getTime()) / 1000));
-        }
-        // Circuit breaker count = ticket count in circuit breaker target column
-        let circuitBreakerCount = 0;
-        if (bs.circuit_breaker.target_column_id) {
-            const targetCol = bs.columns.find((c) => c.id === bs.circuit_breaker.target_column_id);
-            if (targetCol)
-                circuitBreakerCount = targetCol.ticket_count;
-        }
-        return {
-            columns: bs.columns.map((c) => ({
-                id: c.id,
-                name: c.name,
-                position: c.position,
-                column_type: c.type,
-                wip_limit: c.wip_limit,
-                ticket_count: c.ticket_count,
-            })),
-            active_loops: activeLoopsPerColumn,
-            last_fired_at: lastFiredSeconds,
-            circuit_breaker_count: circuitBreakerCount,
-            backlog_ticket_count: bs.backlog_ticket_count,
-        };
-    }
-    /**
-     * Convert FiringConstraintLite from column scope to full FiringConstraint
-     * expected by the evaluator.
-     */
-    toFiringConstraints(lites) {
-        return lites.map((c) => ({
-            id: c.id,
-            project_id: this.projectId,
-            board_id: this.boardId,
-            column_id: c.column_id,
-            name: c.name,
-            description: null,
-            enabled: c.enabled,
-            subject_type: c.subject_type,
-            subject_ref: c.subject_ref,
-            subject_param: null,
-            operator: c.operator,
-            value: c.value,
-            scope: c.scope,
-            notify: c.notify,
-            position: 0,
-            fail_open: c.fail_open ?? false,
-            system: c.system ?? false,
-            created_at: '',
-            updated_at: '',
-        }));
-    }
-    /**
-     * Evaluate firing constraints for a column. Returns the EvalResult if any
-     * constraint failed, or null if all passed (column is clear to fire).
-     *
-     * Handles logging and optional signal creation for blocked columns.
-     */
-    evaluateColumnConstraints(columnId) {
-        const colScope = this.columnScopes.get(columnId);
-        // Build constraint list: user-defined + synthetic safety net
-        let constraints = [];
-        if (colScope?.firing_constraints && colScope.firing_constraints.length > 0) {
-            constraints = this.toFiringConstraints(colScope.firing_constraints);
-        }
-        // Synthetic safety net: if this is a pipeline column with a prompt but no
-        // user-defined column.ticket_count constraint, inject one to prevent
-        // firing on empty lanes. This is the runtime guarantee — even if the
-        // persisted system constraint is deleted, we never waste tokens.
-        const hasTicketCountConstraint = constraints.some((c) => c.enabled && c.scope === 'column' && c.subject_type === 'column.ticket_count'
-            && (c.subject_ref === null || c.subject_ref === 'self'));
-        if (!hasTicketCountConstraint && this.pipelineColumns.has(columnId)) {
-            constraints.push({
-                id: '00000000-0000-0000-0000-000000000000',
-                project_id: this.projectId,
-                board_id: this.boardId,
-                column_id: columnId,
-                name: 'Minimum tickets (synthetic)',
-                description: null,
-                enabled: true,
-                subject_type: 'column.ticket_count',
-                subject_ref: null,
-                subject_param: null,
-                operator: 'gt',
-                value: 0,
-                scope: 'column',
-                notify: false,
-                position: -1,
-                fail_open: false,
-                system: true,
-                created_at: '',
-                updated_at: '',
-            });
-        }
-        if (constraints.length === 0) {
-            return null;
-        }
-        const boardState = this.buildBoardState();
-        const result = evaluateConstraints(constraints, boardState, columnId);
-        if (result.summary.failed === 0) {
-            return null; // All passed
-        }
-        // Log each failed constraint clearly
-        const colName = colScope?.column.name ?? columnId;
-        for (const r of result.results) {
-            if (!r.passed && !r.error) {
-                console.error(`  [blocked] Column "${colName}" (${columnId}): constraint "${r.name}" ` +
-                    `FAILED — resolved=${String(r.resolved_value)} ${r.threshold.operator} ${String(r.threshold.value)}`);
-            }
-        }
-        // Emit constraint events
-        for (const r of result.results) {
-            if (!r.passed && !r.error) {
-                this.deps.eventEmitter?.emit({
-                    layer: 'constraint',
-                    eventType: 'constraint_blocked',
-                    severity: 'failure',
-                    summary: `Constraint "${r.name}" blocked [${colName}]`,
-                    detail: {
-                        constraint_name: r.name,
-                        constraint_id: r.constraint_id,
-                        resolved_value: r.resolved_value,
-                        threshold: { operator: r.threshold.operator, value: r.threshold.value },
-                        fail_open: false,
-                        blocked_tickets: [],
-                        column_name: colName,
-                    },
-                    columnId,
-                });
-            }
-        }
-        if (result.summary.errors > 0) {
-            for (const r of result.results) {
-                if (r.error) {
-                    console.error(`  [constraint-error] Column "${colName}" (${columnId}): "${r.name}" — ${r.error} (fail-open)`);
-                }
-            }
-        }
-        // Handle notify flag: create signals for blocked constraints with notify=true
-        const constraintMap = new Map(constraints.map((c) => [c.id, c]));
-        for (const r of result.results) {
-            if (!r.passed && !r.error) {
-                const constraint = constraintMap.get(r.constraint_id);
-                if (constraint?.notify && this.deps.createColumnSignal) {
-                    void this.deps.createColumnSignal(columnId, `Firing constraint "${r.name}" blocked column: ` +
-                        `resolved=${String(r.resolved_value)} ${r.threshold.operator} ${String(r.threshold.value)}`).catch((err) => {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        console.error(`  [warn] Failed to create constraint signal: ${msg}`);
-                    });
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Check if a column is blocked by firing constraints.
-     * Returns true if blocked (should not fire), false if clear.
-     */
-    isColumnBlocked(columnId) {
-        const result = this.evaluateColumnConstraints(columnId);
-        return result !== null;
-    }
-    /**
-     * Scan all pipeline columns for existing tickets and spawn loops.
-     * Refreshes column scopes before scanning to avoid stale ticket lists.
-     * Evaluates firing constraints per column before processing tickets.
-     * Respects per-column concurrency limits — excess tickets are queued.
-     */
-    async scanAndSpawn() {
-        if (this.pipelinePaused) {
-            console.error('  [scan] Pipeline paused by replanner — skipping scan');
-            return;
-        }
-        if (this.deps.costTracker?.isExhausted()) {
-            if (!this.pipelinePaused) {
-                this.pipelinePaused = true;
-                console.error('[budget] Token budget exhausted — pausing pipeline');
-            }
-            return;
-        }
-        // Reset knownTickets each scan cycle so that completed loops can be
-        // re-evaluated on the next poll.  The activeLoops and spawning checks
-        // already prevent true double-spawns; knownTickets only deduplicates
-        // within a single scan (e.g. ticket appearing in stale column scope).
-        this.knownTickets.clear();
-        // Re-populate with tickets that are actively running or queued
-        for (const ticketId of this.activeLoops.keys()) {
-            this.knownTickets.add(ticketId);
-        }
-        for (const [, queue] of this.loopQueues) {
-            for (const ticketId of queue) {
-                this.knownTickets.add(ticketId);
-            }
-        }
-        // Re-evaluate deferred tickets — their blockers may have resolved (H12)
-        // Note: deferred tickets are NOT added to knownTickets so they can be re-spawned
-        for (const [ticketId, columnId] of Array.from(this.deferredTickets)) {
-            try {
-                const stillBlocked = await this.deps.hasUnresolvedBlockers(ticketId);
-                if (!stillBlocked) {
-                    this.deferredTickets.delete(ticketId);
-                    await this.spawnOrQueue(ticketId, columnId, true);
-                }
-                else {
-                    // Still blocked — add to knownTickets so the column scan doesn't re-process it
-                    this.knownTickets.add(ticketId);
-                }
-            }
-            catch (err) {
-                // Leave deferred — will re-evaluate next cycle
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`  [warn] Deferred blocker re-evaluation failed for ${ticketId}: ${msg}`);
-                this.knownTickets.add(ticketId);
-            }
-        }
-        // Refresh board scope for fresh ticket counts used by constraint evaluation
-        await this.refreshBoardScope();
-        this.blockedColumns.clear();
-        for (const [columnId] of this.pipelineColumns) {
-            await this.refreshColumnScope(columnId);
-            const colScope = this.columnScopes.get(columnId);
-            if (!colScope) {
-                console.error(`  [scan] Column ${columnId}: no cached scope`);
-                continue;
-            }
-            // Evaluate column-scope firing constraints BEFORE processing tickets
-            if (this.isColumnBlocked(columnId)) {
-                this.blockedColumns.add(columnId);
-                console.error(`  [scan] Column ${columnId} (${colScope.column.name}): BLOCKED by firing constraints — skipping ${String(colScope.tickets.length)} ticket(s)`);
-                continue;
-            }
-            console.error(`  [scan] Column ${columnId} (${colScope.column.name}): ${String(colScope.tickets.length)} ticket(s)`);
-            for (const ticket of colScope.tickets) {
-                await this.spawnOrQueue(ticket.id, columnId);
-            }
-        }
-    }
-    /**
-     * Handle a pipeline event (typically from WebSocket via EventQueue).
-     */
-    async handleEvent(event) {
-        switch (event.type) {
-            case 'ticket:moved':
-            case 'ticket:created': {
-                if (event.columnId && this.pipelineColumns.has(event.columnId)) {
-                    // Check firing constraints before spawning
-                    if (this.isColumnBlocked(event.columnId)) {
-                        console.error(`  [event] ${event.type} ${event.ticketId} → column ${event.columnId}: BLOCKED by firing constraints — deferred`);
-                        this.deferredTickets.set(event.ticketId, event.columnId);
-                        // Don't break — still need to re-evaluate blockers below for ticket:moved
-                    }
-                    else {
-                        await this.spawnOrQueue(event.ticketId, event.columnId, true);
-                    }
-                }
-                if (event.type === 'ticket:moved') {
-                    let blockedIds = null;
-                    try {
-                        const blocked = await this.deps.fetchBlockedTickets(event.ticketId);
-                        blockedIds = new Set(blocked.map(b => b.id));
-                        for (const dep of blocked) {
-                            if (dep.id === event.ticketId)
-                                continue;
-                            if (dep.column_id && this.pipelineColumns.has(dep.column_id)) {
-                                this.knownTickets.delete(dep.id);
-                                this.deferredTickets.delete(dep.id);
-                                await this.spawnOrQueue(dep.id, dep.column_id, true);
-                            }
-                        }
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        console.error(`  [warn] Failed to fetch blocked tickets for ${event.ticketId}: ${msg}`);
-                    }
-                    // Re-evaluate deferred tickets scoped to those blocked by the moved ticket.
-                    // Falls back to re-evaluating all if fetchBlockedTickets failed (blockedIds is null).
-                    const toReEvaluate = Array.from(this.deferredTickets).filter(([deferredId]) => deferredId !== event.ticketId && (!blockedIds || blockedIds.has(deferredId)));
-                    for (const [deferredId, deferredCol] of toReEvaluate) {
-                        this.knownTickets.delete(deferredId);
-                        this.deferredTickets.delete(deferredId);
-                        await this.spawnOrQueue(deferredId, deferredCol, true);
-                    }
-                }
-                break;
-            }
-            case 'ticket:updated': {
-                // Re-evaluate the ticket if it's deferred in a pipeline column
-                if (event.columnId && this.pipelineColumns.has(event.columnId)) {
-                    if (this.deferredTickets.has(event.ticketId)) {
-                        this.knownTickets.delete(event.ticketId);
-                        this.deferredTickets.delete(event.ticketId);
-                        await this.spawnOrQueue(event.ticketId, event.columnId, true);
-                    }
-                }
-                break;
-            }
-            case 'ticket:deleted':
-            case 'ticket:archived': {
-                // If there's an active loop for this ticket, it will detect the
-                // change via fingerprint/404. We just clean up our tracking.
-                this.activeLoops.delete(event.ticketId);
-                this.knownTickets.delete(event.ticketId);
-                this.deferredTickets.delete(event.ticketId);
-                this.spawning.delete(event.ticketId);
-                this.advisorBudget.delete(event.ticketId);
-                // Also remove from any queue
-                for (const [, queue] of this.loopQueues) {
-                    const idx = queue.indexOf(event.ticketId);
-                    if (idx !== -1) {
-                        queue.splice(idx, 1);
-                    }
-                }
-                break;
-            }
-        }
-    }
-    /**
-     * Spawn a loop for a ticket if under concurrency limit, otherwise queue it.
-     * @param skipKnownCheck - true for event-driven spawns (bypass scan dedup)
-     */
-    async spawnOrQueue(ticketId, columnId, skipKnownCheck = false, skipCompletingCheck = false) {
-        if (this.pipelinePaused)
-            return;
-        // Don't double-spawn
-        if (this.activeLoops.has(ticketId))
-            return;
-        // Prevent double-spawn race: two rapid events passing the activeLoops check
-        if (this.spawning.has(ticketId))
-            return;
-        // Prevent double-spawn during async advisor recovery (H1)
-        // Skipped for retry paths that call spawnOrQueue from within onLoopComplete.
-        if (!skipCompletingCheck && this.completing.has(ticketId))
-            return;
-        // During scanAndSpawn, prevent re-processing tickets seen in other columns
-        if (!skipKnownCheck && this.knownTickets.has(ticketId))
-            return;
-        const colConfig = this.pipelineColumns.get(columnId);
-        if (!colConfig)
-            return;
-        // Belt-and-suspenders: check firing constraints even if already checked at column level.
-        // This catches paths like blocker re-evaluation and deferred ticket re-queue.
-        if (this.isColumnBlocked(columnId)) {
-            return;
-        }
-        // Count active loops for this column
-        const activeInColumn = this.activeCountForColumn(columnId);
-        // Mark as known to prevent re-processing
-        this.knownTickets.add(ticketId);
-        if (activeInColumn >= colConfig.concurrency) {
-            // Queue it
-            const queue = this.loopQueues.get(columnId);
-            if (queue && !queue.includes(ticketId)) {
-                queue.push(ticketId);
-            }
-            return;
-        }
-        // Mark as in-progress spawning to prevent double-spawn race
-        this.spawning.add(ticketId);
-        // Reserve the concurrency slot before the async claimTicket call
-        this.reserveSlot(columnId);
-        try {
-            const blocked = await this.deps.hasUnresolvedBlockers(ticketId);
-            if (blocked) {
-                this.spawning.delete(ticketId);
-                this.releaseSlot(columnId);
-                this.deferredTickets.set(ticketId, columnId);
-                console.error(`  [skip] ${ticketId} has unresolved blockers — deferred`);
-                void this.drainQueue(columnId).catch((err) => {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`  [error] drainQueue failed for column ${columnId}: ${msg}`);
-                });
-                return;
-            }
-        }
-        catch (err) {
-            // Defer rather than proceed — cost of false-defer (retried next scan) is
-            // lower than cost of wasted agent iterations on a blocked ticket (H5)
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`  [warn] Blocker check failed for ${ticketId}, deferring: ${msg}`);
-            this.spawning.delete(ticketId);
-            this.releaseSlot(columnId);
-            this.deferredTickets.set(ticketId, columnId);
-            void this.drainQueue(columnId).catch((err) => {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`  [error] drainQueue failed for column ${columnId}: ${msg}`);
-            });
-            return;
-        }
-        // Spawn the loop
-        try {
-            await this.deps.claimTicket(ticketId);
-            this.startTrackedLoop(ticketId, columnId, colConfig);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`  [error] Failed to claim ticket ${ticketId}: ${msg}`);
-            this.knownTickets.delete(ticketId);
-            this.deferredTickets.set(ticketId, columnId); // Re-evaluate on next move/scan
-        }
-        finally {
-            this.spawning.delete(ticketId);
-            this.releaseSlot(columnId);
-        }
-    }
-    /**
-     * Start a loop and track it. Attach completion handler for cleanup + queue drain.
-     */
-    startTrackedLoop(ticketId, columnId, config) {
-        // Evaluator columns always use heavy tier (need full tool access for adversarial review)
-        const tier = config.columnType === 'evaluator' ? 'heavy' : classifyTier({
-            hasPromptDocument: this.columnScopes.get(columnId)?.prompt_document != null,
-            invocationTier: config.invocationTier,
-        });
-        if (tier === 'light' && this.deps.dispatchLightCall) {
-            const promise = this.deps.dispatchLightCall(ticketId, columnId).then(async (response) => {
-                try {
-                    switch (response.action) {
-                        case 'move_ticket': {
-                            const targetColId = response.params.column_id;
-                            if (targetColId && this.deps.moveTicketToColumn) {
-                                await this.deps.moveTicketToColumn(ticketId, targetColId, {
-                                    reason: response.reason,
-                                    source: 'light_call',
-                                });
-                            }
-                            return { reason: 'moved', iterations: 1, gutterCount: 0 };
-                        }
-                        case 'set_field_value': {
-                            if (this.deps.setFieldValue) {
-                                const fieldName = response.params.field_name;
-                                const value = response.params.value;
-                                if (fieldName)
-                                    await this.deps.setFieldValue(ticketId, fieldName, value);
-                            }
-                            return { reason: 'stalled', iterations: 1, gutterCount: 0 };
-                        }
-                        case 'archive_ticket': {
-                            if (this.deps.archiveTicket) {
-                                await this.deps.archiveTicket(ticketId);
-                            }
-                            return { reason: 'moved', iterations: 1, gutterCount: 0 };
-                        }
-                        case 'create_comment': {
-                            const body = response.params.body;
-                            if (body)
-                                await this.deps.createComment(ticketId, body);
-                            return { reason: 'stalled', iterations: 1, gutterCount: 0 };
-                        }
-                        case 'no_action':
-                        default:
-                            return { reason: 'stalled', iterations: 1, gutterCount: 0 };
-                    }
-                }
-                catch (err) {
-                    return {
-                        reason: 'error',
-                        iterations: 1,
-                        gutterCount: 0,
-                        lastError: err instanceof Error ? err.message : String(err),
-                    };
-                }
-            }, (err) => ({
-                reason: 'error',
-                iterations: 1,
-                gutterCount: 0,
-                lastError: err instanceof Error ? err.message : String(err),
-            }));
-            this.activeLoops.set(ticketId, { columnId, promise });
-            // Track last fire time for column.last_fired_at constraint subject
-            this.lastFiredAt.set(columnId, new Date());
-            void promise.then((result) => this.onLoopComplete(ticketId, columnId, result).catch((err) => {
-                console.error(`onLoopComplete error for ${ticketId}:`, err);
-            }));
-            return;
-        }
-        // Consume any model override (set by RETRY_DIFFERENT_MODEL advisor action)
-        const modelOverride = this.ticketModelOverrides.get(ticketId);
-        this.ticketModelOverrides.delete(ticketId);
-        // Read checkpoint if enabled — resume from saved iteration/gutter/model state
-        if (config.checkpointEnabled && this.deps.getFieldValues) {
-            // Placeholder to prevent double-spawn during async checkpoint read.
-            // Times out after 30s as a safety net — if checkpoint read hangs,
-            // the ticket won't be permanently locked.
-            let timeoutId;
-            const placeholder = new Promise((_, reject) => {
-                timeoutId = setTimeout(() => {
-                    // Set completing guard FIRST to prevent scanAndSpawn from grabbing this ticket
-                    this.completing.add(ticketId);
-                    this.activeLoops.delete(ticketId);
-                    this.knownTickets.delete(ticketId);
-                    // Clear completing — ticket is fully released now, guard was only needed during cleanup
-                    this.completing.delete(ticketId);
-                    console.error(`  [warn] Checkpoint read timed out for ${ticketId} — releasing lock`);
-                    reject(new Error('Checkpoint read timeout'));
-                }, 30_000);
-            });
-            placeholder.catch(() => { }); // Prevent unhandled rejection
-            this.activeLoops.set(ticketId, { columnId, promise: placeholder });
-            this.lastFiredAt.set(columnId, new Date());
-            // Note: setFieldValue is required by CheckpointDeps interface but only used by
-            // writeCheckpoint/clearCheckpoint, not readCheckpoint.
-            void readCheckpoint({
-                setFieldValue: async () => { },
-                getFieldValues: this.deps.getFieldValues,
-            }, ticketId, columnId).then((checkpoint) => {
-                clearTimeout(timeoutId);
-                if (checkpoint) {
-                    console.error(`  [checkpoint] Resuming ${ticketId} at iteration ${String(checkpoint.iteration + 1)} (model: ${checkpoint.model_tier})`);
-                    this.startLoopWithConfig(ticketId, columnId, config, checkpoint.iteration + 1, checkpoint.gutter_count, modelOverride ?? checkpoint.model_tier, checkpoint.last_fingerprint);
-                }
-                else {
-                    this.startLoopWithConfig(ticketId, columnId, config, undefined, undefined, modelOverride);
-                }
-            }).catch((err) => {
-                clearTimeout(timeoutId);
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`  [warn] Checkpoint read failed for ${ticketId} (starting fresh): ${msg}`);
-                this.startLoopWithConfig(ticketId, columnId, config, undefined, undefined, modelOverride);
-            });
-            return;
-        }
-        // No checkpoint — start directly
-        this.startLoopWithConfig(ticketId, columnId, config, undefined, undefined, modelOverride);
-    }
-    /**
-     * Build a LoopConfig and start a loop, tracking it in activeLoops.
-     * Handles model routing resolution: resumeModelTier > modelRouting.initial > modelPreference.
-     */
-    startLoopWithConfig(ticketId, columnId, config, startIteration, startGutterCount, resumeModelTier, startFingerprint) {
-        // Resolve effective model: resume tier > routing initial > column preference
-        const effectiveModel = resumeModelTier
-            ?? config.modelRouting?.initial
-            ?? config.modelPreference;
-        const loopConfig = {
-            maxIterations: config.maxIterations,
-            gutterThreshold: config.gutterThreshold,
-            ...(effectiveModel !== undefined && { model: effectiveModel }),
-            ...(config.maxBudgetUsd !== undefined && { maxBudgetUsd: config.maxBudgetUsd }),
-            // Resolve worktree name from ticket context
-            ...((() => {
-                const colScope = this.columnScopes.get(columnId);
-                const ticket = colScope?.tickets.find(t => t.id === ticketId);
-                const wName = config.worktreeEnabled && ticket
-                    ? generateWorktreeName(ticket.ticket_number, config.name)
-                    : undefined;
-                return wName !== undefined ? { worktreeName: wName } : {};
-            })()),
-            ...(config.lookaheadColumnId !== undefined && { lookaheadColumnId: config.lookaheadColumnId }),
-            // Resume from checkpoint iteration/gutter if provided
-            ...(startIteration !== undefined && { startIteration }),
-            ...(startGutterCount !== undefined && { startGutterCount }),
-            ...(startFingerprint !== undefined && { startFingerprint }),
-            ...(config.stuckDetection && { stuckDetection: config.stuckDetection }),
-        };
-        // Resolve tool profile for this column
-        const toolRestrictions = resolveToolRestrictions(config.builtinTools, config.allowedTools, config.disallowedTools);
-        if (toolRestrictions.tools !== undefined || toolRestrictions.allowedTools || toolRestrictions.disallowedTools) {
-            loopConfig.toolRestrictions = toolRestrictions;
-        }
-        const promise = this.deps.startLoop(ticketId, columnId, loopConfig);
-        this.activeLoops.set(ticketId, { columnId, promise });
-        // Track last fire time for column.last_fired_at constraint subject
-        this.lastFiredAt.set(columnId, new Date());
-        // Attach completion handler — do NOT await
-        void promise.then((result) => this.onLoopComplete(ticketId, columnId, result).catch((err) => {
-            console.error(`onLoopComplete error for ${ticketId}:`, err);
-        }), (err) => this.onLoopComplete(ticketId, columnId, {
-            reason: 'error',
-            iterations: 0,
-            gutterCount: 0,
-            lastError: err instanceof Error ? err.message : String(err),
-        }).catch((completionErr) => {
-            console.error(`onLoopComplete error for ${ticketId}:`, completionErr);
-        }));
-    }
-    /**
-     * Phase 2: Invoke the advisor for failure recovery.
-     * Returns true if the ticket should be retried, false if handled.
-     */
-    async invokeAdvisorRecovery(ticketId, columnId, result, colConfig) {
-        if (!this.deps.invokeAdvisor)
-            return false;
-        if (!colConfig.advisorEnabled)
-            return false;
-        const remaining = this.advisorBudget.get(ticketId) ?? colConfig.advisorMaxInvocations ?? 2;
-        if (remaining <= 0)
-            return false;
-        const colScope = this.columnScopes.get(columnId);
-        // ticketDescription: ColumnTicket does not carry a description field (only id, ticket_number,
-        // title). The full description is fetched lazily by the loop itself and is not propagated back
-        // in LoopResult. Leave empty — the advisor prompt shows the title and field values instead.
-        const input = {
-            ticketTitle: '',
-            ticketDescription: '',
-            ticketId,
-            ticketNumber: 0,
-            columnName: colScope?.column.name ?? columnId,
-            exitReason: result.reason,
-            iterations: result.iterations,
-            gutterCount: result.gutterCount,
-            ...(result.lastError !== undefined && { lastError: result.lastError }),
-            // recentComments: LoopResult does not carry comments; leave empty.
-            recentComments: [],
-            fieldValues: [],
-            failurePatterns: '',
-            remainingBudget: remaining,
-            modelTier: result.model ?? colConfig.modelPreference ?? 'default',
-            escalationModels: colConfig.modelRouting?.escalation ?? [],
-            ...(this.cachedBoardScope?.circuit_breaker.target_column_id != null && {
-                circuitBreakerTargetId: this.cachedBoardScope.circuit_breaker.target_column_id,
-            }),
-        };
-        const ticket = colScope?.tickets.find((t) => t.id === ticketId);
-        if (ticket) {
-            input.ticketTitle = ticket.title;
-            input.ticketNumber = ticket.ticket_number;
-        }
-        // Populate failurePatterns from the latest gate snapshot — gives the advisor concrete
-        // signal about which gates are failing and what their output looks like.
-        if (this.deps.gateSnapshotStore) {
-            const latest = this.deps.gateSnapshotStore.getLatest(ticketId);
-            if (latest) {
-                const failedGates = latest.results.filter((r) => !r.passed);
-                if (failedGates.length > 0) {
-                    input.failurePatterns = failedGates
-                        .map((r) => {
-                        const label = r.required ? `${r.name} (required)` : r.name;
-                        const snippet = r.output ? ` — ${r.output.slice(0, 300)}` : '';
-                        return `${label}${snippet}`;
-                    })
-                        .join('\n');
-                }
-            }
-        }
-        // Enrich advisor context with field values
-        if (this.deps.getFieldValues) {
-            try {
-                input.fieldValues = await this.deps.getFieldValues(ticketId);
-            }
-            catch (err) {
-                // Non-blocking — advisor works with partial context
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`  [warn] Advisor getFieldValues failed for ${ticketId}: ${msg}`);
-            }
-        }
-        // Enrich with gate data from snapshot store
-        if (this.deps.gateSnapshotStore) {
-            const recentSnapshots = this.deps.gateSnapshotStore.getRecent(ticketId, 3);
-            if (recentSnapshots.length > 0) {
-                input.gateHistory = recentSnapshots;
-                const latest = this.deps.gateSnapshotStore.getLatest(ticketId);
-                if (latest) {
-                    input.currentGateResults = latest.results;
-                }
-                input.trajectory = classifyTrajectory(recentSnapshots);
-            }
-        }
-        let response;
-        try {
-            response = await this.deps.invokeAdvisor(input);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`  [advisor] Failed for ${ticketId}: ${msg} — falling back to default behavior`);
-            return false;
-        }
-        // Decrement after successful call — transient errors don't waste budget
-        this.advisorBudget.set(ticketId, remaining - 1);
-        // Emit advisor event
-        const gateSnapshot = this.deps.gateSnapshotStore?.getLatest(ticketId);
-        const gatePassed = gateSnapshot ? gateSnapshot.results.filter(r => r.passed).length : 0;
-        const gateTotal = gateSnapshot ? gateSnapshot.results.length : 0;
-        this.deps.eventEmitter?.emit({
-            layer: 'advisor',
-            eventType: `advisor_${response.action.toLowerCase()}`,
-            severity: response.action === 'ESCALATE' ? 'failure' : response.action === 'RETRY_WITH_FEEDBACK' || response.action === 'RETRY_DIFFERENT_MODEL' ? 'info' : 'warning',
-            summary: `Advisor: ${response.action} — ${response.reason.slice(0, 200)}`,
-            detail: {
-                action: response.action,
-                reason: response.reason,
-                feedback: response.feedback ?? null,
-                budget_remaining: `${String(remaining - 1)}/${String(colConfig.advisorMaxInvocations ?? 2)}`,
-                gate_summary: gateTotal > 0 ? { passed: gatePassed, total: gateTotal } : null,
-                trajectory: input.trajectory ? { status: input.trajectory.status, confidence: input.trajectory.confidence } : null,
-                ticket_number: ticket?.ticket_number ?? null,
-            },
-            ticketId,
-            columnId,
-        });
-        switch (response.action) {
-            case 'RETRY_WITH_FEEDBACK': {
-                if (response.feedback) {
-                    await this.safeAction(ticketId, 'advisor:createComment', () => this.deps.createComment(ticketId, `ADVISOR FEEDBACK:\n${response.feedback}`));
-                }
-                // activeLoops.delete already ran at top of onLoopComplete.
-                this.knownTickets.delete(ticketId);
-                await this.spawnOrQueue(ticketId, columnId, true, true);
-                // Clear completing guard AFTER spawnOrQueue to prevent concurrent scanAndSpawn racing in.
-                this.completing.delete(ticketId);
-                return true;
-            }
-            case 'RETRY_DIFFERENT_MODEL': {
-                // Resolve next model from escalation ladder
-                const currentModel = result.model ?? colConfig.modelPreference ?? 'default';
-                const escalation = colConfig.modelRouting?.escalation ?? [];
-                let nextModel;
-                // Find current model's position in the full ladder [initial, ...escalation]
-                const fullLadder = colConfig.modelRouting
-                    ? [colConfig.modelRouting.initial, ...colConfig.modelRouting.escalation]
-                    : [];
-                const currentIdx = fullLadder.indexOf(currentModel);
-                if (currentIdx >= 0 && currentIdx < fullLadder.length - 1) {
-                    nextModel = fullLadder[currentIdx + 1];
-                }
-                else if (escalation.length > 0) {
-                    // Current model not in ladder — use first escalation model
-                    nextModel = escalation[0];
-                }
-                const escalatedModel = nextModel ?? currentModel;
-                if (escalatedModel === currentModel) {
-                    // Already at top of escalation ladder — cannot escalate further
-                    return false;
-                }
-                await this.safeAction(ticketId, 'advisor:createComment', () => this.deps.createComment(ticketId, `ADVISOR: Escalating model ${currentModel} → ${escalatedModel} — ${response.reason}`));
-                this.knownTickets.delete(ticketId);
-                // Store model override and go through spawnOrQueue to respect concurrency
-                this.ticketModelOverrides.set(ticketId, escalatedModel);
-                await this.spawnOrQueue(ticketId, columnId, true, true);
-                // Clear completing guard AFTER spawnOrQueue to prevent concurrent scanAndSpawn racing in.
-                this.completing.delete(ticketId);
-                return true;
-            }
-            case 'RELAX_WITH_DEBT': {
-                // Extract waived gates once — used for both field storage and move metadata
-                const waivedGates = (response.debt_items ?? [])
-                    .filter((d) => d.type === 'waived_gate')
-                    .map((d) => d.description);
-                if (response.debt_items && response.debt_items.length > 0 && this.deps.setFieldValue) {
-                    const items = response.debt_items.map((d) => ({ ...d, source_column: colScope?.column.name ?? '' }));
-                    await this.safeAction(ticketId, 'advisor:setFieldValue:debt_items', () => this.deps.setFieldValue(ticketId, 'debt_items', items));
-                    // Record waived gates on ticket — gate proxy will skip these
-                    if (waivedGates.length > 0) {
-                        await this.safeAction(ticketId, 'advisor:setFieldValue:gate_waiver', () => this.deps.setFieldValue(ticketId, 'gate_waiver', waivedGates));
-                    }
-                    await this.safeAction(ticketId, 'advisor:createSignal:debt', () => this.deps.createSignal(ticketId, `DEBT: This ticket advanced with ${String(items.length)} unresolved items (${String(items.filter((d) => d.severity === 'high').length)} high, ${String(items.filter((d) => d.severity === 'medium').length)} medium).`));
-                    // G4: Propagate upstream debt signal to blocked tickets
-                    if (this.deps.fetchBlockedTickets) {
-                        try {
-                            const blocked = await this.deps.fetchBlockedTickets(ticketId);
-                            const ticketNum = colScope?.tickets.find((t) => t.id === ticketId)?.ticket_number;
-                            for (const dep of blocked) {
-                                if (dep.id === ticketId)
-                                    continue;
-                                await this.safeAction(dep.id, 'advisor:createSignal:upstream_debt', () => this.deps.createSignal(dep.id, `UPSTREAM DEBT: Blocking ticket #${String(ticketNum ?? '?')} advanced with debt. Review debt_items before building on its interfaces.`));
-                            }
-                        }
-                        catch (err) {
-                            // Non-blocking
-                            const msg = err instanceof Error ? err.message : String(err);
-                            console.error(`  [warn] Upstream debt signal propagation failed for ${ticketId}: ${msg}`);
-                        }
-                    }
-                }
-                await this.safeAction(ticketId, 'advisor:createComment', () => this.deps.createComment(ticketId, `ADVISOR: Relaxing with debt — ${response.reason}`));
-                // G3: Move ticket to next column (by board position)
-                if (this.deps.moveTicketToColumn) {
-                    const nextColumn = this.findNextColumn(columnId);
-                    if (nextColumn) {
-                        const moved = await this.safeAction(ticketId, 'advisor:moveTicket', () => this.deps.moveTicketToColumn(ticketId, nextColumn.columnId, {
-                            relaxed_with_debt: true,
-                            source_column: colScope?.column.name,
-                            debt_item_count: response.debt_items?.length ?? 0,
-                            gate_waivers: waivedGates,
-                        }));
-                        if (!moved) {
-                            await this.safeAction(ticketId, 'advisor:failComment', () => this.deps.createComment(ticketId, `ADVISOR: Attempted to move ticket but the operation failed. Manual intervention needed.`));
-                        }
-                    }
-                }
-                return false;
-            }
-            case 'SPLIT_TICKET': {
-                if (response.split_specs && response.split_specs.length > 0 && this.deps.createTickets) {
-                    try {
-                        await this.deps.createTickets(ticketId, response.split_specs);
-                        // Only archive parent after children are successfully created
-                        if (this.deps.archiveTicket) {
-                            await this.safeAction(ticketId, 'advisor:archiveTicket', () => this.deps.archiveTicket(ticketId));
-                        }
-                    }
-                    catch (err) {
-                        // createTickets failed — do not archive the parent
-                        const msg = err instanceof Error ? err.message : String(err);
-                        console.error(`  [warn] SPLIT_TICKET createTickets failed for ${ticketId}: ${msg}`);
-                    }
-                }
-                await this.safeAction(ticketId, 'advisor:createComment', () => this.deps.createComment(ticketId, `ADVISOR: Split ticket — ${response.reason}`));
-                return false;
-            }
-            case 'ESCALATE': {
-                const targetColId = this.cachedBoardScope?.circuit_breaker.target_column_id;
-                if (targetColId && this.deps.moveTicketToColumn) {
-                    const moved = await this.safeAction(ticketId, 'advisor:moveTicket', () => this.deps.moveTicketToColumn(ticketId, targetColId, {
-                        escalation_reason: response.reason,
-                        source_column: colScope?.column.name,
-                    }));
-                    if (!moved) {
-                        await this.safeAction(ticketId, 'advisor:failComment', () => this.deps.createComment(ticketId, `ADVISOR: Attempted to move ticket but the operation failed. Manual intervention needed.`));
-                    }
-                }
-                await this.safeAction(ticketId, 'advisor:createComment', () => this.deps.createComment(ticketId, `ADVISOR: Escalated for human review — ${response.reason}`));
-                return false;
-            }
-        }
-        return false;
-    }
-    /**
-     * Handle evaluator column verdict: parse the output, determine action, move ticket accordingly.
-     */
-    async handleEvaluatorVerdict(ticketId, columnId, result, colConfig) {
-        const verdict = parseVerdict(result.output ?? '');
-        // Circuit breaker: if verdict parse failed, hold ticket for manual review instead of bouncing
-        if ('parseFailed' in verdict && verdict.parseFailed) {
-            await this.deps.createComment(ticketId, `EVALUATOR: Verdict could not be parsed — ticket held for manual review.\n\nRaw output: ${(result.output ?? '').slice(0, 500)}`).catch((e) => {
-                console.error(`  [warn] Failed to write parse-failure comment for ${ticketId}: ${e instanceof Error ? e.message : String(e)}`);
-            });
-            return;
-        }
-        const action = resolveVerdictAction(verdict);
-        // Emit evaluator verdict event
-        const blockers = verdict.findings.filter((f) => f.severity === 'blocker');
-        const warnings = verdict.findings.filter((f) => f.severity === 'warning');
-        const nits = verdict.findings.filter((f) => f.severity === 'nit');
-        this.deps.eventEmitter?.emit({
-            layer: 'evaluator',
-            eventType: action === 'forward' ? 'evaluator_approved'
-                : action === 'reject' ? 'evaluator_rejected'
-                    : 'evaluator_forwarded',
-            severity: action === 'forward' ? 'info'
-                : action === 'reject' ? 'failure'
-                    : 'warning',
-            summary: `Evaluator: ${action} (${String(blockers.length)} blockers, ${String(warnings.length)} warnings, ${String(nits.length)} nits)`,
-            detail: {
-                decision: verdict.decision,
-                summary: verdict.summary,
-                findings: verdict.findings,
-                ticket_number: this.columnScopes.get(columnId)?.tickets.find(t => t.id === ticketId)?.ticket_number ?? null,
-            },
-            ticketId,
-            columnId,
-        });
-        switch (action) {
-            case 'forward': {
-                // Move to next column with verdict in handoff
-                if (this.deps.moveTicketToColumn) {
-                    const nextColumn = this.findNextColumn(columnId);
-                    if (nextColumn) {
-                        const moved = await this.safeAction(ticketId, 'evaluator:moveTicket:forward', () => this.deps.moveTicketToColumn(ticketId, nextColumn.columnId, {
-                            evaluator_verdict: 'approved',
-                            verdict_summary: verdict.summary,
-                        }));
-                        if (!moved) {
-                            await this.safeAction(ticketId, 'evaluator:failComment', () => this.deps.createComment(ticketId, `EVALUATOR: Attempted to move ticket forward but the operation failed. Manual intervention needed.`));
-                        }
-                    }
-                }
-                await this.safeAction(ticketId, 'evaluator:createComment', () => this.deps.createComment(ticketId, `EVALUATOR: Approved — ${verdict.summary}`));
-                break;
-            }
-            case 'reject': {
-                // Move BACK to previous column (source column) with rejection comment
-                if (this.deps.moveTicketToColumn) {
-                    const prevColumn = this.findPreviousColumn(columnId);
-                    if (prevColumn) {
-                        const moved = await this.safeAction(ticketId, 'evaluator:moveTicket:reject', () => this.deps.moveTicketToColumn(ticketId, prevColumn.columnId, {
-                            evaluator_verdict: 'rejected',
-                            verdict_summary: verdict.summary,
-                            findings: verdict.findings,
-                        }));
-                        if (!moved) {
-                            await this.safeAction(ticketId, 'evaluator:failComment', () => this.deps.createComment(ticketId, `EVALUATOR: Attempted to reject ticket but the move operation failed. Manual intervention needed.`));
-                        }
-                    }
-                }
-                const findingsText = verdict.findings
-                    .map((f) => `- [${f.severity}] ${f.description}${f.file ? ` (${f.file}${f.line ? `:${String(f.line)}` : ''})` : ''}`)
-                    .join('\n');
-                await this.safeAction(ticketId, 'evaluator:createComment', () => this.deps.createComment(ticketId, `EVALUATOR: Rejected — ${verdict.summary}\n\n${findingsText}`));
-                break;
-            }
-            case 'forward_with_signals': {
-                // Move forward, attach findings as signals
-                if (this.deps.moveTicketToColumn) {
-                    const nextColumn = this.findNextColumn(columnId);
-                    if (nextColumn) {
-                        const moved = await this.safeAction(ticketId, 'evaluator:moveTicket:forward_with_signals', () => this.deps.moveTicketToColumn(ticketId, nextColumn.columnId, {
-                            evaluator_verdict: 'approved_with_warnings',
-                            verdict_summary: verdict.summary,
-                        }));
-                        if (!moved) {
-                            await this.safeAction(ticketId, 'evaluator:failComment', () => this.deps.createComment(ticketId, `EVALUATOR: Attempted to move ticket forward but the operation failed. Manual intervention needed.`));
-                        }
-                    }
-                }
-                // Create signals for each finding
-                for (const f of verdict.findings) {
-                    await this.safeAction(ticketId, 'evaluator:createSignal', () => this.deps.createSignal(ticketId, `EVALUATOR: [${f.severity}] ${f.description}`));
-                }
-                await this.safeAction(ticketId, 'evaluator:createComment', () => this.deps.createComment(ticketId, `EVALUATOR: Forwarded with ${String(verdict.findings.length)} warning(s) — ${verdict.summary}`));
-                break;
-            }
-        }
-    }
-    /**
-     * Find the previous pipeline column by board position (for evaluator rejections — send back to worker).
-     * Returns null if current column is the first pipeline column.
-     */
-    findPreviousColumn(currentColumnId) {
-        const bs = this.cachedBoardScope;
-        if (!bs)
-            return null;
-        const currentBoardCol = bs.columns.find((c) => c.id === currentColumnId);
-        if (!currentBoardCol)
-            return null;
-        // Find previous column by position that is a pipeline column
-        const prevBoardCol = bs.columns
-            .filter((c) => c.position < currentBoardCol.position && this.pipelineColumns.has(c.id))
-            .sort((a, b) => b.position - a.position)[0]; // sort descending, take first (closest)
-        return prevBoardCol ? this.pipelineColumns.get(prevBoardCol.id) ?? null : null;
-    }
-    /**
-     * Find the next pipeline column by board position (for RELAX_WITH_DEBT forward moves).
-     * Returns null if current column is the last pipeline column.
-     */
-    findNextColumn(currentColumnId) {
-        const bs = this.cachedBoardScope;
-        if (!bs)
-            return null;
-        const currentBoardCol = bs.columns.find((c) => c.id === currentColumnId);
-        if (!currentBoardCol)
-            return null;
-        // Find next column by position that is a pipeline column
-        const nextBoardCol = bs.columns
-            .filter((c) => c.position > currentBoardCol.position && this.pipelineColumns.has(c.id))
-            .sort((a, b) => a.position - b.position)[0];
-        return nextBoardCol ? this.pipelineColumns.get(nextBoardCol.id) ?? null : null;
-    }
-    /**
-     * Called when a loop finishes. Cleans up tracking and drains the queue.
-     */
-    async onLoopComplete(ticketId, columnId, result) {
-        // H1: Mark as completing before removing from activeLoops.
-        // Guards the async window (advisor LLM call, replanner, etc.) against double-spawn.
-        this.completing.add(ticketId);
-        this.activeLoops.delete(ticketId);
-        try {
-            // Resolve ticket_number and invocation_type for event detail
-            const colScope = this.columnScopes.get(columnId);
-            const ticket = colScope?.tickets.find(t => t.id === ticketId);
-            const colCfg = this.pipelineColumns.get(columnId);
-            const invocationType = colCfg?.columnType === 'evaluator' ? 'evaluator'
-                : colCfg?.invocationTier === 'light' ? 'light' : 'heavy';
-            // Emit session-end event
-            this.deps.eventEmitter?.emit({
-                layer: 'session',
-                eventType: result.reason === 'error' ? 'session_error' : 'session_ended',
-                severity: result.reason === 'error' ? 'failure' : 'info',
-                summary: `Session ended: ${result.reason} (${String(result.iterations)} iter${result.model ? `, ${result.model}` : ''})`,
-                detail: {
-                    model: result.model ?? null,
-                    invocation_type: invocationType,
-                    duration_ms: result.durationMs ?? null,
-                    tokens_in: result.tokensIn ?? null,
-                    tokens_out: result.tokensOut ?? null,
-                    tool_call_count: result.toolCallCount ?? null,
-                    exit_reason: result.reason,
-                    gutter_count: result.gutterCount,
-                    worktree_name: colCfg?.worktreeEnabled && ticket
-                        ? generateWorktreeName(ticket.ticket_number, colCfg.name) : null,
-                    ticket_number: ticket?.ticket_number ?? null,
-                },
-                ticketId,
-                columnId,
-                iteration: result.iterations,
-            });
-            // Emit gate events from final snapshot
-            if (result.finalGateSnapshot && this.deps.eventEmitter) {
-                const gateSnapshots = this.deps.gateSnapshotStore?.getRecent(ticketId, 10) ?? [];
-                const trajectory = gateSnapshots.length > 0 ? classifyTrajectory(gateSnapshots) : null;
-                for (const gate of result.finalGateSnapshot.results) {
-                    const history = gateSnapshots.map(s => {
-                        const gr = s.results.find(r => r.name === gate.name);
-                        return gr ? { passed: gr.passed, iteration: s.iteration } : null;
-                    }).filter(Boolean);
-                    this.deps.eventEmitter.emit({
-                        layer: 'gate',
-                        eventType: gate.passed ? 'gate_passed' : 'gate_failed',
-                        severity: gate.passed ? 'info' : 'failure',
-                        summary: `Gate "${gate.name}" ${gate.passed ? 'passed' : gate.timed_out ? 'timed out' : 'failed'} for ${ticket ? `PET-${String(ticket.ticket_number)}` : ticketId.slice(0, 8)}`,
-                        detail: {
-                            gate_name: gate.name,
-                            exit_code: gate.exit_code,
-                            duration_ms: gate.duration_ms,
-                            required: gate.required,
-                            timed_out: gate.timed_out,
-                            output: gate.output.slice(0, 2000),
-                            gate_history: history,
-                            trajectory: trajectory?.status ?? null,
-                            ticket_number: ticket?.ticket_number ?? null,
-                        },
-                        ticketId,
-                        columnId,
-                        iteration: result.iterations,
-                    });
-                }
-            }
-            // Emit cost event
-            if (this.deps.eventEmitter && this.deps.costTracker) {
-                const tc = this.deps.costTracker.getTicketCost(ticketId);
-                if (tc) {
-                    const totalIn = this.deps.costTracker.totalTokensIn;
-                    const totalOut = this.deps.costTracker.totalTokensOut;
-                    const maxIn = this.deps.costTracker.maxInputTokens;
-                    const pctUsed = maxIn > 0 ? Math.round(((totalIn + totalOut) / (maxIn * 2)) * 100) : 0;
-                    const severity = this.deps.costTracker.isExhausted() ? 'failure'
-                        : this.deps.costTracker.isWarning() ? 'warning' : 'info';
-                    this.deps.eventEmitter.emit({
-                        layer: 'cost',
-                        eventType: this.deps.costTracker.isExhausted() ? 'budget_exhausted'
-                            : this.deps.costTracker.isWarning() ? 'budget_warning' : 'tokens_tracked',
-                        severity,
-                        summary: `Token usage: ${String(result.tokensIn ?? 0)} in / ${String(result.tokensOut ?? 0)} out`,
-                        detail: {
-                            tokens_in: result.tokensIn ?? 0,
-                            tokens_out: result.tokensOut ?? 0,
-                            pct_used: pctUsed,
-                            max_tokens: maxIn,
-                            ticket_number: ticket?.ticket_number ?? null,
-                        },
-                        ticketId,
-                        columnId,
-                        iteration: result.iterations,
-                    });
-                }
-            }
-            // Evaluator verdict handling — overrides normal loop completion
-            const colConfig = this.pipelineColumns.get(columnId);
-            // Shared terminal cleanup — runs for ALL exit paths including evaluator
-            const terminalCleanup = async () => {
-                this.advisorBudget.delete(ticketId);
-                if (colConfig?.checkpointEnabled && this.deps.setFieldValue) {
-                    await this.safeAction(ticketId, 'clearCheckpoint', () => this.deps.setFieldValue(ticketId, 'loop_checkpoint', null));
-                }
-                const isTerminal = result.reason === 'moved' || result.reason === 'max_iterations' || result.reason === 'error' || result.reason === 'stalled' || result.reason === 'stopped' || result.reason === 'deleted';
-                if (isTerminal && colConfig?.worktreeOnDone === 'cleanup' && this.deps.cleanupWorktree) {
-                    const colScope = this.columnScopes.get(columnId);
-                    const ticket = colScope?.tickets.find(t => t.id === ticketId);
-                    if (ticket) {
-                        const worktreeName = generateWorktreeName(ticket.ticket_number, colConfig.name);
-                        void this.deps.cleanupWorktree(worktreeName).then((success) => {
-                            if (!success) {
-                                console.error(`  [warn] Worktree cleanup failed for ${worktreeName} — may need manual removal`);
-                            }
-                        }).catch((err) => {
-                            console.error(`  [warn] Worktree cleanup error for ${worktreeName}: ${err instanceof Error ? err.message : String(err)}`);
-                        });
-                    }
-                }
-                this.deps.gateSnapshotStore?.clear(ticketId);
-            };
-            if (colConfig?.columnType === 'evaluator') {
-                await this.handleEvaluatorVerdict(ticketId, columnId, result, colConfig);
-                await this.drainQueue(columnId);
-                await terminalCleanup();
-                return;
-            }
-            // Advisor recovery for failure exits — runs before drain
-            // so the retry slot isn't filled by a queued ticket
-            const isFailure = result.reason === 'stalled' || result.reason === 'error' || result.reason === 'max_iterations';
-            if (isFailure && colConfig) {
-                const retried = await this.invokeAdvisorRecovery(ticketId, columnId, result, colConfig);
-                if (retried)
-                    return; // Advisor re-spawned the loop — skip drain + default behavior
-            }
-            // Drain queue to minimize slot idle time (H13) — after advisor to preserve retry slot
-            await this.drainQueue(columnId);
-            // Check replanner triggers after advisor recovery, before comments
-            if (this.deps.invokeReplanner && !this.pipelinePaused) {
-                const state = this.buildPipelineState();
-                const triggers = {
-                    escalation_count: 3,
-                    cost_threshold_pct: 75,
-                    repeated_gate_failure_count: 3,
-                    duration_threshold_minutes: 480,
-                };
-                if (shouldFireReplanner(triggers, state) && this.replannerInvocations < this.replannerMaxInvocations) {
-                    this.replannerInvocations++;
-                    try {
-                        // Build ticket summaries from cached column scopes
-                        const ticketSummaries = [];
-                        for (const [colId, scope] of this.columnScopes) {
-                            const colConfig = this.pipelineColumns.get(colId);
-                            const columnName = colConfig?.name ?? colId;
-                            const colQueue = this.loopQueues.get(colId) ?? [];
-                            for (const ticket of scope.tickets) {
-                                const isActive = this.activeLoops.has(ticket.id);
-                                const isQueued = colQueue.includes(ticket.id);
-                                const status = isActive ? 'active' : isQueued ? 'queued' : 'idle';
-                                // Get gate pass rate from snapshot store if available
-                                let gatePassRate = 0;
-                                if (this.deps.gateSnapshotStore) {
-                                    const latest = this.deps.gateSnapshotStore.getLatest(ticket.id);
-                                    if (latest) {
-                                        const total = latest.results.length;
-                                        const passed = latest.results.filter(r => r.passed).length;
-                                        gatePassRate = total > 0 ? passed / total : 0;
-                                    }
-                                }
-                                ticketSummaries.push({
-                                    id: ticket.id,
-                                    title: ticket.title,
-                                    column: columnName,
-                                    status,
-                                    iterations: 0, // Not tracked at orchestrator level
-                                    gatePassRate,
-                                });
-                            }
-                        }
-                        const triggerReason = this.identifyTriggerReason(triggers, state);
-                        const response = await this.deps.invokeReplanner({
-                            ...state,
-                            ticketSummaries,
-                            triggerReason,
-                        });
-                        // Emit replanner event
-                        this.deps.eventEmitter?.emit({
-                            layer: 'replanner',
-                            eventType: `replanner_${response.action.toLowerCase()}`,
-                            severity: response.action === 'CONTINUE' ? 'info'
-                                : response.action === 'PAUSE_PIPELINE' ? 'warning' : 'info',
-                            summary: `Replanner: ${response.action} — ${response.reason.slice(0, 200)}`,
-                            detail: {
-                                action: response.action,
-                                reason: response.reason,
-                            },
-                        });
-                        await this.executeReplannerAction(response);
-                        // Only count non-CONTINUE responses toward the auto-pause limit
-                        if (response.action === 'CONTINUE') {
-                            this.replannerInvocations--; // Don't count CONTINUE toward limit
-                        }
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        console.error(`  [replanner] Failed: ${msg} — pausing pipeline for safety`);
-                        this.pipelinePaused = true;
-                    }
-                }
-                if (this.replannerInvocations >= this.replannerMaxInvocations) {
-                    this.pipelinePaused = true;
-                    console.error('Replanner fired 3 non-CONTINUE actions — auto-pausing pipeline');
-                }
-            }
-            // Write reason-specific comment
-            let comment;
-            switch (result.reason) {
-                case 'moved':
-                    comment = `Pipeline agent advanced ticket after ${result.iterations} iteration(s).`;
-                    // Append loop success to run memory
-                    if (this.deps.appendRunMemory) {
-                        await this.safeAction(ticketId, 'appendRunMemory', () => this.deps.appendRunMemory('Discovered Interfaces', `- Ticket ${ticketId} completed in ${colConfig?.name ?? columnId} after ${String(result.iterations)} iteration(s)`));
-                    }
-                    break;
-                case 'max_iterations':
-                    comment = `Pipeline agent reached iteration limit (${result.iterations}) without advancing. Manual review needed.`;
-                    break;
-                case 'stalled':
-                    comment = `Pipeline agent stalled — no progress for ${result.gutterCount} consecutive iterations (of ${result.iterations} total). Manual review needed.`;
-                    break;
-                case 'error':
-                    comment = `Pipeline agent encountered an error after ${result.iterations} iteration(s): ${result.lastError ?? 'unknown error'}`;
-                    break;
-                case 'stopped':
-                    comment = `Pipeline agent was stopped externally after ${result.iterations} iteration(s).`;
-                    break;
-                case 'deleted':
-                    comment = `Pipeline agent stopped — ticket was deleted or archived during iteration ${result.iterations}.`;
-                    break;
-            }
-            if (result.reason !== 'deleted') {
-                await this.deps.createComment(ticketId, comment).catch((err) => {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`  [warn] Failed to write completion comment for ${ticketId}: ${msg}`);
-                });
-            }
-            // Create signal for failure exits so future agents inherit the context
-            if (result.reason === 'stalled') {
-                await this.deps.createSignal(ticketId, `Previous pipeline run stalled after ${result.iterations} iterations with no progress. Review comments for details before retrying.`).catch((err) => {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`  [warn] Failed to write signal for ${ticketId}: ${msg}`);
-                });
-            }
-            else if (result.reason === 'error') {
-                await this.deps.createSignal(ticketId, `Previous pipeline run failed after ${result.iterations} iteration(s): ${result.lastError ?? 'unknown error'}. Review comments for details before retrying.`).catch((err) => {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`  [warn] Failed to write signal for ${ticketId}: ${msg}`);
-                });
-            }
-            // Shared terminal cleanup — advisor budget, checkpoint, worktree, snapshot memory
-            await terminalCleanup();
-        }
-        finally {
-            this.completing.delete(ticketId);
-        }
-    }
-    /**
-     * Build PipelineState from orchestrator internals for replanner evaluation.
-     */
-    buildPipelineState() {
-        const costTracker = this.deps.costTracker;
-        const totalTokensIn = costTracker ? costTracker.totalTokensIn : 0;
-        const maxInputTokens = costTracker ? costTracker.maxInputTokens : 5_000_000;
-        // Count escalated tickets — those moved to circuit breaker target column
-        let escalatedTickets = 0;
-        const targetColId = this.cachedBoardScope?.circuit_breaker.target_column_id;
-        if (targetColId) {
-            const targetCol = this.cachedBoardScope?.columns.find((c) => c.id === targetColId);
-            if (targetCol)
-                escalatedTickets = targetCol.ticket_count;
-        }
-        // Compute repeated gate failures from snapshot store
-        const repeatedGateFailures = {};
-        if (this.deps.gateSnapshotStore) {
-            const ticketIds = this.deps.gateSnapshotStore.getAllTicketIds();
-            for (const tid of ticketIds) {
-                const latest = this.deps.gateSnapshotStore.getLatest(tid);
-                if (latest) {
-                    for (const r of latest.results) {
-                        if (!r.passed) {
-                            repeatedGateFailures[r.name] = (repeatedGateFailures[r.name] ?? 0) + 1;
-                        }
-                    }
-                }
-            }
-        }
-        const durationMinutes = (Date.now() - this.pipelineStartTime) / 60_000;
-        return { escalatedTickets, totalTokensIn, maxInputTokens, repeatedGateFailures, durationMinutes };
-    }
-    /**
-     * Identify which trigger condition caused the replanner to fire.
-     */
-    identifyTriggerReason(triggers, state) {
-        const reasons = [];
-        if (state.escalatedTickets >= triggers.escalation_count) {
-            reasons.push(`${String(state.escalatedTickets)} tickets escalated (threshold: ${String(triggers.escalation_count)})`);
-        }
-        if (state.maxInputTokens > 0) {
-            const pct = (state.totalTokensIn / state.maxInputTokens) * 100;
-            if (pct >= triggers.cost_threshold_pct) {
-                reasons.push(`Token usage at ${pct.toFixed(0)}% (threshold: ${String(triggers.cost_threshold_pct)}%)`);
-            }
-        }
-        for (const [gate, count] of Object.entries(state.repeatedGateFailures)) {
-            if (count >= triggers.repeated_gate_failure_count) {
-                reasons.push(`Gate "${gate}" failing on ${String(count)} ticket(s) (threshold: ${String(triggers.repeated_gate_failure_count)})`);
-            }
-        }
-        if (state.durationMinutes >= triggers.duration_threshold_minutes) {
-            reasons.push(`Pipeline running for ${state.durationMinutes.toFixed(0)}min (threshold: ${String(triggers.duration_threshold_minutes)}min)`);
-        }
-        return reasons.length > 0 ? reasons.join('; ') : 'Unknown trigger';
-    }
-    /**
-     * Execute the action returned by the replanner.
-     */
-    async executeReplannerAction(response) {
-        switch (response.action) {
-            case 'CONTINUE':
-                break;
-            case 'PAUSE_PIPELINE':
-                this.pipelinePaused = true;
-                break;
-            case 'ARCHIVE_TICKETS':
-                if (response.ticket_ids && this.deps.archiveTicket) {
-                    for (const id of response.ticket_ids) {
-                        await this.safeAction(id, 'replanner:archiveTicket', () => this.deps.archiveTicket(id));
-                    }
-                }
-                break;
-            case 'CREATE_SIGNAL':
-                if (response.signal_content && this.deps.createColumnSignal) {
-                    for (const colId of this.pipelineColumns.keys()) {
-                        await this.safeAction(colId, 'replanner:createColumnSignal', () => this.deps.createColumnSignal(colId, response.signal_content));
-                    }
-                }
-                break;
-            case 'ESCALATE_ALL':
-                this.pipelinePaused = true;
-                break;
-            case 'ADJUST_BUDGET':
-                console.error('  [replanner] ADJUST_BUDGET requested but not yet implemented — treating as CONTINUE');
-                break;
-        }
-    }
-    /**
-     * Start queued tickets for a column until concurrency limit is reached (H16: fills multiple slots).
-     */
-    async drainQueue(columnId) {
-        const colConfig = this.pipelineColumns.get(columnId);
-        if (!colConfig)
-            return;
-        const queue = this.loopQueues.get(columnId);
-        if (!queue || queue.length === 0)
-            return;
-        // Check firing constraints before draining — if column is now blocked, stop
-        if (this.isColumnBlocked(columnId)) {
-            console.error(`  [drain] Column ${columnId}: BLOCKED by firing constraints — ${String(queue.length)} ticket(s) remain queued`);
-            return;
-        }
-        // Loop to fill all available slots (H16)
-        while (queue.length > 0) {
-            const activeInColumn = this.activeCountForColumn(columnId);
-            if (activeInColumn >= colConfig.concurrency)
-                return;
-            const nextTicketId = queue.shift();
-            // Guard against double-spawn race with concurrent scanAndSpawn (C2)
-            if (this.spawning.has(nextTicketId) || this.activeLoops.has(nextTicketId)) {
-                continue;
-            }
-            this.spawning.add(nextTicketId);
-            this.reserveSlot(columnId);
-            try {
-                const blocked = await this.deps.hasUnresolvedBlockers(nextTicketId);
-                if (blocked) {
-                    this.deferredTickets.set(nextTicketId, columnId);
-                    this.spawning.delete(nextTicketId);
-                    this.releaseSlot(columnId);
-                    continue; // try next ticket in queue
-                }
-            }
-            catch (err) {
-                // If check fails, defer rather than proceeding with potentially blocked ticket
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`  [warn] drainQueue blocker check failed for ${nextTicketId}: ${msg} — deferring`);
-                this.deferredTickets.set(nextTicketId, columnId);
-                this.spawning.delete(nextTicketId);
-                this.releaseSlot(columnId);
-                continue;
-            }
-            try {
-                await this.deps.claimTicket(nextTicketId);
-                this.startTrackedLoop(nextTicketId, columnId, colConfig);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`  [error] Failed to claim/start queued ticket ${nextTicketId}: ${msg}`);
-                this.knownTickets.delete(nextTicketId);
-            }
-            finally {
-                this.spawning.delete(nextTicketId);
-                this.releaseSlot(columnId);
-            }
-        }
-    }
-    /**
-     * Count active loops + in-flight reservations for a specific column.
-     */
-    activeCountForColumn(columnId) {
-        let count = 0;
-        for (const [, loop] of this.activeLoops) {
-            if (loop.columnId === columnId)
-                count++;
-        }
-        return count + (this.columnReservations.get(columnId) ?? 0);
-    }
-    reserveSlot(columnId) {
-        this.columnReservations.set(columnId, (this.columnReservations.get(columnId) ?? 0) + 1);
-    }
-    releaseSlot(columnId) {
-        const current = this.columnReservations.get(columnId) ?? 0;
-        if (current > 0)
-            this.columnReservations.set(columnId, current - 1);
-    }
-}
-//# sourceMappingURL=orchestrator.js.map