kantban-cli 0.1.6 → 0.1.8

package/dist/lib/orchestrator.js

@@ -1,3 +1,19 @@
+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.
  *
@@ -23,12 +39,55 @@ export class PipelineOrchestrator {
     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() {
@@ -46,6 +105,14 @@ export class PipelineOrchestrator {
         }
         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;
@@ -56,8 +123,9 @@ export class PipelineOrchestrator {
      */
     async initialize() {
         const boardScope = await this.deps.fetchBoardScope(this.boardId);
-        // Identify pipeline columns: has_prompt=true AND type !== 'done'
-        const pipelineCols = boardScope.columns.filter((col) => col.has_prompt && col.type !== 'done');
+        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);
@@ -65,13 +133,35 @@ export class PipelineOrchestrator {
             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,
-                worktreePattern: cfg?.worktree?.path_pattern,
+                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);
@@ -87,17 +177,258 @@ export class PipelineOrchestrator {
         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);
         }
-        catch {
-            // Keep stale scope rather than crash
+        // 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
@@ -126,11 +457,16 @@ export class PipelineOrchestrator {
                     this.knownTickets.add(ticketId);
                 }
             }
-            catch {
+            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);
@@ -138,6 +474,12 @@ export class PipelineOrchestrator {
                 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);
@@ -152,15 +494,24 @@ export class PipelineOrchestrator {
             case 'ticket:moved':
             case 'ticket:created': {
                 if (event.columnId && this.pipelineColumns.has(event.columnId)) {
-                    await this.spawnOrQueue(event.ticketId, event.columnId, true);
+                    // 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);
+                    }
                 }
-                // On any move, check if the moved ticket unblocks dependents
                 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; // skip self
+                                continue;
                             if (dep.column_id && this.pipelineColumns.has(dep.column_id)) {
                                 this.knownTickets.delete(dep.id);
                                 this.deferredTickets.delete(dep.id);
@@ -172,10 +523,10 @@ export class PipelineOrchestrator {
                         const msg = err instanceof Error ? err.message : String(err);
                         console.error(`  [warn] Failed to fetch blocked tickets for ${event.ticketId}: ${msg}`);
                     }
-                    // Re-evaluate all deferred tickets — resolution is server-side now
-                    for (const [deferredId, deferredCol] of Array.from(this.deferredTickets)) {
-                        if (deferredId === event.ticketId)
-                            continue; // already handled above
+                    // 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);
@@ -202,6 +553,7 @@ export class PipelineOrchestrator {
                 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);
@@ -217,19 +569,30 @@ export class PipelineOrchestrator {
      * 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) {
+    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
@@ -253,7 +616,10 @@ export class PipelineOrchestrator {
                 this.releaseSlot(columnId);
                 this.deferredTickets.set(ticketId, columnId);
                 console.error(`  [skip] ${ticketId} has unresolved blockers — deferred`);
-                void this.drainQueue(columnId).catch(() => { });
+                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;
             }
         }
@@ -265,7 +631,10 @@ export class PipelineOrchestrator {
             this.spawning.delete(ticketId);
             this.releaseSlot(columnId);
             this.deferredTickets.set(ticketId, columnId);
-            void this.drainQueue(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
@@ -277,6 +646,7 @@ export class PipelineOrchestrator {
             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);
@@ -287,16 +657,161 @@ export class PipelineOrchestrator {
      * 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,
-            ...(config.modelPreference !== undefined && { modelPreference: config.modelPreference }),
+            ...(effectiveModel !== undefined && { model: effectiveModel }),
             ...(config.maxBudgetUsd !== undefined && { maxBudgetUsd: config.maxBudgetUsd }),
-            ...(config.worktreeEnabled !== undefined && { worktreeEnabled: config.worktreeEnabled }),
-            ...(config.worktreePattern !== undefined && { worktreePattern: config.worktreePattern }),
+            // 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);
@@ -309,54 +824,734 @@ export class PipelineOrchestrator {
             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);
-        // Drain queue FIRST to minimize slot idle time (H13)
-        await this.drainQueue(columnId);
-        // Write reason-specific comment
-        let comment;
-        switch (result.reason) {
-            case 'moved':
-                comment = `Pipeline agent advanced ticket after ${result.iterations} iteration(s).`;
+        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 'max_iterations':
-                comment = `Pipeline agent reached iteration limit (${result.iterations}) without advancing. Manual review needed.`;
+            case 'PAUSE_PIPELINE':
+                this.pipelinePaused = true;
                 break;
-            case 'stalled':
-                comment = `Pipeline agent stalled — no progress for ${result.gutterCount} consecutive iterations (of ${result.iterations} total). Manual review needed.`;
+            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 'error':
-                comment = `Pipeline agent encountered an error after ${result.iterations} iteration(s): ${result.lastError ?? 'unknown error'}`;
+            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 'stopped':
-                comment = `Pipeline agent was stopped externally after ${result.iterations} iteration(s).`;
+            case 'ESCALATE_ALL':
+                this.pipelinePaused = true;
                 break;
-            case 'deleted':
-                comment = `Pipeline agent stopped — ticket was deleted or archived during iteration ${result.iterations}.`;
+            case 'ADJUST_BUDGET':
+                console.error('  [replanner] ADJUST_BUDGET requested but not yet implemented — treating as CONTINUE');
                 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}`);
-            });
-        }
     }
     /**
      * Start queued tickets for a column until concurrency limit is reached (H16: fills multiple slots).
@@ -368,6 +1563,11 @@ export class PipelineOrchestrator {
         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);
@@ -389,8 +1589,14 @@ export class PipelineOrchestrator {
                     continue; // try next ticket in queue
                 }
             }
-            catch {
-                // If check fails, proceed anyway — agent will handle it
+            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);
@@ -398,7 +1604,8 @@ export class PipelineOrchestrator {
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
-                console.error(`  [error] Failed to claim queued ticket ${nextTicketId}: ${msg}`);
+                console.error(`  [error] Failed to claim/start queued ticket ${nextTicketId}: ${msg}`);
+                this.knownTickets.delete(nextTicketId);
             }
             finally {
                 this.spawning.delete(nextTicketId);