kantban-cli 0.1.8 → 0.1.11

package/dist/pipeline-7LG74YA2.js

@@ -0,0 +1,4098 @@
+import {
+  LoopCheckpointSchema,
+  RalphLoop,
+  VerdictSchema,
+  classifyTrajectory,
+  cleanupGateProxyConfigs,
+  cleanupMcpConfig,
+  composeStuckDetectionPrompt,
+  generateGateProxyMcpConfig,
+  generateMcpConfig,
+  parseGateConfig,
+  parseJsonFromLlmOutput,
+  parseStuckDetectionResponse,
+  parseTimeout,
+  resolveGatesForColumn
+} from "./chunk-ZCUIGFSP.js";
+
+// src/commands/pipeline.ts
+import { spawn as spawn2, execSync } from "child_process";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync2, unlinkSync as unlinkSync2, existsSync, appendFileSync as appendFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/lib/tool-profiles.ts
+function resolveToolRestrictions(builtinTools, allowedTools, disallowedTools) {
+  const hasRestrictions = builtinTools !== void 0 || allowedTools && allowedTools.length > 0 || disallowedTools && disallowedTools.length > 0;
+  if (!hasRestrictions) {
+    return { includeMcpConfig: true };
+  }
+  return {
+    ...builtinTools !== void 0 && { tools: builtinTools },
+    ...allowedTools && allowedTools.length > 0 && { allowedTools },
+    ...disallowedTools && disallowedTools.length > 0 && { disallowedTools },
+    includeMcpConfig: true
+  };
+}
+
+// src/lib/worktree.ts
+import { execFile as defaultExecFile } from "child_process";
+function generateWorktreeName(ticketNumber, columnName) {
+  const slug = columnName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return `kantban-${ticketNumber}-${slug}`;
+}
+async function cleanupWorktree(worktreeName, exec = defaultExecFile) {
+  return new Promise((resolve) => {
+    exec("git", ["worktree", "remove", "--force", worktreeName], (err) => {
+      if (err) {
+        console.error(`[worktree] cleanup failed for ${worktreeName}: ${err.message}`);
+        resolve(false);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+function execPromise(exec, cmd, args) {
+  return new Promise((resolve, reject) => {
+    exec(cmd, args, (err, stdout, stderr) => {
+      if (err) reject(Object.assign(err, { stdout, stderr }));
+      else resolve({ stdout, stderr });
+    });
+  });
+}
+async function mergeWorktreeBranch(worktreeName, integrationBranch, exec = defaultExecFile) {
+  try {
+    await execPromise(exec, "git", ["branch", integrationBranch, "HEAD"]).catch(() => {
+    });
+    const { stdout: baseOut } = await execPromise(exec, "git", ["merge-base", integrationBranch, worktreeName]);
+    const mergeBase = baseOut.trim();
+    const { stdout: integrationSha } = await execPromise(exec, "git", ["rev-parse", integrationBranch]);
+    if (integrationSha.trim() === mergeBase) {
+      const { stdout: worktreeSha } = await execPromise(exec, "git", ["rev-parse", worktreeName]);
+      await execPromise(exec, "git", ["update-ref", `refs/heads/${integrationBranch}`, worktreeSha.trim()]);
+      console.error(`[worktree] fast-forward merged ${worktreeName} \u2192 ${integrationBranch}`);
+      return true;
+    }
+    const tmpWorktree = `merge-tmp-${Date.now()}`;
+    try {
+      await execPromise(exec, "git", ["worktree", "add", tmpWorktree, integrationBranch]);
+      await execPromise(exec, "git", ["-C", tmpWorktree, "merge", "--no-edit", worktreeName]);
+      console.error(`[worktree] merged ${worktreeName} \u2192 ${integrationBranch}`);
+    } finally {
+      await execPromise(exec, "git", ["worktree", "remove", "--force", tmpWorktree]).catch(() => {
+      });
+    }
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[worktree] merge failed for ${worktreeName} \u2192 ${integrationBranch}: ${msg}`);
+    return false;
+  }
+}
+
+// src/lib/constraint-evaluator.ts
+function resolveColumn(board, columnId, subjectRef) {
+  const ref = subjectRef ?? "self";
+  if (ref === "self" || ref === null) {
+    const col2 = board.columns.find((c) => c.id === columnId) ?? null;
+    return { column: col2, error: col2 ? null : `Column ${columnId} not found` };
+  }
+  if (ref === "next") {
+    const sorted = [...board.columns].sort((a, b) => a.position - b.position);
+    const idx = sorted.findIndex((c) => c.id === columnId);
+    const next = idx >= 0 && idx < sorted.length - 1 ? sorted[idx + 1] : null;
+    return { column: next, error: next ? null : "No next column exists" };
+  }
+  if (ref === "prev") {
+    const sorted = [...board.columns].sort((a, b) => a.position - b.position);
+    const idx = sorted.findIndex((c) => c.id === columnId);
+    const prev = idx > 0 ? sorted[idx - 1] : null;
+    return { column: prev, error: prev ? null : "No prev column exists" };
+  }
+  const col = board.columns.find((c) => c.id === ref) ?? null;
+  return { column: col, error: col ? null : `Column ${ref} not found` };
+}
+function applyOperator(resolved, operator, threshold) {
+  if (operator === "eq" || operator === "neq") {
+    const rn = Number(resolved);
+    const tn = Number(threshold);
+    const bothNumeric = !isNaN(rn) && !isNaN(tn) && resolved !== "" && threshold !== "";
+    const equal = bothNumeric ? rn === tn : resolved === threshold;
+    return operator === "eq" ? equal : !equal;
+  }
+  const r = Number(resolved);
+  const t = Number(threshold);
+  if (isNaN(r) || isNaN(t)) return false;
+  switch (operator) {
+    case "lt":
+      return r < t;
+    case "lte":
+      return r <= t;
+    case "gt":
+      return r > t;
+    case "gte":
+      return r >= t;
+    default:
+      return false;
+  }
+}
+function evaluateConstraints(constraints, board, columnId, now) {
+  const enabled = constraints.filter((c) => c.enabled && c.scope === "column").sort((a, b) => a.position - b.position);
+  const results = [];
+  const summary = { total: 0, passed: 0, failed: 0, errors: 0 };
+  for (const constraint of enabled) {
+    summary.total++;
+    let resolvedValue = null;
+    let resolveError = null;
+    const subjectType = constraint.subject_type;
+    const subjectRef = constraint.subject_ref;
+    switch (subjectType) {
+      case "column.ticket_count": {
+        const { column, error } = resolveColumn(board, columnId, subjectRef);
+        if (error || !column) {
+          resolveError = error ?? "Column resolution failed";
+        } else {
+          resolvedValue = column.ticket_count;
+        }
+        break;
+      }
+      case "column.active_loops": {
+        const { column, error } = resolveColumn(board, columnId, subjectRef);
+        if (error || !column) {
+          resolveError = error ?? "Column resolution failed";
+        } else {
+          resolvedValue = board.active_loops.get(column.id) ?? 0;
+        }
+        break;
+      }
+      case "column.wip_remaining": {
+        const { column, error } = resolveColumn(board, columnId, subjectRef);
+        if (error || !column) {
+          resolveError = error ?? "Column resolution failed";
+        } else {
+          resolvedValue = column.wip_limit === null ? 999999 : column.wip_limit - column.ticket_count;
+        }
+        break;
+      }
+      case "column.last_fired_at": {
+        const { column, error } = resolveColumn(board, columnId, subjectRef);
+        if (error || !column) {
+          resolveError = error ?? "Column resolution failed";
+        } else {
+          const secondsSinceLastFire = board.last_fired_at.get(column.id);
+          resolvedValue = secondsSinceLastFire ?? 999999;
+        }
+        break;
+      }
+      case "board.total_active_loops": {
+        let total = 0;
+        for (const v of board.active_loops.values()) {
+          total += v;
+        }
+        resolvedValue = total;
+        break;
+      }
+      case "board.circuit_breaker_count": {
+        resolvedValue = board.circuit_breaker_count;
+        break;
+      }
+      case "backlog.ticket_count": {
+        resolvedValue = board.backlog_ticket_count;
+        break;
+      }
+      case "ticket.field_value": {
+        resolveError = "ticket.field_value requires ticket context (ticket-scope only)";
+        resolvedValue = null;
+        break;
+      }
+      case "time.hour": {
+        const date = now ?? /* @__PURE__ */ new Date();
+        resolvedValue = date.getUTCHours();
+        break;
+      }
+      default: {
+        resolveError = `Unknown subject type: ${subjectType}`;
+        break;
+      }
+    }
+    if (resolveError !== null) {
+      summary.errors++;
+      const failOpen = constraint.fail_open === true;
+      const passed2 = failOpen;
+      results.push({
+        constraint_id: constraint.id,
+        name: constraint.name,
+        column_id: constraint.column_id,
+        passed: passed2,
+        resolved_value: null,
+        threshold: { operator: constraint.operator, value: constraint.value },
+        error: failOpen ? `Unresolvable (fail_open=true): ${resolveError}` : `Unresolvable (fail-closed): ${resolveError}`
+      });
+      if (passed2) {
+        summary.passed++;
+      } else {
+        summary.failed++;
+      }
+      continue;
+    }
+    const passed = applyOperator(resolvedValue, constraint.operator, constraint.value);
+    results.push({
+      constraint_id: constraint.id,
+      name: constraint.name,
+      column_id: constraint.column_id,
+      passed,
+      resolved_value: resolvedValue,
+      threshold: { operator: constraint.operator, value: constraint.value }
+    });
+    if (passed) {
+      summary.passed++;
+    } else {
+      summary.failed++;
+    }
+  }
+  return { results, summary };
+}
+
+// src/lib/checkpoint.ts
+var CHECKPOINT_FIELD = "loop_checkpoint";
+var DEFAULT_STALE_THRESHOLD_MINUTES = 600;
+async function readCheckpoint(deps, ticketId, currentColumnId, staleMinutes) {
+  try {
+    const fields = await deps.getFieldValues(ticketId);
+    const entry = fields.find((f) => f.field_name === CHECKPOINT_FIELD);
+    if (!entry) return null;
+    const parsed = LoopCheckpointSchema.safeParse(entry.value);
+    if (!parsed.success) return null;
+    const checkpoint = parsed.data;
+    if (checkpoint.column_id !== currentColumnId) return null;
+    const threshold = Math.max(staleMinutes ?? DEFAULT_STALE_THRESHOLD_MINUTES, 1);
+    const updatedAt = new Date(checkpoint.updated_at).getTime();
+    const ageMinutes = (Date.now() - updatedAt) / (1e3 * 60);
+    if (ageMinutes > threshold) return null;
+    return checkpoint;
+  } catch (err) {
+    console.warn(`[checkpoint] readCheckpoint failed for ${ticketId}: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+
+// src/lib/evaluator.ts
+function parseVerdict(raw) {
+  try {
+    const parsed = parseJsonFromLlmOutput(raw);
+    return VerdictSchema.parse(parsed);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown";
+    return {
+      decision: "reject",
+      summary: `Evaluator verdict parse error: ${msg.slice(0, 100)}`,
+      findings: [{ severity: "blocker", description: `Verdict parse error \u2014 raw output did not contain valid JSON verdict. Error: ${msg.slice(0, 200)}` }],
+      parseFailed: true
+    };
+  }
+}
+function resolveVerdictAction(verdict) {
+  if (verdict.decision === "approve") return "forward";
+  const hasBlockers = verdict.findings.some((f) => f.severity === "blocker");
+  if (hasBlockers || verdict.findings.length === 0) return "reject";
+  return "forward_with_signals";
+}
+
+// src/lib/replanner.ts
+import { z } from "zod";
+function shouldFireReplanner(triggers, state) {
+  if (state.escalatedTickets >= triggers.escalation_count) return true;
+  if (state.maxInputTokens > 0) {
+    const pct = state.totalTokensIn / state.maxInputTokens * 100;
+    if (pct >= triggers.cost_threshold_pct) return true;
+  }
+  for (const count of Object.values(state.repeatedGateFailures)) {
+    if (count >= triggers.repeated_gate_failure_count) return true;
+  }
+  if (state.durationMinutes >= triggers.duration_threshold_minutes) return true;
+  return false;
+}
+var ReplannerActionSchema = z.enum([
+  "CONTINUE",
+  "PAUSE_PIPELINE",
+  "ARCHIVE_TICKETS",
+  "CREATE_SIGNAL",
+  "ADJUST_BUDGET",
+  "ESCALATE_ALL"
+]);
+var ReplannerResponseSchema = z.object({
+  action: ReplannerActionSchema,
+  reason: z.string(),
+  ticket_ids: z.array(z.string()).optional(),
+  signal_content: z.string().optional(),
+  new_max_input_tokens: z.number().optional()
+});
+function composeReplannerPrompt(state) {
+  const parts = [];
+  parts.push("You are a pipeline replanner. A trigger threshold has been crossed.");
+  parts.push(`
+Trigger: ${state.triggerReason}`);
+  parts.push(`
+Pipeline State:`);
+  parts.push(`- Escalated tickets: ${state.escalatedTickets}`);
+  parts.push(`- Token usage: ${state.totalTokensIn} / ${state.maxInputTokens}`);
+  parts.push(`- Duration: ${state.durationMinutes} minutes`);
+  if (Object.keys(state.repeatedGateFailures).length > 0) {
+    parts.push(`
+Repeated gate failures:`);
+    for (const [gate, count] of Object.entries(state.repeatedGateFailures)) {
+      parts.push(`- ${gate}: ${count} tickets failing`);
+    }
+  }
+  parts.push(`
+Ticket summaries:`);
+  for (const t of state.ticketSummaries) {
+    parts.push(`- ${t.title} [${t.column}] status=${t.status} iterations=${t.iterations} gate_pass=${t.gatePassRate}%`);
+  }
+  parts.push(`
+Actions available: CONTINUE, PAUSE_PIPELINE, ARCHIVE_TICKETS, CREATE_SIGNAL, ADJUST_BUDGET, ESCALATE_ALL`);
+  parts.push(`
+Be conservative. Primary value is knowing when to stop.`);
+  parts.push(`
+Respond with a JSON object: { "action": "...", "reason": "..." }`);
+  return parts.join("\n");
+}
+function parseReplannerResponse(raw) {
+  try {
+    const parsed = parseJsonFromLlmOutput(raw);
+    return ReplannerResponseSchema.parse(parsed);
+  } catch {
+    return { action: "PAUSE_PIPELINE", reason: "Failed to parse replanner response \u2014 defaulting to pause for safety" };
+  }
+}
+
+// src/lib/orchestrator.ts
+function classifyTier(input) {
+  if (input.invocationTier === "light") return "light";
+  if (input.invocationTier === "heavy") return "heavy";
+  if (!input.hasPromptDocument) return "light";
+  return "heavy";
+}
+var PipelineOrchestrator = class {
+  boardId;
+  projectId;
+  deps;
+  /** Column ID -> column configuration */
+  pipelineColumns = /* @__PURE__ */ new Map();
+  /** Column ID -> cached column scope (from initialize) */
+  columnScopes = /* @__PURE__ */ new Map();
+  /** Ticket ID -> active loop tracking */
+  activeLoops = /* @__PURE__ */ new Map();
+  /** Column ID -> queued ticket IDs (FIFO) */
+  loopQueues = /* @__PURE__ */ new Map();
+  /** Ticket IDs that have been spawned or queued (prevents re-processing) */
+  knownTickets = /* @__PURE__ */ new Set();
+  /** Tickets deferred because they have unresolved blockers. Re-queued when a blocker reaches Done. */
+  deferredTickets = /* @__PURE__ */ new Map();
+  // ticketId → columnId
+  /** Ticket IDs currently in the spawning process (prevents double-spawn race) */
+  spawning = /* @__PURE__ */ new Set();
+  /** Ticket IDs currently in onLoopComplete (prevents double-spawn during async advisor recovery) */
+  completing = /* @__PURE__ */ new Set();
+  /** Per-column reservation count for in-flight spawns (prevents concurrency overshoot) */
+  columnReservations = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+  /** Column IDs currently blocked by firing constraints (prevents redundant re-evaluation within a scan) */
+  blockedColumns = /* @__PURE__ */ new Set();
+  /** Per-ticket advisor invocation count for the current column transit */
+  advisorBudget = /* @__PURE__ */ new Map();
+  /** Per-ticket model override (set by RETRY_DIFFERENT_MODEL, consumed by startTrackedLoop) */
+  ticketModelOverrides = /* @__PURE__ */ 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 = /* @__PURE__ */ 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;
+    const pipelineCols = boardScope.columns.filter(
+      (col) => (col.has_prompt || col.type === "evaluator") && col.type !== "done"
+    );
+    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,
+          worktreeIntegrationBranch: cfg?.worktree?.integration_branch,
+          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
+          } : void 0,
+          stuckDetection: cfg?.stuck_detection?.enabled ? {
+            enabled: true,
+            firstCheck: cfg.stuck_detection.first_check ?? 3,
+            interval: cfg.stuck_detection.interval ?? 2
+          } : void 0,
+          builtinTools: cfg?.builtin_tools,
+          allowedTools: cfg?.allowed_tools,
+          disallowedTools: cfg?.disallowed_tools
+        });
+        this.columnScopes.set(col.id, colScope);
+        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} \u2014 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;
+      if (this.pipelinePaused) {
+        const anyColumnFailing = Array.from(this.columnScopeRefreshFailures.values()).some((c) => c >= 3);
+        if (!anyColumnFailing) {
+          console.error("  [info] Scope refresh succeeded \u2014 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 \u2014 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() {
+    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: /* @__PURE__ */ new Map(),
+        last_fired_at: /* @__PURE__ */ new Map(),
+        circuit_breaker_count: 0,
+        backlog_ticket_count: 0
+      };
+    }
+    const activeLoopsPerColumn = /* @__PURE__ */ new Map();
+    for (const [, loop] of this.activeLoops) {
+      activeLoopsPerColumn.set(loop.columnId, (activeLoopsPerColumn.get(loop.columnId) ?? 0) + 1);
+    }
+    const now = Date.now();
+    const lastFiredSeconds = /* @__PURE__ */ new Map();
+    for (const [colId, firedAt] of this.lastFiredAt) {
+      lastFiredSeconds.set(colId, Math.floor((now - firedAt.getTime()) / 1e3));
+    }
+    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);
+    let constraints = [];
+    if (colScope?.firing_constraints && colScope.firing_constraints.length > 0) {
+      constraints = this.toFiringConstraints(colScope.firing_constraints);
+    }
+    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;
+    }
+    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 \u2014 resolved=${String(r.resolved_value)} ${r.threshold.operator} ${String(r.threshold.value)}`
+        );
+      }
+    }
+    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}" \u2014 ${r.error} (fail-open)`
+          );
+        }
+      }
+    }
+    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 \u2014 skipping scan");
+      return;
+    }
+    if (this.deps.costTracker?.isExhausted()) {
+      if (!this.pipelinePaused) {
+        this.pipelinePaused = true;
+        console.error("[budget] Token budget exhausted \u2014 pausing pipeline");
+      }
+      return;
+    }
+    this.knownTickets.clear();
+    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);
+      }
+    }
+    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 {
+          this.knownTickets.add(ticketId);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  [warn] Deferred blocker re-evaluation failed for ${ticketId}: ${msg}`);
+        this.knownTickets.add(ticketId);
+      }
+    }
+    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;
+      }
+      if (this.isColumnBlocked(columnId)) {
+        this.blockedColumns.add(columnId);
+        console.error(`  [scan] Column ${columnId} (${colScope.column.name}): BLOCKED by firing constraints \u2014 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)) {
+          if (this.isColumnBlocked(event.columnId)) {
+            console.error(`  [event] ${event.type} ${event.ticketId} \u2192 column ${event.columnId}: BLOCKED by firing constraints \u2014 deferred`);
+            this.deferredTickets.set(event.ticketId, event.columnId);
+          } 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}`);
+          }
+          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": {
+        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": {
+        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);
+        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;
+    if (this.activeLoops.has(ticketId)) return;
+    if (this.spawning.has(ticketId)) return;
+    if (!skipCompletingCheck && this.completing.has(ticketId)) return;
+    if (!skipKnownCheck && this.knownTickets.has(ticketId)) return;
+    const colConfig = this.pipelineColumns.get(columnId);
+    if (!colConfig) return;
+    if (this.isColumnBlocked(columnId)) {
+      return;
+    }
+    const activeInColumn = this.activeCountForColumn(columnId);
+    this.knownTickets.add(ticketId);
+    if (activeInColumn >= colConfig.concurrency) {
+      const queue = this.loopQueues.get(columnId);
+      if (queue && !queue.includes(ticketId)) {
+        queue.push(ticketId);
+      }
+      return;
+    }
+    this.spawning.add(ticketId);
+    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 \u2014 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) {
+      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((err2) => {
+        const msg2 = err2 instanceof Error ? err2.message : String(err2);
+        console.error(`  [error] drainQueue failed for column ${columnId}: ${msg2}`);
+      });
+      return;
+    }
+    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);
+    } 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) {
+    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 });
+      this.lastFiredAt.set(columnId, /* @__PURE__ */ new Date());
+      void promise.then(
+        (result) => this.onLoopComplete(ticketId, columnId, result).catch((err) => {
+          console.error(`onLoopComplete error for ${ticketId}:`, err);
+        })
+      );
+      return;
+    }
+    const modelOverride = this.ticketModelOverrides.get(ticketId);
+    this.ticketModelOverrides.delete(ticketId);
+    if (config.checkpointEnabled && this.deps.getFieldValues) {
+      let timeoutId;
+      const placeholder = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          this.completing.add(ticketId);
+          this.activeLoops.delete(ticketId);
+          this.knownTickets.delete(ticketId);
+          this.completing.delete(ticketId);
+          console.error(`  [warn] Checkpoint read timed out for ${ticketId} \u2014 releasing lock`);
+          reject(new Error("Checkpoint read timeout"));
+        }, 3e4);
+      });
+      placeholder.catch(() => {
+      });
+      this.activeLoops.set(ticketId, { columnId, promise: placeholder });
+      this.lastFiredAt.set(columnId, /* @__PURE__ */ new Date());
+      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, void 0, void 0, 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, void 0, void 0, modelOverride);
+      });
+      return;
+    }
+    this.startLoopWithConfig(ticketId, columnId, config, void 0, void 0, 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) {
+    const effectiveModel = resumeModelTier ?? config.modelRouting?.initial ?? config.modelPreference;
+    const loopConfig = {
+      maxIterations: config.maxIterations,
+      gutterThreshold: config.gutterThreshold,
+      ...effectiveModel !== void 0 && { model: effectiveModel },
+      ...config.maxBudgetUsd !== void 0 && { 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) : void 0;
+        return wName !== void 0 ? { worktreeName: wName } : {};
+      })(),
+      ...config.lookaheadColumnId !== void 0 && { lookaheadColumnId: config.lookaheadColumnId },
+      // Resume from checkpoint iteration/gutter if provided
+      ...startIteration !== void 0 && { startIteration },
+      ...startGutterCount !== void 0 && { startGutterCount },
+      ...startFingerprint !== void 0 && { startFingerprint },
+      ...config.stuckDetection && { stuckDetection: config.stuckDetection }
+    };
+    const toolRestrictions = resolveToolRestrictions(
+      config.builtinTools,
+      config.allowedTools,
+      config.disallowedTools
+    );
+    if (toolRestrictions.tools !== void 0 || toolRestrictions.allowedTools || toolRestrictions.disallowedTools) {
+      loopConfig.toolRestrictions = toolRestrictions;
+    }
+    const promise = this.deps.startLoop(ticketId, columnId, loopConfig);
+    this.activeLoops.set(ticketId, { columnId, promise });
+    this.lastFiredAt.set(columnId, /* @__PURE__ */ new Date());
+    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);
+    const input = {
+      ticketTitle: "",
+      ticketDescription: "",
+      ticketId,
+      ticketNumber: 0,
+      columnName: colScope?.column.name ?? columnId,
+      exitReason: result.reason,
+      iterations: result.iterations,
+      gutterCount: result.gutterCount,
+      ...result.lastError !== void 0 && { 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;
+    }
+    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 ? ` \u2014 ${r.output.slice(0, 300)}` : "";
+            return `${label}${snippet}`;
+          }).join("\n");
+        }
+      }
+    }
+    if (this.deps.getFieldValues) {
+      try {
+        input.fieldValues = await this.deps.getFieldValues(ticketId);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  [warn] Advisor getFieldValues failed for ${ticketId}: ${msg}`);
+      }
+    }
+    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} \u2014 falling back to default behavior`);
+      return false;
+    }
+    this.advisorBudget.set(ticketId, remaining - 1);
+    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} \u2014 ${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:
+${response.feedback}`)
+          );
+        }
+        this.knownTickets.delete(ticketId);
+        await this.spawnOrQueue(ticketId, columnId, true, true);
+        this.completing.delete(ticketId);
+        return true;
+      }
+      case "RETRY_DIFFERENT_MODEL": {
+        const currentModel = result.model ?? colConfig.modelPreference ?? "default";
+        const escalation = colConfig.modelRouting?.escalation ?? [];
+        let nextModel;
+        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) {
+          nextModel = escalation[0];
+        }
+        const escalatedModel = nextModel ?? currentModel;
+        if (escalatedModel === currentModel) {
+          return false;
+        }
+        await this.safeAction(
+          ticketId,
+          "advisor:createComment",
+          () => this.deps.createComment(
+            ticketId,
+            `ADVISOR: Escalating model ${currentModel} \u2192 ${escalatedModel} \u2014 ${response.reason}`
+          )
+        );
+        this.knownTickets.delete(ticketId);
+        this.ticketModelOverrides.set(ticketId, escalatedModel);
+        await this.spawnOrQueue(ticketId, columnId, true, true);
+        this.completing.delete(ticketId);
+        return true;
+      }
+      case "RELAX_WITH_DEBT": {
+        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)
+          );
+          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).`
+            )
+          );
+          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) {
+              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 \u2014 ${response.reason}`)
+        );
+        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);
+            if (this.deps.archiveTicket) {
+              await this.safeAction(
+                ticketId,
+                "advisor:archiveTicket",
+                () => this.deps.archiveTicket(ticketId)
+              );
+            }
+          } catch (err) {
+            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 \u2014 ${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 \u2014 ${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 ?? "");
+    if ("parseFailed" in verdict && verdict.parseFailed) {
+      await this.deps.createComment(ticketId, `EVALUATOR: Verdict could not be parsed \u2014 ticket held for manual review.
+
+Raw 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);
+    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": {
+        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 \u2014 ${verdict.summary}`)
+        );
+        break;
+      }
+      case "reject": {
+        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 \u2014 ${verdict.summary}
+
+${findingsText}`)
+        );
+        break;
+      }
+      case "forward_with_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.`)
+              );
+            }
+          }
+        }
+        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) \u2014 ${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;
+    const prevBoardCol = bs.columns.filter((c) => c.position < currentBoardCol.position && this.pipelineColumns.has(c.id)).sort((a, b) => b.position - a.position)[0];
+    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;
+    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) {
+    this.completing.add(ticketId);
+    this.activeLoops.delete(ticketId);
+    try {
+      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";
+      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
+      });
+      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, 2e3),
+              gate_history: history,
+              trajectory: trajectory?.status ?? null,
+              ticket_number: ticket?.ticket_number ?? null
+            },
+            ticketId,
+            columnId,
+            iteration: result.iterations
+          });
+        }
+      }
+      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
+          });
+        }
+      }
+      const colConfig = this.pipelineColumns.get(columnId);
+      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) {
+          const colScope2 = this.columnScopes.get(columnId);
+          const ticket2 = colScope2?.tickets.find((t) => t.id === ticketId);
+          if (ticket2) {
+            const worktreeName = generateWorktreeName(ticket2.ticket_number, colConfig.name);
+            if (colConfig.worktreeOnDone === "merge" && colConfig.worktreeIntegrationBranch && this.deps.mergeWorktree) {
+              void this.deps.mergeWorktree(worktreeName, colConfig.worktreeIntegrationBranch).then((success) => {
+                if (!success) {
+                  console.error(`  [warn] Worktree merge failed for ${worktreeName} \u2192 ${colConfig.worktreeIntegrationBranch} \u2014 may need manual resolution`);
+                }
+              }).catch((err) => {
+                console.error(`  [warn] Worktree merge error for ${worktreeName}: ${err instanceof Error ? err.message : String(err)}`);
+              });
+            } else if (colConfig.worktreeOnDone === "cleanup" && this.deps.cleanupWorktree) {
+              void this.deps.cleanupWorktree(worktreeName).then((success) => {
+                if (!success) {
+                  console.error(`  [warn] Worktree cleanup failed for ${worktreeName} \u2014 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;
+      }
+      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;
+      }
+      await this.drainQueue(columnId);
+      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 {
+            const ticketSummaries = [];
+            for (const [colId, scope] of this.columnScopes) {
+              const colConfig2 = this.pipelineColumns.get(colId);
+              const columnName = colConfig2?.name ?? colId;
+              const colQueue = this.loopQueues.get(colId) ?? [];
+              for (const ticket2 of scope.tickets) {
+                const isActive = this.activeLoops.has(ticket2.id);
+                const isQueued = colQueue.includes(ticket2.id);
+                const status = isActive ? "active" : isQueued ? "queued" : "idle";
+                let gatePassRate = 0;
+                if (this.deps.gateSnapshotStore) {
+                  const latest = this.deps.gateSnapshotStore.getLatest(ticket2.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: ticket2.id,
+                  title: ticket2.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
+            });
+            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} \u2014 ${response.reason.slice(0, 200)}`,
+              detail: {
+                action: response.action,
+                reason: response.reason
+              }
+            });
+            await this.executeReplannerAction(response);
+            if (response.action === "CONTINUE") {
+              this.replannerInvocations--;
+            }
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`  [replanner] Failed: ${msg} \u2014 pausing pipeline for safety`);
+            this.pipelinePaused = true;
+          }
+        }
+        if (this.replannerInvocations >= this.replannerMaxInvocations) {
+          this.pipelinePaused = true;
+          console.error("Replanner fired 3 non-CONTINUE actions \u2014 auto-pausing pipeline");
+        }
+      }
+      let comment;
+      switch (result.reason) {
+        case "moved":
+          comment = `Pipeline agent advanced ticket after ${result.iterations} iteration(s).`;
+          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 \u2014 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 \u2014 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}`);
+        });
+      }
+      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}`);
+        });
+      }
+      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 : 5e6;
+    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;
+    }
+    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) / 6e4;
+    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 \u2014 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;
+    if (this.isColumnBlocked(columnId)) {
+      console.error(`  [drain] Column ${columnId}: BLOCKED by firing constraints \u2014 ${String(queue.length)} ticket(s) remain queued`);
+      return;
+    }
+    while (queue.length > 0) {
+      const activeInColumn = this.activeCountForColumn(columnId);
+      if (activeInColumn >= colConfig.concurrency) return;
+      const nextTicketId = queue.shift();
+      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;
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  [warn] drainQueue blocker check failed for ${nextTicketId}: ${msg} \u2014 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);
+  }
+};
+
+// src/lib/run-memory.ts
+var DEFAULT_COMPACTION_THRESHOLD = 500;
+var RunMemory = class {
+  boardName;
+  deps;
+  _documentId = null;
+  _writeQueue = Promise.resolve();
+  constructor(_boardId, boardName, deps) {
+    this.boardName = boardName;
+    this.deps = deps;
+  }
+  get documentId() {
+    return this._documentId;
+  }
+  /**
+   * Create the run memory document. Optional seedContent prepopulates the
+   * Codebase Conventions section.
+   */
+  async initialize(seedContent) {
+    if (this._documentId !== null) return;
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const title = `Pipeline Run Memory \u2014 ${this.boardName} \u2014 ${date}`;
+    const content = buildTemplate(seedContent);
+    this._documentId = await this.deps.createDocument(content, title);
+  }
+  /**
+   * Get current document content. Returns '' if not initialized or on error.
+   */
+  async getContent() {
+    if (this._documentId === null) {
+      return "";
+    }
+    try {
+      return await this.deps.getDocument(this._documentId);
+    } catch (err) {
+      console.warn(`[run-memory] getContent failed: ${err instanceof Error ? err.message : String(err)}`);
+      return "";
+    }
+  }
+  /**
+   * Check if document exceeds line threshold (default 500).
+   */
+  async needsCompaction(threshold = DEFAULT_COMPACTION_THRESHOLD) {
+    const content = await this.getContent();
+    if (!content) return false;
+    const lineCount = content.split("\n").length;
+    return lineCount > threshold;
+  }
+  /**
+   * Append content under a specific section heading.
+   * Agents call this after successful iterations to share discoveries.
+   */
+  async append(section, content) {
+    if (this._documentId === null) return;
+    this._writeQueue = this._writeQueue.then(async () => {
+      try {
+        const current = await this.deps.getDocument(this._documentId);
+        const sectionHeader = `## ${section}`;
+        const idx = current.indexOf(sectionHeader);
+        if (idx === -1) {
+          await this.deps.updateDocument(this._documentId, current + `
+
+${sectionHeader}
+
+${content}`);
+        } else {
+          const afterHeader = idx + sectionHeader.length;
+          const nextSection = current.indexOf("\n## ", afterHeader);
+          const insertAt = nextSection === -1 ? current.length : nextSection;
+          const updated = current.slice(0, insertAt) + `
+${content}
+` + current.slice(insertAt);
+          await this.deps.updateDocument(this._documentId, updated);
+        }
+      } catch (err) {
+        console.warn(`[run-memory] append failed (section="${section}"): ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }).catch(() => {
+    });
+    await this._writeQueue;
+  }
+  /**
+   * Replace document content with a compacted version.
+   * Called by the orchestrator after a Haiku summarization call.
+   */
+  async compact(compactedContent) {
+    if (this._documentId === null) return;
+    this._writeQueue = this._writeQueue.then(async () => {
+      try {
+        await this.deps.updateDocument(this._documentId, compactedContent);
+      } catch (err) {
+        console.warn(`[run-memory] compact failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }).catch(() => {
+    });
+    await this._writeQueue;
+  }
+};
+function buildTemplate(seedContent) {
+  const conventionsSection = seedContent ? `## Codebase Conventions
+
+${seedContent}` : `## Codebase Conventions`;
+  return [
+    conventionsSection,
+    `## Discovered Interfaces`,
+    `## Failure Patterns`,
+    `## QA Rejection History`
+  ].join("\n\n");
+}
+
+// src/lib/event-queue.ts
+function isDestructive(type) {
+  return type === "ticket:archived" || type === "ticket:deleted";
+}
+var EventQueue = class {
+  queue = /* @__PURE__ */ new Map();
+  // keyed by ticketId for coalescing
+  handler;
+  onError;
+  timer = null;
+  drainRateMs;
+  running = false;
+  draining = false;
+  constructor(handler, options = {}) {
+    this.handler = handler;
+    this.drainRateMs = options.drainRateMs ?? 100;
+    this.onError = options.onError ?? ((event, error) => console.error("EventQueue handler error for event", event, error));
+  }
+  start() {
+    this.running = true;
+    this.timer = setInterval(() => void this.drain(), this.drainRateMs);
+  }
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.queue.clear();
+  }
+  push(event) {
+    if (!this.running) return;
+    const existing = this.queue.get(event.ticketId);
+    if (existing && isDestructive(existing.type) && !isDestructive(event.type)) {
+      return;
+    }
+    this.queue.set(event.ticketId, event);
+  }
+  pushPriority(event) {
+    if (!this.running) return;
+    this.queue.delete(event.ticketId);
+    const result = this.handler(event);
+    if (result instanceof Promise) {
+      result.catch((error) => this.onError(event, error));
+    }
+  }
+  async drain() {
+    if (this.draining) return;
+    if (this.queue.size === 0) return;
+    this.draining = true;
+    try {
+      const [ticketId, event] = this.queue.entries().next().value;
+      this.queue.delete(ticketId);
+      try {
+        await this.handler(event);
+      } catch (error) {
+        this.onError(event, error);
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+};
+
+// src/lib/ws-client.ts
+import WebSocket from "ws";
+var PipelineWsClient = class {
+  ws = null;
+  client;
+  options;
+  pingTimer = null;
+  stopped = false;
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+  }
+  /** Whether the WebSocket is currently open. */
+  get connected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  async connect() {
+    if (this.ws) {
+      try {
+        this.ws.removeAllListeners();
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.cleanupPing();
+    const { ticket } = await this.client.post("/ws-ticket");
+    const wsUrl = this.client.baseUrl.replace(/^http/, "ws") + `/ws?ticket=${ticket}`;
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      this.ws = new WebSocket(wsUrl);
+      let subscribed = false;
+      this.ws.on("open", () => {
+        this.pingTimer = setInterval(() => this.send({ type: "ping", payload: {} }), 3e4);
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const event = JSON.parse(data.toString());
+          if (!subscribed) {
+            subscribed = true;
+            this.send({ type: "board:subscribe", payload: { boardId: this.options.boardId, projectId: this.options.projectId } });
+            this.options.onConnect();
+            if (!resolved) {
+              resolved = true;
+              resolve();
+            }
+          }
+          this.options.onEvent(event);
+        } catch (err) {
+          console.error("WS message parse error:", err);
+        }
+      });
+      this.ws.on("close", (code) => {
+        this.cleanupPing();
+        this.options.onDisconnect();
+        if (!resolved) {
+          resolved = true;
+          reject(new Error(`WebSocket closed before handshake (code ${code})`));
+        }
+      });
+      this.ws.on("error", (err) => {
+        if (!resolved) {
+          resolved = true;
+          reject(err);
+        }
+      });
+    });
+  }
+  /**
+   * Attempt to reconnect. Called by the polling fallback on each cycle.
+   * Returns true if reconnected, false if it failed (polling continues).
+   */
+  async tryReconnect() {
+    if (this.stopped || this.connected) return this.connected;
+    try {
+      await this.connect();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    this.cleanupPing();
+    if (this.ws) {
+      try {
+        this.ws.removeAllListeners();
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  send(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  cleanupPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+};
+
+// src/lib/logger.ts
+import { mkdirSync, writeFileSync, appendFileSync, readdirSync, rmSync, statSync, renameSync } from "fs";
+import { join } from "path";
+var MAX_LOG_BYTES = 5 * 1024 * 1024;
+var MAX_ROTATED_FILES = 3;
+var ROTATION_CHECK_INTERVAL = 100;
+var PipelineLogger = class {
+  boardDir;
+  writeCount = 0;
+  constructor(baseDir, boardId) {
+    this.boardDir = join(baseDir, boardId);
+    mkdirSync(this.boardDir, { recursive: true });
+  }
+  orchestrator(message) {
+    const logPath = join(this.boardDir, "orchestrator.log");
+    const entry = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+    appendFileSync(logPath, entry);
+    this.writeCount++;
+    if (this.writeCount >= ROTATION_CHECK_INTERVAL) {
+      this.writeCount = 0;
+      this.rotateIfNeeded(logPath);
+    }
+  }
+  rotateIfNeeded(logPath) {
+    try {
+      const stat = statSync(logPath);
+      if (stat.size < MAX_LOG_BYTES) return;
+      for (let i = MAX_ROTATED_FILES; i >= 1; i--) {
+        const from = i === 1 ? logPath : `${logPath}.${String(i - 1)}`;
+        const to = `${logPath}.${String(i)}`;
+        try {
+          if (i === MAX_ROTATED_FILES) {
+            try {
+              rmSync(to, { force: true });
+            } catch {
+            }
+          }
+          renameSync(from, to);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  iteration(ticketNumber, iterationNum, data) {
+    const ticketDir = join(this.boardDir, ticketNumber);
+    mkdirSync(ticketDir, { recursive: true });
+    const padded = String(iterationNum).padStart(3, "0");
+    const logPath = join(ticketDir, `iteration-${padded}.log`);
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      iteration: iterationNum,
+      ...data
+    };
+    writeFileSync(logPath, JSON.stringify(entry, null, 2));
+  }
+  formatConsole(ticketNumber, columnName, iteration, status) {
+    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    const ticket = ticketNumber.padEnd(10);
+    const col = columnName.padEnd(12);
+    return `[${time}] ${ticket} ${col} iter:${iteration}  ${status}`;
+  }
+  pruneOldLogs(retentionDays) {
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+    try {
+      const entries = readdirSync(this.boardDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(this.boardDir, entry.name);
+        if (entry.isDirectory() && entry.name !== ".") {
+          try {
+            const stat = statSync(fullPath);
+            if (stat.mtimeMs < cutoff) {
+              rmSync(fullPath, { recursive: true, force: true });
+            }
+          } catch {
+          }
+        }
+        if (entry.isFile() && /^orchestrator\.log\.\d+$/.test(entry.name)) {
+          try {
+            const stat = statSync(fullPath);
+            if (stat.mtimeMs < cutoff) {
+              rmSync(fullPath, { force: true });
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/lib/light-call.ts
+import { z as z2 } from "zod";
+var LightResponseSchema = z2.object({
+  action: z2.enum(["move_ticket", "set_field_value", "create_comment", "archive_ticket", "no_action"]),
+  params: z2.record(z2.string(), z2.unknown()),
+  reason: z2.string()
+});
+function composeLightPrompt(ctx) {
+  const fieldLines = ctx.fieldValues.length > 0 ? ctx.fieldValues.map((f) => `  ${f.field_name}: ${f.value != null ? JSON.stringify(f.value) : "(not set)"}`).join("\n") : "  (none)";
+  const parts = [];
+  parts.push(`Ticket #${String(ctx.ticketNumber)}: "${ctx.ticketTitle}"
+Column: ${ctx.columnName}
+Project: ${ctx.projectId}
+Tool prefix: ${ctx.toolPrefix}`);
+  if (ctx.ticketDescription) {
+    const truncated = ctx.ticketDescription.length > 300 ? ctx.ticketDescription.slice(0, 300) + "..." : ctx.ticketDescription;
+    parts.push(`Description: ${truncated}`);
+  }
+  parts.push(`
+Field values:
+${fieldLines}`);
+  if (ctx.availableColumns && ctx.availableColumns.length > 0) {
+    const colLines = ctx.availableColumns.map((c) => `  ${c.name} (${c.id})`).join("\n");
+    parts.push(`Available columns:
+${colLines}`);
+  }
+  if (ctx.transitionRules) {
+    parts.push(`Transition rules:
+${ctx.transitionRules}`);
+  }
+  parts.push(`Decide the single best next action for this ticket.
+Respond with ONLY a JSON object \u2014 no markdown, no explanation outside the JSON:
+
+{
+  "action": "<move_ticket|set_field_value|create_comment|archive_ticket|no_action>",
+  "params": { /* action-specific params */ },
+  "reason": "<one sentence>"
+}
+
+Action params shapes:
+- move_ticket:     { column_id: string }
+- set_field_value: { field_name: string, value: unknown }
+- create_comment:  { body: string }
+- archive_ticket:  {}
+- no_action:       {}`);
+  return parts.join("\n");
+}
+function parseLightResponse(raw) {
+  let parsed;
+  try {
+    parsed = parseJsonFromLlmOutput(raw);
+  } catch (err) {
+    throw new Error(`LightResponse: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const result = LightResponseSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(`LightResponse: validation failed \u2014 ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/lib/advisor.ts
+import { z as z3 } from "zod";
+var AdvisorResponseSchema = z3.object({
+  action: z3.enum([
+    "RETRY_WITH_FEEDBACK",
+    "RETRY_DIFFERENT_MODEL",
+    "RELAX_WITH_DEBT",
+    "SPLIT_TICKET",
+    "ESCALATE"
+  ]),
+  reason: z3.string(),
+  feedback: z3.string().nullish().transform((v) => v ?? void 0),
+  debt_items: z3.array(z3.object({
+    type: z3.string(),
+    description: z3.string(),
+    severity: z3.enum(["high", "medium", "low"]).default("medium")
+  })).nullish().transform((v) => v ?? void 0),
+  split_specs: z3.array(z3.object({
+    title: z3.string(),
+    description: z3.string()
+  })).nullish().transform((v) => v ?? void 0)
+});
+function composeAdvisorPrompt(input) {
+  const parts = [];
+  parts.push(`You are a pipeline recovery advisor. A Ralph Loop has exited without moving the ticket.
+Analyze the failure context and choose the single best recovery action.`);
+  parts.push(`
+Ticket: #${String(input.ticketNumber)} "${input.ticketTitle}"`);
+  parts.push(`Column: ${input.columnName}`);
+  parts.push(`Model: ${input.modelTier}`);
+  if (input.ticketDescription) {
+    parts.push(`
+Description:
+${input.ticketDescription}`);
+  }
+  parts.push(`
+Failure context:`);
+  parts.push(`  Exit reason: ${input.exitReason}`);
+  parts.push(`  Iterations completed: ${input.iterations}`);
+  parts.push(`  Gutter (no-progress) count: ${input.gutterCount}`);
+  if (input.lastError) {
+    parts.push(`  Last error: ${input.lastError}`);
+  }
+  if (input.gateHistory && input.gateHistory.length > 0) {
+    parts.push(`
+## Gate History (last ${String(input.gateHistory.length)} iterations)`);
+    for (const snap of input.gateHistory) {
+      const passed = snap.results.filter((r) => r.passed).length;
+      const total = snap.results.length;
+      const deltaLabel = snap.delta_from_previous === "first_check" ? "first check (no baseline)" : snap.delta_from_previous;
+      parts.push(`- Iter ${String(snap.iteration)}: ${String(passed)}/${String(total)} gates passed (delta: ${deltaLabel})`);
+    }
+  }
+  if (input.currentGateResults && input.currentGateResults.length > 0) {
+    parts.push(`
+## Current Gate Results`);
+    for (const r of input.currentGateResults) {
+      const status = r.passed ? "PASS" : "FAIL";
+      parts.push(`- ${r.name}: ${status}${r.required ? " (required)" : ""}`);
+      if (!r.passed && r.output) {
+        parts.push(`  Output: ${r.output.slice(0, 500)}`);
+      }
+    }
+  }
+  if (input.trajectory) {
+    parts.push(`
+Trajectory: ${input.trajectory.status} \u2014 ${input.trajectory.evidence}`);
+  }
+  if (input.diffStats) {
+    parts.push(`
+Git diff: ${String(input.diffStats.files_changed)} files, +${String(input.diffStats.insertions)}/-${String(input.diffStats.deletions)}`);
+  }
+  const commentLines = input.recentComments.length > 0 ? input.recentComments.map((c) => `  [${c.author}] ${c.body.slice(0, 150)}`).join("\n") : "  (none)";
+  parts.push(`
+Recent comments:
+${commentLines}`);
+  const fieldLines = input.fieldValues.length > 0 ? input.fieldValues.map((f) => `  ${f.field_name}: ${f.value != null ? JSON.stringify(f.value) : "(not set)"}`).join("\n") : "  (none)";
+  parts.push(`
+Field values:
+${fieldLines}`);
+  parts.push(`
+Failure patterns from run memory:
+${input.failurePatterns}`);
+  parts.push(`
+## Decision Guide
+| Gate pattern | Recommended action |
+|---|---|
+| Same test failing, different error each time | RETRY_WITH_FEEDBACK |
+| Same exact error every iteration | RETRY_DIFFERENT_MODEL |
+| All gates pass but agent didn't move | RETRY_WITH_FEEDBACK ("Gates pass \u2014 call move_ticket") |
+| Gates regressing across iterations | SPLIT_TICKET |
+| Zero gates pass after max iterations | ESCALATE |
+| Most gates pass, one stubborn failure | RELAX_WITH_DEBT |`);
+  const escalationSection = input.escalationModels.length > 0 ? `Available escalation models: ${input.escalationModels.join(", ")}` : `Available escalation models: none \u2014 RETRY_DIFFERENT_MODEL is unavailable`;
+  const budgetNote = input.remainingBudget <= 1 ? `
+This is your final invocation (remaining budget: ${String(input.remainingBudget)}). Prefer RELAX_WITH_DEBT or ESCALATE.` : `Remaining advisor budget: ${String(input.remainingBudget)}`;
+  parts.push(`
+Model context:`);
+  parts.push(`  Current model: ${input.modelTier}`);
+  parts.push(`  ${escalationSection}`);
+  parts.push(`  ${budgetNote}`);
+  if (input.circuitBreakerTargetId) {
+    parts.push(`  Circuit breaker target column ID: ${input.circuitBreakerTargetId}`);
+  }
+  parts.push(`
+Choose one of the following actions. Respond with ONLY a JSON object \u2014 no markdown, no explanation outside the JSON:
+
+{
+  "action": "<action>",
+  "reason": "<one sentence>",
+  "feedback": "<optional: guidance for retry>",
+  "debt_items": [{ "type": "...", "description": "...", "severity": "high|medium|low" }],
+  "split_specs": [{ "title": "...", "description": "..." }]
+}
+
+Actions:
+- RETRY_WITH_FEEDBACK      \u2014 Retry the loop with targeted feedback in the prompt. Include "feedback" field.
+- RETRY_DIFFERENT_MODEL    \u2014 Retry using a higher-capability model. Only valid if escalation models are available.
+- RELAX_WITH_DEBT          \u2014 Accept partial progress; log unmet criteria as debt. Include "debt_items" array.
+- SPLIT_TICKET             \u2014 Ticket is too broad; propose sub-tickets. Include "split_specs" array.
+- ESCALATE                 \u2014 Surface to a human; cannot be resolved automatically.`);
+  return parts.join("\n");
+}
+function parseAdvisorResponse(raw) {
+  let parsed;
+  try {
+    parsed = parseJsonFromLlmOutput(raw);
+  } catch (err) {
+    throw new Error(`AdvisorResponse: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const result = AdvisorResponseSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(`AdvisorResponse: validation failed \u2014 ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/lib/reaper.ts
+import { spawn } from "child_process";
+import { writeFileSync as writeFileSync2, unlinkSync, readFileSync } from "fs";
+var REAPER_POLL_MS = 3e3;
+function buildReaperScript(config) {
+  return `
+const fs = require('fs');
+const path = require('path');
+
+const ORCHESTRATOR_PID = ${config.orchestratorPid};
+const MANIFEST_PATH = ${JSON.stringify(config.manifestPath)};
+const PID_FILE_PATH = ${JSON.stringify(config.pidFilePath)};
+const REAPER_PID_PATH = ${JSON.stringify(config.reaperPidPath)};
+const MCP_CONFIG_PATH = ${JSON.stringify(config.mcpConfigPath)};
+const PIPELINE_DIR = ${JSON.stringify(config.pipelineDir)};
+const POLL_MS = ${REAPER_POLL_MS};
+
+function isAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function readManifest() {
+  try {
+    return fs.readFileSync(MANIFEST_PATH, 'utf-8')
+      .split('\\n')
+      .map(l => parseInt(l.trim(), 10))
+      .filter(p => !isNaN(p) && p > 0);
+  } catch { return []; }
+}
+
+function killPid(pid, signal) {
+  try { process.kill(pid, signal); } catch { /* already dead */ }
+}
+
+function cleanup() {
+  const pids = readManifest();
+  for (const pid of pids) {
+    killPid(pid, 'SIGTERM');
+    try { process.kill(-pid, 'SIGTERM'); } catch { /* ignore */ }
+  }
+
+  setTimeout(() => {
+    for (const pid of pids) {
+      if (isAlive(pid)) {
+        killPid(pid, 'SIGKILL');
+        try { process.kill(-pid, 'SIGKILL'); } catch { /* ignore */ }
+      }
+    }
+
+    try { fs.unlinkSync(MANIFEST_PATH); } catch {}
+    try { fs.unlinkSync(PID_FILE_PATH); } catch {}
+    try { fs.unlinkSync(REAPER_PID_PATH); } catch {}
+    try { fs.unlinkSync(MCP_CONFIG_PATH); } catch {}
+
+    try {
+      const files = fs.readdirSync(PIPELINE_DIR);
+      for (const f of files) {
+        if (f.startsWith('mcp-config-') && f.endsWith('.json')) {
+          try { fs.unlinkSync(path.join(PIPELINE_DIR, f)); } catch {}
+        }
+      }
+    } catch {}
+
+    process.exit(0);
+  }, 5000);
+}
+
+function pidFileExists() {
+  try { fs.accessSync(PID_FILE_PATH); return true; } catch { return false; }
+}
+
+const timer = setInterval(() => {
+  if (!pidFileExists()) {
+    clearInterval(timer);
+    process.exit(0);
+    return;
+  }
+
+  if (!isAlive(ORCHESTRATOR_PID)) {
+    clearInterval(timer);
+    cleanup();
+  }
+}, POLL_MS);
+`;
+}
+function spawnReaper(config) {
+  const script = buildReaperScript(config);
+  const child = spawn(process.execPath, ["-e", script], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  if (child.pid) {
+    writeFileSync2(config.reaperPidPath, String(child.pid), { mode: 384 });
+  }
+  return child;
+}
+function killReaper(reaperPidPath) {
+  try {
+    const pid = parseInt(
+      readFileSync(reaperPidPath, "utf-8").trim(),
+      10
+    );
+    if (pid && !isNaN(pid)) {
+      process.kill(pid, "SIGTERM");
+    }
+  } catch {
+  }
+  try {
+    unlinkSync(reaperPidPath);
+  } catch {
+  }
+}
+
+// src/lib/stream-parser.ts
+import { EventEmitter } from "events";
+var StreamJsonParser = class extends EventEmitter {
+  buffer = "";
+  toolCallCount = 0;
+  feed(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const event = JSON.parse(trimmed);
+        if (event.type === "assistant" && Array.isArray(event.content)) {
+          for (const block of event.content) {
+            if (block.type === "tool_use") this.toolCallCount++;
+          }
+        }
+        this.emit("event", event);
+      } catch {
+        this.emit("error", new Error(`Failed to parse stream-json line: ${trimmed.slice(0, 100)}`));
+      }
+    }
+  }
+  /** Flush any remaining buffer content (call after stream ends). */
+  flush() {
+    const trimmed = this.buffer.trim();
+    this.buffer = "";
+    if (!trimmed) return;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.type === "assistant" && Array.isArray(event.content)) {
+        for (const block of event.content) {
+          if (block.type === "tool_use") this.toolCallCount++;
+        }
+      }
+      this.emit("event", event);
+    } catch {
+    }
+  }
+  getToolCallCount() {
+    return this.toolCallCount;
+  }
+  reset() {
+    this.buffer = "";
+    this.toolCallCount = 0;
+  }
+};
+
+// src/lib/gate-snapshot.ts
+var MAX_SNAPSHOTS_PER_TICKET = 100;
+function computeDelta(previous, currentResults) {
+  if (!previous) return "first_check";
+  const prevPassing = previous.results.filter((r) => r.passed).length;
+  const currPassing = currentResults.filter((r) => r.passed).length;
+  if (currPassing > prevPassing) return "improved";
+  if (currPassing < prevPassing) return "regressed";
+  return "same";
+}
+var GateSnapshotStore = class {
+  snapshots = /* @__PURE__ */ new Map();
+  record(ticketId, iteration, results) {
+    const previous = this.getLatest(ticketId);
+    const delta = computeDelta(previous, results);
+    const snapshot = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      iteration,
+      results,
+      all_required_passed: results.filter((r) => r.required).every((r) => r.passed),
+      delta_from_previous: delta
+    };
+    const existing = this.snapshots.get(ticketId) ?? [];
+    existing.push(snapshot);
+    if (existing.length > MAX_SNAPSHOTS_PER_TICKET) {
+      existing.splice(0, existing.length - MAX_SNAPSHOTS_PER_TICKET);
+    }
+    this.snapshots.set(ticketId, existing);
+    return snapshot;
+  }
+  getLatest(ticketId) {
+    const snaps = this.snapshots.get(ticketId);
+    return snaps?.[snaps.length - 1];
+  }
+  getRecent(ticketId, count) {
+    const snaps = this.snapshots.get(ticketId) ?? [];
+    return snaps.slice(-count);
+  }
+  clear(ticketId) {
+    this.snapshots.delete(ticketId);
+  }
+  /** Returns all ticket IDs that have at least one snapshot recorded. */
+  getAllTicketIds() {
+    return Array.from(this.snapshots.keys());
+  }
+};
+
+// src/lib/gate-runner.ts
+import { execFile } from "child_process";
+async function runGate(gate, options = {}) {
+  const timeoutMs = gate.timeout ? parseTimeout(gate.timeout) : options.timeoutMs ?? 6e4;
+  const start = Date.now();
+  return new Promise((resolve) => {
+    const child = execFile("sh", ["-c", gate.run], {
+      timeout: timeoutMs,
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      maxBuffer: options.maxBuffer ?? 1024 * 1024
+      // 1MB output cap
+    }, (error, stdout, stderr) => {
+      const duration_ms = Date.now() - start;
+      const output = (stdout + stderr).trim();
+      const timed_out = error?.killed === true;
+      const buffer_exceeded = error?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+      if (error) {
+        let annotation = "";
+        if (timed_out) annotation = `
+[TIMED OUT after ${timeoutMs}ms]`;
+        else if (buffer_exceeded) annotation = `
+[OUTPUT TRUNCATED \u2014 buffer limit exceeded]`;
+        resolve({
+          name: gate.name,
+          passed: false,
+          required: gate.required ?? true,
+          duration_ms,
+          output: output + annotation,
+          stderr: stderr.trim(),
+          exit_code: child.exitCode ?? (typeof error.code === "number" ? error.code : 1),
+          timed_out: timed_out || buffer_exceeded
+        });
+        return;
+      }
+      resolve({
+        name: gate.name,
+        passed: true,
+        required: gate.required ?? true,
+        duration_ms,
+        output,
+        stderr: stderr.trim(),
+        exit_code: 0,
+        timed_out: false
+      });
+    });
+  });
+}
+async function runGates(gates, options = {}) {
+  const results = [];
+  const totalStart = Date.now();
+  for (const gate of gates) {
+    if (options.totalTimeoutMs) {
+      const elapsed = Date.now() - totalStart;
+      if (elapsed >= options.totalTimeoutMs) {
+        results.push({
+          name: gate.name,
+          passed: false,
+          required: gate.required ?? true,
+          duration_ms: 0,
+          output: "[SKIPPED \u2014 total timeout exceeded]",
+          stderr: "",
+          exit_code: -1,
+          timed_out: true
+        });
+        continue;
+      }
+      const remainingMs = options.totalTimeoutMs - elapsed;
+      const gateTimeout = gate.timeout ? parseTimeout(gate.timeout) : options.timeoutMs ?? 6e4;
+      const effectiveTimeout = Math.min(gateTimeout, remainingMs);
+      results.push(await runGate(gate, { ...options, timeoutMs: effectiveTimeout }));
+    } else {
+      results.push(await runGate(gate, options));
+    }
+  }
+  return results;
+}
+
+// src/lib/cost-tracker.ts
+var PipelineCostTracker = class {
+  runId;
+  budget;
+  _totalIn = 0;
+  _totalOut = 0;
+  ticketCosts = /* @__PURE__ */ new Map();
+  columnCosts = /* @__PURE__ */ new Map();
+  modelCosts = /* @__PURE__ */ new Map();
+  constructor(runId, budget) {
+    this.runId = runId;
+    this.budget = budget;
+  }
+  get totalTokensIn() {
+    return this._totalIn;
+  }
+  get totalTokensOut() {
+    return this._totalOut;
+  }
+  get maxInputTokens() {
+    return this.budget?.max_input_tokens ?? 5e6;
+  }
+  record(inv) {
+    this._totalIn += inv.tokensIn;
+    this._totalOut += inv.tokensOut;
+    const tc = this.ticketCosts.get(inv.ticketId) ?? {
+      tokens_in: 0,
+      tokens_out: 0,
+      iterations: 0,
+      advisor_calls: 0
+    };
+    tc.tokens_in += inv.tokensIn;
+    tc.tokens_out += inv.tokensOut;
+    if (inv.type === "heavy") tc.iterations++;
+    if (inv.type === "advisor") tc.advisor_calls++;
+    this.ticketCosts.set(inv.ticketId, tc);
+    const cc = this.columnCosts.get(inv.columnId) ?? {
+      tokens_in: 0,
+      tokens_out: 0,
+      light_calls: 0,
+      heavy_calls: 0,
+      advisor_calls: 0
+    };
+    cc.tokens_in += inv.tokensIn;
+    cc.tokens_out += inv.tokensOut;
+    if (inv.type === "light") cc.light_calls++;
+    if (inv.type === "heavy") cc.heavy_calls++;
+    if (inv.type === "advisor" || inv.type === "stuck_detection") cc.advisor_calls++;
+    this.columnCosts.set(inv.columnId, cc);
+    const mc = this.modelCosts.get(inv.model) ?? { tokens_in: 0, tokens_out: 0, calls: 0 };
+    mc.tokens_in += inv.tokensIn;
+    mc.tokens_out += inv.tokensOut;
+    mc.calls++;
+    this.modelCosts.set(inv.model, mc);
+  }
+  getTicketCost(ticketId) {
+    return this.ticketCosts.get(ticketId);
+  }
+  getColumnCost(columnId) {
+    return this.columnCosts.get(columnId);
+  }
+  isWarning() {
+    if (!this.budget) return false;
+    const inPct = this._totalIn / this.budget.max_input_tokens * 100;
+    const outPct = this._totalOut / this.budget.max_output_tokens * 100;
+    return inPct >= this.budget.warn_pct || outPct >= this.budget.warn_pct;
+  }
+  isExhausted() {
+    if (!this.budget) return false;
+    return this._totalIn >= this.budget.max_input_tokens || this._totalOut >= this.budget.max_output_tokens;
+  }
+  generateReport(pricing) {
+    const fmt = (n) => {
+      if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+      if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+      return String(n);
+    };
+    const lines = [];
+    const budgetStr = this.budget ? ` (of ${fmt(this.budget.max_input_tokens)} / ${fmt(this.budget.max_output_tokens)} budget)` : "";
+    lines.push(`Tokens: ${fmt(this._totalIn)} in / ${fmt(this._totalOut)} out${budgetStr}`);
+    if (this.columnCosts.size > 0) {
+      const colParts = Array.from(this.columnCosts.entries()).map(
+        ([id, c]) => `${id.slice(0, 8)} ${fmt(c.tokens_in)}/${fmt(c.tokens_out)}`
+      );
+      lines.push(`  By column: ${colParts.join(", ")}`);
+    }
+    if (this.modelCosts.size > 0) {
+      const modelParts = Array.from(this.modelCosts.entries()).map(
+        ([model, c]) => `${model} ${fmt(c.tokens_in)}/${fmt(c.tokens_out)} (${c.calls} calls)`
+      );
+      lines.push(`  By model: ${modelParts.join(", ")}`);
+    }
+    if (pricing) {
+      let totalCost = 0;
+      for (const [model, mc] of this.modelCosts) {
+        const p = pricing[model];
+        if (p) {
+          totalCost += mc.tokens_in / 1e6 * p.input_per_mtok;
+          totalCost += mc.tokens_out / 1e6 * p.output_per_mtok;
+        }
+      }
+      if (totalCost > 0) {
+        lines.push(`  Estimated cost: $${totalCost.toFixed(2)} (user-provided pricing)`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/lib/event-emitter.ts
+var SIGNIFICANT_TYPES = /* @__PURE__ */ new Set([
+  "advisor_escalate",
+  "evaluator_rejected",
+  "budget_exhausted",
+  "replanner_paused"
+]);
+var FLUSH_INTERVAL_MS = 5e3;
+var MAX_BATCH_SIZE = 100;
+var PipelineEventEmitter = class _PipelineEventEmitter {
+  constructor(apiBaseUrl, projectId, apiToken, boardId, runId) {
+    this.apiBaseUrl = apiBaseUrl;
+    this.projectId = projectId;
+    this.apiToken = apiToken;
+    this.boardId = boardId;
+    this.runId = runId;
+    this.flushTimer = setInterval(() => void this.flush(), FLUSH_INTERVAL_MS);
+  }
+  buffer = [];
+  flushTimer = null;
+  closed = false;
+  inFlight = false;
+  static MAX_BUFFER_SIZE = 1e4;
+  emit(opts) {
+    if (this.closed) return;
+    const event = {
+      board_id: this.boardId,
+      ticket_id: opts.ticketId ?? null,
+      column_id: opts.columnId ?? null,
+      run_id: this.runId,
+      session_id: opts.sessionId ?? null,
+      layer: opts.layer,
+      event_type: opts.eventType,
+      severity: opts.severity,
+      summary: opts.summary,
+      detail: opts.detail ?? null,
+      iteration: opts.iteration ?? null
+    };
+    this.buffer.push(event);
+    if (SIGNIFICANT_TYPES.has(opts.eventType) || this.buffer.length >= MAX_BATCH_SIZE) {
+      void this.flush();
+    }
+  }
+  async flush() {
+    if (this.inFlight || this.buffer.length === 0) return;
+    this.inFlight = true;
+    const batch = this.buffer.splice(0, MAX_BATCH_SIZE);
+    try {
+      const res = await fetch(`${this.apiBaseUrl}/projects/${this.projectId}/pipeline-events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiToken}`
+        },
+        body: JSON.stringify({ events: batch })
+      });
+      if (!res.ok) {
+        if (res.status >= 500) {
+          this.buffer.unshift(...batch);
+          if (this.buffer.length > _PipelineEventEmitter.MAX_BUFFER_SIZE) {
+            this.buffer.splice(0, this.buffer.length - _PipelineEventEmitter.MAX_BUFFER_SIZE);
+          }
+        } else {
+          console.error(`[event-emitter] Dropping ${batch.length} events: HTTP ${res.status}`);
+        }
+      }
+    } catch {
+      this.buffer.unshift(...batch);
+      if (this.buffer.length > _PipelineEventEmitter.MAX_BUFFER_SIZE) {
+        this.buffer.splice(0, this.buffer.length - _PipelineEventEmitter.MAX_BUFFER_SIZE);
+      }
+    } finally {
+      this.inFlight = false;
+    }
+  }
+  async close() {
+    this.closed = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    while (this.inFlight) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    await this.flush();
+  }
+};
+
+// src/commands/pipeline.ts
+function parseArgs(args) {
+  const positional = [];
+  let once = false;
+  let dryRun = false;
+  let columnFilter = null;
+  let maxIterations = null;
+  let maxBudget = null;
+  let model = null;
+  let concurrency = null;
+  let logRetention = 7;
+  let yes = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--once":
+        once = true;
+        break;
+      case "--dry-run":
+        dryRun = true;
+        break;
+      case "--yes":
+      case "-y":
+        yes = true;
+        break;
+      case "--column":
+        columnFilter = args[++i] ?? null;
+        break;
+      case "--max-iterations": {
+        const val = Number(args[++i]);
+        if (isNaN(val) || val <= 0) {
+          console.error(`Error: --max-iterations requires a positive number, got: ${args[i]}`);
+          process.exit(1);
+        }
+        maxIterations = val;
+        break;
+      }
+      case "--max-budget": {
+        const val = Number(args[++i]);
+        if (isNaN(val) || val < 0) {
+          console.error(`Error: --max-budget requires a non-negative number, got: ${args[i]}`);
+          process.exit(1);
+        }
+        maxBudget = val;
+        break;
+      }
+      case "--model":
+        model = args[++i] ?? null;
+        break;
+      case "--concurrency": {
+        const val = Number(args[++i]);
+        if (isNaN(val) || val <= 0) {
+          console.error(`Error: --concurrency requires a positive number, got: ${args[i]}`);
+          process.exit(1);
+        }
+        concurrency = val;
+        break;
+      }
+      case "--log-retention":
+        logRetention = Number(args[++i]) || 7;
+        break;
+      default:
+        if (!arg.startsWith("--")) positional.push(arg);
+        break;
+    }
+  }
+  const boardId = positional[0] ?? "";
+  const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  if (boardId && !UUID_RE.test(boardId)) {
+    console.error(`Error: invalid board ID "${boardId}" \u2014 expected UUID`);
+    process.exit(1);
+  }
+  if (!boardId) {
+    console.error(`Usage: kantban pipeline <board-id> [flags]
+
+Flags:
+  --once                Run one scan, wait for loops, then exit
+  --dry-run             Show config without starting
+  --column <id>         Filter to a single column
+  --max-iterations <n>  Override max iterations per ticket
+  --max-budget <usd>    Per-ticket budget cap (USD)
+  --model <model>       Override model preference
+  --concurrency <n>     Override concurrency per column
+  --log-retention <d>   Log retention in days (default: 7)
+  --yes, -y             Skip safety confirmation`);
+    process.exit(1);
+  }
+  return { boardId, once, dryRun, columnFilter, maxIterations, maxBudget, model, concurrency, logRetention, yes };
+}
+function pidDir(boardId) {
+  return join2(homedir(), ".kantban", "pipelines", boardId);
+}
+function pidFilePath(boardId) {
+  return join2(pidDir(boardId), "orchestrator.pid");
+}
+function writePidFile(boardId) {
+  const dir = pidDir(boardId);
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  writeFileSync3(pidFilePath(boardId), String(process.pid), { mode: 384 });
+}
+function removePidFile(boardId) {
+  try {
+    unlinkSync2(pidFilePath(boardId));
+  } catch {
+  }
+}
+function childManifestPath(boardId) {
+  return join2(pidDir(boardId), "children.pid");
+}
+function appendChildPid(boardId, pid) {
+  const dir = pidDir(boardId);
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  appendFileSync2(childManifestPath(boardId), `${String(pid)}
+`, { mode: 384 });
+}
+function removeChildPid(boardId, pid) {
+  const manifestPath = childManifestPath(boardId);
+  try {
+    const contents = readFileSync2(manifestPath, "utf-8");
+    const pids = contents.split("\n").filter((l) => l.trim() !== "" && l.trim() !== String(pid));
+    writeFileSync3(manifestPath, pids.length > 0 ? pids.join("\n") + "\n" : "", { mode: 384 });
+  } catch {
+  }
+}
+function readChildManifest(boardId) {
+  try {
+    const contents = readFileSync2(childManifestPath(boardId), "utf-8");
+    return contents.split("\n").map((l) => l.trim()).filter((l) => l !== "").map(Number).filter((n) => !isNaN(n) && n > 0);
+  } catch {
+    return [];
+  }
+}
+function removeChildManifest(boardId) {
+  try {
+    unlinkSync2(childManifestPath(boardId));
+  } catch {
+  }
+}
+function cleanupOrphanedProcesses(boardId) {
+  const pidPath = pidFilePath(boardId);
+  if (existsSync(pidPath)) {
+    try {
+      const stalePid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
+      if (stalePid && stalePid !== process.pid) {
+        try {
+          process.kill(stalePid, 0);
+          process.kill(stalePid, "SIGTERM");
+          console.log(`Killed stale orchestrator (PID ${String(stalePid)})`);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    removePidFile(boardId);
+  }
+  const manifestPids = readChildManifest(boardId);
+  if (manifestPids.length > 0) {
+    for (const pid of manifestPids) {
+      try {
+        process.kill(pid, 0);
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    console.log(`Killed ${String(manifestPids.length)} orphaned child process(es) from manifest`);
+    removeChildManifest(boardId);
+  }
+  const staleReaperPath = join2(pidDir(boardId), "reaper.pid");
+  try {
+    if (existsSync(staleReaperPath)) {
+      const reaperPid = parseInt(readFileSync2(staleReaperPath, "utf-8").trim(), 10);
+      if (reaperPid && !isNaN(reaperPid)) {
+        try {
+          process.kill(reaperPid, 0);
+          process.kill(reaperPid, "SIGTERM");
+          console.log(`Killed stale reaper (PID ${String(reaperPid)})`);
+        } catch {
+        }
+      }
+      unlinkSync2(staleReaperPath);
+    }
+  } catch {
+  }
+  try {
+    const boardDir = pidDir(boardId).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const out = execSync(
+      `ps aux | grep 'claude.*-p' | grep '${boardDir}' | grep -v grep | awk '{print $2}'`,
+      { encoding: "utf-8", timeout: 5e3 }
+    ).trim();
+    if (out) {
+      const pids = out.split("\n").filter(Boolean);
+      for (const pid of pids) {
+        try {
+          process.kill(parseInt(pid, 10), "SIGTERM");
+        } catch {
+        }
+      }
+      if (pids.length > 0) {
+        console.log(`Killed ${String(pids.length)} orphaned claude agent(s)`);
+      }
+    }
+  } catch {
+  }
+}
+var activeChildProcesses = /* @__PURE__ */ new Set();
+var currentBoardId = "";
+var CLAUDE_TIMEOUT_MS = 60 * 60 * 1e3;
+async function invokeClaudeP(prompt, options) {
+  const args = ["-p", prompt, "--dangerously-skip-permissions", "--output-format", "stream-json", "--verbose"];
+  if (options.includeMcpConfig !== false && options.mcpConfigPath) {
+    args.push("--mcp-config", options.mcpConfigPath);
+  }
+  if (options.model) args.push("--model", options.model);
+  if (options.maxTurns) {
+    args.push("--max-turns", String(options.maxTurns));
+  } else if (options.maxBudgetUsd !== void 0 && options.maxBudgetUsd !== null) {
+    args.push("--max-turns", String(Math.max(1, Math.ceil(options.maxBudgetUsd * 10))));
+  }
+  if (options.worktree) args.push("--worktree", options.worktree);
+  if (options.tools !== void 0) {
+    args.push("--tools", options.tools);
+  }
+  if (options.allowedTools?.length) {
+    args.push("--allowedTools", ...options.allowedTools);
+  }
+  if (options.disallowedTools?.length) {
+    args.push("--disallowedTools", ...options.disallowedTools);
+  }
+  return new Promise((resolve) => {
+    const child = spawn2("claude", args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    activeChildProcesses.add(child);
+    if (child.pid && currentBoardId) appendChildPid(currentBoardId, child.pid);
+    const parser = new StreamJsonParser();
+    parser.on("error", (err) => {
+      process.stderr.write(`[stream-parser] ${err.message}
+`);
+    });
+    let lastOutput = "";
+    let tokensIn = 0;
+    let tokensOut = 0;
+    parser.on("event", (event) => {
+      if (event.type === "result") {
+        const usage = event.usage;
+        tokensIn += usage?.input_tokens ?? 0;
+        tokensOut += usage?.output_tokens ?? 0;
+        if (typeof event.result === "string") lastOutput = event.result;
+      }
+      options.onStreamEvent?.(event);
+    });
+    child.stdout?.on("data", (chunk) => {
+      parser.feed(chunk.toString());
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.stdin?.end();
+    let killTimer;
+    const timeoutHandle = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      killTimer = setTimeout(() => {
+        if (!resolved) {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }
+      }, 5e3);
+    }, CLAUDE_TIMEOUT_MS);
+    let resolved = false;
+    child.on("close", (code) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeoutHandle);
+      if (killTimer) clearTimeout(killTimer);
+      activeChildProcesses.delete(child);
+      if (child.pid && currentBoardId) removeChildPid(currentBoardId, child.pid);
+      parser.flush();
+      resolve({
+        exitCode: code ?? 1,
+        output: lastOutput || stderr,
+        toolCallCount: parser.getToolCallCount(),
+        tokensIn,
+        tokensOut
+      });
+    });
+    child.on("error", (err) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeoutHandle);
+      if (killTimer) clearTimeout(killTimer);
+      activeChildProcesses.delete(child);
+      if (child.pid && currentBoardId) removeChildPid(currentBoardId, child.pid);
+      parser.flush();
+      resolve({
+        exitCode: 1,
+        output: err.message,
+        toolCallCount: parser.getToolCallCount(),
+        tokensIn,
+        tokensOut
+      });
+    });
+  });
+}
+function killAllChildProcesses() {
+  for (const child of activeChildProcesses) {
+    try {
+      if (child.pid) {
+        try {
+          process.kill(-child.pid, "SIGTERM");
+        } catch {
+          try {
+            child.kill("SIGTERM");
+          } catch {
+          }
+        }
+      } else {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+}
+function printSafetyWarning() {
+  console.log(`
+=== SAFETY WARNING ===
+
+This pipeline will run Claude Code agents with --dangerously-skip-permissions.
+Agents will have unrestricted access to tools, file system, and MCP servers.
+
+Before proceeding:
+  1. Review all prompt documents linked to pipeline columns
+  2. Ensure your project signals/guardrails are configured correctly
+  3. Verify your MCP server configuration is appropriate
+
+Press Ctrl+C to cancel, or re-run with --yes to skip this warning.
+`);
+}
+function waitForConfirmation() {
+  return new Promise((resolve) => {
+    process.stdout.write("Continue? [y/N] ");
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (data) => {
+      const answer = data.trim().toLowerCase();
+      resolve(answer === "y" || answer === "yes");
+    });
+    process.stdin.once("end", () => resolve(false));
+  });
+}
+async function runPipeline(client, args) {
+  if (args[0] === "init") {
+    const { runPipelineInit } = await import("./pipeline-init-IGZZOOLK.js");
+    await runPipelineInit();
+    return;
+  }
+  const opts = parseArgs(args);
+  currentBoardId = opts.boardId;
+  if (!opts.yes && !opts.dryRun) {
+    printSafetyWarning();
+    const confirmed = await waitForConfirmation();
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  const gateFilePath = join2(process.cwd(), "pipeline.gates.yaml");
+  let gateConfig;
+  if (!existsSync(gateFilePath)) {
+    console.error(`Error: pipeline.gates.yaml not found in ${process.cwd()}`);
+    console.error('Run "kantban pipeline init" to generate a starter gate file.');
+    process.exit(1);
+  }
+  try {
+    const gateYaml = readFileSync2(gateFilePath, "utf-8");
+    gateConfig = parseGateConfig(gateYaml);
+    console.log(`Gate config loaded: ${gateConfig.default.length} default gate(s)`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: Invalid pipeline.gates.yaml: ${message}`);
+    process.exit(1);
+  }
+  const costTracker = gateConfig.settings?.budget ? new PipelineCostTracker(crypto.randomUUID(), gateConfig.settings.budget) : void 0;
+  const gateSnapshotStore = new GateSnapshotStore();
+  let projectId = process.env["KANTBAN_PROJECT_ID"] ?? "";
+  if (!projectId) {
+    try {
+      const result = await client.getBoardProject(opts.boardId);
+      projectId = result.project_id;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Error: Could not resolve project ID for board ${opts.boardId}: ${message}`);
+      console.error("Set KANTBAN_PROJECT_ID environment variable or ensure the board exists.");
+      process.exit(1);
+    }
+  }
+  const mcpConfigPath = generateMcpConfig(client.baseUrl, client.token, opts.boardId);
+  const logBaseDir = join2(homedir(), ".kantban", "pipelines");
+  const logger = new PipelineLogger(logBaseDir, opts.boardId);
+  logger.pruneOldLogs(opts.logRetention);
+  let runMemory = null;
+  const pipelineSessionId = crypto.randomUUID();
+  const eventEmitter = new PipelineEventEmitter(
+    client.baseUrl,
+    projectId,
+    client.token,
+    opts.boardId,
+    pipelineSessionId
+  );
+  const deps = {
+    fetchBoardScope: (boardId) => client.get(`/projects/${projectId}/pipeline-context`, { boardId }),
+    fetchColumnScope: (columnId) => client.get(`/projects/${projectId}/pipeline-context`, { columnId }),
+    startLoop: async (ticketId, columnId, config) => {
+      const effectiveConfig = {
+        ...config,
+        ...opts.maxIterations !== null && { maxIterations: opts.maxIterations },
+        ...opts.maxBudget !== null && { maxBudgetUsd: opts.maxBudget },
+        ...opts.model !== null && { model: opts.model }
+      };
+      const mem = runMemory;
+      const colScopeForName = await client.get(
+        `/projects/${projectId}/pipeline-context`,
+        { columnId }
+      );
+      const resolvedColumnName = colScopeForName.column.name;
+      const columnGates = resolveGatesForColumn(gateConfig, resolvedColumnName);
+      const effectiveMcpConfigPath = columnGates.length > 0 ? generateGateProxyMcpConfig(
+        client.baseUrl,
+        client.token,
+        opts.boardId,
+        gateFilePath,
+        columnId,
+        resolvedColumnName,
+        projectId
+      ) : mcpConfigPath;
+      const loopDeps = {
+        fetchTicketContext: (tid) => client.get(`/projects/${projectId}/pipeline-context`, { ticketId: tid }),
+        fetchColumnContext: (cid) => client.get(`/projects/${projectId}/pipeline-context`, { columnId: cid }),
+        fetchFingerprint: (tid) => client.getFingerprint(projectId, tid),
+        invokeClaudeP,
+        mcpConfigPath: effectiveMcpConfigPath,
+        projectId,
+        log: (msg) => {
+          logger.orchestrator(`[${ticketId}] ${msg}`);
+        },
+        // Run memory enrichment — inject accumulated discoveries into each iteration prompt
+        fetchRunMemoryContent: mem ? async () => {
+          const content = await mem.getContent();
+          const lines = content.split("\n");
+          if (lines.length > 500) {
+            return lines.slice(-500).join("\n");
+          }
+          return content;
+        } : void 0,
+        // Lookahead enrichment — fetch next-column prompt doc so agent can anticipate exit criteria
+        fetchLookaheadDocument: effectiveConfig.lookaheadColumnId ? async () => {
+          const colScope = await client.get(
+            `/projects/${projectId}/pipeline-context`,
+            { columnId: effectiveConfig.lookaheadColumnId }
+          );
+          if (!colScope.prompt_document) return void 0;
+          return { title: colScope.prompt_document.title, content: colScope.prompt_document.content };
+        } : void 0,
+        // Pipeline event emission — forward stream/session events to WS for browser delivery
+        onStreamEvent: deps.emitPipelineEvent ? (event, context) => {
+          deps.emitPipelineEvent({
+            type: "pipeline:stream",
+            payload: {
+              boardId: opts.boardId,
+              ticketId: context.ticketId,
+              columnId: context.columnId,
+              runId: context.runId,
+              sessionId: pipelineSessionId,
+              event
+            }
+          });
+        } : void 0,
+        onSessionStart: deps.emitPipelineEvent ? (meta) => {
+          deps.emitPipelineEvent({
+            type: "pipeline:session-start",
+            payload: {
+              boardId: opts.boardId,
+              ticketId,
+              columnId,
+              runId: meta.runId,
+              sessionId: pipelineSessionId,
+              model: meta.model,
+              invocationType: "heavy",
+              iteration: meta.iteration
+            }
+          });
+        } : void 0,
+        onSessionEnd: (meta) => {
+          costTracker?.record({
+            ticketId,
+            columnId,
+            model: effectiveConfig.model ?? "default",
+            tokensIn: meta.tokensIn,
+            tokensOut: meta.tokensOut,
+            type: "heavy"
+          });
+          if (deps.emitPipelineEvent) {
+            deps.emitPipelineEvent({
+              type: "pipeline:session-end",
+              payload: {
+                boardId: opts.boardId,
+                runId: meta.runId,
+                exitReason: null,
+                tokensIn: meta.tokensIn,
+                tokensOut: meta.tokensOut,
+                toolCallCount: meta.toolCallCount,
+                durationMs: meta.durationMs
+              }
+            });
+          }
+        }
+      };
+      if (deps.setFieldValue) {
+        effectiveConfig.onCheckpoint = async (tid, checkpoint) => {
+          try {
+            await deps.setFieldValue(tid, "loop_checkpoint", checkpoint);
+          } catch {
+          }
+        };
+      }
+      if (effectiveConfig.stuckDetection) {
+        effectiveConfig.invokeStuckDetection = async (input) => {
+          const prompt = composeStuckDetectionPrompt(input);
+          const { exitCode, output } = await invokeClaudeP(prompt, {
+            mcpConfigPath,
+            model: "haiku",
+            maxBudgetUsd: 0.01,
+            tools: "",
+            includeMcpConfig: false
+          });
+          if (exitCode !== 0) {
+            throw new Error(`Stuck detection call failed (exit ${String(exitCode)})`);
+          }
+          return parseStuckDetectionResponse(output);
+        };
+      }
+      effectiveConfig.onPostIterationGates = async (tid, iteration) => {
+        const gates = resolveGatesForColumn(gateConfig, resolvedColumnName);
+        if (gates.length === 0) {
+          return gateSnapshotStore.record(tid, iteration, []);
+        }
+        const runOpts = {};
+        if (gateConfig.settings?.cwd) runOpts.cwd = gateConfig.settings.cwd;
+        if (gateConfig.settings?.env) runOpts.env = gateConfig.settings.env;
+        if (gateConfig.settings?.total_timeout) {
+          runOpts.totalTimeoutMs = parseTimeout(gateConfig.settings.total_timeout);
+        }
+        const results = await runGates(gates, runOpts);
+        return gateSnapshotStore.record(tid, iteration, results);
+      };
+      const loop = new RalphLoop(ticketId, columnId, effectiveConfig, loopDeps);
+      activeRalphLoops.add(loop);
+      return loop.run().finally(() => {
+        activeRalphLoops.delete(loop);
+      });
+    },
+    createComment: (ticketId, body) => client.post(`/projects/${projectId}/tickets/${ticketId}/comments`, { body }),
+    createSignal: (ticketId, body) => client.post(`/projects/${projectId}/signals`, {
+      scopeType: "ticket",
+      scopeId: ticketId,
+      content: body
+    }),
+    createColumnSignal: (columnId, body) => client.post(`/projects/${projectId}/signals`, {
+      scopeType: "column",
+      scopeId: columnId,
+      content: body
+    }),
+    claimTicket: (ticketId) => client.claimTicket(projectId, ticketId),
+    fetchBlockedTickets: (ticketId) => client.get(
+      `/projects/${projectId}/tickets/${ticketId}/blocked-tickets`
+    ),
+    hasUnresolvedBlockers: async (ticketId) => {
+      const blockers = await client.get(
+        `/projects/${projectId}/tickets/${ticketId}/unresolved-blockers`
+      );
+      return blockers.length > 0;
+    },
+    dispatchLightCall: async (ticketId, columnId) => {
+      const [ticketCtx, colScope, boardScope] = await Promise.all([
+        client.get(`/projects/${projectId}/pipeline-context`, { ticketId }),
+        client.get(`/projects/${projectId}/pipeline-context`, { columnId }),
+        client.get(
+          `/projects/${projectId}/pipeline-context`,
+          { boardId: opts.boardId }
+        )
+      ]);
+      const lightCtx = {
+        ticketId,
+        ticketNumber: ticketCtx.ticket.ticket_number,
+        ticketTitle: ticketCtx.ticket.title,
+        ...ticketCtx.ticket.description ? { ticketDescription: ticketCtx.ticket.description } : {},
+        columnName: colScope.column.name,
+        fieldValues: ticketCtx.field_values,
+        toolPrefix: colScope.tool_prefix,
+        projectId,
+        ...colScope.transition_rules ? { transitionRules: colScope.transition_rules } : {},
+        ...boardScope.columns && boardScope.columns.length > 0 && {
+          availableColumns: boardScope.columns.map((col) => ({ id: col.id, name: col.name }))
+        }
+      };
+      const prompt = composeLightPrompt(lightCtx);
+      logger.orchestrator(`[${ticketId}] Light call: composing prompt for column "${colScope.column.name}"`);
+      const { exitCode, output, tokensIn, tokensOut } = await invokeClaudeP(prompt, {
+        mcpConfigPath,
+        model: "haiku",
+        maxBudgetUsd: 0.01,
+        maxTurns: 3,
+        tools: "",
+        // Strip all built-in tools
+        includeMcpConfig: false
+        // No MCP tools either
+      });
+      costTracker?.record({ ticketId, columnId, model: "haiku", tokensIn, tokensOut, type: "light" });
+      if (exitCode !== 0) {
+        throw new Error(`Light call exited with code ${exitCode}: ${output.slice(0, 200)}`);
+      }
+      const response = parseLightResponse(output);
+      logger.orchestrator(`[${ticketId}] Light call result: ${response.action} \u2014 ${response.reason}`);
+      return response;
+    },
+    // Advisor invocation — recovers from failure exits (stalled/error/max_iterations)
+    invokeAdvisor: async (input) => {
+      const prompt = composeAdvisorPrompt(input);
+      logger.orchestrator(`[${input.ticketId}] Advisor: invoking for ${input.exitReason}`);
+      const { exitCode, output, tokensIn, tokensOut } = await invokeClaudeP(prompt, {
+        mcpConfigPath,
+        model: "haiku",
+        maxBudgetUsd: 0.01,
+        tools: "",
+        includeMcpConfig: false
+      });
+      costTracker?.record({ ticketId: input.ticketId, columnId: "", model: "haiku", tokensIn, tokensOut, type: "advisor" });
+      if (exitCode !== 0) {
+        throw new Error(`Advisor call exited with code ${exitCode}: ${output.slice(0, 200)}`);
+      }
+      const response = parseAdvisorResponse(output);
+      logger.orchestrator(`[${input.ticketId}] Advisor: ${response.action} \u2014 ${response.reason}`);
+      return response;
+    },
+    // Field value management — used for debt items, checkpoint writes, and escalation metadata
+    setFieldValue: async (ticketId, fieldName, value) => {
+      await client.put(`/projects/${projectId}/tickets/${ticketId}/field-values`, {
+        values: { [fieldName]: value }
+      });
+    },
+    getFieldValues: async (ticketId) => {
+      const ctx = await client.get(
+        `/projects/${projectId}/pipeline-context`,
+        { ticketId }
+      );
+      return ctx.field_values;
+    },
+    // Ticket management for advisor actions (ESCALATE, SPLIT_TICKET)
+    moveTicketToColumn: async (ticketId, columnId, handoff) => {
+      await client.patch(`/projects/${projectId}/tickets/${ticketId}/move`, {
+        column_id: columnId,
+        handoff
+      });
+    },
+    createTickets: async (parentTicketId, specs) => {
+      const ids = [];
+      for (const spec of specs) {
+        const result = await client.post(
+          `/projects/${projectId}/tickets`,
+          { title: spec.title, description: spec.description, parent_id: parentTicketId }
+        );
+        ids.push(result.id);
+      }
+      return ids;
+    },
+    archiveTicket: async (ticketId) => {
+      await client.post(`/projects/${projectId}/tickets/${ticketId}/archive`, {});
+    },
+    // Run memory append — closure captures runMemory by reference (set after initialization)
+    appendRunMemory: (section, content) => runMemory ? runMemory.append(section, content) : Promise.resolve(),
+    cleanupWorktree: (name) => cleanupWorktree(name),
+    mergeWorktree: (name, integrationBranch) => mergeWorktreeBranch(name, integrationBranch),
+    // Pipeline event emission — wsClient captured by reference (set later before any loops run)
+    emitPipelineEvent: (event) => {
+      wsClient?.send(event);
+    },
+    boardId: opts.boardId,
+    eventEmitter,
+    costTracker,
+    gateSnapshotStore,
+    invokeReplanner: async (state) => {
+      const prompt = composeReplannerPrompt(state);
+      const { exitCode, output, tokensIn, tokensOut } = await invokeClaudeP(prompt, {
+        mcpConfigPath,
+        model: "haiku",
+        maxBudgetUsd: 0.01,
+        tools: "",
+        includeMcpConfig: false
+      });
+      costTracker?.record({ ticketId: "replanner", columnId: "pipeline", model: "haiku", tokensIn, tokensOut, type: "orchestrator" });
+      if (exitCode !== 0) throw new Error(`Replanner failed`);
+      return parseReplannerResponse(output);
+    }
+  };
+  const orchestrator = new PipelineOrchestrator(opts.boardId, projectId, deps);
+  console.log(`Initializing pipeline for board ${opts.boardId}...`);
+  logger.orchestrator("Initializing pipeline");
+  try {
+    await orchestrator.initialize();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: Failed to initialize pipeline: ${message}`);
+    console.error("Check that the board exists, has pipeline columns configured, and the API is reachable.");
+    cleanupMcpConfig(mcpConfigPath);
+    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    process.exit(1);
+  }
+  const columnIds = orchestrator.pipelineColumnIds;
+  try {
+    for (const colId of columnIds) {
+      const colScope = await client.get(
+        `/projects/${projectId}/pipeline-context`,
+        { columnId: colId }
+      );
+      if (colScope.agent_config?.run_memory) {
+        const boardScope = await client.get(
+          `/projects/${projectId}/pipeline-context`,
+          { boardId: opts.boardId }
+        );
+        const spaces = await client.get(
+          `/projects/${projectId}/spaces`
+        );
+        const spaceId = spaces[0]?.id;
+        if (!spaceId) {
+          logger.orchestrator("Run memory: no spaces found in project \u2014 skipping run memory");
+          console.warn("Warning: Run memory requires at least one document space in the project \u2014 skipping.");
+          break;
+        }
+        runMemory = new RunMemory(opts.boardId, boardScope.board.name, {
+          createDocument: async (content, title) => {
+            const result = await client.post(
+              `/projects/${projectId}/spaces/${spaceId}/documents`,
+              { title, content }
+            );
+            return result.id;
+          },
+          getDocument: async (docId) => {
+            const doc = await client.get(
+              `/projects/${projectId}/documents/${docId}`
+            );
+            return doc.content;
+          },
+          updateDocument: async (docId, content) => {
+            await client.patch(`/projects/${projectId}/documents/${docId}`, { content });
+          }
+        });
+        await runMemory.initialize();
+        logger.orchestrator(`Run memory initialized (doc=${runMemory.documentId ?? "none"})`);
+        console.log(`Run memory enabled (document: ${runMemory.documentId ?? "none"})`);
+        break;
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.orchestrator(`Run memory init failed (non-fatal): ${msg}`);
+    console.error(`Warning: Run memory initialization failed: ${msg}`);
+  }
+  if (columnIds.length === 0) {
+    console.log('No pipeline columns found (columns need has_prompt=true and type !== "done").');
+    cleanupMcpConfig(mcpConfigPath);
+    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    return;
+  }
+  console.log(`Discovered ${String(columnIds.length)} pipeline column(s).`);
+  logger.orchestrator(`Discovered ${String(columnIds.length)} pipeline columns: ${columnIds.join(", ")}`);
+  if (opts.dryRun) {
+    console.log("\n--- Dry Run Configuration ---");
+    console.log(`Board ID:       ${opts.boardId}`);
+    console.log(`Project ID:     ${projectId}`);
+    console.log(`Pipeline cols:  ${String(columnIds.length)}`);
+    console.log(`Column filter:  ${opts.columnFilter ?? "(none)"}`);
+    console.log(`Max iterations: ${opts.maxIterations !== null ? String(opts.maxIterations) : "(per-column default)"}`);
+    console.log(`Max budget:     ${opts.maxBudget !== null ? `$${String(opts.maxBudget)}` : "(per-column default)"}`);
+    console.log(`Model:          ${opts.model ?? "(per-column default)"}`);
+    console.log(`Concurrency:    ${opts.concurrency !== null ? String(opts.concurrency) : "(per-column default)"}`);
+    console.log(`Mode:           ${opts.once ? "once" : "persistent"}`);
+    console.log(`Log retention:  ${String(opts.logRetention)} days`);
+    console.log(`MCP config:     ${mcpConfigPath}`);
+    console.log("\n[Dry run -- no agents started]");
+    cleanupMcpConfig(mcpConfigPath);
+    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    return;
+  }
+  let shutdownInProgress = false;
+  const shutdown = async (signal) => {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    console.log(`
+Received ${signal}. Shutting down gracefully...`);
+    logger.orchestrator(`Shutdown initiated (${signal})`);
+    if (rescanTimer) clearInterval(rescanTimer);
+    eventQueue?.stop();
+    wsClient?.send({ type: "pipeline:stopped", payload: { boardId: opts.boardId } });
+    await new Promise((r) => setTimeout(r, 200));
+    await eventEmitter.close();
+    wsClient?.stop();
+    for (const loop of activeRalphLoops) {
+      loop.stop();
+    }
+    killAllChildProcesses();
+    const deadline = Date.now() + 5e3;
+    while (activeChildProcesses.size > 0 && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    if (activeChildProcesses.size > 0) {
+      console.error(`Warning: ${String(activeChildProcesses.size)} child process(es) did not exit. Sending SIGKILL...`);
+      for (const child of activeChildProcesses) {
+        try {
+          if (child.pid) {
+            try {
+              process.kill(-child.pid, "SIGKILL");
+            } catch {
+              try {
+                child.kill("SIGKILL");
+              } catch {
+              }
+            }
+          } else {
+            try {
+              child.kill("SIGKILL");
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    if (costTracker) {
+      console.log("\n--- Pipeline Cost Report ---");
+      console.log(costTracker.generateReport(gateConfig.settings?.pricing));
+    }
+    cleanupMcpConfig(mcpConfigPath);
+    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    killReaper(reaperPidPath);
+    removePidFile(opts.boardId);
+    removeChildManifest(opts.boardId);
+    logger.orchestrator("Shutdown complete");
+    console.log("Pipeline stopped.");
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => {
+    shutdown("SIGTERM").catch((err) => {
+      console.error("Error during shutdown:", err);
+      process.exit(1);
+    });
+  });
+  process.on("SIGINT", () => {
+    shutdown("SIGINT").catch((err) => {
+      console.error("Error during shutdown:", err);
+      process.exit(1);
+    });
+  });
+  process.on("SIGHUP", () => {
+    shutdown("SIGHUP").catch((err) => {
+      console.error("Error during shutdown:", err);
+      process.exit(1);
+    });
+  });
+  cleanupOrphanedProcesses(opts.boardId);
+  writePidFile(opts.boardId);
+  logger.orchestrator(`PID file written: ${String(process.pid)}`);
+  const reaperPidPath = join2(pidDir(opts.boardId), "reaper.pid");
+  const reaperProcess = spawnReaper({
+    orchestratorPid: process.pid,
+    manifestPath: childManifestPath(opts.boardId),
+    pidFilePath: pidFilePath(opts.boardId),
+    reaperPidPath,
+    mcpConfigPath,
+    pipelineDir: pidDir(opts.boardId)
+  });
+  logger.orchestrator(`Watchdog reaper spawned (PID ${String(reaperProcess.pid ?? "unknown")})`);
+  let eventQueue = null;
+  let wsClient = null;
+  let rescanTimer = null;
+  const onEventError = (event, err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.orchestrator(`Event handler error for ${event.type} ticket=${event.ticketId}: ${msg}`);
+    console.error(`Event handler error: ${msg}`);
+  };
+  eventQueue = new EventQueue(
+    (event) => orchestrator.handleEvent(event),
+    {
+      drainRateMs: 100,
+      onError: onEventError
+    }
+  );
+  wsClient = new PipelineWsClient(client, {
+    boardId: opts.boardId,
+    projectId,
+    onEvent: (wsEvent) => {
+      const payload = wsEvent.payload;
+      const ticket = payload["ticket"];
+      const ticketId = (typeof payload["ticketId"] === "string" ? payload["ticketId"] : null) ?? (ticket && typeof ticket["id"] === "string" ? ticket["id"] : null);
+      const columnId = (typeof payload["columnId"] === "string" ? payload["columnId"] : null) ?? (ticket && typeof ticket["column_id"] === "string" ? ticket["column_id"] : null);
+      if (wsEvent.type === "firing_constraint:created" || wsEvent.type === "firing_constraint:updated" || wsEvent.type === "firing_constraint:deleted") {
+        logger.orchestrator(`WS event: ${wsEvent.type} \u2014 refreshing constraint caches`);
+        void orchestrator.refreshConstraints().catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          logger.orchestrator(`Constraint cache refresh failed: ${msg}`);
+        });
+        return;
+      }
+      if (!ticketId) return;
+      const eventType = wsEvent.type;
+      if (eventType === "ticket:created" || eventType === "ticket:moved" || eventType === "ticket:updated" || eventType === "ticket:archived" || eventType === "ticket:deleted") {
+        const pipelineEvent = { type: eventType, ticketId, columnId };
+        eventQueue.push(pipelineEvent);
+        logger.orchestrator(`WS event: ${eventType} ticket=${ticketId} column=${columnId ?? "null"}`);
+      }
+    },
+    onConnect: () => {
+      console.log("WebSocket connected. Listening for board events...");
+      logger.orchestrator("WebSocket connected");
+    },
+    onDisconnect: () => {
+      logger.orchestrator("WebSocket disconnected");
+    }
+  });
+  try {
+    await wsClient.connect();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Warning: WebSocket connection failed: ${message}`);
+    console.error("Pipeline will poll for changes and retry WS periodically.");
+    logger.orchestrator(`WebSocket connection failed: ${message}`);
+  }
+  eventQueue.start();
+  console.log("Scanning pipeline columns for tickets...");
+  logger.orchestrator("Starting scan and spawn");
+  try {
+    await orchestrator.scanAndSpawn();
+    logger.orchestrator(`Scan complete. Active loops: ${String(orchestrator.activeLoopCount)}`);
+    console.log(`Scan complete. Active loops: ${String(orchestrator.activeLoopCount)}`);
+  } catch (scanErr) {
+    const scanMsg = scanErr instanceof Error ? scanErr.message : String(scanErr);
+    logger.orchestrator(`Scan error: ${scanMsg}`);
+    console.error(`Scan error: ${scanMsg}`);
+  }
+  if (opts.once) {
+    console.log("Running in --once mode. Waiting for all loops to complete...");
+    logger.orchestrator("Once mode: waiting for loops to complete");
+    await waitForAllLoops(orchestrator);
+    if (costTracker) {
+      console.log("\n--- Pipeline Cost Report ---");
+      console.log(costTracker.generateReport(gateConfig.settings?.pricing));
+    }
+    wsClient.send({ type: "pipeline:stopped", payload: { boardId: opts.boardId } });
+    await new Promise((r) => setTimeout(r, 200));
+    await eventEmitter.close();
+    wsClient.stop();
+    eventQueue.stop();
+    cleanupMcpConfig(mcpConfigPath);
+    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    killReaper(reaperPidPath);
+    removePidFile(opts.boardId);
+    removeChildManifest(opts.boardId);
+    logger.orchestrator("Once mode complete. Exiting.");
+    console.log("All loops complete. Pipeline exiting.");
+  } else {
+    let consecutiveScanFailures = 0;
+    rescanTimer = setInterval(() => {
+      void (async () => {
+        try {
+          await orchestrator.scanAndSpawn();
+          if (consecutiveScanFailures > 0) {
+            console.log(`Rescan recovered after ${String(consecutiveScanFailures)} failure(s)`);
+          }
+          consecutiveScanFailures = 0;
+        } catch (err) {
+          consecutiveScanFailures++;
+          const msg = err instanceof Error ? err.message : String(err);
+          logger.orchestrator(`Periodic rescan error (${String(consecutiveScanFailures)}x): ${msg}`);
+          if (consecutiveScanFailures === 1 || consecutiveScanFailures % 10 === 0) {
+            console.error(`Warning: Rescan has failed ${String(consecutiveScanFailures)} consecutive time(s): ${msg}`);
+          }
+        }
+        if (wsClient && !wsClient.connected) {
+          const reconnected = await wsClient.tryReconnect();
+          if (reconnected) {
+            logger.orchestrator("WS reconnected via poll cycle");
+          }
+        }
+      })();
+    }, 3e4);
+    console.log(`Pipeline running (PID ${String(process.pid)}). Use 'kantban pipeline stop ${opts.boardId}' to stop.`);
+    logger.orchestrator("Pipeline running in persistent mode");
+  }
+}
+var activeRalphLoops = /* @__PURE__ */ new Set();
+async function waitForAllLoops(orchestrator, timeoutMs = 4 * 60 * 60 * 1e3) {
+  let consecutiveIdle = 0;
+  const startTime = Date.now();
+  let lastProgressLog = 0;
+  while (consecutiveIdle < 2) {
+    if (Date.now() - startTime > timeoutMs) {
+      console.error(
+        `Warning: waitForAllLoops timed out after ${String(Math.round(timeoutMs / 6e4))}m. Active: ${String(activeRalphLoops.size)}, orchestrator: ${String(orchestrator.activeLoopCount)}, queued: ${String(orchestrator.hasQueuedWork)}`
+      );
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    if (activeRalphLoops.size === 0 && orchestrator.activeLoopCount === 0 && !orchestrator.hasActiveQueuedWork) {
+      consecutiveIdle++;
+    } else {
+      consecutiveIdle = 0;
+      const now = Date.now();
+      if (now - lastProgressLog > 3e4) {
+        lastProgressLog = now;
+        console.log(
+          `Waiting... Active loops: ${String(activeRalphLoops.size)}, queued work: ${String(orchestrator.hasQueuedWork)}`
+        );
+      }
+    }
+  }
+}
+async function stopPipeline(args) {
+  const boardId = args[0];
+  if (!boardId) {
+    console.error("Usage: kantban pipeline stop <board-id>");
+    process.exit(1);
+  }
+  const pidFile = pidFilePath(boardId);
+  let pid;
+  try {
+    const content = readFileSync2(pidFile, "utf8").trim();
+    pid = Number(content);
+    if (isNaN(pid) || pid <= 0) {
+      throw new Error("Invalid PID");
+    }
+  } catch {
+    console.error(`No running pipeline found for board ${boardId}.`);
+    console.error(`Expected PID file at: ${pidFile}`);
+    process.exit(1);
+    return;
+  }
+  try {
+    try {
+      process.kill(-pid, "SIGTERM");
+      console.log(`Sent SIGTERM to pipeline process group (pgid ${String(pid)}) for board ${boardId}.`);
+    } catch {
+      process.kill(pid, "SIGTERM");
+      console.log(`Sent SIGTERM to pipeline process ${String(pid)} for board ${boardId}.`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to stop pipeline (PID ${String(pid)}): ${message}`);
+    console.error("The process may have already exited. Removing stale PID file.");
+    removePidFile(boardId);
+    process.exit(1);
+  }
+}
+export {
+  runPipeline,
+  stopPipeline
+};
+//# sourceMappingURL=pipeline-7LG74YA2.js.map