kantban-cli 0.1.15 → 0.1.17

package/dist/chunk-4RQDDZLM.js

@@ -0,0 +1,1162 @@
+import {
+  VALID_BRANCH_RE
+} from "./chunk-MN4H5NSU.js";
+
+// src/lib/stuck-detector.ts
+import { z } from "zod";
+
+// src/lib/parse-utils.ts
+function parseJsonFromLlmOutput(raw) {
+  try {
+    return JSON.parse(raw.trim());
+  } catch {
+  }
+  const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenceMatch?.[1]) {
+    const fenced = fenceMatch[1].trim();
+    try {
+      return JSON.parse(fenced);
+    } catch {
+    }
+  }
+  for (let i = 0; i < raw.length; i++) {
+    if (raw[i] !== "{") continue;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let j = i; j < raw.length; j++) {
+      const ch = raw[j];
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\" && inString) {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{") depth++;
+      if (ch === "}") depth--;
+      if (depth === 0) {
+        const candidate = raw.slice(i, j + 1);
+        try {
+          return JSON.parse(candidate);
+        } catch {
+          break;
+        }
+      }
+    }
+  }
+  throw new Error(`Invalid JSON in LLM output: ${raw.slice(0, 120)}`);
+}
+
+// src/lib/stuck-detector.ts
+function shouldCheckStuckDetection(config, iteration) {
+  if (!config.enabled) return false;
+  const firstCheck = config.firstCheck ?? 3;
+  const interval = config.interval ?? 2;
+  if (interval <= 0) return iteration === firstCheck;
+  if (iteration < firstCheck) return false;
+  if (iteration === firstCheck) return true;
+  return (iteration - firstCheck) % interval === 0;
+}
+function composeStuckDetectionPrompt(input) {
+  const commentLines = input.recentComments.length > 0 ? input.recentComments.map((c) => `  [${c.author}] ${c.body.slice(0, 200)}`).join("\n") : "  (no comments)";
+  return `You are a pipeline trajectory classifier. Analyze recent agent activity and classify the trajectory.
+
+Ticket: #${String(input.ticketNumber)} "${input.ticketTitle}"
+Column: ${input.columnName}
+Iteration: ${String(input.iteration)} of ${String(input.maxIterations)}
+
+Recent iteration comments:
+${commentLines}
+
+Classify as one of:
+- "progressing" \u2014 each iteration makes distinct forward progress (new code, new tests, new fields set)
+- "spinning" \u2014 agent is active but repeating similar actions without advancing (same error, same approach retried, output duplicated)
+- "blocked" \u2014 agent cannot make progress due to external dependency, missing information, or fundamental task issue
+
+Respond with ONLY a JSON object:
+{"status": "progressing|spinning|blocked", "confidence": 0.0-1.0, "evidence": "one sentence"}`;
+}
+var StuckDetectionResponseSchema = z.object({
+  status: z.enum(["progressing", "spinning", "blocked"]),
+  confidence: z.number().min(0).max(1),
+  evidence: z.string()
+});
+function parseStuckDetectionResponse(raw) {
+  let parsed;
+  try {
+    parsed = parseJsonFromLlmOutput(raw);
+  } catch (err) {
+    throw new Error(`StuckDetectionResponse: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (parsed && typeof parsed === "object" && "confidence" in parsed) {
+    const p = parsed;
+    if (typeof p.confidence === "number") {
+      p.confidence = Math.min(1, Math.max(0, p.confidence));
+    }
+  }
+  const result = StuckDetectionResponseSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(`StuckDetectionResponse: validation failed \u2014 ${result.error.message}`);
+  }
+  return result.data;
+}
+function classifyTrajectory(snapshots) {
+  if (snapshots.length === 0) {
+    return { status: "progressing", evidence: "no data", confidence: 0.5 };
+  }
+  const recent = snapshots.slice(-3);
+  const deltas = recent.map((s) => s.delta_from_previous);
+  const meaningful = deltas.filter((d) => d !== "first_check");
+  if (meaningful.length === 0) {
+    return { status: "progressing", evidence: "only initial checks", confidence: 0.5 };
+  }
+  if (meaningful.length < 2) {
+    return { status: "progressing", evidence: "insufficient data for trajectory", confidence: 0.3 };
+  }
+  if (meaningful.every((d) => d === "same")) {
+    return { status: "spinning", evidence: "identical gate results", confidence: 1 };
+  }
+  if (meaningful.every((d) => d === "regressed" || d === "same")) {
+    return { status: "regressing", evidence: "gate results degrading", confidence: 1 };
+  }
+  if (meaningful.some((d) => d === "improved")) {
+    const lastMeaningful = meaningful[meaningful.length - 1];
+    if (lastMeaningful === "improved") {
+      return { status: "progressing", evidence: "gate results improving", confidence: 1 };
+    }
+  }
+  if (meaningful.some((d) => d === "improved") && meaningful.some((d) => d === "regressed")) {
+    return { status: "spinning", evidence: "oscillating gate results", confidence: 1 };
+  }
+  if (meaningful.some((d) => d === "improved")) {
+    return { status: "spinning", evidence: "stale improvement \u2014 no recent progress", confidence: 0.8 };
+  }
+  return { status: "spinning", evidence: "no improvement detected", confidence: 1 };
+}
+
+// src/lib/prompt-composer.ts
+var PROMPT_BUDGETS = {
+  system_preamble: 800,
+  gate_results: 500,
+  column_prompt: Infinity,
+  // NEVER truncated
+  lookahead: 1e3,
+  run_memory: 1e3,
+  rejection: 500,
+  ticket_details: 1500,
+  comments: 2e3,
+  transition_rules: 500,
+  transition_history: 1e3,
+  dependency_requirements: 500,
+  linked_documents: 2e3,
+  metadata: 200
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateToTokens(text, maxTokens) {
+  if (maxTokens === Infinity) return text;
+  const maxChars = maxTokens * 4;
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + "\n[...truncated]";
+}
+function windowComments(comments, maxTokens) {
+  const pinned = comments.filter((c) => c.pinned);
+  const unpinned = comments.filter((c) => !c.pinned);
+  const recentFull = unpinned.slice(-3);
+  const older = unpinned.slice(0, -3);
+  const parts = [];
+  for (const c of pinned) {
+    parts.push(`[pinned] **${c.author}** (${c.created_at}):
+${c.body}
+`);
+  }
+  for (const c of recentFull) {
+    parts.push(`**${c.author}** (${c.created_at}):
+${c.body}
+`);
+  }
+  for (const c of older) {
+    const firstLine = c.body.split("\n")[0]?.slice(0, 100) ?? "";
+    parts.push(`- ${c.author}: ${firstLine}`);
+  }
+  const joined = parts.join("\n");
+  return truncateToTokens(joined, maxTokens);
+}
+function composePrompt(columnContext, ticketContext, meta) {
+  const parts = [];
+  if (!columnContext.prompt_document?.content) {
+    throw new Error(
+      `Column "${columnContext.column.name}" has no prompt document. Configure a prompt document for this column before running the pipeline.`
+    );
+  }
+  const hasUnresolvedBlockers = ticketContext.ticket_links.some(
+    (l) => l.direction === "inward" && l.link_type === "blocks" && !l.resolved
+  );
+  parts.push(`# Pipeline Agent Instructions
+
+You are a pipeline automation agent processing ticket #${String(ticketContext.ticket.ticket_number)}: "${ticketContext.ticket.title}".
+
+## Your Goal
+Advance this ticket through the pipeline. Your success criteria:
+1. Complete the work described in the ticket and column prompt below
+2. Move the ticket to the next column using \`${ticketContext.tool_prefix}move_ticket\`
+3. Or mark it complete using \`${ticketContext.tool_prefix}complete_task\`
+
+## Iteration ${meta.iteration} of ${meta.maxIterations}
+${meta.iteration >= meta.maxIterations - 1 ? "**FINAL ITERATIONS** \u2014 prioritize moving the ticket NOW or it will be marked stalled." : `You have ${meta.maxIterations - meta.iteration} iterations remaining. Make meaningful progress each iteration.`}
+${meta.gutterCount > 0 ? `
+## Progress Warning
+No meaningful progress detected for ${meta.gutterCount} consecutive iteration(s).
+${meta.gutterThreshold - meta.gutterCount} iteration(s) remain before this loop is terminated as stalled.
+
+You MUST change approach. What you've been doing is not working. Consider:
+- Breaking the problem into smaller steps
+- Setting a field value to record partial progress
+- Creating a comment explaining what's blocking you
+- Asking for help via a signal
+` : ""}
+## Available Tools (prefix: ${ticketContext.tool_prefix})
+- **${ticketContext.tool_prefix}check_transition** \u2014 ALWAYS call this before moving. Returns allowed/blocked with recovery steps.
+  Params: \`{ projectId, boardId, ticketId, targetColumnId }\`
+- **${ticketContext.tool_prefix}move_ticket** \u2014 Move ticket to a new column. Include handoff data for the next agent.
+  Params: \`{ projectId, ticketId, column_id, handoff: { branch?, commit_sha?, build_status?, notes? } }\`
+- **${ticketContext.tool_prefix}complete_task** \u2014 Move to a done column with handoff data.
+  Params: \`{ projectId, ticketId, handoff: { ... } }\`
+- **${ticketContext.tool_prefix}set_field_value** \u2014 Set a required field before moving (check transition rules).
+  Params: \`{ projectId, ticketId, fieldId, value }\`
+- **${ticketContext.tool_prefix}create_signal** \u2014 Leave knowledge for future agents at any scope.
+- **${ticketContext.tool_prefix}create_comment** \u2014 Add progress notes to the ticket.
+- **${ticketContext.tool_prefix}append_run_memory** \u2014 Share discoveries with future agents.
+  Params: \`{ section: 'conventions'|'interfaces'|'failures'|'decisions', content: string }\`
+
+## Knowledge Sharing
+Before moving the ticket to the next column, you MUST:
+1. **Write a signal** via \`${ticketContext.tool_prefix}create_signal\` summarizing the key outcome of your work:
+   - What you discovered, built, validated, or decided
+   - Scope it to the ticket (\`ticketId\`) so future agents on this ticket see it
+   - One concise signal is better than none \u2014 don't skip this step
+2. **Contribute to run memory** via \`${ticketContext.tool_prefix}append_run_memory\` if you discovered:
+   - Conventions or patterns others should follow (\`section: 'conventions'\`)
+   - Interfaces or APIs consumed or created (\`section: 'interfaces'\`)
+   - Failures or dead-ends to avoid (\`section: 'failures'\`)
+   - Design decisions and their rationale (\`section: 'decisions'\`)
+
+Signals and run memory are how you communicate with future agents. Without them, the next agent starts blind.
+
+## Iteration Summary
+If you made meaningful progress this iteration, create a comment using \`${ticketContext.tool_prefix}create_comment\` summarizing:
+- What you accomplished
+- What remains to be done
+- Any blockers or issues encountered
+
+## Critical Rules
+1. **Always call ${ticketContext.tool_prefix}check_transition before ${ticketContext.tool_prefix}move_ticket** \u2014 moves that violate workflow rules will fail.
+2. **If the ticket has UNRESOLVED blockers, do not attempt to move it.** Create a comment explaining you are waiting, then stop.
+3. **Include handoff data** when moving \u2014 the next agent needs context (branch name, build status, etc.).
+4. **If you cannot make progress**, create a comment explaining why and stop. Do not burn iterations.
+${hasUnresolvedBlockers ? "\n**WARNING: This ticket has UNRESOLVED blockers. Do NOT attempt to move it. Document your status and stop.**\n" : ""}
+---
+`);
+  const worktreeConfig = columnContext.agent_config?.worktree;
+  if (worktreeConfig?.enabled) {
+    const integrationBranch = worktreeConfig.integration_branch ?? "main";
+    if (!VALID_BRANCH_RE.test(integrationBranch)) {
+      parts.push(`## Git Worktree
+
+You are working in an isolated git worktree. Integration branch name is invalid \u2014 contact the pipeline operator.`);
+    } else {
+      parts.push(`## Git Worktree
+
+You are working in an isolated git worktree. Before starting any code changes:
+1. Merge \`${integrationBranch}\` into your current branch: \`git merge '${integrationBranch}'\`
+2. Resolve any merge conflicts before proceeding with ticket work
+3. Never rebase \u2014 always merge (rebase destroys traceability across the pipeline)
+
+After completing your work, commit all changes to your worktree branch.
+`);
+    }
+  }
+  if (ticketContext.signals.length > 0) {
+    parts.push(`
+## Signals (Guardrails)
+`);
+    for (const s of ticketContext.signals) {
+      parts.push(`- ${s}`);
+    }
+  }
+  if (meta.gateResults && meta.gateResults.length > 0) {
+    parts.push(`
+## Previous Gate Results
+`);
+    for (const r of meta.gateResults) {
+      const status = r.passed ? "PASS" : "FAIL";
+      const req = r.required ? "(required)" : "(advisory)";
+      parts.push(`- **${r.name}** ${status} ${req} [${String(r.duration_ms)}ms]`);
+      if (!r.passed && r.output) {
+        parts.push(`  \`\`\`
+  ${truncateToTokens(r.output, 200)}
+  \`\`\``);
+      }
+    }
+  }
+  if (meta.rejectionFindings) {
+    parts.push(`
+## Previous Rejection (fix these before resubmitting)
+`);
+    parts.push(truncateToTokens(meta.rejectionFindings, PROMPT_BUDGETS.rejection));
+  } else {
+    const rejectionComment = ticketContext.comments.slice().reverse().find((c) => c.body.startsWith("QA REJECTION:") || c.body.startsWith("REJECTION:"));
+    if (rejectionComment) {
+      parts.push(`
+## Previous Rejection (fix these before resubmitting)
+`);
+      parts.push(truncateToTokens(rejectionComment.body, PROMPT_BUDGETS.rejection));
+    }
+  }
+  if (columnContext.prompt_document?.content) {
+    parts.push(columnContext.prompt_document.content);
+  }
+  if (meta.lookaheadDocument?.content) {
+    parts.push(`
+## Downstream Criteria (build to pass these)
+`);
+    parts.push(`*From: ${meta.lookaheadDocument.title}*
+`);
+    parts.push(truncateToTokens(meta.lookaheadDocument.content, PROMPT_BUDGETS.lookahead));
+  }
+  if (meta.runMemoryContent) {
+    parts.push(`
+## Run Memory
+`);
+    parts.push(truncateToTokens(meta.runMemoryContent, PROMPT_BUDGETS.run_memory));
+  }
+  const ticketParts = [];
+  ticketParts.push(`## Current Ticket
+`);
+  ticketParts.push(`**Title:** ${ticketContext.ticket.title}`);
+  ticketParts.push(`**Ticket ID:** ${ticketContext.ticket.id}`);
+  ticketParts.push(`**Ticket Number:** ${String(ticketContext.ticket.ticket_number)}`);
+  if (ticketContext.ticket.description) {
+    ticketParts.push(`
+${ticketContext.ticket.description}`);
+  }
+  if (ticketContext.ticket.assignee) {
+    ticketParts.push(`**Assignee:** ${ticketContext.ticket.assignee.name}`);
+  }
+  if (ticketContext.ticket.column) {
+    ticketParts.push(`**Current Column:** ${ticketContext.ticket.column.name} (${ticketContext.ticket.column.type})`);
+  }
+  if (ticketContext.ticket.backward_transitions > 0) {
+    ticketParts.push(`**Backward Transitions:** ${String(ticketContext.ticket.backward_transitions)}`);
+  }
+  if (ticketContext.field_values.length > 0) {
+    ticketParts.push(`
+## Field Values
+`);
+    for (const fv of ticketContext.field_values) {
+      ticketParts.push(`- **${fv.field_name}:** ${fv.value !== null ? JSON.stringify(fv.value) : "(not set)"}`);
+    }
+  }
+  if (ticketContext.parent) {
+    ticketParts.push(`
+## Parent Ticket
+`);
+    ticketParts.push(`- #${String(ticketContext.parent.ticket_number)}: ${ticketContext.parent.title}`);
+  }
+  if (ticketContext.children.length > 0) {
+    ticketParts.push(`
+## Child Tickets
+`);
+    for (const child of ticketContext.children) {
+      ticketParts.push(`- #${String(child.ticket_number)}: ${child.title}${child.column_name ? ` (${child.column_name})` : ""}`);
+    }
+  }
+  if (ticketContext.transitions.length > 0) {
+    ticketParts.push(`
+## Transition History
+`);
+    let transitionTokens = 0;
+    for (const t of ticketContext.transitions) {
+      let line = `- ${t.from ?? "Backlog"} \u2192 ${t.to}`;
+      if (t.handoff) line += ` (handoff: ${JSON.stringify(t.handoff)})`;
+      const lineTokens = estimateTokens(line);
+      if (transitionTokens + lineTokens > PROMPT_BUDGETS.transition_history) {
+        ticketParts.push(`- [...truncated \u2014 ${String(ticketContext.transitions.length)} total transitions]`);
+        break;
+      }
+      ticketParts.push(line);
+      transitionTokens += lineTokens;
+    }
+  }
+  if (ticketContext.ticket_links.length > 0) {
+    ticketParts.push(`
+## Ticket Links
+`);
+    const blockers = ticketContext.ticket_links.filter((l) => l.direction === "inward" && l.link_type === "blocks");
+    const blocking = ticketContext.ticket_links.filter((l) => l.direction === "outward" && l.link_type === "blocks");
+    const related = ticketContext.ticket_links.filter((l) => l.link_type === "relates_to");
+    if (blockers.length > 0) {
+      ticketParts.push(`**Blocked by:**`);
+      for (const l of blockers) {
+        const status = l.resolved ? "(resolved)" : "UNRESOLVED";
+        ticketParts.push(`- #${String(l.ticket_number)}: ${l.title} [${l.column_name ?? "backlog"}] ${status}`);
+      }
+    }
+    if (blocking.length > 0) {
+      ticketParts.push(`**Blocks:**`);
+      for (const l of blocking) {
+        ticketParts.push(`- #${String(l.ticket_number)}: ${l.title} [${l.column_name ?? "backlog"}]`);
+      }
+    }
+    if (related.length > 0) {
+      ticketParts.push(`**Related:**`);
+      for (const l of related) {
+        ticketParts.push(`- #${String(l.ticket_number)}: ${l.title}`);
+      }
+    }
+  }
+  parts.push(truncateToTokens(ticketParts.join("\n"), PROMPT_BUDGETS.ticket_details));
+  if (ticketContext.comments.length > 0) {
+    parts.push(`
+## Comments
+`);
+    parts.push(windowComments(ticketContext.comments, PROMPT_BUDGETS.comments));
+  }
+  if (ticketContext.transition_rules) {
+    parts.push(`
+## Transition Rules
+`);
+    parts.push(truncateToTokens(ticketContext.transition_rules, PROMPT_BUDGETS.transition_rules));
+  }
+  if (ticketContext.dependency_requirements && ticketContext.dependency_requirements !== "No dependency or field requirements configured.") {
+    parts.push(`
+## Dependency & Field Requirements
+`);
+    parts.push(truncateToTokens(ticketContext.dependency_requirements, PROMPT_BUDGETS.dependency_requirements));
+  }
+  if (ticketContext.linked_documents.length > 0) {
+    parts.push(`
+## Linked Documents
+`);
+    let remainingTokens = PROMPT_BUDGETS.linked_documents;
+    for (const doc of ticketContext.linked_documents) {
+      if (doc.content) {
+        const docHeader = `### ${doc.title}
+`;
+        const headerTokens = estimateTokens(docHeader);
+        const contentTokens = estimateTokens(doc.content);
+        if (headerTokens + contentTokens <= remainingTokens) {
+          parts.push(docHeader);
+          parts.push(doc.content);
+          remainingTokens -= headerTokens + contentTokens;
+        } else if (remainingTokens > headerTokens + 50) {
+          parts.push(docHeader);
+          parts.push(truncateToTokens(doc.content, remainingTokens - headerTokens));
+          remainingTokens = 0;
+        } else {
+          parts.push(`- ${doc.title} (truncated \u2014 token budget exceeded)`);
+          remainingTokens = 0;
+        }
+      } else if (doc.truncated) {
+        parts.push(`- ${doc.title} (document too large \u2014 read via kantban_get_document)`);
+      }
+      if (remainingTokens <= 0) break;
+    }
+  }
+  parts.push(`
+## Pipeline Metadata
+`);
+  parts.push(`- Iteration: ${meta.iteration} / ${meta.maxIterations}`);
+  parts.push(`- Project ID: ${meta.projectId}`);
+  parts.push(`- Tool Prefix: ${ticketContext.tool_prefix}`);
+  parts.push(`- Column: ${columnContext.column.name}`);
+  parts.push(`- Goal: ${columnContext.column.goal ?? "No goal set"}`);
+  return parts.join("\n");
+}
+
+// src/lib/ralph-loop.ts
+var API_TIMEOUT_MS = 3e4;
+function withTimeout(promise, ms, label) {
+  let timer;
+  return Promise.race([
+    promise.finally(() => clearTimeout(timer)),
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    })
+  ]);
+}
+var RalphLoop = class {
+  ticketId;
+  columnId;
+  config;
+  deps;
+  stopped = false;
+  currentIteration = 0;
+  constructor(ticketId, columnId, config, deps) {
+    this.ticketId = ticketId;
+    this.columnId = columnId;
+    this.config = config;
+    this.deps = deps;
+  }
+  stop() {
+    this.stopped = true;
+  }
+  get iteration() {
+    return this.currentIteration;
+  }
+  looksLike404(err) {
+    const statusCode = err?.statusCode ?? err?.status;
+    if (statusCode === 404) return true;
+    const message = err instanceof Error ? err.message : String(err);
+    return message.includes("API error 404");
+  }
+  async run() {
+    let gutterCount = this.config.startGutterCount ?? 0;
+    let lastFingerprint = this.config.startFingerprint ?? null;
+    const log = this.deps.log ?? (() => {
+    });
+    const resolvedModel = this.config.model ?? "default";
+    const gateSnapshots = [];
+    let cumulativeTokensIn = 0;
+    let cumulativeTokensOut = 0;
+    let cumulativeToolCalls = 0;
+    let cumulativeDurationMs = 0;
+    const withCosts = (r) => ({
+      ...r,
+      tokensIn: cumulativeTokensIn,
+      tokensOut: cumulativeTokensOut,
+      toolCallCount: cumulativeToolCalls,
+      durationMs: cumulativeDurationMs
+    });
+    let lastOutput = "";
+    const startIter = this.config.startIteration ?? 1;
+    for (let i = startIter; i <= this.config.maxIterations; i++) {
+      if (this.stopped) return withCosts({ reason: "stopped", iterations: i - 1, gutterCount, model: resolvedModel });
+      if (this.config.isBudgetExhausted?.()) {
+        log(`Budget exhausted \u2014 stopping after ${i - 1} iterations`);
+        return withCosts({ reason: "budget", iterations: i - 1, gutterCount, model: resolvedModel });
+      }
+      this.currentIteration = i;
+      log(`Iteration ${i}/${this.config.maxIterations} starting`);
+      if (!lastFingerprint) {
+        try {
+          lastFingerprint = await withTimeout(
+            this.deps.fetchFingerprint(this.ticketId),
+            API_TIMEOUT_MS,
+            "fetchFingerprint (baseline)"
+          );
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log(`Baseline fingerprint fetch failed: ${message}`);
+          if (this.looksLike404(err)) {
+            return withCosts({ reason: "deleted", iterations: i, gutterCount, model: resolvedModel });
+          }
+          return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `Baseline fingerprint failed: ${message}`, model: resolvedModel });
+        }
+      }
+      let ticketCtx;
+      let columnCtx;
+      try {
+        [ticketCtx, columnCtx] = await Promise.all([
+          withTimeout(this.deps.fetchTicketContext(this.ticketId), API_TIMEOUT_MS, "fetchTicketContext"),
+          withTimeout(this.deps.fetchColumnContext(this.columnId), API_TIMEOUT_MS, "fetchColumnContext")
+        ]);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log(`Context fetch failed: ${message}`);
+        if (this.looksLike404(err)) {
+          return withCosts({ reason: "deleted", iterations: i, gutterCount, model: resolvedModel });
+        }
+        return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `Context fetch failed: ${message}`, model: resolvedModel });
+      }
+      if (ticketCtx.ticket.column && ticketCtx.ticket.column.id !== this.columnId) {
+        log(`Ticket already in column ${ticketCtx.ticket.column.name}, not ${this.columnId} \u2014 exiting as moved`);
+        return withCosts({ reason: "moved", iterations: i - 1, gutterCount, model: resolvedModel });
+      }
+      const runMemoryContent = this.deps.fetchRunMemoryContent ? await this.deps.fetchRunMemoryContent().catch(() => "") : void 0;
+      const lookaheadDocument = this.deps.fetchLookaheadDocument ? await this.deps.fetchLookaheadDocument().catch(() => void 0) : void 0;
+      let prompt;
+      try {
+        prompt = composePrompt(columnCtx, ticketCtx, {
+          iteration: i,
+          maxIterations: this.config.maxIterations,
+          projectId: this.deps.projectId,
+          gutterCount,
+          gutterThreshold: this.config.gutterThreshold,
+          runMemoryContent: runMemoryContent || void 0,
+          lookaheadDocument
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log(`Prompt composition failed: ${message}`);
+        return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `Prompt composition failed: ${message}`, model: resolvedModel });
+      }
+      if (this.stopped) return withCosts({ reason: "stopped", iterations: i - 1, gutterCount, model: resolvedModel });
+      log(`Invoking ${this.deps.provider.displayName} (model=${this.config.model ?? "default"})`);
+      const iterationRunId = `${this.config.runId ?? this.ticketId}-iter-${String(i)}`;
+      this.deps.onSessionStart?.({
+        runId: iterationRunId,
+        model: this.config.model ?? "default",
+        iteration: i
+      });
+      const streamContext = { runId: iterationRunId, ticketId: this.ticketId, columnId: this.columnId };
+      const agentRequest = {
+        prompt,
+        ...this.config.model != null && { model: this.config.model },
+        ...this.config.maxBudgetUsd != null && { maxTurns: Math.max(1, Math.ceil(this.config.maxBudgetUsd * 10)) },
+        ...this.config.worktreeName != null && { workingDirectory: this.config.worktreeName },
+        ...this.deps.mcpConfig != null && { mcpConfig: this.deps.mcpConfig },
+        ...this.config.toolRestrictions != null && {
+          toolRestrictions: { ...this.config.toolRestrictions, includeMcpConfig: this.config.toolRestrictions.includeMcpConfig ?? true }
+        },
+        onStreamEvent: (event) => this.deps.onStreamEvent?.(event, streamContext)
+      };
+      const { exitCode, output, toolCallCount, usage, durationMs: iterationDurationMs, degradedCapabilities } = await this.deps.provider.invoke(agentRequest);
+      const tokensIn = usage.inputTokens;
+      const tokensOut = usage.outputTokens;
+      if (i === startIter && degradedCapabilities?.length) {
+        log(`Provider ${this.deps.provider.id} degraded: ${degradedCapabilities.join(", ")}`);
+      }
+      cumulativeTokensIn += tokensIn;
+      cumulativeTokensOut += tokensOut;
+      cumulativeToolCalls += toolCallCount;
+      cumulativeDurationMs += iterationDurationMs;
+      this.deps.onSessionEnd?.({
+        runId: iterationRunId,
+        exitCode,
+        tokensIn,
+        tokensOut,
+        toolCallCount,
+        durationMs: iterationDurationMs
+      });
+      if (exitCode !== 0) {
+        const snippet = output.slice(-200);
+        log(`${this.deps.provider.displayName} exited with code ${exitCode}: ${snippet}`);
+        return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `non-zero exit code: ${exitCode}. Last output: ${snippet}`, model: resolvedModel });
+      }
+      log(`${this.deps.provider.displayName} exited successfully`);
+      lastOutput = output;
+      let afterFp;
+      try {
+        const retryDelayMs = this.config.postMoveRetryDelayMs ?? 1500;
+        afterFp = await withTimeout(
+          this.deps.fetchFingerprint(this.ticketId),
+          API_TIMEOUT_MS,
+          "fetchFingerprint (post-iteration)"
+        );
+        if (afterFp.column_id === this.columnId) {
+          for (let retry = 0; retry < 2; retry++) {
+            await new Promise((r) => setTimeout(r, retryDelayMs));
+            if (this.stopped) break;
+            try {
+              afterFp = await withTimeout(
+                this.deps.fetchFingerprint(this.ticketId),
+                API_TIMEOUT_MS,
+                "fetchFingerprint (retry)"
+              );
+            } catch (err) {
+              log(`Fingerprint retry ${retry + 1} failed: ${err instanceof Error ? err.message : String(err)} \u2014 using last good value`);
+              break;
+            }
+            if (afterFp.column_id !== this.columnId) break;
+          }
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log(`Post-iteration fingerprint failed: ${message}`);
+        if (this.looksLike404(err)) {
+          return withCosts({ reason: "deleted", iterations: i, gutterCount, model: resolvedModel });
+        }
+        return withCosts({ reason: "error", iterations: i, gutterCount, lastError: `Post-iteration fingerprint failed: ${message}`, model: resolvedModel });
+      }
+      if (afterFp.column_id !== this.columnId) {
+        log(`Ticket moved to column ${afterFp.column_id ?? "null"}`);
+        return withCosts({ reason: "moved", iterations: i, gutterCount, model: resolvedModel, output: lastOutput });
+      }
+      const gutterBeforeGates = gutterCount;
+      if (this.config.onPostIterationGates) {
+        try {
+          const snapshot = await this.config.onPostIterationGates(this.ticketId, i);
+          gateSnapshots.push(snapshot);
+          const fieldDelta = lastFingerprint ? afterFp.field_value_count !== lastFingerprint.field_value_count : false;
+          switch (snapshot.delta_from_previous) {
+            case "improved":
+              if (gutterCount > 0) log(`Gate improvement detected \u2014 gutter counter reset`);
+              gutterCount = 0;
+              break;
+            case "same":
+              if (!fieldDelta) {
+                gutterCount++;
+                log(`No gate progress (gutter ${gutterCount}/${this.config.gutterThreshold})`);
+              } else {
+                log(`Gates unchanged but fields changed \u2014 not incrementing gutter`);
+              }
+              break;
+            case "regressed":
+              gutterCount += 2;
+              log(`Gate regression detected (gutter ${gutterCount}/${this.config.gutterThreshold})`);
+              break;
+            case "first_check":
+              break;
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log(`Post-iteration gate check failed (non-blocking): ${message}`);
+          if (lastFingerprint && fingerprintsMatch(lastFingerprint, afterFp)) {
+            gutterCount++;
+            log(`No progress detected via fingerprint fallback (gutter ${gutterCount}/${this.config.gutterThreshold})`);
+          } else {
+            if (gutterCount > 0) log(`Progress detected \u2014 gutter counter reset`);
+            gutterCount = 0;
+          }
+        }
+      } else {
+        if (lastFingerprint && fingerprintsMatch(lastFingerprint, afterFp)) {
+          gutterCount++;
+          log(`No progress detected (gutter ${gutterCount}/${this.config.gutterThreshold})`);
+        } else {
+          if (gutterCount > 0) log(`Progress detected \u2014 gutter counter reset`);
+          gutterCount = 0;
+        }
+      }
+      lastFingerprint = afterFp;
+      if (this.config.stuckDetection && shouldCheckStuckDetection(this.config.stuckDetection, i)) {
+        try {
+          let sdStatus;
+          let sdEvidence;
+          let sdConfidence;
+          if (gateSnapshots.length > 0) {
+            const trajectory = classifyTrajectory(gateSnapshots);
+            sdStatus = trajectory.status === "regressing" ? "spinning" : trajectory.status;
+            sdEvidence = trajectory.evidence;
+            sdConfidence = trajectory.confidence;
+            log(`Gate-based stuck detection: ${sdStatus} (confidence=${String(sdConfidence)}) \u2014 ${sdEvidence}`);
+          } else if (this.config.invokeStuckDetection) {
+            const sdInput = {
+              ticketNumber: ticketCtx.ticket.ticket_number,
+              ticketTitle: ticketCtx.ticket.title,
+              columnName: columnCtx.column.name,
+              iteration: i,
+              maxIterations: this.config.maxIterations,
+              recentComments: ticketCtx.comments.slice(-3).map((c) => ({
+                author: c.author,
+                body: c.body
+              }))
+            };
+            const sdResult = await this.config.invokeStuckDetection(sdInput);
+            sdStatus = sdResult.status;
+            sdEvidence = sdResult.evidence;
+            sdConfidence = sdResult.confidence;
+            log(`Stuck detection: ${sdStatus} (confidence=${String(sdConfidence)}) \u2014 ${sdEvidence}`);
+          } else {
+            sdStatus = "progressing";
+            sdEvidence = "no detection method";
+            sdConfidence = 0;
+          }
+          switch (sdStatus) {
+            case "progressing":
+              if (gutterCount > 0) {
+                log(`Stuck detection override: resetting gutter counter (was ${String(gutterCount)})`);
+                gutterCount = 0;
+              }
+              break;
+            case "spinning":
+              gutterCount = gutterBeforeGates + 2;
+              log(`Stuck detection: spinning \u2014 gutter set to ${String(gutterCount)}/${String(this.config.gutterThreshold)}`);
+              break;
+            case "blocked":
+              log(`Stuck detection: blocked \u2014 exiting immediately`);
+              return withCosts({
+                reason: "stalled",
+                iterations: i,
+                gutterCount: this.config.gutterThreshold,
+                model: resolvedModel,
+                output: lastOutput,
+                ...gateSnapshots.length > 0 && { finalGateSnapshot: gateSnapshots[gateSnapshots.length - 1] }
+              });
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log(`Stuck detection failed (non-blocking): ${message}`);
+        }
+      }
+      if (gutterCount >= this.config.gutterThreshold) {
+        return withCosts({
+          reason: "stalled",
+          iterations: i,
+          gutterCount,
+          model: resolvedModel,
+          output: lastOutput,
+          ...gateSnapshots.length > 0 && { finalGateSnapshot: gateSnapshots[gateSnapshots.length - 1] }
+        });
+      }
+      if (this.config.onCheckpoint) {
+        try {
+          await this.config.onCheckpoint(this.ticketId, {
+            run_id: this.config.runId ?? "00000000-0000-0000-0000-000000000000",
+            column_id: this.columnId,
+            iteration: i,
+            gutter_count: gutterCount,
+            advisor_invocations: 0,
+            // tracked by orchestrator, not loop
+            model_tier: resolvedModel,
+            last_fingerprint: afterFp,
+            updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+            worktree_name: this.config.worktreeName
+          });
+        } catch (err) {
+          log(`Checkpoint write failed (non-blocking): ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    return withCosts({
+      reason: "max_iterations",
+      iterations: this.config.maxIterations,
+      gutterCount,
+      model: resolvedModel,
+      output: lastOutput,
+      ...gateSnapshots.length > 0 && { finalGateSnapshot: gateSnapshots[gateSnapshots.length - 1] }
+    });
+  }
+};
+function fingerprintsMatch(a, b) {
+  return a.column_id === b.column_id && a.field_value_count === b.field_value_count && a.comment_count === b.comment_count;
+}
+
+// src/lib/mcp-config.ts
+import { writeFileSync, unlinkSync, mkdirSync, existsSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function generateMcpConfig(apiUrl, apiToken, boardId) {
+  const localMcpPath = existsSync(join(__dirname, "..", "..", "mcp", "dist", "index.js")) ? join(__dirname, "..", "..", "mcp", "dist", "index.js") : join(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
+  const useLocal = existsSync(localMcpPath);
+  const kantbanServer = useLocal ? {
+    command: "node",
+    args: [localMcpPath],
+    env: {
+      KANTBAN_API_TOKEN: apiToken,
+      KANTBAN_API_URL: apiUrl
+    }
+  } : {
+    command: "npx",
+    args: ["-y", "kantban-mcp@latest"],
+    env: {
+      KANTBAN_API_TOKEN: apiToken,
+      KANTBAN_API_URL: apiUrl
+    }
+  };
+  const config = {
+    mcpServers: {
+      kantban: kantbanServer
+    }
+  };
+  const dir = join(homedir(), ".kantban", "pipelines", boardId);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const filePath = join(dir, "mcp-config.json");
+  writeFileSync(filePath, JSON.stringify(config, null, 2), { mode: 384 });
+  return filePath;
+}
+function cleanupMcpConfig(filePath) {
+  try {
+    if (existsSync(filePath)) {
+      unlinkSync(filePath);
+    }
+  } catch {
+  }
+}
+function generateGateProxyMcpConfig(apiUrl, apiToken, boardId, gateConfigPath, columnId, columnName, projectId, gateCwd, ticketId) {
+  const localMcpPath = existsSync(join(__dirname, "..", "..", "mcp", "dist", "index.js")) ? join(__dirname, "..", "..", "mcp", "dist", "index.js") : join(__dirname, "..", "..", "..", "mcp", "dist", "index.js");
+  const useLocal = existsSync(localMcpPath);
+  const kantbanServer = useLocal ? { command: "node", args: [localMcpPath], env: { KANTBAN_API_TOKEN: apiToken, KANTBAN_API_URL: apiUrl, KANTBAN_HIDDEN_TOOLS: "kantban_move_ticket,kantban_move_tickets,kantban_complete_task,kantban_move_to_board" } } : { command: "npx", args: ["-y", "kantban-mcp@latest"], env: { KANTBAN_API_TOKEN: apiToken, KANTBAN_API_URL: apiUrl, KANTBAN_HIDDEN_TOOLS: "kantban_move_ticket,kantban_move_tickets,kantban_complete_task,kantban_move_to_board" } };
+  const gateProxyPath = existsSync(join(__dirname, "lib", "gate-proxy-server.js")) ? join(__dirname, "lib", "gate-proxy-server.js") : join(__dirname, "gate-proxy-server.js");
+  const gateProxyEnv = {
+    GATE_CONFIG_PATH: gateConfigPath,
+    COLUMN_ID: columnId,
+    COLUMN_NAME: columnName,
+    PROJECT_ID: projectId,
+    KANTBAN_API_TOKEN: apiToken,
+    KANTBAN_API_URL: apiUrl
+  };
+  if (gateCwd) gateProxyEnv["GATE_CWD"] = gateCwd;
+  const gateProxyServer = {
+    command: "node",
+    args: [gateProxyPath],
+    env: gateProxyEnv
+  };
+  const config = {
+    mcpServers: {
+      kantban: kantbanServer,
+      "kantban-gates": gateProxyServer
+    }
+  };
+  const dir = join(homedir(), ".kantban", "pipelines", boardId);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const suffix = ticketId ? `${columnId}-${ticketId}` : columnId;
+  const filePath = join(dir, `mcp-config-${suffix}.json`);
+  writeFileSync(filePath, JSON.stringify(config, null, 2), { mode: 384 });
+  return filePath;
+}
+function cleanupGateProxyConfigs(pipelineDir) {
+  try {
+    const files = readdirSync(pipelineDir);
+    for (const f of files) {
+      if (f.startsWith("mcp-config-") && f.endsWith(".json")) {
+        try {
+          unlinkSync(join(pipelineDir, f));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+
+// src/providers/claude-provider.ts
+import { spawn } from "child_process";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/providers/claude-stream-parser.ts
+var ClaudeStreamParser = 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 stream-json line: ${line.slice(0, 100)}`));
+    }
+  }
+  translateEvent(raw) {
+    const message = raw.message;
+    const content = message?.content ?? raw.content;
+    if (raw.type === "assistant" && Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "text" && typeof block.text === "string") {
+          this.onEvent({ type: "text", text: block.text });
+        } else if (block.type === "tool_use") {
+          this.toolCallCount++;
+          this.onEvent({
+            type: "tool_call",
+            tool: block.name ?? "unknown",
+            input: block.input
+          });
+        } else if (block.type === "tool_result") {
+          this.onEvent({
+            type: "tool_result",
+            tool: block.name ?? "unknown",
+            output: block.content ?? block.output
+          });
+        }
+      }
+    } else if (raw.type === "result") {
+      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 });
+      }
+      if (typeof raw.result === "string") {
+        this.lastOutput = raw.result;
+        this.onEvent({ type: "done", result: raw.result });
+      }
+    }
+  }
+};
+
+// src/providers/claude-provider.ts
+var CLAUDE_TIMEOUT_MS = 60 * 60 * 1e3;
+var ClaudeProvider = class {
+  id = "claude";
+  displayName = "Claude Code";
+  capabilities() {
+    return {
+      supportsToolAllowlist: true,
+      supportsToolDenylist: true,
+      supportsBuiltinToolStripping: true,
+      supportsMaxTurns: true,
+      supportsMcpConfigInjection: true,
+      supportsMcpConfigOverride: false,
+      supportsWorktreeFlag: true,
+      supportsSandboxModes: false,
+      supportedModels: [
+        { id: "claude-haiku-4-5-20251001", displayName: "Haiku 4.5", tier: "fast" },
+        { id: "claude-sonnet-4-6", displayName: "Sonnet 4.6", tier: "default" },
+        { id: "claude-opus-4-6", displayName: "Opus 4.6", tier: "thorough" }
+      ],
+      streamFormat: "stream-json"
+    };
+  }
+  async invoke(request) {
+    const args = this.buildArgs(request);
+    const startTime = Date.now();
+    return new Promise((resolve) => {
+      const child = spawn("claude", args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        ...request.workingDirectory && { cwd: request.workingDirectory }
+      });
+      const parser = new ClaudeStreamParser();
+      parser.onEvent = (event) => request.onStreamEvent?.(event);
+      parser.onError = (err) => process.stderr.write(`[claude-stream] ${err.message}
+`);
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => parser.feed(chunk.toString()));
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.stdin?.end();
+      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);
+      }, CLAUDE_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();
+        resolve({
+          exitCode: code ?? 1,
+          output: errorMsg ?? (parser.getLastOutput() || stderr),
+          toolCallCount: parser.getToolCallCount(),
+          usage,
+          durationMs: Date.now() - startTime
+        });
+      };
+      child.on("close", (code) => finish(code));
+      child.on("error", (err) => finish(1, err.message));
+    });
+  }
+  async preflight() {
+    try {
+      const whichModule = await import("which");
+      const syncFn = whichModule.default?.sync ?? whichModule.sync;
+      syncFn("claude");
+      return { available: true, authenticated: true };
+    } catch {
+      return { available: false, authenticated: false, error: "claude binary not found on PATH" };
+    }
+  }
+  buildArgs(request) {
+    const args = [
+      "-p",
+      request.prompt,
+      "--dangerously-skip-permissions",
+      "--output-format",
+      "stream-json",
+      "--verbose"
+    ];
+    if (request.mcpConfig && request.toolRestrictions?.includeMcpConfig !== false) {
+      const configPath = this.writeMcpConfigJson(request.mcpConfig);
+      args.push("--mcp-config", configPath);
+    }
+    if (request.model) args.push("--model", request.model);
+    if (request.maxTurns) {
+      args.push("--max-turns", String(request.maxTurns));
+    }
+    if (request.workingDirectory) {
+      args.push("--worktree", request.workingDirectory);
+    }
+    if (request.toolRestrictions) {
+      const tr = request.toolRestrictions;
+      if (tr.tools !== void 0) args.push("--tools", tr.tools);
+      if (tr.allowedTools?.length) args.push("--allowedTools", ...tr.allowedTools);
+      if (tr.disallowedTools?.length) args.push("--disallowedTools", ...tr.disallowedTools);
+    }
+    return args;
+  }
+  writeMcpConfigJson(mcpConfig) {
+    if (!mcpConfig) return "";
+    const config = { mcpServers: mcpConfig.servers };
+    const dir = join2(homedir2(), ".kantban", "tmp");
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+    const filePath = join2(dir, `mcp-config-${Date.now()}.json`);
+    writeFileSync2(filePath, JSON.stringify(config, null, 2), { mode: 384 });
+    return filePath;
+  }
+};
+
+export {
+  parseJsonFromLlmOutput,
+  composeStuckDetectionPrompt,
+  parseStuckDetectionResponse,
+  classifyTrajectory,
+  RalphLoop,
+  generateMcpConfig,
+  cleanupMcpConfig,
+  generateGateProxyMcpConfig,
+  cleanupGateProxyConfigs,
+  ClaudeProvider
+};
+//# sourceMappingURL=chunk-4RQDDZLM.js.map