kantban-cli 0.1.15 → 0.1.16

package/dist/{pipeline-UNO4PIW4.js → pipeline-6SDPVNFK.js}

@@ -1,23 +1,28 @@
 import {
-  LoopCheckpointSchema,
+  runGates
+} from "./chunk-4IUZAIFL.js";
+import {
+  ClaudeProvider,
   RalphLoop,
-  VerdictSchema,
   classifyTrajectory,
   cleanupGateProxyConfigs,
   cleanupMcpConfig,
   composeStuckDetectionPrompt,
   generateGateProxyMcpConfig,
   generateMcpConfig,
-  parseGateConfig,
   parseJsonFromLlmOutput,
-  parseStuckDetectionResponse,
+  parseStuckDetectionResponse
+} from "./chunk-FF77FM7X.js";
+import {
+  LoopCheckpointSchema,
+  VerdictSchema,
+  parseGateConfig,
   parseTimeout,
   resolveGatesForColumn
-} from "./chunk-KGS3M2MY.js";
+} from "./chunk-MN4H5NSU.js";
 
 // src/commands/pipeline.ts
-import { spawn as spawn2 } from "child_process";
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync2, unlinkSync as unlinkSync2, existsSync, appendFileSync as appendFileSync2 } from "fs";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync2, appendFileSync as appendFileSync2 } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
 
@@ -42,6 +47,12 @@ function generateWorktreeName(ticketNumber, columnName) {
   return `kantban-${ticketNumber}-${slug}`;
 }
 async function cleanupWorktree(worktreeName, exec = defaultExecFile) {
+  try {
+    const path = await findWorktreeForBranch(exec, worktreeName);
+    if (!path) return true;
+  } catch {
+    return true;
+  }
   return new Promise((resolve) => {
     exec("git", ["worktree", "remove", "--force", worktreeName], (err) => {
       if (err) {
@@ -79,6 +90,11 @@ async function findWorktreeForBranch(exec, branch) {
 }
 async function mergeWorktreeBranch(worktreeName, integrationBranch, exec = defaultExecFile) {
   try {
+    try {
+      await execPromise(exec, "git", ["rev-parse", "--verify", worktreeName]);
+    } catch {
+      return true;
+    }
     await execPromise(exec, "git", ["branch", integrationBranch, "HEAD"]).catch(() => {
     });
     const checkedOutPath = await findWorktreeForBranch(exec, integrationBranch);
@@ -284,7 +300,16 @@ async function readCheckpoint(deps, ticketId, currentColumnId, staleMinutes) {
     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);
+    let raw = entry.value;
+    if (typeof raw === "string") {
+      if (!raw.trim()) return null;
+      try {
+        raw = JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    const parsed = LoopCheckpointSchema.safeParse(raw);
     if (!parsed.success) return null;
     const checkpoint = parsed.data;
     if (checkpoint.column_id !== currentColumnId) return null;
@@ -486,6 +511,10 @@ var PipelineOrchestrator = class {
     }
     return this.spawning.size > 0;
   }
+  /** Returns true if any onLoopComplete callbacks are still running (for --once mode drain). */
+  get hasCompletingWork() {
+    return this.completing.size > 0;
+  }
   /** Returns the number of queued (waiting) tickets for a column. */
   queuedCount(columnId) {
     return this.loopQueues.get(columnId)?.length ?? 0;
@@ -494,12 +523,17 @@ var PipelineOrchestrator = class {
    * Initialize the orchestrator: fetch board scope, identify pipeline columns,
    * and fetch column-level agent configs.
    */
-  async initialize() {
+  async initialize(columnFilter) {
     const boardScope = await this.deps.fetchBoardScope(this.boardId);
     this.cachedBoardScope = boardScope;
-    const pipelineCols = boardScope.columns.filter(
+    let pipelineCols = boardScope.columns.filter(
       (col) => (col.has_prompt || col.type === "evaluator") && col.type !== "done"
     );
+    if (columnFilter) {
+      pipelineCols = pipelineCols.filter(
+        (col) => col.id === columnFilter || col.name.toLowerCase() === columnFilter.toLowerCase()
+      );
+    }
     await Promise.all(
       pipelineCols.map(async (col) => {
         const colScope = await this.deps.fetchColumnScope(col.id);
@@ -1110,7 +1144,8 @@ var PipelineOrchestrator = class {
       ...startIteration !== void 0 && { startIteration },
       ...startGutterCount !== void 0 && { startGutterCount },
       ...startFingerprint !== void 0 && { startFingerprint },
-      ...config.stuckDetection && { stuckDetection: config.stuckDetection }
+      ...config.stuckDetection && { stuckDetection: config.stuckDetection },
+      ...this.deps.costTracker && { isBudgetExhausted: () => this.deps.costTracker.isExhausted() }
     };
     const toolRestrictions = resolveToolRestrictions(
       config.builtinTools,
@@ -1648,14 +1683,14 @@ ${findingsText}`)
       const colConfig = this.pipelineColumns.get(columnId);
       const terminalCleanup = async () => {
         this.advisorBudget.delete(ticketId);
-        if (colConfig?.checkpointEnabled && this.deps.setFieldValue) {
+        if (colConfig?.checkpointEnabled && this.deps.setFieldValue && result.reason !== "stopped") {
           await this.safeAction(
             ticketId,
             "clearCheckpoint",
-            () => this.deps.setFieldValue(ticketId, "loop_checkpoint", null)
+            () => this.deps.setFieldValue(ticketId, "loop_checkpoint", "")
           );
         }
-        const isTerminal = result.reason === "moved" || result.reason === "max_iterations" || result.reason === "error" || result.reason === "stalled" || result.reason === "stopped" || result.reason === "deleted";
+        const isTerminal = result.reason === "moved" || result.reason === "max_iterations" || result.reason === "error" || result.reason === "stalled" || result.reason === "stopped" || result.reason === "deleted" || result.reason === "budget";
         if (isTerminal && colConfig) {
           const colScope2 = this.columnScopes.get(columnId);
           const ticket2 = colScope2?.tickets.find((t) => t.id === ticketId);
@@ -1795,6 +1830,9 @@ ${findingsText}`)
         case "deleted":
           comment = `Pipeline agent stopped \u2014 ticket was deleted or archived during iteration ${result.iterations}.`;
           break;
+        case "budget":
+          comment = `Pipeline budget exhausted after ${result.iterations} iteration(s). Increase token budget in pipeline.gates.yaml settings.budget to continue.`;
+          break;
       }
       if (result.reason !== "deleted") {
         await this.deps.createComment(ticketId, comment).catch((err) => {
@@ -2685,56 +2723,6 @@ function killReaper(reaperPidPath) {
   }
 }
 
-// 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) {
@@ -2788,84 +2776,6 @@ var GateSnapshotStore = class {
   }
 };
 
-// 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;
@@ -3063,7 +2973,355 @@ var PipelineEventEmitter = class _PipelineEventEmitter {
   }
 };
 
+// src/providers/registry.ts
+var TIER_VALUES = ["fast", "default", "thorough"];
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  get(id) {
+    const provider = this.providers.get(id);
+    if (!provider) throw new Error(`Unknown provider: ${id}. Registered: ${[...this.providers.keys()].join(", ")}`);
+    return provider;
+  }
+  list() {
+    return [...this.providers.values()];
+  }
+  resolveForColumn(board, column) {
+    const id = column.provider ?? board.default_provider ?? "claude";
+    return this.get(id);
+  }
+  resolveForIntelligence(board) {
+    const id = board.intelligence_provider ?? board.default_provider ?? "claude";
+    return this.get(id);
+  }
+  async preflightAll(providerIds) {
+    const unique = [...new Set(providerIds)];
+    const results = await Promise.all(
+      unique.map(async (id) => {
+        const provider = this.get(id);
+        const result = await provider.preflight();
+        return { providerId: id, result };
+      })
+    );
+    return results;
+  }
+  resolveModel(provider, preference) {
+    if (TIER_VALUES.includes(preference)) {
+      const model = provider.capabilities().supportedModels.find((m) => m.tier === preference);
+      if (model) return model.id;
+    }
+    return preference;
+  }
+};
+
+// src/providers/codex-provider.ts
+import { spawn as spawn2, execFileSync } from "child_process";
+import { existsSync } from "fs";
+
+// src/providers/codex-jsonl-parser.ts
+var CodexJsonlParser = class {
+  buffer = "";
+  toolCallCount = 0;
+  inputTokens = 0;
+  outputTokens = 0;
+  lastOutput = "";
+  onEvent = () => {
+  };
+  onError = () => {
+  };
+  feed(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      this.parseLine(line.trim());
+    }
+  }
+  flush() {
+    const trimmed = this.buffer.trim();
+    this.buffer = "";
+    if (trimmed) this.parseLine(trimmed);
+  }
+  getToolCallCount() {
+    return this.toolCallCount;
+  }
+  getUsage() {
+    return { inputTokens: this.inputTokens, outputTokens: this.outputTokens };
+  }
+  getLastOutput() {
+    return this.lastOutput;
+  }
+  reset() {
+    this.buffer = "";
+    this.toolCallCount = 0;
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.lastOutput = "";
+  }
+  parseLine(line) {
+    if (!line) return;
+    try {
+      const raw = JSON.parse(line);
+      this.translateEvent(raw);
+    } catch {
+      this.onError(new Error(`Failed to parse Codex JSONL: ${line.slice(0, 100)}`));
+    }
+  }
+  translateEvent(raw) {
+    const eventType = raw.type;
+    const item = raw.item;
+    if (eventType === "item.started" && item) {
+      const itemType = item.type;
+      if (itemType === "command_execution") {
+        this.toolCallCount++;
+        this.onEvent({ type: "tool_call", tool: "shell", input: { command: item.command } });
+      } else if (itemType === "mcp_tool_call") {
+        this.toolCallCount++;
+        this.onEvent({
+          type: "tool_call",
+          tool: item.tool ?? "unknown",
+          input: item.arguments
+        });
+      }
+    } else if (eventType === "item.completed" && item) {
+      const itemType = item.type;
+      if (itemType === "agent_message") {
+        const text = item.text ?? "";
+        this.lastOutput = text;
+        this.onEvent({ type: "text", text });
+      } else if (itemType === "command_execution") {
+        this.onEvent({
+          type: "tool_result",
+          tool: "shell",
+          output: item.aggregated_output ?? ""
+        });
+      } else if (itemType === "mcp_tool_call") {
+        this.onEvent({
+          type: "tool_result",
+          tool: item.tool ?? "unknown",
+          output: item.result !== void 0 ? item.result : item.error
+        });
+      }
+    } else if (eventType === "turn.completed") {
+      const usage = raw.usage;
+      const inTok = usage?.input_tokens ?? 0;
+      const outTok = usage?.output_tokens ?? 0;
+      this.inputTokens += inTok;
+      this.outputTokens += outTok;
+      if (inTok || outTok) {
+        this.onEvent({ type: "usage", inputTokens: inTok, outputTokens: outTok });
+      }
+    } else if (eventType === "turn.failed") {
+      const err = raw.error;
+      const msg = err?.message ?? "turn failed";
+      this.lastOutput = msg;
+      this.onEvent({ type: "error", message: msg });
+    } else if (eventType === "error") {
+      const msg = raw.message ?? "unknown error";
+      this.lastOutput = msg;
+      this.onEvent({ type: "error", message: msg });
+    }
+  }
+};
+
+// src/providers/codex-provider.ts
+var CODEX_TIMEOUT_MS = 60 * 60 * 1e3;
+var CodexProvider = class {
+  id = "codex";
+  displayName = "Codex CLI";
+  capabilities() {
+    return {
+      supportsToolAllowlist: false,
+      supportsToolDenylist: false,
+      supportsBuiltinToolStripping: false,
+      supportsMaxTurns: false,
+      supportsMcpConfigInjection: false,
+      supportsMcpConfigOverride: true,
+      supportsWorktreeFlag: false,
+      supportsSandboxModes: true,
+      supportedModels: [
+        { id: "gpt-5.1-codex-mini", displayName: "Codex Mini", tier: "fast" },
+        { id: "gpt-5.3-codex", displayName: "GPT-5.3 Codex", tier: "default" },
+        { id: "gpt-5.4", displayName: "GPT-5.4", tier: "thorough" }
+      ],
+      streamFormat: "jsonl"
+    };
+  }
+  async invoke(request) {
+    const degraded = [];
+    const args = this.buildArgs(request, degraded);
+    const env = this.buildEnv();
+    const startTime = Date.now();
+    if (request.workingDirectory) {
+      if (!existsSync(request.workingDirectory)) {
+        try {
+          execFileSync("git", ["worktree", "add", "-b", request.workingDirectory, request.workingDirectory, "HEAD"], {
+            stdio: "pipe"
+          });
+        } catch {
+          try {
+            execFileSync("git", ["worktree", "add", request.workingDirectory, request.workingDirectory], {
+              stdio: "pipe"
+            });
+          } catch {
+            degraded.push("worktreeCreation");
+          }
+        }
+      } else {
+        try {
+          execFileSync("git", ["-C", request.workingDirectory, "rev-parse", "--git-dir"], {
+            stdio: "pipe"
+          });
+        } catch {
+          try {
+            execFileSync("rm", ["-rf", request.workingDirectory], { stdio: "pipe" });
+            execFileSync("git", ["worktree", "add", "-b", request.workingDirectory, request.workingDirectory, "HEAD"], {
+              stdio: "pipe"
+            });
+          } catch {
+            try {
+              execFileSync("git", ["worktree", "add", request.workingDirectory, request.workingDirectory], {
+                stdio: "pipe"
+              });
+            } catch {
+              degraded.push("worktreeCreation");
+            }
+          }
+        }
+      }
+    }
+    return new Promise((resolve) => {
+      const child = spawn2("codex", args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, ...env }
+      });
+      const parser = new CodexJsonlParser();
+      parser.onEvent = (event) => request.onStreamEvent?.(event);
+      parser.onError = (err) => process.stderr.write(`[codex-jsonl] ${err.message}
+`);
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => parser.feed(chunk.toString()));
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      if (request.abortSignal) {
+        request.abortSignal.addEventListener("abort", () => {
+          try {
+            child.kill("SIGTERM");
+          } catch {
+          }
+        }, { once: true });
+      }
+      let killTimer;
+      const timeoutHandle = setTimeout(() => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        killTimer = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+      }, CODEX_TIMEOUT_MS);
+      let resolved = false;
+      const finish = (code, errorMsg) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutHandle);
+        if (killTimer) clearTimeout(killTimer);
+        parser.flush();
+        const usage = parser.getUsage();
+        const result = {
+          exitCode: code ?? 1,
+          output: errorMsg ?? (parser.getLastOutput() || stderr),
+          toolCallCount: parser.getToolCallCount(),
+          usage,
+          durationMs: Date.now() - startTime
+        };
+        if (degraded.length > 0) result.degradedCapabilities = degraded;
+        resolve(result);
+      };
+      child.on("close", (code) => finish(code));
+      child.on("error", (err) => finish(1, err.message));
+    });
+  }
+  async preflight() {
+    try {
+      const which = await import("which");
+      const w = which;
+      const whichSync = w.sync ?? w.default?.sync ?? w.default;
+      whichSync("codex");
+      return { available: true, authenticated: true };
+    } catch {
+      return { available: false, authenticated: false, error: "codex binary not found on PATH" };
+    }
+  }
+  buildArgs(request, degraded) {
+    const args = [
+      "exec",
+      "--json",
+      "--dangerously-bypass-approvals-and-sandbox"
+    ];
+    if (request.model) args.push("-m", request.model);
+    if (request.workingDirectory) {
+      args.push("-C", request.workingDirectory);
+    }
+    if (request.mcpConfig && Object.keys(request.mcpConfig.servers).length > 0) {
+      for (const [name, server] of Object.entries(request.mcpConfig.servers)) {
+        args.push("-c", `mcp_servers.${name}.command=${JSON.stringify(server.command)}`);
+        args.push("-c", `mcp_servers.${name}.args=${JSON.stringify(server.args)}`);
+        if (Object.keys(server.env).length > 0) {
+          for (const [key, value] of Object.entries(server.env)) {
+            args.push("-c", `mcp_servers.${name}.env.${key}=${JSON.stringify(value)}`);
+          }
+        }
+      }
+    }
+    if (request.toolRestrictions) {
+      const tr = request.toolRestrictions;
+      const writingTools = ["Write", "Edit", "Bash", "NotebookEdit", "shell", "file_write", "file_edit"];
+      if (tr.tools === "") {
+        args.push("--sandbox", "read-only");
+        degraded.push("builtinToolStripping");
+      } else if (tr.disallowedTools?.some((t) => writingTools.includes(t))) {
+        args.push("--sandbox", "read-only");
+        degraded.push("toolDenylist");
+      }
+      if (tr.allowedTools?.length) {
+        degraded.push("toolAllowlist");
+      }
+      if (tr.disallowedTools?.length && !degraded.includes("toolDenylist")) {
+        degraded.push("toolDenylist");
+      }
+    }
+    if (request.maxTurns) {
+      degraded.push("maxTurns");
+    }
+    args.push(request.prompt);
+    return args;
+  }
+  buildEnv() {
+    const env = {};
+    env.CODEX_FEATURE_TOOL_CALL_MCP_ELICITATION = "false";
+    return env;
+  }
+};
+
 // src/commands/pipeline.ts
+function createProviderRegistry() {
+  const registry = new ProviderRegistry();
+  registry.register(new ClaudeProvider());
+  registry.register(new CodexProvider());
+  return registry;
+}
+function readMcpConfigAsProviderConfig(filePath) {
+  const raw = JSON.parse(readFileSync2(filePath, "utf-8"));
+  return { servers: raw.mcpServers };
+}
 function parseArgs(args) {
   const positional = [];
   let once = false;
@@ -3072,6 +3330,7 @@ function parseArgs(args) {
   let maxIterations = null;
   let maxBudget = null;
   let model = null;
+  let provider = null;
   let concurrency = null;
   let logRetention = 7;
   let yes = false;
@@ -3112,6 +3371,9 @@ function parseArgs(args) {
       case "--model":
         model = args[++i] ?? null;
         break;
+      case "--provider":
+        provider = args[++i] ?? null;
+        break;
       case "--concurrency": {
         const val = Number(args[++i]);
         if (isNaN(val) || val <= 0) {
@@ -3145,12 +3407,13 @@ Flags:
   --max-iterations <n>  Override max iterations per ticket
   --max-budget <usd>    Per-ticket budget cap (USD)
   --model <model>       Override model preference
+  --provider <id>       Override default provider (claude, codex)
   --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 };
+  return { boardId, once, dryRun, columnFilter, maxIterations, maxBudget, model, provider, concurrency, logRetention, yes };
 }
 function pidDir(boardId) {
   return join2(homedir(), ".kantban", "pipelines", boardId);
@@ -3172,21 +3435,6 @@ function removePidFile(boardId) {
 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");
@@ -3203,7 +3451,7 @@ function removeChildManifest(boardId) {
 }
 function cleanupOrphanedProcesses(boardId) {
   const pidPath = pidFilePath(boardId);
-  if (existsSync(pidPath)) {
+  if (existsSync2(pidPath)) {
     try {
       const stalePid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
       if (stalePid && stalePid !== process.pid) {
@@ -3232,7 +3480,7 @@ function cleanupOrphanedProcesses(boardId) {
   }
   const staleReaperPath = join2(pidDir(boardId), "reaper.pid");
   try {
-    if (existsSync(staleReaperPath)) {
+    if (existsSync2(staleReaperPath)) {
       const reaperPid = parseInt(readFileSync2(staleReaperPath, "utf-8").trim(), 10);
       if (reaperPid && !isNaN(reaperPid)) {
         try {
@@ -3247,133 +3495,6 @@ function cleanupOrphanedProcesses(boardId) {
   } 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 ===
@@ -3407,7 +3528,7 @@ async function runPipeline(client, args) {
     return;
   }
   const opts = parseArgs(args);
-  currentBoardId = opts.boardId;
+  const registry = createProviderRegistry();
   if (!opts.yes && !opts.dryRun) {
     printSafetyWarning();
     const confirmed = await waitForConfirmation();
@@ -3418,7 +3539,7 @@ async function runPipeline(client, args) {
   }
   const gateFilePath = join2(process.cwd(), "pipeline.gates.yaml");
   let gateConfig;
-  if (!existsSync(gateFilePath)) {
+  if (!existsSync2(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);
@@ -3447,6 +3568,11 @@ async function runPipeline(client, args) {
     }
   }
   const mcpConfigPath = generateMcpConfig(client.baseUrl, client.token, opts.boardId);
+  const boardProviderConfig = {
+    default_provider: opts.provider ?? void 0,
+    intelligence_provider: opts.provider ?? void 0
+  };
+  const intelligenceProvider = registry.resolveForIntelligence(boardProviderConfig);
   const logBaseDir = join2(homedir(), ".kantban", "pipelines");
   const logger = new PipelineLogger(logBaseDir, opts.boardId);
   logger.pruneOldLogs(opts.logRetention);
@@ -3475,6 +3601,14 @@ async function runPipeline(client, args) {
         { columnId }
       );
       const resolvedColumnName = colScopeForName.column.name;
+      const columnProviderOverride = colScopeForName.agent_config?.provider;
+      const columnProvider = registry.resolveForColumn(
+        boardProviderConfig,
+        columnProviderOverride ? { provider: columnProviderOverride } : {}
+      );
+      if (effectiveConfig.model) {
+        effectiveConfig.model = registry.resolveModel(columnProvider, effectiveConfig.model);
+      }
       const columnGates = resolveGatesForColumn(gateConfig, resolvedColumnName);
       const effectiveMcpConfigPath = columnGates.length > 0 ? generateGateProxyMcpConfig(
         client.baseUrl,
@@ -3485,12 +3619,13 @@ async function runPipeline(client, args) {
         resolvedColumnName,
         projectId
       ) : mcpConfigPath;
+      const columnMcpConfig = readMcpConfigAsProviderConfig(effectiveMcpConfigPath);
       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,
+        provider: columnProvider,
+        mcpConfig: columnMcpConfig,
         projectId,
         log: (msg) => {
           logger.orchestrator(`[${ticketId}] ${msg}`);
@@ -3570,25 +3705,25 @@ async function runPipeline(client, args) {
       if (deps.setFieldValue) {
         effectiveConfig.onCheckpoint = async (tid, checkpoint) => {
           try {
-            await deps.setFieldValue(tid, "loop_checkpoint", checkpoint);
-          } catch {
+            const serialized = JSON.stringify(checkpoint);
+            await deps.setFieldValue(tid, "loop_checkpoint", serialized);
+          } catch (err) {
+            console.error(`  [checkpoint] Failed to write for ${tid}: ${err instanceof Error ? err.message : String(err)}`);
           }
         };
       }
       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
+          const result = await intelligenceProvider.invoke({
+            prompt,
+            model: registry.resolveModel(intelligenceProvider, "fast"),
+            maxTurns: 1
           });
-          if (exitCode !== 0) {
-            throw new Error(`Stuck detection call failed (exit ${String(exitCode)})`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Stuck detection call failed (exit ${String(result.exitCode)})`);
           }
-          return parseStuckDetectionResponse(output);
+          return parseStuckDetectionResponse(result.output);
         };
       }
       effectiveConfig.onPostIterationGates = async (tid, iteration) => {
@@ -3663,21 +3798,24 @@ async function runPipeline(client, args) {
       };
       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
+      const lightModel = registry.resolveModel(intelligenceProvider, "fast");
+      const lightResult = await intelligenceProvider.invoke({
+        prompt,
+        model: lightModel,
+        maxTurns: 3
       });
-      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)}`);
+      costTracker?.record({
+        ticketId,
+        columnId,
+        model: lightModel,
+        tokensIn: lightResult.usage.inputTokens,
+        tokensOut: lightResult.usage.outputTokens,
+        type: "light"
+      });
+      if (lightResult.exitCode !== 0) {
+        throw new Error(`Light call exited with code ${lightResult.exitCode}: ${lightResult.output.slice(0, 200)}`);
       }
-      const response = parseLightResponse(output);
+      const response = parseLightResponse(lightResult.output);
       logger.orchestrator(`[${ticketId}] Light call result: ${response.action} \u2014 ${response.reason}`);
       return response;
     },
@@ -3685,18 +3823,24 @@ async function runPipeline(client, args) {
     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
+      const advisorModel = registry.resolveModel(intelligenceProvider, "fast");
+      const advisorResult = await intelligenceProvider.invoke({
+        prompt,
+        model: advisorModel,
+        maxTurns: 1
+      });
+      costTracker?.record({
+        ticketId: input.ticketId,
+        columnId: "",
+        model: advisorModel,
+        tokensIn: advisorResult.usage.inputTokens,
+        tokensOut: advisorResult.usage.outputTokens,
+        type: "advisor"
       });
-      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)}`);
+      if (advisorResult.exitCode !== 0) {
+        throw new Error(`Advisor call exited with code ${advisorResult.exitCode}: ${advisorResult.output.slice(0, 200)}`);
       }
-      const response = parseAdvisorResponse(output);
+      const response = parseAdvisorResponse(advisorResult.output);
       logger.orchestrator(`[${input.ticketId}] Advisor: ${response.action} \u2014 ${response.reason}`);
       return response;
     },
@@ -3707,11 +3851,13 @@ async function runPipeline(client, args) {
       });
     },
     getFieldValues: async (ticketId) => {
-      const ctx = await client.get(
-        `/projects/${projectId}/pipeline-context`,
-        { ticketId }
+      const data = await client.get(
+        `/projects/${projectId}/tickets/${ticketId}/field-values`
       );
-      return ctx.field_values;
+      return data.map((fv) => ({
+        field_name: fv.field_name,
+        value: fv.text_value ?? fv.json_value ?? fv.number_value
+      }));
     },
     // Ticket management for advisor actions (ESCALATE, SPLIT_TICKET)
     moveTicketToColumn: async (ticketId, columnId, handoff) => {
@@ -3749,23 +3895,29 @@ async function runPipeline(client, args) {
     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
+      const replannerModel = registry.resolveModel(intelligenceProvider, "fast");
+      const replannerResult = await intelligenceProvider.invoke({
+        prompt,
+        model: replannerModel,
+        maxTurns: 1
+      });
+      costTracker?.record({
+        ticketId: "replanner",
+        columnId: "pipeline",
+        model: replannerModel,
+        tokensIn: replannerResult.usage.inputTokens,
+        tokensOut: replannerResult.usage.outputTokens,
+        type: "replanner"
       });
-      costTracker?.record({ ticketId: "replanner", columnId: "pipeline", model: "haiku", tokensIn, tokensOut, type: "replanner" });
-      if (exitCode !== 0) throw new Error(`Replanner failed`);
-      return parseReplannerResponse(output);
+      if (replannerResult.exitCode !== 0) throw new Error(`Replanner failed`);
+      return parseReplannerResponse(replannerResult.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();
+    await orchestrator.initialize(opts.columnFilter);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(`Error: Failed to initialize pipeline: ${message}`);
@@ -3866,34 +4018,10 @@ Received ${signal}. Shutting down gracefully...`);
     for (const loop of activeRalphLoops) {
       loop.stop();
     }
-    killAllChildProcesses();
     const deadline = Date.now() + 5e3;
-    while (activeChildProcesses.size > 0 && Date.now() < deadline) {
+    while (activeRalphLoops.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));
@@ -4068,7 +4196,7 @@ async function waitForAllLoops(orchestrator, timeoutMs = 4 * 60 * 60 * 1e3) {
       return;
     }
     await new Promise((resolve) => setTimeout(resolve, 1e3));
-    if (activeRalphLoops.size === 0 && orchestrator.activeLoopCount === 0 && !orchestrator.hasActiveQueuedWork) {
+    if (activeRalphLoops.size === 0 && orchestrator.activeLoopCount === 0 && !orchestrator.hasActiveQueuedWork && !orchestrator.hasCompletingWork) {
       consecutiveIdle++;
     } else {
       consecutiveIdle = 0;
@@ -4122,4 +4250,4 @@ export {
   runPipeline,
   stopPipeline
 };
-//# sourceMappingURL=pipeline-UNO4PIW4.js.map
+//# sourceMappingURL=pipeline-6SDPVNFK.js.map