@tarcisiopgs/lisa 1.26.2 → 1.28.0

package/dist/chunk-UXVSQQID.js

@@ -0,0 +1,3924 @@
+#!/usr/bin/env node
+import {
+  GitHubIssuesSource,
+  GitLabIssuesSource,
+  REQUEST_TIMEOUT_MS,
+  createApiClient,
+  error,
+  getOutputMode,
+  kanbanEmitter,
+  log,
+  normalizeLabels,
+  ok,
+  warn
+} from "./chunk-5N4BWHIT.js";
+import {
+  appendEntry,
+  buildGuardrailsSection,
+  extractContext,
+  extractErrorType
+} from "./chunk-3EOEDL3T.js";
+import {
+  getManifestPath,
+  getPlanPath
+} from "./chunk-7OCDGYDM.js";
+import {
+  appendPrAttribution,
+  appendPrBody,
+  formatError,
+  stripProviderAttribution
+} from "./chunk-2TW2MJXF.js";
+
+// src/providers/aider.ts
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+
+// src/providers/output-buffer.ts
+import { appendFileSync } from "fs";
+var logWriteWarned = false;
+function safeAppendLog(logFile, text) {
+  try {
+    appendFileSync(logFile, text);
+  } catch (err) {
+    if (!logWriteWarned) {
+      logWriteWarned = true;
+      warn(`Failed to write to log file ${logFile}: ${formatError(err)}`);
+    }
+  }
+}
+function escapeShellPath(filePath) {
+  if (/[\x00-\x1f\x7f]/.test(filePath)) {
+    throw new Error(`Path contains control characters: ${filePath}`);
+  }
+  return filePath.replace(/'/g, "'\\''");
+}
+var OutputBuffer = class {
+  chunks = [];
+  totalLength = 0;
+  maxBytes;
+  constructor(maxBytes = 10 * 1024 * 1024) {
+    this.maxBytes = maxBytes;
+  }
+  push(text) {
+    this.chunks.push(text);
+    this.totalLength += text.length;
+    this.evict();
+  }
+  toString() {
+    if (this.chunks.length === 0) return "";
+    if (this.chunks.length === 1) return this.chunks[0];
+    const result = this.chunks.join("");
+    this.chunks = [result];
+    return result;
+  }
+  evict() {
+    if (this.totalLength <= this.maxBytes) return;
+    while (this.chunks.length > 1 && this.totalLength > this.maxBytes) {
+      const removed = this.chunks.shift();
+      if (!removed) break;
+      this.totalLength -= removed.length;
+    }
+    if (this.totalLength > this.maxBytes && this.chunks.length === 1) {
+      const chunk = this.chunks[0];
+      const trimmed = chunk.slice(chunk.length - this.maxBytes);
+      this.chunks[0] = trimmed;
+      this.totalLength = trimmed.length;
+    }
+  }
+};
+
+// src/providers/run-provider.ts
+import { execFile as execFile2, spawn as spawn2 } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify as promisify2 } from "util";
+
+// src/session/overseer.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/providers/timeout.ts
+var TIMEOUT_MESSAGE = "\n[lisa-timeout] Provider killed: exceeded session_timeout. Eligible for fallback.\n";
+var SIGKILL_GRACE_MS = 1e4;
+function killWithEscalation(proc) {
+  proc.kill("SIGTERM");
+  const escalation = setTimeout(() => {
+    try {
+      proc.kill("SIGKILL");
+    } catch {
+    }
+  }, SIGKILL_GRACE_MS);
+  if (escalation && typeof escalation === "object" && "unref" in escalation) {
+    escalation.unref();
+  }
+}
+function createSessionTimeout(proc, timeoutSeconds) {
+  if (!timeoutSeconds || timeoutSeconds <= 0) {
+    return { stop() {
+    }, wasTimedOut: () => false };
+  }
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    killWithEscalation(proc);
+  }, timeoutSeconds * 1e3);
+  return {
+    stop() {
+      clearTimeout(timer);
+    },
+    wasTimedOut() {
+      return timedOut;
+    }
+  };
+}
+
+// src/session/overseer.ts
+var execFileAsync = promisify(execFile);
+var STUCK_MESSAGE = "\n[lisa-overseer] Provider killed: no git changes detected within the stuck threshold. Eligible for fallback.\n";
+var STALL_MESSAGE = "\n[lisa-stall] Provider killed: no output received within the stall timeout. Eligible for fallback.\n";
+var DEFAULT_OUTPUT_STALL_TIMEOUT = 300;
+function createOutputStallDetector(proc, timeoutSeconds) {
+  const timeout = timeoutSeconds ?? DEFAULT_OUTPUT_STALL_TIMEOUT;
+  if (timeout <= 0) {
+    return { reset() {
+    }, wasKilled: () => false, stop() {
+    } };
+  }
+  let killed = false;
+  let timer = setTimeout(() => {
+    killed = true;
+    killWithEscalation(proc);
+  }, timeout * 1e3);
+  return {
+    reset() {
+      if (killed || !timer) return;
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        killed = true;
+        killWithEscalation(proc);
+      }, timeout * 1e3);
+    },
+    wasKilled() {
+      return killed;
+    },
+    stop() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+}
+function createErrorLoopDetector(proc, pattern, threshold = 25) {
+  let consecutive = 0;
+  let killed = false;
+  return {
+    check(text) {
+      if (killed) return;
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        if (pattern.test(trimmed)) {
+          if (++consecutive >= threshold) {
+            killed = true;
+            killWithEscalation(proc);
+            return;
+          }
+        } else {
+          consecutive = 0;
+        }
+      }
+    },
+    wasKilled() {
+      return killed;
+    }
+  };
+}
+async function getGitSnapshot(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["status", "--porcelain"], {
+      cwd,
+      timeout: 1e4
+    });
+    return stdout;
+  } catch {
+    return "";
+  }
+}
+function startOverseer(proc, cwd, config, getSnapshot = getGitSnapshot) {
+  if (!config.enabled) {
+    return {
+      stop() {
+      },
+      wasKilled() {
+        return false;
+      }
+    };
+  }
+  let killed = false;
+  let paused = false;
+  let lastSnapshot;
+  let lastChangeTime = Date.now();
+  let timer = null;
+  const onPauseProvider = () => {
+    paused = true;
+  };
+  const onResumeProvider = () => {
+    paused = false;
+    lastChangeTime = Date.now();
+  };
+  kanbanEmitter.on("loop:pause-provider", onPauseProvider);
+  kanbanEmitter.on("loop:resume-provider", onResumeProvider);
+  const check = async () => {
+    if (killed || paused) return;
+    try {
+      const snapshot = await getSnapshot(cwd);
+      if (lastSnapshot === void 0) {
+        lastSnapshot = snapshot;
+        lastChangeTime = Date.now();
+        return;
+      }
+      if (snapshot !== lastSnapshot) {
+        lastSnapshot = snapshot;
+        lastChangeTime = Date.now();
+        return;
+      }
+      const idleMs = Date.now() - lastChangeTime;
+      if (idleMs >= config.stuck_threshold * 1e3) {
+        killed = true;
+        if (timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+        killWithEscalation(proc);
+      }
+    } catch {
+    }
+  };
+  timer = setInterval(check, config.check_interval * 1e3);
+  if (timer && typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+  return {
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      kanbanEmitter.off("loop:pause-provider", onPauseProvider);
+      kanbanEmitter.off("loop:resume-provider", onResumeProvider);
+    },
+    wasKilled() {
+      return killed;
+    }
+  };
+}
+
+// src/providers/heap.ts
+function buildNodeOptions(heapMb = 8192) {
+  const existing = process.env.NODE_OPTIONS ?? "";
+  if (existing.includes("max-old-space-size")) {
+    return existing;
+  }
+  return `${existing} --max-old-space-size=${heapMb}`.trim();
+}
+
+// src/providers/pty.ts
+import { spawn } from "child_process";
+import { platform } from "os";
+var ANSI_REGEX = /\x1b(?:\[[0-9;?]*[a-zA-Z]|\][^\x07]*\x07|\([A-Z0-9]|[A-Z])/g;
+var CTRL_D_REGEX = /\x04/g;
+var CARET_D_BACKSPACE_REGEX = /\^D\x08\x08/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_REGEX, "").replace(CTRL_D_REGEX, "").replace(CARET_D_BACKSPACE_REGEX, "").replace(/\r\n/g, "\n").replace(/\r/g, "");
+}
+function buildPtyArgs(command, os) {
+  const currentOs = os ?? platform();
+  const wrappedCommand = `stty eof undef 2>/dev/null; ${command} < /dev/null`;
+  if (currentOs === "darwin") {
+    return { file: "script", args: ["-qF", "/dev/null", "sh", "-c", wrappedCommand] };
+  }
+  if (currentOs === "linux") {
+    return { file: "script", args: ["-qef", "-c", wrappedCommand, "/dev/null"] };
+  }
+  return null;
+}
+function spawnWithPty(command, options = {}) {
+  const ptyArgs = buildPtyArgs(command);
+  if (ptyArgs) {
+    const proc2 = spawn(ptyArgs.file, ptyArgs.args, {
+      ...options,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { proc: proc2, isPty: true };
+  }
+  const proc = spawn("sh", ["-c", command], {
+    ...options,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return { proc, isPty: false };
+}
+
+// src/providers/run-provider.ts
+var SAFE_SHELL_ARG = /^[a-zA-Z0-9._:/@-]+$/;
+function validateShellArg(value, label) {
+  if (!SAFE_SHELL_ARG.test(value)) {
+    throw new Error(
+      `Invalid ${label}: "${value}" contains unsafe characters. Only alphanumeric, dots, colons, slashes, hyphens, and underscores are allowed.`
+    );
+  }
+}
+var execFileAsync2 = promisify2(execFile2);
+var availabilityCache = /* @__PURE__ */ new Map();
+async function isCommandAvailable(command, args = ["--version"]) {
+  const key = `${command}:${args.join(",")}`;
+  const cached = availabilityCache.get(key);
+  if (cached !== void 0) return cached;
+  try {
+    await execFileAsync2(command, args, { stdio: "ignore" });
+    availabilityCache.set(key, true);
+    return true;
+  } catch {
+    availabilityCache.set(key, false);
+    return false;
+  }
+}
+async function runProviderProcess(config, prompt, opts) {
+  const start = Date.now();
+  const tmpDir = mkdtempSync(join(tmpdir(), "lisa-"));
+  const promptFile = join(tmpDir, "prompt.md");
+  writeFileSync(promptFile, prompt, { encoding: "utf-8", mode: 384 });
+  try {
+    const promptCatExpr = `"$(cat '${escapeShellPath(promptFile)}')"`;
+    const command = config.buildCommand(promptCatExpr);
+    log(`[${config.name}] Running: ${config.logLine}`.trim());
+    if (opts.issueId) {
+      kanbanEmitter.emit("issue:output", opts.issueId, config.kanbanLine);
+    }
+    const spawnEnv = {
+      ...process.env,
+      ...opts.env,
+      NODE_OPTIONS: buildNodeOptions(),
+      ...config.extraEnv
+    };
+    let proc;
+    let isPty;
+    if (config.forceRawSpawn) {
+      proc = spawn2("sh", ["-c", command], {
+        cwd: opts.cwd,
+        env: spawnEnv,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      isPty = false;
+    } else {
+      ({ proc, isPty } = spawnWithPty(command, { cwd: opts.cwd, env: spawnEnv }));
+    }
+    if (proc.pid) opts.onProcess?.(proc.pid);
+    const overseer = opts.overseer?.enabled ? startOverseer(proc, opts.cwd, opts.overseer) : null;
+    const sessionTimeout = createSessionTimeout(proc, opts.sessionTimeout);
+    const errorLoopDetector = createErrorLoopDetector(proc, config.errorPattern);
+    const outputStall = createOutputStallDetector(proc, opts.outputStallTimeout);
+    const chunks = new OutputBuffer();
+    const stderrChunks = new OutputBuffer();
+    proc.stdout?.on("data", (chunk) => {
+      const raw = chunk.toString();
+      const cleaned = isPty ? stripAnsi(raw) : raw;
+      const text = config.outputTransform ? config.outputTransform(cleaned) : cleaned;
+      if (!text) return;
+      errorLoopDetector.check(text);
+      outputStall.reset();
+      if (getOutputMode() !== "tui") process.stdout.write(text);
+      if (opts.issueId) {
+        kanbanEmitter.emit("issue:output", opts.issueId, text);
+      }
+      chunks.push(text);
+      safeAppendLog(opts.logFile, text);
+    });
+    proc.stderr?.on("data", (chunk) => {
+      const raw = chunk.toString();
+      const text = isPty ? stripAnsi(raw) : raw;
+      if (getOutputMode() !== "tui") process.stderr.write(raw);
+      stderrChunks.push(text);
+      safeAppendLog(opts.logFile, text);
+    });
+    const exitCode = await new Promise((resolve2) => {
+      proc.on("close", (code) => {
+        overseer?.stop();
+        sessionTimeout.stop();
+        outputStall.stop();
+        resolve2(code ?? 1);
+      });
+    });
+    if (sessionTimeout.wasTimedOut()) {
+      chunks.push(TIMEOUT_MESSAGE);
+    } else if (outputStall.wasKilled()) {
+      chunks.push(STALL_MESSAGE);
+    } else if (overseer?.wasKilled() || errorLoopDetector.wasKilled()) {
+      chunks.push(STUCK_MESSAGE);
+    }
+    const success = exitCode === 0 && !overseer?.wasKilled() && !errorLoopDetector.wasKilled() && !outputStall.wasKilled() && !sessionTimeout.wasTimedOut();
+    const stderrOutput = stderrChunks.toString();
+    if (!success && stderrOutput) {
+      chunks.push(`
+[stderr]
+${stderrOutput}`);
+    }
+    return {
+      success,
+      output: chunks.toString(),
+      duration: Date.now() - start,
+      exitCode
+    };
+  } catch (err) {
+    return {
+      success: false,
+      output: formatError(err),
+      duration: Date.now() - start
+    };
+  } finally {
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// src/providers/aider.ts
+var AIDER_API_KEY_ENV_VARS = [
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "GEMINI_API_KEY",
+  "GROQ_API_KEY",
+  "OPENROUTER_API_KEY",
+  "COHERE_API_KEY",
+  "MISTRAL_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "AZURE_API_KEY",
+  "XAI_API_KEY"
+];
+var AiderProvider = class {
+  name = "aider";
+  async isAvailable() {
+    return isCommandAvailable("aider");
+  }
+  async run(prompt, opts) {
+    const hasApiKey = AIDER_API_KEY_ENV_VARS.some((v) => process.env[v]);
+    if (!hasApiKey) {
+      return {
+        success: false,
+        output: `Aider requires a direct LLM API key. Set one of: ${AIDER_API_KEY_ENV_VARS.join(", ")}`,
+        duration: 0
+      };
+    }
+    try {
+      if (opts.model) validateShellArg(opts.model, "model");
+      const modelFlag = opts.model ? `--model ${opts.model}` : "";
+      const aiderTmpDir = mkdtempSync2(join2(tmpdir2(), "lisa-aider-"));
+      const aiderPromptFile = join2(aiderTmpDir, "prompt.md");
+      writeFileSync2(aiderPromptFile, prompt, { encoding: "utf-8", mode: 384 });
+      const config = {
+        name: "aider",
+        buildCommand: () => `aider --message-file '${escapeShellPath(aiderPromptFile)}' --yes-always ${modelFlag}`,
+        logLine: `aider --message-file --yes-always ${modelFlag || "(default model)"}`,
+        kanbanLine: `$ aider --message-file --yes-always ${modelFlag || "(default model)"} <prompt: ${prompt.length} chars>
+`,
+        errorPattern: /^Error /
+      };
+      try {
+        return await runProviderProcess(config, prompt, opts);
+      } finally {
+        try {
+          rmSync2(aiderTmpDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    } catch (err) {
+      return { success: false, output: formatError(err), duration: 0 };
+    }
+  }
+};
+
+// src/providers/claude.ts
+var ClaudeProvider = class {
+  name = "claude";
+  supportsNativeWorktree = false;
+  // --worktree flag requires a TTY and hangs in non-interactive mode
+  async isAvailable() {
+    return isCommandAvailable("claude");
+  }
+  async run(prompt, opts) {
+    try {
+      const flags = ["-p", "--dangerously-skip-permissions"];
+      if (opts.model) {
+        validateShellArg(opts.model, "model");
+        flags.push("--model", opts.model);
+      }
+      if (opts.providerOptions?.effort) {
+        validateShellArg(opts.providerOptions.effort, "effort");
+        flags.push("--effort", opts.providerOptions.effort);
+      }
+      const flagStr = flags.join(" ");
+      const config = {
+        name: "claude",
+        buildCommand: (promptCatExpr) => `claude ${flagStr} ${promptCatExpr}`,
+        logLine: `claude ${flagStr}`,
+        kanbanLine: `$ claude ${flagStr} <prompt: ${prompt.length} chars>
+`,
+        errorPattern: /^Error /,
+        extraEnv: { CLAUDECODE: void 0 },
+        // When Lisa itself runs inside an active Claude Code session (CLAUDECODE is set in the
+        // parent environment), the script PTY wrapper reads EOF from its closed stdin and
+        // forwards ^D to Claude, causing it to exit. Use a plain spawn without PTY instead.
+        forceRawSpawn: Boolean(process.env.CLAUDECODE)
+      };
+      return await runProviderProcess(config, prompt, opts);
+    } catch (err) {
+      return { success: false, output: formatError(err), duration: 0 };
+    }
+  }
+};
+
+// src/providers/codex.ts
+var CodexProvider = class {
+  name = "codex";
+  async isAvailable() {
+    return isCommandAvailable("codex");
+  }
+  async run(prompt, opts) {
+    try {
+      if (opts.model) validateShellArg(opts.model, "model");
+      const modelFlag = opts.model ? `--model ${opts.model}` : "";
+      const config = {
+        name: "codex",
+        buildCommand: (promptCatExpr) => `codex exec --dangerously-bypass-approvals-and-sandbox --ephemeral ${modelFlag} ${promptCatExpr}`,
+        logLine: `codex exec --dangerously-bypass-approvals-and-sandbox --ephemeral ${modelFlag || "(default model)"}`,
+        kanbanLine: `$ codex exec --dangerously-bypass-approvals-and-sandbox --ephemeral ${modelFlag || "(default model)"} <prompt: ${prompt.length} chars>
+`,
+        errorPattern: /^Error /,
+        extraEnv: { CODEX_QUIET_MODE: "1" }
+      };
+      return await runProviderProcess(config, prompt, opts);
+    } catch (err) {
+      return { success: false, output: formatError(err), duration: 0 };
+    }
+  }
+};
+
+// src/providers/copilot.ts
+var CopilotProvider = class {
+  name = "copilot";
+  async isAvailable() {
+    return isCommandAvailable("copilot", ["version"]);
+  }
+  async run(prompt, opts) {
+    try {
+      if (opts.model) validateShellArg(opts.model, "model");
+      const modelFlag = opts.model ? `--model ${opts.model}` : "";
+      const config = {
+        name: "copilot",
+        buildCommand: (promptCatExpr) => `copilot --allow-all --no-alt-screen ${modelFlag} -p ${promptCatExpr}`,
+        logLine: `copilot --allow-all --no-alt-screen ${modelFlag || "(default model)"} -p`,
+        kanbanLine: `$ copilot --allow-all --no-alt-screen ${modelFlag || "(default model)"} -p <prompt: ${prompt.length} chars>
+`,
+        errorPattern: /^Error /
+      };
+      return await runProviderProcess(config, prompt, opts);
+    } catch (err) {
+      return { success: false, output: formatError(err), duration: 0 };
+    }
+  }
+};
+
+// src/providers/cursor.ts
+import { execSync } from "child_process";
+function findCursorBinary() {
+  for (const bin of ["agent", "cursor-agent"]) {
+    try {
+      execSync(`which ${bin}`, { stdio: "ignore" });
+      return bin;
+    } catch {
+    }
+  }
+  return null;
+}
+var TOOL_LABELS = {
+  readToolCall: "Read",
+  editToolCall: "Edit",
+  writeToolCall: "Write",
+  runCommandToolCall: "Run",
+  listDirectoryToolCall: "List",
+  codebaseSearchToolCall: "Search",
+  grepToolCall: "Grep",
+  fileSearchToolCall: "Find",
+  deleteToolCall: "Delete"
+};
+function formatStreamEvent(event) {
+  const type = event.type;
+  if (type === "assistant") {
+    const message = event.message;
+    const text = message?.content?.[0]?.text;
+    return text ? `${text}
+` : null;
+  }
+  if (type === "tool_call") {
+    const subtype = event.subtype;
+    const toolCall = event.tool_call;
+    if (!toolCall) return null;
+    const toolKey = Object.keys(toolCall)[0];
+    if (!toolKey) return null;
+    const label = TOOL_LABELS[toolKey] ?? toolKey.replace(/ToolCall$/, "");
+    const toolData = toolCall[toolKey];
+    if (subtype === "started") {
+      const path = toolData?.args?.path;
+      const command = toolData?.args?.command;
+      const query = toolData?.args?.query;
+      const target = path ?? command ?? query ?? "";
+      return `\u25CF ${label} ${target}
+`;
+    }
+    if (subtype === "completed") {
+      const result = toolData?.result;
+      if (result?.error) {
+        const errMsg = typeof result.error === "string" ? result.error : result.error?.message ?? "error";
+        return `\u2717 ${label} \u2014 ${errMsg}
+`;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+function createStreamJsonTransform() {
+  let buffer = "";
+  return (raw) => {
+    buffer += raw;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    let output = "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const event = JSON.parse(trimmed);
+        const formatted = formatStreamEvent(event);
+        if (formatted) output += formatted;
+      } catch {
+        output += `${trimmed}
+`;
+      }
+    }
+    return output;
+  };
+}
+var CursorProvider = class {
+  name = "cursor";
+  _bin = void 0;
+  resolveBin() {
+    if (this._bin === void 0) this._bin = findCursorBinary();
+    return this._bin;
+  }
+  async isAvailable() {
+    return this.resolveBin() !== null;
+  }
+  async run(prompt, opts) {
+    const bin = this.resolveBin();
+    if (!bin) {
+      return {
+        success: false,
+        output: "cursor agent (agent / cursor-agent) is not installed or not in PATH",
+        duration: 0
+      };
+    }
+    try {
+      if (opts.model) validateShellArg(opts.model, "model");
+      const modelFlag = opts.model ? `--model ${opts.model}` : "";
+      const config = {
+        name: "cursor",
+        buildCommand: (promptCatExpr) => `${bin} -p ${promptCatExpr} --output-format stream-json --force ${modelFlag}`,
+        logLine: `${bin} -p --output-format stream-json --force ${modelFlag || "(default model)"}`,
+        kanbanLine: `$ ${bin} -p --output-format stream-json --force ${modelFlag || "(default model)"} <prompt: ${prompt.length} chars>
+`,
+        errorPattern: /^Error /,
+        outputTransform: createStreamJsonTransform()
+      };
+      return await runProviderProcess(config, prompt, opts);
+    } catch (err) {
+      return { success: false, output: formatError(err), duration: 0 };
+    }
+  }
+};
+
+// src/providers/gemini.ts
+var GEMINI_ERROR_PATTERN = /^Error (executing tool|generating content)/;
+var GeminiProvider = class {
+  name = "gemini";
+  async isAvailable() {
+    return isCommandAvailable("gemini");
+  }
+  async run(prompt, opts) {
+    try {
+      if (opts.model) validateShellArg(opts.model, "model");
+      const modelFlag = opts.model ? `--model ${opts.model}` : "";
+      const config = {
+        name: "gemini",
+        buildCommand: (promptCatExpr) => `gemini --yolo ${modelFlag} -p ${promptCatExpr}`,
+        logLine: `gemini --yolo ${modelFlag || "(default model)"} -p`,
+        kanbanLine: `$ gemini --yolo ${modelFlag || "(default model)"} -p <prompt: ${prompt.length} chars>
+`,
+        errorPattern: GEMINI_ERROR_PATTERN
+      };
+      return await runProviderProcess(config, prompt, opts);
+    } catch (err) {
+      return { success: false, output: formatError(err), duration: 0 };
+    }
+  }
+};
+
+// src/providers/goose.ts
+var GooseProvider = class {
+  name = "goose";
+  async isAvailable() {
+    return isCommandAvailable("goose");
+  }
+  async run(prompt, opts) {
+    try {
+      let providerFlag = "";
+      if (process.env.GOOSE_PROVIDER) {
+        validateShellArg(process.env.GOOSE_PROVIDER, "GOOSE_PROVIDER");
+        providerFlag = `--provider ${process.env.GOOSE_PROVIDER}`;
+      }
+      if (opts.model) validateShellArg(opts.model, "model");
+      const modelFlag = opts.model ? `--model ${opts.model}` : "";
+      const config = {
+        name: "goose",
+        buildCommand: (promptCatExpr) => `goose run ${providerFlag} ${modelFlag} --text ${promptCatExpr}`,
+        logLine: `goose run ${providerFlag} ${modelFlag || "(default model)"} --text`,
+        kanbanLine: `$ goose run ${providerFlag} ${modelFlag || "(default model)"} --text <prompt: ${prompt.length} chars>
+`,
+        errorPattern: /^Error /
+      };
+      return await runProviderProcess(config, prompt, opts);
+    } catch (err) {
+      return { success: false, output: formatError(err), duration: 0 };
+    }
+  }
+};
+
+// src/providers/opencode.ts
+var OpenCodeProvider = class {
+  name = "opencode";
+  async isAvailable() {
+    return isCommandAvailable("opencode");
+  }
+  async run(prompt, opts) {
+    try {
+      if (opts.model) validateShellArg(opts.model, "model");
+      const modelFlag = opts.model ? `--model ${opts.model}` : "";
+      const config = {
+        name: "opencode",
+        buildCommand: (promptCatExpr) => `opencode run ${modelFlag} ${promptCatExpr}`,
+        logLine: `opencode run ${modelFlag || "(default model)"}`,
+        kanbanLine: `$ opencode run ${modelFlag || "(default model)"} <prompt: ${prompt.length} chars>
+`,
+        errorPattern: /^Error /
+      };
+      return await runProviderProcess(config, prompt, opts);
+    } catch (err) {
+      return { success: false, output: formatError(err), duration: 0 };
+    }
+  }
+};
+
+// src/providers/index.ts
+var providers = {
+  claude: () => new ClaudeProvider(),
+  gemini: () => new GeminiProvider(),
+  opencode: () => new OpenCodeProvider(),
+  copilot: () => new CopilotProvider(),
+  cursor: () => new CursorProvider(),
+  goose: () => new GooseProvider(),
+  aider: () => new AiderProvider(),
+  codex: () => new CodexProvider()
+};
+async function getAllProvidersWithAvailability() {
+  const all = Object.values(providers).map((f) => f());
+  return Promise.all(all.map(async (p) => ({ provider: p, available: await p.isAvailable() })));
+}
+function createProvider(name) {
+  const factory = providers[name];
+  if (!factory) {
+    throw new Error(`Unknown provider: ${name}. Available: ${Object.keys(providers).join(", ")}`);
+  }
+  return factory();
+}
+var ELIGIBLE_ERROR_PATTERNS = [
+  /429/i,
+  /quota/i,
+  /rate.?limit/i,
+  /too many requests/i,
+  /resource.?exhausted/i,
+  /overloaded/i,
+  /unavailable/i,
+  /not\s+available/i,
+  /interactive mode/i,
+  /not.?found.*model/i,
+  /model.*not.?found/i,
+  /does not exist/i,
+  /ETIMEDOUT/,
+  /ECONNREFUSED/,
+  /ECONNRESET/,
+  /ENOTFOUND/,
+  /fetch failed/i,
+  /\btimeout\b/i,
+  /\btimed?\s*out\b/i,
+  /network.?error/i,
+  /not installed/i,
+  /not in PATH/i,
+  /command not found/i,
+  /lisa-overseer/i,
+  /lisa-timeout/i,
+  /lisa-stall/i,
+  /lisa-reconciliation/i,
+  /named models unavailable/i,
+  /free plans can only use/i,
+  /empty commit/i,
+  // Process crash patterns (OOM, fatal errors, signals)
+  /heap.*out of memory/i,
+  /out of memory/i,
+  /FATAL ERROR/,
+  /allocation failed/i,
+  /segmentation fault/i,
+  /\bSIGKILL\b/,
+  /\bSIGABRT\b/,
+  /\bSIGSEGV\b/
+];
+function isEligibleForFallback(output, exitCode) {
+  if (ELIGIBLE_ERROR_PATTERNS.some((pattern) => pattern.test(output))) return true;
+  if (exitCode !== void 0 && exitCode > 128) return true;
+  return false;
+}
+function isCompleteProviderExhaustion(attempts) {
+  if (attempts.length === 0) return false;
+  return attempts.every((a) => !a.success && a.error !== "Non-eligible error");
+}
+async function runWithFallback(models, prompt, opts) {
+  const attempts = [];
+  for (const spec of models) {
+    if (opts.shouldAbort?.()) {
+      break;
+    }
+    kanbanEmitter.emit("provider:model-changed", spec.model ?? spec.provider);
+    const provider = createProvider(spec.provider);
+    const available = await provider.isAvailable();
+    if (!available) {
+      attempts.push({
+        provider: spec.provider,
+        model: spec.model,
+        success: false,
+        error: `Provider "${spec.provider}" is not installed or not in PATH`,
+        duration: 0
+      });
+      continue;
+    }
+    const guardrailsSection = opts.guardrailsDir ? buildGuardrailsSection(opts.guardrailsDir) : "";
+    const fullPrompt = guardrailsSection ? `${prompt}${guardrailsSection}` : prompt;
+    const result = await provider.run(fullPrompt, { ...opts, model: spec.model });
+    if (result.success || opts.earlySuccess?.()) {
+      attempts.push({
+        provider: spec.provider,
+        model: spec.model,
+        success: true,
+        duration: result.duration
+      });
+      return {
+        success: true,
+        output: result.output,
+        duration: result.duration,
+        providerUsed: spec.model ? `${spec.provider}/${spec.model}` : spec.provider,
+        provider,
+        attempts
+      };
+    }
+    if (opts.guardrailsDir && opts.issueId) {
+      appendEntry(opts.guardrailsDir, {
+        issueId: opts.issueId,
+        date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+        provider: spec.provider,
+        errorType: extractErrorType(result.output),
+        context: extractContext(result.output)
+      });
+    }
+    const eligible = isEligibleForFallback(result.output, result.exitCode);
+    attempts.push({
+      provider: spec.provider,
+      model: spec.model,
+      success: false,
+      error: eligible ? "Eligible error (quota/unavailable/timeout)" : "Non-eligible error",
+      duration: result.duration
+    });
+    if (!eligible) {
+      return {
+        success: false,
+        output: result.output,
+        duration: result.duration,
+        providerUsed: spec.model ? `${spec.provider}/${spec.model}` : spec.provider,
+        provider,
+        attempts
+      };
+    }
+  }
+  const totalDuration = attempts.reduce((sum, a) => sum + a.duration, 0);
+  return {
+    success: false,
+    output: formatAttemptsReport(attempts),
+    duration: totalDuration,
+    providerUsed: attempts[attempts.length - 1]?.provider ?? models[0]?.provider ?? "claude",
+    attempts
+  };
+}
+function formatAttemptsReport(attempts) {
+  const lines = ["All models exhausted. Attempt history:"];
+  for (const [i, a] of attempts.entries()) {
+    const status = a.success ? "OK" : "FAILED";
+    const error2 = a.error ? ` \u2014 ${a.error}` : "";
+    const duration = a.duration > 0 ? ` (${Math.round(a.duration / 1e3)}s)` : "";
+    const label = a.model ? `${a.provider}/${a.model}` : a.provider;
+    lines.push(`  ${i + 1}. ${label}: ${status}${error2}${duration}`);
+  }
+  return lines.join("\n");
+}
+
+// src/sources/jira.ts
+var PRIORITY_RANK = {
+  highest: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+  lowest: 5
+};
+function getBaseUrl() {
+  const url = process.env.JIRA_BASE_URL;
+  if (!url) throw new Error("JIRA_BASE_URL is not set");
+  return url.replace(/\/$/, "");
+}
+function getAuthHeaders() {
+  const email = process.env.JIRA_EMAIL;
+  const token = process.env.JIRA_API_TOKEN;
+  if (!email || !token) throw new Error("JIRA_EMAIL and JIRA_API_TOKEN must be set");
+  const credentials = Buffer.from(`${email}:${token}`).toString("base64");
+  return {
+    Authorization: `Basic ${credentials}`,
+    Accept: "application/json"
+  };
+}
+var _api = null;
+function api() {
+  if (!_api) _api = createApiClient(`${getBaseUrl()}/rest/api/3`, getAuthHeaders, "Jira");
+  return _api;
+}
+function jiraGet(path) {
+  return api().get(path);
+}
+function jiraPost(path, body) {
+  return api().post(path, body);
+}
+function jiraPut(path, body) {
+  return api().put(path, body);
+}
+async function jiraSearchJql(jql, fields, maxResults) {
+  return jiraPost("/search/jql", { jql, fields: fields.split(","), maxResults });
+}
+function priorityRank(issue) {
+  const name = issue.fields.priority?.name?.toLowerCase() ?? "";
+  return PRIORITY_RANK[name] ?? Number.MAX_SAFE_INTEGER;
+}
+function extractDescription(description) {
+  if (!description) return "";
+  if (typeof description === "string") return description;
+  if (typeof description === "object") {
+    return extractAdfText(description);
+  }
+  return "";
+}
+function extractAdfText(node) {
+  if (node.type === "text" && typeof node.text === "string") return node.text;
+  const parts = [];
+  if (Array.isArray(node.content)) {
+    for (const child of node.content) {
+      const text = extractAdfText(child);
+      if (text) parts.push(text);
+    }
+  }
+  return parts.join("\n");
+}
+function escapeJql(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function resolveStatusId(scope, statusName) {
+  try {
+    const data = await jiraGet(
+      `/project/${encodeURIComponent(scope)}/statuses`
+    );
+    for (const issueType of data) {
+      const match = issueType.statuses.find(
+        (s) => s.name.toLowerCase() === statusName.toLowerCase()
+      );
+      if (match) return match.id;
+    }
+  } catch {
+  }
+  return null;
+}
+function issueUrl(baseUrl, key) {
+  return `${baseUrl}/browse/${key}`;
+}
+var JiraSource = class {
+  name = "jira";
+  async fetchNextIssue(config) {
+    const labels = normalizeLabels(config);
+    const labelClause = labels.map((l) => `labels = "${escapeJql(l)}"`).join(" AND ");
+    const statusId = await resolveStatusId(config.scope, config.pick_from);
+    const statusClause = statusId ? `status = ${statusId}` : `status = "${escapeJql(config.pick_from)}"`;
+    const jql = `project = "${escapeJql(config.scope)}" AND ${labelClause} AND ${statusClause} ORDER BY priority ASC, created ASC`;
+    const fields = "summary,description,priority,status,labels,issuelinks";
+    const data = await jiraSearchJql(jql, fields, 50);
+    const issues = data.issues ?? [];
+    if (issues.length === 0) return null;
+    const unblocked = [];
+    const blocked = [];
+    for (const issue2 of issues) {
+      const activeBlockers = (issue2.fields.issuelinks ?? []).filter((link) => {
+        if (link.inwardIssue && link.type.inward.toLowerCase().includes("is blocked by")) {
+          return link.inwardIssue.fields.status.statusCategory.key !== "done";
+        }
+        return false;
+      }).map((link) => link.inwardIssue?.key ?? "");
+      if (activeBlockers.length === 0) {
+        unblocked.push(issue2);
+      } else {
+        blocked.push({ key: issue2.key, blockers: activeBlockers });
+      }
+    }
+    if (unblocked.length === 0) {
+      if (blocked.length > 0) {
+        warn("No unblocked issues found. Blocked issues:");
+        for (const entry of blocked) {
+          warn(`  ${entry.key} \u2014 blocked by: ${entry.blockers.join(", ")}`);
+        }
+      }
+      return null;
+    }
+    const sorted = [...unblocked].sort((a, b) => priorityRank(a) - priorityRank(b));
+    const issue = sorted[0];
+    if (!issue) return null;
+    const baseUrl = getBaseUrl();
+    return {
+      id: issue.key,
+      title: issue.fields.summary,
+      description: extractDescription(issue.fields.description),
+      url: issueUrl(baseUrl, issue.key)
+    };
+  }
+  async fetchIssueById(id) {
+    const key = parseJiraIdentifier(id);
+    try {
+      const issue = await jiraGet(
+        `/issue/${key}?fields=summary,description,priority,status,labels`
+      );
+      const baseUrl = getBaseUrl();
+      return {
+        id: issue.key,
+        title: issue.fields.summary,
+        description: extractDescription(issue.fields.description),
+        url: issueUrl(baseUrl, issue.key),
+        status: issue.fields.status.name
+      };
+    } catch {
+      return null;
+    }
+  }
+  async updateStatus(issueId, statusName) {
+    const key = parseJiraIdentifier(issueId);
+    const data = await jiraGet(`/issue/${key}/transitions`);
+    const lowerName = statusName.toLowerCase();
+    const transition = data.transitions.find((t) => t.to.name.toLowerCase() === lowerName) ?? data.transitions.find((t) => t.name.toLowerCase() === lowerName);
+    if (!transition) {
+      const available = data.transitions.map((t) => `${t.name} \u2192 ${t.to.name}`).join(", ");
+      throw new Error(`Jira transition "${statusName}" not found. Available: ${available}`);
+    }
+    await jiraPost(`/issue/${key}/transitions`, { transition: { id: transition.id } });
+  }
+  async attachPullRequest(issueId, prUrl) {
+    const key = parseJiraIdentifier(issueId);
+    await jiraPost(`/issue/${key}/remotelink`, {
+      object: {
+        url: prUrl,
+        title: "Pull Request",
+        icon: {
+          url16x16: "https://github.com/favicon.ico",
+          title: "GitHub"
+        }
+      }
+    });
+  }
+  async completeIssue(issueId, statusName, labelToRemove) {
+    await this.updateStatus(issueId, statusName);
+    if (labelToRemove) {
+      await this.removeLabel(issueId, labelToRemove);
+    }
+  }
+  async listIssues(config) {
+    const labels = normalizeLabels(config);
+    const labelClause = labels.map((l) => `labels = "${escapeJql(l)}"`).join(" AND ");
+    const statusId = await resolveStatusId(config.scope, config.pick_from);
+    const statusClause = statusId ? `status = ${statusId}` : `status = "${escapeJql(config.pick_from)}"`;
+    const jql = `project = "${escapeJql(config.scope)}" AND ${labelClause} AND ${statusClause} ORDER BY priority ASC, created ASC`;
+    const fields = "summary,description,priority,status,labels";
+    const data = await jiraSearchJql(jql, fields, 100);
+    const baseUrl = getBaseUrl();
+    return (data.issues ?? []).map((issue) => ({
+      id: issue.key,
+      title: issue.fields.summary,
+      description: extractDescription(issue.fields.description),
+      url: issueUrl(baseUrl, issue.key)
+    }));
+  }
+  async listScopes() {
+    const data = await jiraGet(
+      "/project/search?maxResults=50"
+    );
+    return (data.values ?? []).map((p) => ({
+      value: p.key,
+      label: `${p.key} \u2014 ${p.name}`
+    }));
+  }
+  async listLabels() {
+    const data = await jiraGet("/label?maxResults=100");
+    return (data.values ?? []).map((l) => ({
+      value: l,
+      label: l
+    }));
+  }
+  async listStatuses(scope) {
+    const data = await jiraGet(
+      `/project/${encodeURIComponent(scope)}/statuses`
+    );
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const issueType of data) {
+      for (const status of issueType.statuses) {
+        if (!seen.has(status.name)) {
+          seen.add(status.name);
+          results.push({ value: status.name, label: status.name });
+        }
+      }
+    }
+    return results;
+  }
+  async removeLabel(issueId, labelName) {
+    const key = parseJiraIdentifier(issueId);
+    const issue = await jiraGet(`/issue/${key}?fields=labels`);
+    const currentLabels = issue.fields.labels ?? [];
+    const filtered = currentLabels.filter((l) => l.toLowerCase() !== labelName.toLowerCase());
+    if (filtered.length === currentLabels.length) return;
+    await jiraPut(`/issue/${key}`, { fields: { labels: filtered } });
+  }
+  async createIssue(opts, config) {
+    const labels = Array.isArray(opts.label) ? opts.label : [opts.label];
+    const fields = {
+      project: { key: config.scope },
+      summary: opts.title,
+      description: {
+        type: "doc",
+        version: 1,
+        content: [
+          {
+            type: "paragraph",
+            content: [{ type: "text", text: opts.description }]
+          }
+        ]
+      },
+      issuetype: { name: "Task" },
+      labels
+    };
+    if (opts.parentId) fields.parent = { key: opts.parentId };
+    const result = await jiraPost("/issue", { fields });
+    if (opts.status) {
+      try {
+        await this.updateStatus(result.key, opts.status);
+      } catch {
+      }
+    }
+    return result.key;
+  }
+  async linkDependency(issueId, dependsOnId) {
+    await jiraPost("/issueLink", {
+      type: { name: "Blocks" },
+      inwardIssue: { key: dependsOnId },
+      outwardIssue: { key: issueId }
+    });
+  }
+};
+function parseJiraIdentifier(input) {
+  const urlMatch = input.match(/\/browse\/([A-Z][A-Z0-9_]+-\d+)/);
+  if (urlMatch?.[1]) return urlMatch[1];
+  return input;
+}
+
+// src/sources/linear.ts
+var API_URL = "https://api.linear.app/graphql";
+function getApiKey() {
+  const key = process.env.LINEAR_API_KEY;
+  if (!key) throw new Error("LINEAR_API_KEY is not set");
+  return key;
+}
+async function gql(query, variables) {
+  const res = await fetch(API_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: getApiKey()
+    },
+    body: JSON.stringify({ query, variables }),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Linear API error (${res.status}): ${text}`);
+  }
+  const json = await res.json();
+  if (json.errors?.length) {
+    throw new Error(`Linear GraphQL error: ${json.errors.map((e) => e.message).join(", ")}`);
+  }
+  return json.data;
+}
+var LinearSource = class {
+  name = "linear";
+  async fetchNextIssue(config) {
+    const labels = normalizeLabels(config);
+    const primaryLabel = labels[0] ?? "";
+    const data = await gql(
+      `query($teamName: String!, $projectName: String!, $labelName: String!, $statusName: String!) {
+				issues(
+					filter: {
+						team: { name: { eq: $teamName } }
+						project: { name: { eq: $projectName } }
+						labels: { name: { eq: $labelName } }
+						state: { name: { eq: $statusName } }
+					}
+					first: 50
+				) {
+					nodes {
+						id
+						identifier
+						title
+						description
+						url
+						priority
+						labels { nodes { name } }
+						inverseRelations(first: 50) {
+							nodes {
+								type
+								issue {
+									identifier
+									state { type }
+								}
+							}
+						}
+					}
+				}
+			}`,
+      {
+        teamName: config.scope,
+        projectName: config.project,
+        labelName: primaryLabel,
+        statusName: config.pick_from
+      }
+    );
+    const issues = labels.length > 1 ? data.issues.nodes.filter((issue2) => {
+      const issueLabels = new Set(issue2.labels.nodes.map((l) => l.name.toLowerCase()));
+      return labels.every((l) => issueLabels.has(l.toLowerCase()));
+    }) : data.issues.nodes;
+    if (issues.length === 0) return null;
+    const unblocked = [];
+    const blocked = [];
+    const completedBlockerMap = /* @__PURE__ */ new Map();
+    for (const issue2 of issues) {
+      const blockerRelations = issue2.inverseRelations.nodes.filter((r) => r.type === "blocks");
+      const activeBlockers = blockerRelations.filter((r) => r.issue.state.type !== "completed" && r.issue.state.type !== "canceled").map((r) => r.issue.identifier);
+      const completedBlockers = blockerRelations.filter((r) => r.issue.state.type === "completed").map((r) => r.issue.identifier);
+      if (completedBlockers.length > 0) {
+        completedBlockerMap.set(issue2.identifier, completedBlockers);
+      }
+      if (activeBlockers.length === 0) {
+        unblocked.push(issue2);
+      } else {
+        blocked.push({ identifier: issue2.identifier, blockers: activeBlockers });
+      }
+    }
+    if (unblocked.length === 0) {
+      if (blocked.length > 0) {
+        warn("No unblocked issues found. Blocked issues:");
+        for (const entry of blocked) {
+          warn(`  ${entry.identifier} \u2014 blocked by: ${entry.blockers.join(", ")}`);
+        }
+      }
+      return null;
+    }
+    unblocked.sort((a, b) => {
+      const pa = a.priority === 0 ? 5 : a.priority;
+      const pb = b.priority === 0 ? 5 : b.priority;
+      return pa - pb;
+    });
+    const issue = unblocked[0];
+    if (!issue) return null;
+    const completedBlockerIds = completedBlockerMap.get(issue.identifier);
+    return {
+      id: issue.identifier,
+      title: issue.title,
+      description: issue.description || "",
+      url: issue.url,
+      ...completedBlockerIds && { completedBlockerIds }
+    };
+  }
+  async fetchIssueById(id) {
+    const identifier = parseLinearIdentifier(id);
+    const data = await gql(
+      `query($identifier: String!) {
+				issue(id: $identifier) {
+					id
+					identifier
+					title
+					description
+					url
+					state { name }
+				}
+			}`,
+      { identifier }
+    );
+    if (!data.issue) return null;
+    return {
+      id: data.issue.identifier,
+      title: data.issue.title,
+      description: data.issue.description || "",
+      url: data.issue.url,
+      status: data.issue.state?.name
+    };
+  }
+  async updateStatus(issueId, statusName) {
+    const issueData = await gql(
+      `query($identifier: String!) {
+				issue(id: $identifier) {
+					id
+					team { id }
+				}
+			}`,
+      { identifier: issueId }
+    );
+    const statesData = await gql(
+      `query($teamId: ID!) {
+				workflowStates(filter: { team: { id: { eq: $teamId } } }) {
+					nodes { id name }
+				}
+			}`,
+      { teamId: issueData.issue.team.id }
+    );
+    const state = statesData.workflowStates.nodes.find(
+      (s) => s.name.toLowerCase() === statusName.toLowerCase()
+    );
+    if (!state) {
+      const available = statesData.workflowStates.nodes.map((s) => s.name).join(", ");
+      throw new Error(`Status "${statusName}" not found. Available: ${available}`);
+    }
+    const mutationResult = await gql(
+      `mutation($issueId: String!, $stateId: String!) {
+				issueUpdate(id: $issueId, input: { stateId: $stateId }) {
+					success
+				}
+			}`,
+      { issueId: issueData.issue.id, stateId: state.id }
+    );
+    if (!mutationResult.issueUpdate.success) {
+      throw new Error(
+        `issueUpdate returned success=false for ${issueId} (stateId: ${state.id}, stateName: ${state.name})`
+      );
+    }
+  }
+  async attachPullRequest(_issueId, _prUrl) {
+  }
+  async completeIssue(issueId, statusName, labelToRemove) {
+    const issueData = await gql(
+      `query($identifier: String!) {
+				issue(id: $identifier) {
+					id
+					team { id }
+					labels { nodes { id name } }
+				}
+			}`,
+      { identifier: issueId }
+    );
+    const statesData = await gql(
+      `query($teamId: ID!) {
+				workflowStates(filter: { team: { id: { eq: $teamId } } }) {
+					nodes { id name }
+				}
+			}`,
+      { teamId: issueData.issue.team.id }
+    );
+    const state = statesData.workflowStates.nodes.find(
+      (s) => s.name.toLowerCase() === statusName.toLowerCase()
+    );
+    if (!state) {
+      const available = statesData.workflowStates.nodes.map((s) => s.name).join(", ");
+      throw new Error(`Status "${statusName}" not found. Available: ${available}`);
+    }
+    const input = { stateId: state.id };
+    if (labelToRemove) {
+      const currentLabels = issueData.issue.labels.nodes;
+      const filtered = currentLabels.filter(
+        (l) => l.name.toLowerCase() !== labelToRemove.toLowerCase()
+      );
+      if (filtered.length !== currentLabels.length) {
+        input.labelIds = filtered.map((l) => l.id);
+      }
+    }
+    const mutationResult = await gql(
+      `mutation($issueId: String!, $input: IssueUpdateInput!) {
+				issueUpdate(id: $issueId, input: $input) {
+					success
+				}
+			}`,
+      { issueId: issueData.issue.id, input }
+    );
+    if (!mutationResult.issueUpdate.success) {
+      throw new Error(
+        `issueUpdate returned success=false for ${issueId} (stateId: ${state.id}, stateName: ${state.name})`
+      );
+    }
+  }
+  async listIssues(config) {
+    const labels = normalizeLabels(config);
+    const primaryLabel = labels[0] ?? "";
+    const data = await gql(
+      `query($teamName: String!, $projectName: String!, $labelName: String!, $statusName: String!) {
+				issues(
+					filter: {
+						team: { name: { eq: $teamName } }
+						project: { name: { eq: $projectName } }
+						labels: { name: { eq: $labelName } }
+						state: { name: { eq: $statusName } }
+					}
+					first: 100
+				) {
+					nodes {
+						identifier
+						title
+						description
+						url
+						labels { nodes { name } }
+					}
+				}
+			}`,
+      {
+        teamName: config.scope,
+        projectName: config.project,
+        labelName: primaryLabel,
+        statusName: config.pick_from
+      }
+    );
+    const filtered = labels.length > 1 ? data.issues.nodes.filter((issue) => {
+      const issueLabels = new Set(issue.labels.nodes.map((l) => l.name.toLowerCase()));
+      return labels.every((l) => issueLabels.has(l.toLowerCase()));
+    }) : data.issues.nodes;
+    return filtered.map((issue) => ({
+      id: issue.identifier,
+      title: issue.title,
+      description: issue.description || "",
+      url: issue.url
+    }));
+  }
+  async addLabel(issueId, labelName) {
+    const issueData = await gql(
+      `query($identifier: String!) {
+				issue(id: $identifier) {
+					id
+					team {
+						id
+						labels { nodes { id name } }
+					}
+					labels { nodes { id name } }
+				}
+			}`,
+      { identifier: issueId }
+    );
+    let teamLabel = issueData.issue.team.labels.nodes.find(
+      (l) => l.name.toLowerCase() === labelName.toLowerCase()
+    );
+    if (!teamLabel) {
+      const created = await gql(
+        `mutation($teamId: String!, $name: String!) {
+					issueLabelCreate(input: { teamId: $teamId, name: $name }) {
+						success
+						issueLabel { id name }
+					}
+				}`,
+        { teamId: issueData.issue.team.id, name: labelName }
+      );
+      if (created.issueLabelCreate.success && created.issueLabelCreate.issueLabel) {
+        log(`Label "${labelName}" created automatically in team ${issueData.issue.team.id}`);
+        teamLabel = created.issueLabelCreate.issueLabel;
+      } else {
+        const refetch = await gql(
+          `query($identifier: String!) {
+						issue(id: $identifier) {
+							team { labels { nodes { id name } } }
+						}
+					}`,
+          { identifier: issueId }
+        );
+        teamLabel = refetch.issue.team.labels.nodes.find(
+          (l) => l.name.toLowerCase() === labelName.toLowerCase()
+        );
+        if (!teamLabel) {
+          throw new Error(`Failed to create or find label "${labelName}" in team`);
+        }
+      }
+    }
+    const alreadyHasLabel = issueData.issue.labels.nodes.some(
+      (l) => l.name.toLowerCase() === labelName.toLowerCase()
+    );
+    if (alreadyHasLabel) return;
+    const newLabelIds = [...issueData.issue.labels.nodes.map((l) => l.id), teamLabel.id];
+    const mutationResult = await gql(
+      `mutation($issueId: String!, $labelIds: [String!]!) {
+				issueUpdate(id: $issueId, input: { labelIds: $labelIds }) {
+					success
+				}
+			}`,
+      {
+        issueId: issueData.issue.id,
+        labelIds: newLabelIds
+      }
+    );
+    if (!mutationResult.issueUpdate.success) {
+      throw new Error(
+        `issueUpdate returned success=false when adding label "${labelName}" to ${issueId}`
+      );
+    }
+  }
+  async listProjects(scope) {
+    const data = await gql(
+      `query($teamName: String!) {
+				teams(filter: { name: { eq: $teamName } }) {
+					nodes { id }
+				}
+			}`,
+      { teamName: scope }
+    );
+    const team = data.teams.nodes[0];
+    if (!team) throw new Error(`Team "${scope}" not found`);
+    const projectData = await gql(
+      `query($teamId: ID!) {
+				projects(filter: { accessibleTeams: { id: { eq: $teamId } } }) {
+					nodes { name }
+				}
+			}`,
+      { teamId: team.id }
+    );
+    return projectData.projects.nodes.map((p) => ({ value: p.name, label: p.name }));
+  }
+  async listStatuses(scope) {
+    const data = await gql(
+      `query($teamName: String!) {
+				teams(filter: { name: { eq: $teamName } }) {
+					nodes { id }
+				}
+			}`,
+      { teamName: scope }
+    );
+    const team = data.teams.nodes[0];
+    if (!team) throw new Error(`Team "${scope}" not found`);
+    const statesData = await gql(
+      `query($teamId: ID!) {
+				workflowStates(filter: { team: { id: { eq: $teamId } } }) {
+					nodes { name type }
+				}
+			}`,
+      { teamId: team.id }
+    );
+    return statesData.workflowStates.nodes.map((s) => ({
+      value: s.name,
+      label: `${s.name} (${s.type})`
+    }));
+  }
+  async removeLabel(issueId, labelName) {
+    const issueData = await gql(
+      `query($identifier: String!) {
+				issue(id: $identifier) {
+					id
+					labels { nodes { id name } }
+				}
+			}`,
+      { identifier: issueId }
+    );
+    const currentLabels = issueData.issue.labels.nodes;
+    const filtered = currentLabels.filter((l) => l.name.toLowerCase() !== labelName.toLowerCase());
+    if (filtered.length === currentLabels.length) return;
+    const mutationResult = await gql(
+      `mutation($issueId: String!, $labelIds: [String!]!) {
+				issueUpdate(id: $issueId, input: { labelIds: $labelIds }) {
+					success
+				}
+			}`,
+      {
+        issueId: issueData.issue.id,
+        labelIds: filtered.map((l) => l.id)
+      }
+    );
+    if (!mutationResult.issueUpdate.success) {
+      throw new Error(
+        `issueUpdate returned success=false when removing label "${labelName}" from ${issueId}`
+      );
+    }
+  }
+  async createIssue(opts, config) {
+    const teamData = await gql(
+      `query($teamName: String!) {
+				teams(filter: { name: { eq: $teamName } }) {
+					nodes { id }
+				}
+			}`,
+      { teamName: config.scope }
+    );
+    const team = teamData.teams.nodes[0];
+    if (!team) throw new Error(`Team "${config.scope}" not found`);
+    const statesData = await gql(
+      `query($teamId: ID!) {
+				workflowStates(filter: { team: { id: { eq: $teamId } } }) {
+					nodes { id name }
+				}
+			}`,
+      { teamId: team.id }
+    );
+    const state = statesData.workflowStates.nodes.find(
+      (s) => s.name.toLowerCase() === opts.status.toLowerCase()
+    );
+    if (!state) {
+      const available = statesData.workflowStates.nodes.map((s) => s.name).join(", ");
+      throw new Error(`Status "${opts.status}" not found. Available: ${available}`);
+    }
+    const labelNames = Array.isArray(opts.label) ? opts.label : [opts.label];
+    const teamLabelsData = await gql(
+      `query($teamName: String!) {
+				teams(filter: { name: { eq: $teamName } }) {
+					nodes { labels { nodes { id name } } }
+				}
+			}`,
+      { teamName: config.scope }
+    );
+    const teamLabels = teamLabelsData.teams.nodes[0]?.labels.nodes ?? [];
+    const labelIds = [];
+    for (const name of labelNames) {
+      const label = teamLabels.find((l) => l.name.toLowerCase() === name.toLowerCase());
+      if (!label) throw new Error(`Label "${name}" not found in team "${config.scope}"`);
+      labelIds.push(label.id);
+    }
+    let projectId;
+    if (config.project) {
+      const projectData = await gql(
+        `query($teamId: ID!) {
+					projects(filter: { accessibleTeams: { id: { eq: $teamId } } }) {
+						nodes { id name }
+					}
+				}`,
+        { teamId: team.id }
+      );
+      const project = projectData.projects.nodes.find(
+        (p) => p.name.toLowerCase() === config.project.toLowerCase()
+      );
+      if (project) projectId = project.id;
+    }
+    const input = {
+      teamId: team.id,
+      title: opts.title,
+      description: opts.description,
+      stateId: state.id,
+      labelIds
+    };
+    if (projectId) input.projectId = projectId;
+    if (opts.order !== void 0) input.priority = opts.order;
+    if (opts.parentId) input.parentId = opts.parentId;
+    const result = await gql(
+      `mutation($input: IssueCreateInput!) {
+				issueCreate(input: $input) {
+					success
+					issue { identifier }
+				}
+			}`,
+      { input }
+    );
+    if (!result.issueCreate.success || !result.issueCreate.issue) {
+      throw new Error("issueCreate returned success=false");
+    }
+    return result.issueCreate.issue.identifier;
+  }
+  async linkDependency(issueId, dependsOnId) {
+    const issueData = await gql(
+      `query($identifier: String!) { issue(id: $identifier) { id } }`,
+      { identifier: dependsOnId }
+    );
+    const dependentData = await gql(
+      `query($identifier: String!) { issue(id: $identifier) { id } }`,
+      { identifier: issueId }
+    );
+    await gql(
+      `mutation($issueId: String!, $relatedIssueId: String!) {
+				issueRelationCreate(input: { issueId: $issueId, relatedIssueId: $relatedIssueId, type: blocks }) {
+					success
+				}
+			}`,
+      {
+        issueId: dependentData.issue.id,
+        relatedIssueId: issueData.issue.id
+      }
+    );
+  }
+};
+function parseLinearIdentifier(input) {
+  const urlMatch = input.match(/\/issue\/([A-Z]+-\d+)/);
+  if (urlMatch?.[1]) return urlMatch[1];
+  return input;
+}
+
+// src/sources/plane.ts
+var DEFAULT_BASE_URL = "https://api.plane.so";
+function getBaseUrl2() {
+  return (process.env.PLANE_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+}
+function getAppUrl() {
+  const base = process.env.PLANE_BASE_URL ?? DEFAULT_BASE_URL;
+  if (base === DEFAULT_BASE_URL || base.replace(/\/$/, "") === DEFAULT_BASE_URL) {
+    return "https://app.plane.so";
+  }
+  return base.replace(/\/$/, "");
+}
+function getAuthHeaders2() {
+  const token = process.env.PLANE_API_TOKEN;
+  if (!token) throw new Error("PLANE_API_TOKEN must be set");
+  return { "X-Api-Key": token };
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var _api2 = null;
+function api2() {
+  if (!_api2) _api2 = createApiClient(`${getBaseUrl2()}/api/v1`, getAuthHeaders2, "Plane");
+  return _api2;
+}
+function planeGet(path) {
+  return api2().get(path);
+}
+function planePost(path, body) {
+  return api2().post(path, body);
+}
+function planePatch(path, body) {
+  return api2().patch(path, body);
+}
+async function fetchAll(path) {
+  const data = await planeGet(path);
+  if (Array.isArray(data)) return data;
+  return data.results ?? [];
+}
+var PRIORITY_ORDER = {
+  urgent: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+  none: 5
+};
+function priorityRank2(priority) {
+  return PRIORITY_ORDER[priority.toLowerCase()] ?? 5;
+}
+async function resolveProjectId(workspaceSlug, projectIdentifier) {
+  const projects = await fetchAll(`/workspaces/${workspaceSlug}/projects/`);
+  const project = projects.find(
+    (p) => p.identifier.toLowerCase() === projectIdentifier.toLowerCase() || p.name.toLowerCase() === projectIdentifier.toLowerCase() || p.id === projectIdentifier
+  );
+  if (!project) {
+    const available = projects.map((p) => `${p.name} (${p.identifier})`).join(", ");
+    throw new Error(`Plane project "${projectIdentifier}" not found. Available: ${available}`);
+  }
+  return project.id;
+}
+async function resolveStateId(workspaceSlug, projectId, stateName) {
+  const states = await fetchAll(
+    `/workspaces/${workspaceSlug}/projects/${projectId}/states/`
+  );
+  const state = states.find((s) => s.name.toLowerCase() === stateName.toLowerCase());
+  if (!state) {
+    const available = states.map((s) => s.name).join(", ");
+    throw new Error(`Plane state "${stateName}" not found. Available: ${available}`);
+  }
+  return state.id;
+}
+async function resolveLabelId(workspaceSlug, projectId, labelName) {
+  const labels = await fetchAll(
+    `/workspaces/${workspaceSlug}/projects/${projectId}/labels/`
+  );
+  const label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+  if (!label) {
+    const available = labels.map((l) => l.name).join(", ");
+    throw new Error(`Plane label "${labelName}" not found. Available: ${available}`);
+  }
+  return label.id;
+}
+async function fetchLabels(workspaceSlug, projectId) {
+  return fetchAll(`/workspaces/${workspaceSlug}/projects/${projectId}/labels/`);
+}
+function makeIssueId(workspaceSlug, projectId, issueId) {
+  return `${workspaceSlug}::${projectId}::${issueId}`;
+}
+function parseIssueId(id) {
+  const urlMatch = id.match(/\/([^/]+)\/projects\/([^/]+)\/issues\/([^/?#]+)/);
+  if (urlMatch?.[1] && urlMatch?.[2] && urlMatch?.[3]) {
+    return { workspaceSlug: urlMatch[1], projectId: urlMatch[2], issueId: urlMatch[3] };
+  }
+  const parts = id.split("::");
+  if (parts.length === 3 && parts[0] && parts[1] && parts[2]) {
+    return { workspaceSlug: parts[0], projectId: parts[1], issueId: parts[2] };
+  }
+  throw new Error(
+    `Cannot parse Plane issue ID: "${id}". Expected URL or "workspace::projectId::issueId" format.`
+  );
+}
+var PlaneSource = class {
+  name = "plane";
+  async fetchNextIssue(config) {
+    const workspaceSlug = config.scope;
+    const projectId = await resolveProjectId(workspaceSlug, config.project);
+    const stateId = await resolveStateId(workspaceSlug, projectId, config.pick_from);
+    const labelNames = normalizeLabels(config);
+    const labelIds = await Promise.all(
+      labelNames.map((name) => resolveLabelId(workspaceSlug, projectId, name))
+    );
+    const data = await planeGet(
+      `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/?state=${stateId}&per_page=100`
+    );
+    const matching = data.results.filter((i) => i.state === stateId).filter((i) => labelIds.every((lid) => i.labels.includes(lid)));
+    if (matching.length === 0) return null;
+    const allStates = await fetchAll(
+      `/workspaces/${workspaceSlug}/projects/${projectId}/states/`
+    );
+    const doneGroups = /* @__PURE__ */ new Set(["completed", "cancelled"]);
+    const doneStateIds = new Set(allStates.filter((s) => doneGroups.has(s.group)).map((s) => s.id));
+    const unblocked = [];
+    const blocked = [];
+    for (const issue2 of matching) {
+      const relations = await fetchAll(
+        `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/${issue2.id}/relations/`
+      );
+      const blockerIds = relations.filter((r) => r.relation_type === "blocked_by").map((r) => r.related_issue);
+      const activeBlockers = [];
+      for (const blockerId of blockerIds) {
+        try {
+          const blocker = await planeGet(
+            `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/${blockerId}/`
+          );
+          if (!doneStateIds.has(blocker.state)) {
+            activeBlockers.push(blockerId);
+          }
+        } catch (err) {
+          warn(`Could not fetch blocker ${blockerId}: ${formatError(err)}`);
+          activeBlockers.push(blockerId);
+        }
+      }
+      if (activeBlockers.length === 0) {
+        unblocked.push(issue2);
+      } else {
+        blocked.push({ id: issue2.id, name: issue2.name, blockers: activeBlockers });
+      }
+    }
+    if (unblocked.length === 0) {
+      if (blocked.length > 0) {
+        warn("No unblocked issues found. Blocked issues:");
+        for (const entry of blocked) {
+          warn(`  ${entry.name} \u2014 blocked by: ${entry.blockers.join(", ")}`);
+        }
+      }
+      return null;
+    }
+    const sorted = [...unblocked].sort(
+      (a, b) => priorityRank2(a.priority) - priorityRank2(b.priority)
+    );
+    const issue = sorted[0];
+    if (!issue) return null;
+    const webUrl = `${getAppUrl()}/${workspaceSlug}/projects/${projectId}/issues/${issue.id}`;
+    return {
+      id: makeIssueId(workspaceSlug, projectId, issue.id),
+      title: issue.name,
+      description: issue.description_stripped ?? "",
+      url: webUrl
+    };
+  }
+  async fetchIssueById(id) {
+    try {
+      const { workspaceSlug, projectId, issueId } = parseIssueId(id);
+      const issue = await planeGet(
+        `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/${issueId}/`
+      );
+      const webUrl = `${getAppUrl()}/${workspaceSlug}/projects/${projectId}/issues/${issue.id}`;
+      let stateName;
+      try {
+        const states = await fetchAll(
+          `/workspaces/${workspaceSlug}/projects/${projectId}/states/`
+        );
+        stateName = states.find((s) => s.id === issue.state)?.name;
+      } catch {
+      }
+      return {
+        id: makeIssueId(workspaceSlug, projectId, issue.id),
+        title: issue.name,
+        description: issue.description_stripped ?? "",
+        url: webUrl,
+        status: stateName
+      };
+    } catch {
+      return null;
+    }
+  }
+  async updateStatus(issueId, stateName) {
+    const { workspaceSlug, projectId, issueId: planeIssueId } = parseIssueId(issueId);
+    const stateId = await resolveStateId(workspaceSlug, projectId, stateName);
+    await planePatch(
+      `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/${planeIssueId}/`,
+      { state: stateId }
+    );
+  }
+  async attachPullRequest(issueId, prUrl) {
+    const { workspaceSlug, projectId, issueId: planeIssueId } = parseIssueId(issueId);
+    await planePost(
+      `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/${planeIssueId}/comments/`,
+      {
+        comment_html: `<p>Pull request: <a href="${escapeHtml(prUrl)}">${escapeHtml(prUrl)}</a></p>`
+      }
+    );
+  }
+  async completeIssue(issueId, stateName, labelToRemove) {
+    await this.updateStatus(issueId, stateName);
+    if (labelToRemove) {
+      await this.removeLabel(issueId, labelToRemove);
+    }
+  }
+  async listIssues(config) {
+    const workspaceSlug = config.scope;
+    const projectId = await resolveProjectId(workspaceSlug, config.project);
+    const stateId = await resolveStateId(workspaceSlug, projectId, config.pick_from);
+    const labelNames = normalizeLabels(config);
+    const labelIds = await Promise.all(
+      labelNames.map((name) => resolveLabelId(workspaceSlug, projectId, name))
+    );
+    const data = await planeGet(
+      `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/?state=${stateId}&per_page=100`
+    );
+    return data.results.filter((i) => i.state === stateId).filter((i) => labelIds.every((lid) => i.labels.includes(lid))).map((i) => {
+      const webUrl = `${getAppUrl()}/${workspaceSlug}/projects/${projectId}/issues/${i.id}`;
+      return {
+        id: makeIssueId(workspaceSlug, projectId, i.id),
+        title: i.name,
+        description: i.description_stripped ?? "",
+        url: webUrl
+      };
+    });
+  }
+  async listProjects(scope) {
+    const projects = await fetchAll(`/workspaces/${scope}/projects/`);
+    return projects.map((p) => ({ value: p.identifier, label: p.name }));
+  }
+  async listLabels(scope, project) {
+    if (!project) return [];
+    const projectId = await resolveProjectId(scope, project);
+    const labels = await fetchAll(`/workspaces/${scope}/projects/${projectId}/labels/`);
+    return labels.map((l) => ({ value: l.name, label: l.name }));
+  }
+  async listStatuses(scope, project) {
+    if (!project) return [];
+    const projectId = await resolveProjectId(scope, project);
+    const states = await fetchAll(`/workspaces/${scope}/projects/${projectId}/states/`);
+    return states.map((s) => ({ value: s.name, label: `${s.name} (${s.group})` }));
+  }
+  async removeLabel(issueId, labelName) {
+    const { workspaceSlug, projectId, issueId: planeIssueId } = parseIssueId(issueId);
+    const issue = await planeGet(
+      `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/${planeIssueId}/`
+    );
+    const labels = await fetchLabels(workspaceSlug, projectId);
+    const labelObj = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+    if (!labelObj || !issue.labels.includes(labelObj.id)) return;
+    const updatedLabels = issue.labels.filter((lid) => lid !== labelObj.id);
+    await planePatch(
+      `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/${planeIssueId}/`,
+      { labels: updatedLabels }
+    );
+  }
+  async createIssue(opts, config) {
+    const workspaceSlug = config.scope;
+    const projectId = await resolveProjectId(workspaceSlug, config.project);
+    const stateId = await resolveStateId(workspaceSlug, projectId, opts.status);
+    const labelNames = Array.isArray(opts.label) ? opts.label : [opts.label];
+    const labelIds = await Promise.all(
+      labelNames.map((name) => resolveLabelId(workspaceSlug, projectId, name))
+    );
+    const body = {
+      name: opts.title,
+      description_html: `<p>${escapeHtml(opts.description)}</p>`,
+      state: stateId,
+      label_ids: labelIds
+    };
+    if (opts.order !== void 0) body.priority = opts.order;
+    if (opts.parentId) {
+      const parent = parseIssueId(opts.parentId);
+      body.parent = parent.issueId;
+    }
+    const issue = await planePost(
+      `/workspaces/${workspaceSlug}/projects/${projectId}/work-items/`,
+      body
+    );
+    return makeIssueId(workspaceSlug, projectId, issue.id);
+  }
+};
+
+// src/sources/shortcut.ts
+function getAuthHeaders3() {
+  const token = process.env.SHORTCUT_API_TOKEN;
+  if (!token) throw new Error("SHORTCUT_API_TOKEN must be set");
+  return { "Shortcut-Token": token };
+}
+var _api3 = null;
+function api3() {
+  if (!_api3) _api3 = createApiClient("https://api.app.shortcut.com", getAuthHeaders3, "Shortcut");
+  return _api3;
+}
+function shortcutGet(path) {
+  return api3().get(path);
+}
+function shortcutPost(path, body) {
+  return api3().post(path, body);
+}
+function shortcutPut(path, body) {
+  return api3().put(path, body);
+}
+function extractStories(result) {
+  if (Array.isArray(result)) return result;
+  return result.data ?? [];
+}
+function extractNext(result) {
+  if (Array.isArray(result)) return null;
+  return result.next ?? null;
+}
+async function searchStoriesAll(body) {
+  const all = [];
+  let next = null;
+  do {
+    const req = next ? { ...body, next } : body;
+    const result = await shortcutPost(
+      "/api/v3/stories/search",
+      req
+    );
+    all.push(...extractStories(result));
+    next = extractNext(result);
+  } while (next);
+  return all;
+}
+async function resolveWorkflowStateId(stateName) {
+  const workflows = await shortcutGet("/api/v3/workflows");
+  for (const workflow of workflows) {
+    const state = workflow.states.find((s) => s.name.toLowerCase() === stateName.toLowerCase());
+    if (state) return state.id;
+  }
+  const allStates = workflows.flatMap((w) => w.states.map((s) => s.name));
+  throw new Error(
+    `Shortcut workflow state "${stateName}" not found. Available: ${allStates.join(", ")}`
+  );
+}
+async function resolveAllWorkflowStateIds(stateName) {
+  const workflows = await shortcutGet("/api/v3/workflows");
+  const ids = [];
+  for (const workflow of workflows) {
+    for (const state of workflow.states) {
+      if (state.name.toLowerCase() === stateName.toLowerCase()) {
+        ids.push(state.id);
+      }
+    }
+  }
+  if (ids.length === 0) {
+    const allStates = workflows.flatMap((w) => w.states.map((s) => s.name));
+    throw new Error(
+      `Shortcut workflow state "${stateName}" not found. Available: ${allStates.join(", ")}`
+    );
+  }
+  return ids;
+}
+async function resolveLabelId2(labelName) {
+  const labels = await shortcutGet("/api/v3/labels");
+  const label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase() && !l.archived);
+  if (!label) {
+    const available = labels.filter((l) => !l.archived).map((l) => l.name).join(", ");
+    throw new Error(`Shortcut label "${labelName}" not found. Available: ${available}`);
+  }
+  return label.id;
+}
+function priorityRank3(priority) {
+  if (priority === null) return Number.MAX_SAFE_INTEGER;
+  return priority;
+}
+var ShortcutSource = class {
+  name = "shortcut";
+  async fetchNextIssue(config) {
+    const stateIds = await resolveAllWorkflowStateIds(config.pick_from);
+    const labelNames = normalizeLabels(config);
+    const primaryLabel = labelNames[0] ?? "";
+    const labelIds = await Promise.all(labelNames.map((name) => resolveLabelId2(name)));
+    const workflows = await shortcutGet("/api/v3/workflows");
+    const doneStateIds = /* @__PURE__ */ new Set();
+    for (const workflow of workflows) {
+      for (const state of workflow.states) {
+        if (state.type === "done") {
+          doneStateIds.add(state.id);
+        }
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const allStories = [];
+    for (const stateId of stateIds) {
+      for (const story2 of await searchStoriesAll({
+        workflow_state_id: stateId,
+        label_name: primaryLabel,
+        archived: false
+      })) {
+        if (!seen.has(story2.id)) {
+          seen.add(story2.id);
+          allStories.push(story2);
+        }
+      }
+    }
+    const stories = labelIds.length > 1 ? allStories.filter((s) => labelIds.every((lid) => s.label_ids.includes(lid))) : allStories;
+    if (stories.length === 0) return null;
+    const unblocked = [];
+    const blocked = [];
+    for (const story2 of stories) {
+      const storyLinks = story2.story_links ?? [];
+      const blockerIds = storyLinks.filter((link) => link.verb === "blocks" && link.object_id === story2.id).map((link) => link.subject_id);
+      const activeBlockers = [];
+      for (const blockerId of blockerIds) {
+        try {
+          const blocker = await shortcutGet(`/api/v3/stories/${blockerId}`);
+          if (!doneStateIds.has(blocker.workflow_state_id)) {
+            activeBlockers.push(blockerId);
+          }
+        } catch (err) {
+          warn(`Could not fetch blocker ${blockerId}: ${formatError(err)}`);
+          activeBlockers.push(blockerId);
+        }
+      }
+      if (activeBlockers.length === 0) {
+        unblocked.push(story2);
+      } else {
+        blocked.push({ id: story2.id, name: story2.name, blockers: activeBlockers });
+      }
+    }
+    if (unblocked.length === 0) {
+      if (blocked.length > 0) {
+        warn("No unblocked issues found. Blocked issues:");
+        for (const entry of blocked) {
+          warn(
+            `  #${entry.id} (${entry.name}) \u2014 blocked by: ${entry.blockers.map((b) => `#${b}`).join(", ")}`
+          );
+        }
+      }
+      return null;
+    }
+    const sorted = [...unblocked].sort((a, b) => {
+      const pa = priorityRank3(a.priority);
+      const pb = priorityRank3(b.priority);
+      if (pa !== pb) return pa - pb;
+      return a.position - b.position;
+    });
+    const story = sorted[0];
+    if (!story) return null;
+    return {
+      id: String(story.id),
+      title: story.name,
+      description: story.description ?? "",
+      url: story.app_url
+    };
+  }
+  async fetchIssueById(id) {
+    const storyId = parseShortcutIdentifier(id);
+    try {
+      const story = await shortcutGet(`/api/v3/stories/${storyId}`);
+      let stateName;
+      try {
+        const workflows = await shortcutGet("/api/v3/workflows");
+        for (const workflow of workflows) {
+          const state = workflow.states.find((s) => s.id === story.workflow_state_id);
+          if (state) {
+            stateName = state.name;
+            break;
+          }
+        }
+      } catch {
+      }
+      return {
+        id: String(story.id),
+        title: story.name,
+        description: story.description ?? "",
+        url: story.app_url,
+        status: stateName
+      };
+    } catch {
+      return null;
+    }
+  }
+  async updateStatus(storyId, stateName) {
+    const stateId = await resolveWorkflowStateId(stateName);
+    await shortcutPut(`/api/v3/stories/${storyId}`, {
+      workflow_state_id: stateId
+    });
+  }
+  async attachPullRequest(storyId, prUrl) {
+    await shortcutPost(`/api/v3/stories/${storyId}/comments`, {
+      text: `Pull request: ${prUrl}`
+    });
+  }
+  async completeIssue(storyId, stateName, labelToRemove) {
+    await this.updateStatus(storyId, stateName);
+    if (labelToRemove) {
+      await this.removeLabel(storyId, labelToRemove);
+    }
+  }
+  async listIssues(config) {
+    const stateIds = await resolveAllWorkflowStateIds(config.pick_from);
+    const labelNames = normalizeLabels(config);
+    const primaryLabel = labelNames[0] ?? "";
+    const labelIds = await Promise.all(labelNames.map((name) => resolveLabelId2(name)));
+    const seen = /* @__PURE__ */ new Set();
+    const allStories = [];
+    for (const stateId of stateIds) {
+      for (const story of await searchStoriesAll({
+        workflow_state_id: stateId,
+        label_name: primaryLabel,
+        archived: false
+      })) {
+        if (!seen.has(story.id)) {
+          seen.add(story.id);
+          allStories.push(story);
+        }
+      }
+    }
+    const stories = labelIds.length > 1 ? allStories.filter((s) => labelIds.every((lid) => s.label_ids.includes(lid))) : allStories;
+    return stories.map((story) => ({
+      id: String(story.id),
+      title: story.name,
+      description: story.description ?? "",
+      url: story.app_url
+    }));
+  }
+  async listStatuses() {
+    const workflows = await shortcutGet("/api/v3/workflows");
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const workflow of workflows) {
+      for (const state of workflow.states) {
+        if (!seen.has(state.name)) {
+          seen.add(state.name);
+          result.push({ value: state.name, label: `${state.name} (${state.type})` });
+        }
+      }
+    }
+    return result;
+  }
+  async removeLabel(storyId, labelName) {
+    const story = await shortcutGet(`/api/v3/stories/${storyId}`);
+    const allLabels = await shortcutGet("/api/v3/labels");
+    const labelToRemove = allLabels.find(
+      (l) => l.name.toLowerCase() === labelName.toLowerCase() && !l.archived
+    );
+    if (!labelToRemove || !story.label_ids.includes(labelToRemove.id)) return;
+    const remainingIds = story.label_ids.filter((lid) => lid !== labelToRemove.id);
+    const labelNames = remainingIds.map((lid) => allLabels.find((l) => l.id === lid)).filter((l) => l !== void 0).map((l) => ({ name: l.name }));
+    await shortcutPut(`/api/v3/stories/${storyId}`, {
+      labels: labelNames
+    });
+  }
+  async createIssue(opts, _config) {
+    const stateId = await resolveWorkflowStateId(opts.status);
+    const labelNames = Array.isArray(opts.label) ? opts.label : [opts.label];
+    const body = {
+      name: opts.title,
+      description: opts.description,
+      workflow_state_id: stateId,
+      labels: labelNames.map((name) => ({ name }))
+    };
+    if (opts.parentId) body.epic_id = Number(opts.parentId);
+    const story = await shortcutPost("/api/v3/stories", body);
+    return String(story.id);
+  }
+  async linkDependency(issueId, dependsOnId) {
+    await shortcutPost("/api/v3/story-links", {
+      subject_id: Number(dependsOnId),
+      object_id: Number(issueId),
+      verb: "blocks"
+    });
+  }
+};
+function parseShortcutIdentifier(input) {
+  const urlMatch = input.match(/\/story\/(\d+)/);
+  if (urlMatch?.[1]) return urlMatch[1];
+  return input;
+}
+
+// src/sources/trello.ts
+var API_URL2 = "https://api.trello.com/1";
+function getAuthHeaders4() {
+  const key = process.env.TRELLO_API_KEY;
+  const token = process.env.TRELLO_TOKEN;
+  if (!key || !token) throw new Error("TRELLO_API_KEY and TRELLO_TOKEN must be set");
+  return {
+    Authorization: `OAuth oauth_consumer_key="${key}", oauth_token="${token}"`
+  };
+}
+async function trelloFetch(method, path, params = "") {
+  const sep = params ? "?" : "";
+  const url = `${API_URL2}${path}${sep}${params}`;
+  const res = await fetch(url, {
+    method,
+    headers: getAuthHeaders4(),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Trello API error (${res.status}): ${text}`);
+  }
+  if (method === "DELETE") return void 0;
+  return await res.json();
+}
+async function trelloGet(path, params = "") {
+  return trelloFetch("GET", path, params);
+}
+async function trelloPut(path, params = "") {
+  return trelloFetch("PUT", path, params);
+}
+async function trelloPost(path, params = "") {
+  return trelloFetch("POST", path, params);
+}
+async function trelloDelete(path) {
+  await trelloFetch("DELETE", path);
+}
+async function findBoardByName(name) {
+  const boards = await trelloGet("/members/me/boards", "fields=name");
+  const board = boards.find((b) => b.name.toLowerCase() === name.toLowerCase());
+  if (!board) throw new Error(`Trello board "${name}" not found`);
+  return board;
+}
+async function findListByName(boardId, name) {
+  const lists = await trelloGet(`/boards/${boardId}/lists`, "fields=name");
+  const list = lists.find((l) => l.name.toLowerCase() === name.toLowerCase());
+  if (!list) {
+    const available = lists.map((l) => l.name).join(", ");
+    throw new Error(`Trello list "${name}" not found. Available: ${available}`);
+  }
+  return list;
+}
+async function findLabelByName(boardId, name) {
+  const labels = await trelloGet(`/boards/${boardId}/labels`, "fields=name");
+  const label = labels.find((l) => l.name.toLowerCase() === name.toLowerCase());
+  if (!label) throw new Error(`Trello label "${name}" not found`);
+  return label;
+}
+var TrelloSource = class {
+  name = "trello";
+  async fetchNextIssue(config) {
+    const board = await findBoardByName(config.scope);
+    const list = await findListByName(board.id, config.pick_from);
+    const labelIds = await Promise.all(
+      normalizeLabels(config).map((name) => findLabelByName(board.id, name).then((l) => l.id))
+    );
+    const cards = await trelloGet(
+      `/lists/${list.id}/cards`,
+      "fields=name,desc,url,idLabels,idList"
+    );
+    const matching = cards.filter((c) => labelIds.every((lid) => c.idLabels.includes(lid)));
+    if (matching.length === 0) return null;
+    const card = matching[0];
+    if (!card) return null;
+    return {
+      id: card.id,
+      title: card.name,
+      description: card.desc || "",
+      url: card.url
+    };
+  }
+  async fetchIssueById(id) {
+    const shortLink = parseTrelloIdentifier(id);
+    try {
+      const card = await trelloGet(
+        `/cards/${shortLink}`,
+        "fields=name,desc,url,idLabels,idList&list=true&list_fields=name"
+      );
+      return {
+        id: card.id,
+        title: card.name,
+        description: card.desc || "",
+        url: card.url,
+        status: card.list?.name
+      };
+    } catch {
+      return null;
+    }
+  }
+  async updateStatus(cardId, listName) {
+    const card = await trelloGet(`/cards/${cardId}`, "fields=idBoard");
+    const list = await findListByName(card.idBoard, listName);
+    await trelloPut(`/cards/${cardId}`, `idList=${list.id}`);
+  }
+  async attachPullRequest(cardId, prUrl) {
+    await trelloPost(`/cards/${cardId}/attachments`, `url=${encodeURIComponent(prUrl)}`);
+  }
+  async completeIssue(cardId, listName, labelToRemove) {
+    await this.updateStatus(cardId, listName);
+    if (labelToRemove) {
+      await this.removeLabel(cardId, labelToRemove);
+    }
+  }
+  async listIssues(config) {
+    const board = await findBoardByName(config.scope);
+    const list = await findListByName(board.id, config.pick_from);
+    const labelIds = await Promise.all(
+      normalizeLabels(config).map((name) => findLabelByName(board.id, name).then((l) => l.id))
+    );
+    const cards = await trelloGet(
+      `/lists/${list.id}/cards`,
+      "fields=name,desc,url,idLabels,idList"
+    );
+    return cards.filter((c) => labelIds.every((lid) => c.idLabels.includes(lid))).map((c) => ({
+      id: c.id,
+      title: c.name,
+      description: c.desc || "",
+      url: c.url
+    }));
+  }
+  async listScopes() {
+    const boards = await trelloGet("/members/me/boards", "fields=name");
+    return boards.map((b) => ({ value: b.name, label: b.name }));
+  }
+  async listLabels(scope) {
+    const board = await findBoardByName(scope);
+    const labels = await trelloGet(`/boards/${board.id}/labels`, "fields=name");
+    return labels.filter((l) => l.name.length > 0).map((l) => ({ value: l.name, label: l.name }));
+  }
+  async listStatuses(scope) {
+    const board = await findBoardByName(scope);
+    const lists = await trelloGet(`/boards/${board.id}/lists`, "fields=name");
+    return lists.map((l) => ({ value: l.name, label: l.name }));
+  }
+  async removeLabel(cardId, labelName) {
+    const card = await trelloGet(
+      `/cards/${cardId}`,
+      "fields=idBoard,idLabels"
+    );
+    const label = await findLabelByName(card.idBoard, labelName);
+    if (!card.idLabels.includes(label.id)) return;
+    await trelloDelete(`/cards/${cardId}/idLabels/${label.id}`);
+  }
+  async createIssue(opts, config) {
+    const board = await findBoardByName(config.scope);
+    const list = await findListByName(board.id, opts.status);
+    const labelNames = Array.isArray(opts.label) ? opts.label : [opts.label];
+    const labelIds = await Promise.all(
+      labelNames.map((name) => findLabelByName(board.id, name).then((l) => l.id))
+    );
+    const params = [
+      `idList=${list.id}`,
+      `name=${encodeURIComponent(opts.title)}`,
+      `desc=${encodeURIComponent(opts.description)}`,
+      `pos=${opts.order ?? "bottom"}`,
+      ...labelIds.map((id) => `idLabels=${id}`)
+    ].join("&");
+    const card = await trelloPost("/cards", params);
+    return card.id;
+  }
+};
+function parseTrelloIdentifier(input) {
+  const urlMatch = input.match(/\/c\/([a-zA-Z0-9]+)/);
+  if (urlMatch?.[1]) return urlMatch[1];
+  return input;
+}
+
+// src/sources/index.ts
+var sources = {
+  linear: () => new LinearSource(),
+  trello: () => new TrelloSource(),
+  plane: () => new PlaneSource(),
+  shortcut: () => new ShortcutSource(),
+  "gitlab-issues": () => new GitLabIssuesSource(),
+  "github-issues": () => new GitHubIssuesSource(),
+  jira: () => new JiraSource()
+};
+function createSource(name) {
+  const factory = sources[name];
+  if (!factory) {
+    throw new Error(`Unknown source: ${name}. Available: ${Object.keys(sources).join(", ")}`);
+  }
+  return factory();
+}
+
+// src/loop/models.ts
+var WATCH_POLL_INTERVAL_MS = 6e4;
+function resolveModels(config) {
+  const providerModels = config.provider_options?.[config.provider]?.models;
+  if (!providerModels || providerModels.length === 0) {
+    return [{ provider: config.provider }];
+  }
+  const knownProviders = /* @__PURE__ */ new Set([
+    "claude",
+    "gemini",
+    "opencode",
+    "copilot",
+    "cursor",
+    "goose",
+    "aider",
+    "codex"
+  ]);
+  for (const m of providerModels) {
+    if (knownProviders.has(m) && m !== config.provider) {
+      warn(
+        `Model "${m}" looks like a provider name but provider is "${config.provider}". Since v1.4.0, "models" lists model names within the configured provider, not provider names. Update your .lisa/config.yaml.`
+      );
+    }
+  }
+  for (const m of providerModels) {
+    if (m.includes("/") && m.startsWith(`${config.provider}/`)) {
+      warn(
+        `Model "${m}" starts with the provider name "${config.provider}/". Most provider CLIs expect just the model name (e.g. "${m.slice(config.provider.length + 1)}"). If the provider fails silently, try removing the "${config.provider}/" prefix.`
+      );
+    }
+  }
+  if (config.provider === "cursor") {
+    const hasAuto = providerModels.some((m) => m.toLowerCase() === "auto");
+    if (!hasAuto) {
+      warn(
+        "Cursor Free plan detected (or model not set to 'auto'). Forcing 'auto' model. Set model to 'auto' explicitly in .lisa/config.yaml to silence this warning."
+      );
+      return [{ provider: config.provider, model: "auto" }];
+    }
+  }
+  return providerModels.map((m) => ({
+    provider: config.provider,
+    model: m === config.provider ? void 0 : m
+  }));
+}
+
+// src/session/context-manager.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+function getContextPath(dir) {
+  return join3(dir, ".lisa", "context.md");
+}
+function contextExists(dir) {
+  return existsSync(getContextPath(dir));
+}
+function readContext(dir) {
+  const path = getContextPath(dir);
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// src/session/proof-of-work.ts
+import { spawn as spawn3 } from "child_process";
+var DEFAULT_TIMEOUT = 12e4;
+function runValidationCommand(cmd, cwd, timeoutMs) {
+  const start = Date.now();
+  return new Promise((resolve2) => {
+    const proc = spawn3("sh", ["-c", cmd.run], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let output = "";
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+      }, 1e3);
+    }, timeoutMs);
+    proc.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      const duration = Date.now() - start;
+      if (killed) {
+        resolve2({
+          name: cmd.name,
+          success: false,
+          output: `${output}
+[lisa-validation] Command timed out after ${timeoutMs}ms`,
+          duration
+        });
+      } else {
+        resolve2({ name: cmd.name, success: code === 0, output, duration });
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      resolve2({
+        name: cmd.name,
+        success: false,
+        output: `Spawn error: ${err.message}`,
+        duration: Date.now() - start
+      });
+    });
+  });
+}
+async function runValidationCommands(commands, cwd, timeoutMs) {
+  const timeout = timeoutMs ?? DEFAULT_TIMEOUT;
+  const results = [];
+  for (const cmd of commands) {
+    log(`Validating: ${cmd.name} \u2014 ${cmd.run}`);
+    const result = await runValidationCommand(cmd, cwd, timeout);
+    results.push(result);
+    if (result.success) {
+      ok(`${cmd.name}: passed (${Math.round(result.duration / 1e3)}s)`);
+    } else {
+      error(`${cmd.name}: failed (${Math.round(result.duration / 1e3)}s)`);
+    }
+  }
+  return results;
+}
+function formatProofOfWork(results) {
+  const lines = ["", "---", "## Proof of Work", ""];
+  lines.push("| Check | Status | Duration |");
+  lines.push("|-------|--------|----------|");
+  for (const r of results) {
+    const status = r.success ? "Pass" : "Fail";
+    const duration = `${Math.round(r.duration / 1e3)}s`;
+    lines.push(`| ${r.name} | ${status} | ${duration} |`);
+  }
+  const failures = results.filter((r) => !r.success);
+  if (failures.length > 0) {
+    lines.push("");
+    for (const f of failures) {
+      const trimmed = f.output.trim().slice(-2e3);
+      lines.push(`<details><summary>${f.name} output</summary>`);
+      lines.push("");
+      lines.push("```");
+      lines.push(trimmed);
+      lines.push("```");
+      lines.push("");
+      lines.push("</details>");
+    }
+  }
+  return lines.join("\n");
+}
+function buildValidationRecoveryPrompt(issue, failures) {
+  const failureSections = failures.map((f) => {
+    const trimmed = f.output.trim().slice(-3e3);
+    return `### ${f.name}
+Command: \`${f.name}\`
+Output:
+\`\`\`
+${trimmed}
+\`\`\``;
+  }).join("\n\n");
+  return `You are continuing work on issue ${issue.id}: "${issue.title}".
+
+Your implementation has code changes but the following validation checks failed. Fix the issues, commit your changes, and push.
+
+${failureSections}
+
+IMPORTANT:
+- Do NOT create a new branch \u2014 you are already on the correct branch.
+- Fix ONLY the validation failures above.
+- Commit and push your fixes.
+- Do NOT create a PR \u2014 that will be handled separately.`;
+}
+function isProofOfWorkEnabled(config) {
+  return !!(config?.enabled && config.commands.length > 0);
+}
+
+// src/prompt.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5, resolve } from "path";
+
+// src/context.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join4, relative } from "path";
+var QUALITY_SCRIPT_NAMES = /* @__PURE__ */ new Set([
+  "lint",
+  "typecheck",
+  "check",
+  "format",
+  "test",
+  "build",
+  "ci"
+]);
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  ".worktrees",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".output",
+  "build",
+  ".cache",
+  ".turbo",
+  ".lisa"
+]);
+var CONFIG_FILE_PATTERNS = [
+  // ORM / migrations
+  "prisma/schema.prisma",
+  "drizzle.config.ts",
+  "drizzle.config.js",
+  "drizzle.config.mjs",
+  "data-source.ts",
+  "ormconfig.ts",
+  "ormconfig.js",
+  ".sequelizerc",
+  "alembic.ini",
+  "flyway.conf",
+  "liquibase.properties",
+  // API codegen
+  "orval.config.ts",
+  "orval.config.js",
+  "orval.config.mjs",
+  "kubb.config.ts",
+  "kubb.config.js",
+  "kubb.config.mjs",
+  "codegen.ts",
+  "codegen.js",
+  "codegen.yml",
+  "codegen.yaml",
+  "openapi-ts.config.ts",
+  "openapi-ts.config.js",
+  "openapi-ts.config.mjs",
+  "openapitools.json",
+  "swagger-codegen-config.json",
+  "buf.yaml",
+  "buf.gen.yaml",
+  // Linters / formatters
+  "biome.json",
+  "biome.jsonc",
+  ".eslintrc",
+  ".eslintrc.js",
+  ".eslintrc.cjs",
+  ".eslintrc.json",
+  ".eslintrc.yml",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.ts",
+  ".prettierrc",
+  ".prettierrc.json",
+  ".prettierrc.js",
+  "prettier.config.js",
+  // Language / project markers
+  "go.mod",
+  "Cargo.toml",
+  "Gemfile",
+  "pubspec.yaml",
+  "pyproject.toml",
+  "requirements.txt",
+  "composer.json",
+  "Makefile",
+  "justfile"
+];
+function detectConfigFiles(cwd) {
+  return CONFIG_FILE_PATTERNS.filter((pattern) => {
+    const parts = pattern.split("/");
+    if (parts.length === 2) {
+      return existsSync2(join4(cwd, parts[0], parts[1]));
+    }
+    return existsSync2(join4(cwd, pattern));
+  });
+}
+function analyzeProject(cwd) {
+  return {
+    qualityScripts: detectQualityScripts(cwd),
+    testPattern: detectTestPattern(cwd),
+    projectTree: generateProjectTree(cwd),
+    environment: detectEnvironment(cwd),
+    configFiles: detectConfigFiles(cwd)
+  };
+}
+var CLI_DEPS = [
+  "ink",
+  "citty",
+  "commander",
+  "yargs",
+  "oclif",
+  "meow",
+  "cleye",
+  "cac",
+  "minimist",
+  "caporal"
+];
+var MOBILE_DEPS = ["react-native", "expo", "@react-native", "@expo"];
+var WEB_DEPS = [
+  "react-dom",
+  "next",
+  "vue",
+  "nuxt",
+  "@angular/core",
+  "svelte",
+  "gatsby",
+  "remix",
+  "astro",
+  "@remix-run/react"
+];
+var SERVER_DEPS = ["express", "fastify", "koa", "@hapi/hapi", "@nestjs/core", "hono", "elysia"];
+function detectEnvironment(cwd) {
+  if (existsSync2(join4(cwd, "pubspec.yaml"))) return "mobile";
+  if (existsSync2(join4(cwd, "Cargo.toml"))) return "cli";
+  if (existsSync2(join4(cwd, "go.mod"))) return "server";
+  const packageJsonPath = join4(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) return "unknown";
+  try {
+    const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const depNames = Object.keys(deps);
+    if (pkg.bin || CLI_DEPS.some((d) => depNames.includes(d))) return "cli";
+    if (MOBILE_DEPS.some((d) => depNames.some((dep) => dep === d || dep.startsWith(`${d}/`))) || existsSync2(join4(cwd, "android")) || existsSync2(join4(cwd, "ios")))
+      return "mobile";
+    if (WEB_DEPS.some((d) => depNames.includes(d))) return "web";
+    if (SERVER_DEPS.some((d) => depNames.includes(d))) return "server";
+    return "library";
+  } catch {
+    return "unknown";
+  }
+}
+function detectQualityScripts(cwd) {
+  const packageJsonPath = join4(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) return [];
+  try {
+    const content = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    if (!content.scripts) return [];
+    const scripts = [];
+    for (const [name, command] of Object.entries(content.scripts)) {
+      if (QUALITY_SCRIPT_NAMES.has(name)) {
+        scripts.push({ name, command });
+      }
+    }
+    return scripts;
+  } catch {
+    return [];
+  }
+}
+function detectTestPattern(cwd) {
+  const testFiles = findTestFiles(cwd, 3);
+  if (testFiles.length === 0) return null;
+  const location = inferTestLocation(cwd, testFiles);
+  let style = "unknown";
+  const mocking = /* @__PURE__ */ new Set();
+  let example;
+  for (const file of testFiles) {
+    try {
+      const content = readFileSync2(file, "utf-8");
+      const fileStyle = inferTestStyle(content);
+      if (style === "unknown") {
+        style = fileStyle;
+      } else if (style !== fileStyle && fileStyle !== "unknown") {
+        style = "mixed";
+      }
+      for (const mock of inferMocking(content)) {
+        mocking.add(mock);
+      }
+      if (!example) {
+        example = extractTestExample(content, file, cwd);
+      }
+    } catch {
+    }
+  }
+  return {
+    location,
+    style,
+    mocking: [...mocking],
+    example
+  };
+}
+function generateProjectTree(cwd) {
+  const lines = [];
+  try {
+    const entries = readdirSync(cwd);
+    const filtered = entries.filter((e) => !IGNORED_DIRS.has(e) && !e.startsWith(".")).sort((a, b) => {
+      const aIsDir = isDirectory(join4(cwd, a));
+      const bIsDir = isDirectory(join4(cwd, b));
+      if (aIsDir && !bIsDir) return -1;
+      if (!aIsDir && bIsDir) return 1;
+      return a.localeCompare(b);
+    });
+    for (const entry of filtered) {
+      const fullPath = join4(cwd, entry);
+      if (isDirectory(fullPath)) {
+        lines.push(`${entry}/`);
+        try {
+          const children = readdirSync(fullPath);
+          const filteredChildren = children.filter((c) => !IGNORED_DIRS.has(c) && !c.startsWith(".")).sort().slice(0, 15);
+          for (const child of filteredChildren) {
+            const childPath = join4(fullPath, child);
+            const suffix = isDirectory(childPath) ? "/" : "";
+            lines.push(`  ${child}${suffix}`);
+          }
+          if (children.filter((c) => !IGNORED_DIRS.has(c) && !c.startsWith(".")).length > 15) {
+            lines.push("  ...");
+          }
+        } catch {
+        }
+      } else {
+        lines.push(entry);
+      }
+    }
+  } catch {
+    return "";
+  }
+  return lines.join("\n");
+}
+function formatProjectContext(ctx) {
+  const sections = [];
+  if (ctx.environment !== "unknown" && ctx.environment !== "library") {
+    const labels = {
+      cli: "CLI (Node.js)",
+      mobile: "Mobile (React Native / Flutter / native)",
+      web: "Web (browser)",
+      server: "Server-side (Node.js)",
+      library: "Library",
+      unknown: ""
+    };
+    sections.push(`### Project Environment
+
+**${labels[ctx.environment]}**`);
+  }
+  if (ctx.qualityScripts.length > 0) {
+    const scriptLines = ctx.qualityScripts.map((s) => `- \`${s.name}\`: \`${s.command}\``).join("\n");
+    sections.push(`### Quality Scripts
+
+${scriptLines}`);
+  }
+  if (ctx.configFiles.length > 0) {
+    const fileLines = ctx.configFiles.map((f) => `- \`${f}\``).join("\n");
+    sections.push(`### Config Files Detected
+
+${fileLines}`);
+  }
+  if (ctx.testPattern) {
+    const tp = ctx.testPattern;
+    const details = [
+      `- Location: ${tp.location === "colocated" ? "tests are colocated next to source files" : tp.location === "separate" ? "tests are in a separate directory" : "unknown"}`,
+      `- Style: ${tp.style === "describe-it" ? "describe/it blocks" : tp.style === "test" ? "top-level test() calls" : tp.style === "mixed" ? "mixed (describe/it and test())" : "unknown"}`
+    ];
+    if (tp.mocking.length > 0) {
+      details.push(`- Mocking: ${tp.mocking.join(", ")}`);
+    }
+    let block = `### Test Patterns
+
+${details.join("\n")}`;
+    if (tp.example) {
+      block += `
+
+**Reference test file:**
+\`\`\`typescript
+${tp.example}
+\`\`\``;
+    }
+    sections.push(block);
+  }
+  if (ctx.projectTree) {
+    sections.push(`### Project Structure
+
+\`\`\`
+${ctx.projectTree}
+\`\`\``);
+  }
+  if (sections.length === 0) return "";
+  return `## Project Context
+
+${sections.join("\n\n")}`;
+}
+function findTestFiles(cwd, maxFiles) {
+  const results = [];
+  walkForTests(cwd, cwd, results, maxFiles, 0);
+  return results;
+}
+function walkForTests(root, dir, results, maxFiles, depth) {
+  if (results.length >= maxFiles || depth > 5) return;
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (results.length >= maxFiles) return;
+      if (IGNORED_DIRS.has(entry)) continue;
+      const fullPath = join4(dir, entry);
+      if (isDirectory(fullPath)) {
+        walkForTests(root, fullPath, results, maxFiles, depth + 1);
+      } else if (entry.endsWith(".test.ts") || entry.endsWith(".spec.ts") || entry.endsWith(".test.tsx") || entry.endsWith(".spec.tsx") || entry.endsWith(".test.js") || entry.endsWith(".spec.js")) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+}
+function inferTestLocation(cwd, testFiles) {
+  let colocated = 0;
+  let separate = 0;
+  for (const file of testFiles) {
+    const rel = relative(cwd, file);
+    const parts = rel.split("/");
+    if (parts.some(
+      (p) => p === "__tests__" || p === "tests" || p === "test" || p === "spec" || p === "__specs__"
+    )) {
+      separate++;
+    } else {
+      colocated++;
+    }
+  }
+  if (colocated > 0 && separate === 0) return "colocated";
+  if (separate > 0 && colocated === 0) return "separate";
+  if (colocated > 0 && separate > 0) return "colocated";
+  return "unknown";
+}
+function inferTestStyle(content) {
+  const hasDescribe = /\bdescribe\s*\(/.test(content);
+  const hasIt = /\bit\s*\(/.test(content);
+  const hasTopLevelTest = /\btest\s*\(/.test(content);
+  if (hasDescribe && hasIt) return "describe-it";
+  if (hasTopLevelTest && !hasDescribe) return "test";
+  if (hasDescribe || hasIt) return "describe-it";
+  return "unknown";
+}
+function inferMocking(content) {
+  const mocks = [];
+  if (/\bvi\.(mock|fn|spyOn)\b/.test(content)) mocks.push("vi.mock/vi.fn");
+  if (/\bjest\.(mock|fn|spyOn)\b/.test(content)) mocks.push("jest.mock/jest.fn");
+  if (/\bfixture/.test(content)) mocks.push("fixtures");
+  return mocks;
+}
+function extractTestExample(content, filePath, cwd) {
+  const lines = content.split("\n");
+  const snippet = lines.slice(0, 30).join("\n").trim();
+  if (snippet.length < 10) return void 0;
+  const relPath = relative(cwd, filePath);
+  return `// ${relPath}
+${snippet}`;
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/git/bitbucket.ts
+import { execa } from "execa";
+var API_URL3 = "https://api.bitbucket.org/2.0";
+var REQUEST_TIMEOUT_MS2 = 3e4;
+var PROVIDER_DISPLAY_NAMES = {
+  claude: "Claude Code",
+  gemini: "Gemini CLI",
+  opencode: "OpenCode",
+  copilot: "GitHub Copilot CLI",
+  cursor: "Cursor Agent",
+  goose: "Goose",
+  aider: "Aider",
+  codex: "OpenAI Codex"
+};
+function formatProviderName(providerUsed) {
+  const providerKey = providerUsed.split("/")[0] ?? providerUsed;
+  return PROVIDER_DISPLAY_NAMES[providerKey] ?? providerKey;
+}
+function getAuthHeader() {
+  const token = process.env.BITBUCKET_TOKEN;
+  if (!token) throw new Error("BITBUCKET_TOKEN is not set");
+  return `Bearer ${token}`;
+}
+async function appendPrAttribution2(prUrl, providerUsed) {
+  try {
+    const match = prUrl.match(/bitbucket\.org\/([^/]+)\/([^/]+)\/pull-requests\/(\d+)/);
+    if (!match) return;
+    const [, workspace, repoSlug, prId] = match;
+    if (!process.env.BITBUCKET_TOKEN) return;
+    const authHeader = getAuthHeader();
+    const getRes = await fetch(
+      `${API_URL3}/repositories/${workspace}/${repoSlug}/pullrequests/${prId}`,
+      {
+        headers: { Authorization: authHeader },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+      }
+    );
+    if (!getRes.ok) return;
+    const prData = await getRes.json();
+    const currentDescription = prData.description ?? "";
+    const currentTitle = prData.title ?? "";
+    const providerName = formatProviderName(providerUsed);
+    const attribution = `
+
+---
+\u{1F916} Resolved by [lisa](https://github.com/tarcisiopgs/lisa) using **${providerName}**`;
+    const newDescription = stripProviderAttribution(currentDescription) + attribution;
+    await fetch(`${API_URL3}/repositories/${workspace}/${repoSlug}/pullrequests/${prId}`, {
+      method: "PUT",
+      headers: {
+        Authorization: authHeader,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ description: newDescription, title: currentTitle }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+  } catch {
+  }
+}
+async function appendPrBody2(prUrl, content) {
+  try {
+    const match = prUrl.match(/bitbucket\.org\/([^/]+)\/([^/]+)\/pull-requests\/(\d+)/);
+    if (!match) return;
+    const [, workspace, repoSlug, prId] = match;
+    if (!process.env.BITBUCKET_TOKEN) return;
+    const authHeader = getAuthHeader();
+    const getRes = await fetch(
+      `${API_URL3}/repositories/${workspace}/${repoSlug}/pullrequests/${prId}`,
+      {
+        headers: { Authorization: authHeader },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+      }
+    );
+    if (!getRes.ok) return;
+    const prData = await getRes.json();
+    const newDescription = (prData.description ?? "") + content;
+    await fetch(`${API_URL3}/repositories/${workspace}/${repoSlug}/pullrequests/${prId}`, {
+      method: "PUT",
+      headers: {
+        Authorization: authHeader,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ description: newDescription, title: prData.title ?? "" }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+  } catch {
+  }
+}
+
+// src/git/gitlab.ts
+import { execa as execa2 } from "execa";
+var REQUEST_TIMEOUT_MS3 = 3e4;
+var PROVIDER_DISPLAY_NAMES2 = {
+  claude: "Claude Code",
+  gemini: "Gemini CLI",
+  opencode: "OpenCode",
+  copilot: "GitHub Copilot CLI",
+  cursor: "Cursor Agent",
+  goose: "Goose",
+  aider: "Aider",
+  codex: "OpenAI Codex"
+};
+function formatProviderName2(providerUsed) {
+  const providerKey = providerUsed.split("/")[0] ?? providerUsed;
+  return PROVIDER_DISPLAY_NAMES2[providerKey] ?? providerKey;
+}
+function buildApiBase(host) {
+  return `https://${host}/api/v4`;
+}
+async function appendMrAttribution(mrUrl, providerUsed) {
+  try {
+    const match = mrUrl.match(/https?:\/\/([^/]+)\/(.+?)\/-\/merge_requests\/(\d+)/);
+    if (!match) return;
+    const [, host, projectPath, iidStr] = match;
+    const token = process.env.GITLAB_TOKEN;
+    if (!token) return;
+    const apiBase = buildApiBase(host ?? "gitlab.com");
+    const encodedPath = encodeURIComponent(projectPath ?? "");
+    const iid = iidStr;
+    const getRes = await fetch(`${apiBase}/projects/${encodedPath}/merge_requests/${iid}`, {
+      headers: { "PRIVATE-TOKEN": token },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+    });
+    if (!getRes.ok) return;
+    const mrData = await getRes.json();
+    const currentDescription = mrData.description ?? "";
+    const providerName = formatProviderName2(providerUsed);
+    const attribution = `
+
+---
+\u{1F916} Resolved by [lisa](https://github.com/tarcisiopgs/lisa) using **${providerName}**`;
+    const newDescription = stripProviderAttribution(currentDescription) + attribution;
+    await fetch(`${apiBase}/projects/${encodedPath}/merge_requests/${iid}`, {
+      method: "PUT",
+      headers: {
+        "PRIVATE-TOKEN": token,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ description: newDescription }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+    });
+  } catch {
+  }
+}
+async function appendMrBody(mrUrl, content) {
+  try {
+    const match = mrUrl.match(/https?:\/\/([^/]+)\/(.+?)\/-\/merge_requests\/(\d+)/);
+    if (!match) return;
+    const [, host, projectPath, iid] = match;
+    const token = process.env.GITLAB_TOKEN;
+    if (!token) return;
+    const apiBase = buildApiBase(host ?? "gitlab.com");
+    const encodedPath = encodeURIComponent(projectPath ?? "");
+    const getRes = await fetch(`${apiBase}/projects/${encodedPath}/merge_requests/${iid}`, {
+      headers: { "PRIVATE-TOKEN": token },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+    });
+    if (!getRes.ok) return;
+    const mrData = await getRes.json();
+    const newDescription = (mrData.description ?? "") + content;
+    await fetch(`${apiBase}/projects/${encodedPath}/merge_requests/${iid}`, {
+      method: "PUT",
+      headers: {
+        "PRIVATE-TOKEN": token,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ description: newDescription }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+    });
+  } catch {
+  }
+}
+
+// src/git/platform.ts
+async function appendPlatformAttribution(prUrl, providerUsed, platform2) {
+  if (platform2 === "gitlab") {
+    await appendMrAttribution(prUrl, providerUsed);
+  } else if (platform2 === "bitbucket") {
+    await appendPrAttribution2(prUrl, providerUsed);
+  } else {
+    await appendPrAttribution(prUrl, providerUsed);
+  }
+}
+async function appendPlatformProofOfWork(prUrl, results, platform2) {
+  const section = formatProofOfWork(results);
+  try {
+    if (platform2 === "gitlab") {
+      await appendMrBody(prUrl, section);
+    } else if (platform2 === "bitbucket") {
+      await appendPrBody2(prUrl, section);
+    } else {
+      await appendPrBody(prUrl, section);
+    }
+  } catch {
+  }
+}
+function buildPrCreateInstruction(platform2, targetBranch) {
+  const base = targetBranch ? ` --base ${targetBranch}` : "";
+  if (platform2 === "gitlab") {
+    const branchArg = targetBranch ? ` --target-branch ${targetBranch}` : "";
+    return `**Create MR**: Create a merge request on GitLab:
+   **Option A \u2014 glab CLI (if available):**
+   \`glab mr create --fill${branchArg} --yes\`
+
+   **Option B \u2014 curl with GITLAB_TOKEN:**
+   \`\`\`bash
+   GITLAB_PROJECT=$(git remote get-url origin | sed 's/.*gitlab\\.com[:/]//;s/\\.git$//' | python3 -c "import sys,urllib.parse; print(urllib.parse.quote(sys.stdin.read().strip(), safe=''))")
+   BRANCH=$(git branch --show-current)
+   curl --request POST \\
+     --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \\
+     --header "Content-Type: application/json" \\
+     --data "{\\"source_branch\\":\\"$BRANCH\\",\\"target_branch\\":\\"${targetBranch ?? "main"}\\",\\"title\\":\\"<conventional-commit-title>\\",\\"description\\":\\"<markdown-summary>\\"}" \\
+     "https://gitlab.com/api/v4/projects/$GITLAB_PROJECT/merge_requests"
+   \`\`\`
+   Capture the MR URL (\`web_url\`) from the output.`;
+  }
+  if (platform2 === "bitbucket") {
+    const dest = targetBranch ?? "main";
+    return `**Create PR**: Create a pull request on Bitbucket:
+   \`\`\`bash
+   WORKSPACE=$(git remote get-url origin | sed 's/.*bitbucket\\.org[:/]//;s/\\/.*$//')
+   REPO=$(git remote get-url origin | sed 's/.*bitbucket\\.org[:/][^/]*\\///;s/\\.git$//')
+   BRANCH=$(git branch --show-current)
+   curl -X POST \\
+     -H "Authorization: Basic $(printf '%s:%s' "$BITBUCKET_USERNAME" "$BITBUCKET_TOKEN" | base64)" \\
+     -H "Content-Type: application/json" \\
+     "https://api.bitbucket.org/2.0/repositories/$WORKSPACE/$REPO/pullrequests" \\
+     --data "{\\"title\\":\\"<conventional-commit-title>\\",\\"description\\":\\"<markdown-summary>\\",\\"source\\":{\\"branch\\":{\\"name\\":\\"$BRANCH\\"}},\\"destination\\":{\\"branch\\":{\\"name\\":\\"${dest}\\"}}}"
+   \`\`\`
+   Capture the PR URL (\`links.html.href\`) from the output.`;
+  }
+  return `**Create PR**: Create a pull request using the GitHub CLI:
+   \`gh pr create --title "<conventional-commit-title>" --body "<markdown-summary>"${base}\`
+   Capture the PR URL from the output.`;
+}
+
+// src/prompt.ts
+function detectPackageManager(cwd) {
+  if (existsSync3(join5(cwd, "bun.lockb")) || existsSync3(join5(cwd, "bun.lock"))) return "bun";
+  if (existsSync3(join5(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join5(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function detectTestRunner(cwd) {
+  const packageJsonPath = join5(cwd, "package.json");
+  if (!existsSync3(packageJsonPath)) return null;
+  try {
+    const content = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+    const deps = { ...content.dependencies, ...content.devDependencies };
+    if ("vitest" in deps) return "vitest";
+    if ("jest" in deps) return "jest";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function extractReadmeHeadings(cwd) {
+  const readmePath = join5(cwd, "README.md");
+  if (!existsSync3(readmePath)) return [];
+  try {
+    const content = readFileSync3(readmePath, "utf-8");
+    return content.split("\n").filter((line) => /^#{1,6}\s/.test(line)).map((line) => line.trim());
+  } catch {
+    return [];
+  }
+}
+function buildPrompt(opts) {
+  const {
+    issue,
+    variant,
+    testRunner,
+    pm,
+    baseBranch,
+    projectContext,
+    cwd,
+    platform: platform2 = "cli",
+    repoContextMd,
+    config,
+    step,
+    previousResults = [],
+    isLastStep = false
+  } = opts;
+  let manifestPath = opts.manifestPath;
+  if (!manifestPath && variant === "branch" && config) {
+    manifestPath = getManifestPath(resolve(config.workspace));
+  }
+  const testBlock = buildTestInstructions(testRunner ?? null, pm);
+  const headings = cwd ? extractReadmeHeadings(cwd) : [];
+  const readmeBlock = buildReadmeInstructions(headings);
+  const hookBlock = buildPreCommitHookInstructions();
+  const contextBlock = projectContext ? formatProjectContext(projectContext) : "";
+  const depBlock = issue.dependency ? buildDependencyContext(issue.dependency) : "";
+  const specWarningBlock = buildSpecWarningBlock(issue.specWarning);
+  const contextMdBlock = buildContextMdBlock(repoContextMd ?? null);
+  const prBase = issue.dependency ? issue.dependency.branch : baseBranch;
+  const prCreateBlock = buildPrCreateInstruction(platform2, prBase);
+  const manifestLocation = manifestPath ? `\`${manifestPath}\`` : "`.lisa/manifests/default.json` in the **current directory**";
+  let preamble = "You are an autonomous implementation agent. You MUST complete ALL steps below \u2014 implementation, commit, push, PR creation, and manifest file \u2014 before finishing.\nDo NOT stop after implementing code. The task is NOT complete until the manifest file is written with the PR URL.\nDo NOT use interactive skills, ask clarifying questions, or wait for user input. You are running unattended. No human will see your output or respond to questions.";
+  if (variant === "scoped") {
+  } else {
+    preamble += " If the issue is too ambiguous to implement, you MUST STOP and provide a clear explanation.";
+  }
+  let workContext = "";
+  if (variant === "worktree") {
+    workContext = `
+You are already inside the correct repository worktree on the correct branch.
+Do NOT create a new branch \u2014 just work on the current one.
+${cwd ? `
+**Working directory:** \`${cwd}\`
+All file paths are relative to this directory. Use this as the base for any absolute paths.
+` : ""}`;
+  } else if (variant === "native-worktree" || variant === "scoped") {
+    workContext = `
+You are working inside a git worktree that was automatically created for this task.
+Work on the current branch \u2014 it was created for you.
+${cwd ? `
+**Working directory:** \`${cwd}\`
+All file paths are relative to this directory. Use this as the base for any absolute paths.
+` : ""}`;
+  }
+  let scopeSection = "";
+  if (variant === "scoped" && step) {
+    const previousBlock = previousResults.length > 0 ? `
+## Previous Steps
+
+The following repos have already been implemented as part of this issue:
+
+${previousResults.map((r) => `- **${r.repoPath}**: branch \`${r.branch}\`${r.prUrl ? ` \u2014 PR: ${r.prUrl}` : ""}`).join("\n")}
+
+Use this context if the current step depends on changes from previous steps.
+` : "";
+    scopeSection = `
+## Your Scope
+
+You are responsible for **this specific part** of the issue:
+
+> ${step.scope}
+
+Focus only on this scope. Do NOT implement changes outside this scope.
+${previousBlock}`;
+  }
+  let instructions = "";
+  if (variant === "branch" && config) {
+    const workspace = resolve(config.workspace);
+    const repoEntries = config.repos.map(
+      (r) => `   - If it says "Repo: ${r.name}" or title starts with "${r.match}" \u2192 \`${resolve(workspace, r.path)}\` (base branch: \`${r.base_branch}\`)`
+    ).join("\n");
+    const baseBranchInstruction = issue.dependency ? `From \`${issue.dependency.branch}\` (dependency branch)` : config.repos.length > 0 ? "From the repo's base branch (listed above)" : `From \`${baseBranch}\``;
+    instructions = `## Instructions
+
+1. **Identify the repo**: Look at the issue description for relevant files or repo references.
+${repoEntries}
+   - If it references multiple repos, pick the PRIMARY one (the one with the most files listed).
+
+2. **Create a branch**: ${baseBranchInstruction}, create a branch with an **English** slug:
+   \`feat/${issue.id.toLowerCase()}-short-english-description\`
+   The description MUST be in English \u2014 translate or summarize the issue title if it's in another language.
+   Example: "Implementar rate limiting na API" \u2192 \`feat/${issue.id.toLowerCase()}-add-rate-limiting-to-api\`
+
+3. **Implement**: Follow the issue description exactly:
+   - Read all relevant files listed in the description first (if present)
+   - Follow the implementation instructions exactly
+   - Verify each acceptance criteria (if present)
+   - Respect any stack or technical constraints (if present)
+${testBlock}${hookBlock}
+4. **Validate**: Run the project's linter/typecheck/tests if available:
+   - Check \`package.json\` (or equivalent) for lint, typecheck, check, or test scripts.
+   - Run whichever validation scripts exist (e.g., \`npm run lint\`, \`npm run typecheck\`).
+   - Fix any errors before proceeding.
+${readmeBlock}
+**CRITICAL \u2014 Do NOT stop here. The following steps (commit, push, PR, manifest) are MANDATORY. Skipping them means the task has FAILED.**
+
+5. **Commit & Push**: Make atomic commits with conventional commit messages.
+   Push the branch to origin:
+   \`git push -u origin <branch-name>\`
+   If the push fails due to a pre-push hook, read the error, fix the root cause, amend the commit, and retry. Do NOT use \`--no-verify\`.
+   **IMPORTANT \u2014 Language rules:**
+   - All commit messages MUST be in English.
+   - Use conventional commits format: \`feat: ...\`, \`fix: ...\`, \`refactor: ...\`, \`chore: ...\`
+
+6. ${prCreateBlock}
+
+7. **Update tracker**: Call the lisa CLI to mark the issue as done:
+   \`lisa issue done ${issue.id} --pr-url <pr-url>\`
+   Wait 1 second before calling this command.
+
+8. **Write manifest**: Before finishing, create \`${manifestPath ?? getManifestPath(resolve(config.workspace))}\` with JSON:
+   \`\`\`json
+   {"repoPath": "<absolute path to this repo>", "branch": "<branch name>", "prUrl": "<pull request URL>"}
+   \`\`\`
+   Do NOT commit this file.`;
+  } else if (variant === "scoped") {
+    const trackerStep = isLastStep ? `
+6. **Update tracker**: Call \`lisa issue done ${issue.id} --pr-url <pr-url>\` (wait 1 second before calling).
+` : `
+6. **Skip tracker update**: This is not the last step. The caller handles the tracker update after all steps complete.
+`;
+    instructions = `## Instructions
+
+1. **Implement**: Follow the scope above. Read the full issue description for context, but only implement what is described in "Your Scope":
+   - Read all relevant files first
+   - Follow the implementation instructions exactly
+   - Verify each acceptance criteria relevant to your scope
+${testBlock}${hookBlock}
+2. **Validate**: Run the project's linter/typecheck/tests if available:
+   - Check \`package.json\` (or equivalent) for lint, typecheck, check, or test scripts.
+   - Run whichever validation scripts exist (e.g., \`npm run lint\`, \`npm run typecheck\`).
+   - Fix any errors before proceeding.
+${readmeBlock}
+**CRITICAL \u2014 Do NOT stop here. The following steps (commit, push, PR, manifest) are MANDATORY. Skipping them means the task has FAILED.**
+
+3. **Commit**: Make atomic commits with conventional commit messages.
+   **Branch name must be in English.** If the current branch name contains non-English words,
+   rename it: \`git branch -m <current-name> feat/${issue.id.toLowerCase()}-short-english-slug\`
+   **IMPORTANT \u2014 Language rules:**
+   - All commit messages MUST be in English.
+   - Use conventional commits format: \`feat: ...\`, \`fix: ...\`, \`refactor: ...\`, \`chore: ...\`
+
+4. **Push**: Push the branch to origin:
+   \`git push -u origin <branch-name>\`
+   If the push fails due to a pre-push hook, read the error, fix the root cause, amend the commit, and retry. Do NOT use \`--no-verify\`.
+
+5. ${prCreateBlock}
+${trackerStep}
+7. **Write manifest**: Create ${manifestLocation} with JSON:
+   \`\`\`json
+   {"branch": "<final English branch name>", "prUrl": "<pull request URL>"}
+   \`\`\`
+   Do NOT commit this file.`;
+  } else {
+    const branchRenameInstruction = variant === "worktree" ? `   rename it before committing using the single-argument form:
+   \`git branch -m feat/${issue.id.toLowerCase()}-short-english-slug\`` : `   rename it: \`git branch -m <current-name> feat/${issue.id.toLowerCase()}-short-english-slug\``;
+    instructions = `## Instructions
+
+1. **Implement**: Follow the issue description exactly:
+   - Read all relevant files listed in the description first (if present)
+   - Follow the implementation instructions exactly
+   - Verify each acceptance criteria (if present)
+   - Respect any stack or technical constraints (if present)
+${testBlock}${hookBlock}
+2. **Validate**: Run the project's linter/typecheck/tests if available:
+   - Check \`package.json\` (or equivalent) for lint, typecheck, check, or test scripts.
+   - Run whichever validation scripts exist (e.g., \`npm run lint\`, \`npm run typecheck\`).
+   - Fix any errors before proceeding.
+${readmeBlock}
+**CRITICAL \u2014 Do NOT stop here. The following steps (commit, push, PR, manifest) are MANDATORY. Skipping them means the task has FAILED.**
+
+3. **Commit**: Make atomic commits with conventional commit messages.
+   **Branch name must be in English.** If the current branch name contains non-English words,
+${branchRenameInstruction}
+   **IMPORTANT \u2014 Language rules:**
+   - All commit messages MUST be in English.
+   - Use conventional commits format: \`feat: ...\`, \`fix: ...\`, \`refactor: ...\`, \`chore: ...\`
+
+4. **Push**: Push the branch to origin:
+   \`git push -u origin <branch-name>\`
+   If the push fails due to a pre-push hook, read the error, fix the root cause, amend the commit, and retry. Do NOT use \`--no-verify\`.
+
+5. ${prCreateBlock}
+
+6. **Update tracker**: Call the lisa CLI to mark the issue as done:
+   \`lisa issue done ${issue.id} --pr-url <pr-url>\`
+   Wait 1 second before calling this command.
+
+7. **Write manifest**: Create ${manifestLocation} with JSON:
+   \`\`\`json
+   {"branch": "<final English branch name>", "prUrl": "<pull request URL>"}
+   \`\`\`
+   Do NOT commit this file.`;
+  }
+  let rulesSection;
+  if (variant === "branch") {
+    rulesSection = buildRulesSection(
+      projectContext?.environment,
+      "issue",
+      "- Do NOT modify files outside the target repo.\n"
+    );
+  } else if (variant === "scoped") {
+    rulesSection = buildRulesSection(projectContext?.environment, "scope");
+  } else {
+    rulesSection = buildRulesSection(projectContext?.environment);
+  }
+  return `${preamble}
+${workContext}
+## Issue
+
+- **ID:** ${issue.id}
+- **Title:** ${issue.title}
+- **URL:** ${issue.url}
+
+### Description
+
+${issue.description}
+${specWarningBlock}${contextBlock ? `
+${contextBlock}
+` : ""}${contextMdBlock}${depBlock ? `
+${depBlock}
+` : ""}${scopeSection}
+${instructions}
+
+${rulesSection}
+
+## Completion Checklist
+
+Before finishing, verify ALL of the following are true:
+- [ ] Code changes are committed (no uncommitted changes)
+- [ ] Branch is pushed to origin
+- [ ] Pull request is created and URL is captured
+- [ ] Manifest file is written with \`prUrl\` field
+If ANY item is unchecked, go back and complete it. Do NOT finish with incomplete steps.`;
+}
+function buildImplementPrompt(issue, config, testRunner, pm, projectContext, cwd, manifestPath, repoContextMd) {
+  const workspace = resolve(config.workspace);
+  const resolvedManifestPath = manifestPath ?? getManifestPath(workspace);
+  if (config.workflow === "worktree") {
+    return buildPrompt({
+      issue,
+      variant: "worktree",
+      testRunner,
+      pm,
+      baseBranch: config.base_branch,
+      projectContext,
+      manifestPath: resolvedManifestPath,
+      cwd,
+      platform: config.platform,
+      repoContextMd
+    });
+  }
+  return buildPrompt({
+    issue,
+    variant: "branch",
+    testRunner,
+    pm,
+    baseBranch: config.base_branch,
+    projectContext,
+    manifestPath: resolvedManifestPath,
+    cwd,
+    platform: config.platform,
+    repoContextMd,
+    config
+  });
+}
+function buildNativeWorktreePrompt(issue, repoPath, testRunner, pm, baseBranch, projectContext, manifestPath, platform2 = "cli", repoContextMd) {
+  return buildPrompt({
+    issue,
+    variant: "native-worktree",
+    testRunner,
+    pm,
+    baseBranch,
+    projectContext,
+    manifestPath,
+    cwd: repoPath,
+    platform: platform2,
+    repoContextMd
+  });
+}
+function buildScopedImplementPrompt(issue, step, previousResults, testRunner, pm, isLastStep = false, baseBranch, projectContext, manifestPath, cwd, platform2 = "cli", repoContextMd) {
+  return buildPrompt({
+    issue,
+    variant: "scoped",
+    testRunner,
+    pm,
+    baseBranch,
+    projectContext,
+    manifestPath,
+    cwd,
+    platform: platform2,
+    repoContextMd,
+    step,
+    previousResults,
+    isLastStep
+  });
+}
+function buildTestInstructions(testRunner, pm = "npm") {
+  if (!testRunner) return "";
+  const testCmd = pm === "bun" ? "bun run test" : `${pm} run test`;
+  return `
+**MANDATORY \u2014 Unit Tests:**
+This project uses **${testRunner}** as its test runner.
+- You MUST write unit tests (\`*.test.ts\`) for every new file or module you create.
+- Tests should cover the main functionality, edge cases, and error scenarios.
+- Run \`${testCmd}\` and ensure ALL tests pass before committing.
+- Do NOT skip writing tests \u2014 the PR will be blocked if tests are missing or failing.
+`;
+}
+function buildSpecWarningBlock(warning) {
+  if (!warning) return "";
+  return `
+> **Warning \u2014 incomplete spec:** ${warning}
+> Proceed using reasonable assumptions based on the title and description.
+> If the issue is genuinely too ambiguous to implement, STOP and explain what is missing.
+`;
+}
+function buildRulesSection(env, variant = "issue", extraRules = "") {
+  const envRule = buildEnvironmentDependencyRule(env);
+  const scopeRule = variant === "scope" ? "- One scope only. Do not pick up additional work outside your scope." : "- One issue only. Do not pick up additional issues.";
+  return `## Rules
+
+- **ALL git commits, branch names, PR titles, and PR descriptions MUST be in English.**
+- The issue description may be in any language \u2014 read it for context but write all code artifacts in English.
+- Do NOT install new dependencies unless the issue explicitly requires it.
+- Do NOT use documentation lookup MCP tools (e.g., Context7, codesearch, Exa) \u2014 they have free-tier rate limits that will block your execution. Read files directly from the repository. Web search is allowed only when strictly necessary (e.g., looking up an external API format not available in the codebase).
+${envRule}${extraRules}- If you get stuck or the issue is unclear, STOP and explain why.
+${scopeRule}
+- If the repo has a CLAUDE.md, read it first and follow its conventions.`;
+}
+function buildEnvironmentDependencyRule(env) {
+  if (env === "cli") {
+    return "- **Environment**: This is a CLI (Node.js) project. Do NOT install browser/DOM packages (`jsdom`, `happy-dom`, `@testing-library/dom`, `@testing-library/react`). All dependencies and tests must be Node.js-compatible.\n";
+  }
+  if (env === "mobile") {
+    return "- **Environment**: This is a mobile project (React Native/Flutter). Do NOT install browser/DOM packages or web-only libraries. Use only packages compatible with the mobile runtime.\n";
+  }
+  if (env === "server") {
+    return "- **Environment**: This is a server-side (Node.js) project. Do NOT install browser/DOM packages. Use only Node.js-compatible packages.\n";
+  }
+  return "";
+}
+function buildPreCommitHookInstructions() {
+  return `
+**Pre-commit hooks:**
+If \`git commit\` fails due to a pre-commit hook (e.g. husky), read the error output carefully and fix the underlying issue:
+- Linter/formatter failures \u2192 run the project's lint/format commands, then re-stage and retry the commit.
+- Code generation errors (e.g. stale Prisma client) \u2192 run the required generation command (e.g. \`npx prisma generate\`), then re-stage and retry.
+- Type errors \u2192 fix the type issues in the source files, then re-stage and retry.
+Do NOT skip or bypass hooks (no \`--no-verify\`). Fix the root cause and retry.
+`;
+}
+function buildReadmeInstructions(headings) {
+  if (headings.length === 0) return "";
+  const headingList = headings.map((h) => `   - ${h}`).join("\n");
+  return `
+**README.md Validation:**
+The current README.md documents these sections:
+${headingList}
+
+Review your implementation diff against these sections. Update README.md if your changes affect any documented behavior:
+- CLI commands, flags, or usage examples
+- Providers, sources, or integrations
+- Configuration fields or schema
+- Pipeline stages, workflow modes, or architecture
+- Environment variables
+
+Do NOT update README.md for internal refactors, bug fixes, test-only changes, logging, or dependency updates.
+
+If an update is needed, modify only the affected sections. Keep the existing style and structure. Include the README change in the same commit.
+`;
+}
+function buildContextMdBlock(content) {
+  if (!content?.trim()) return "";
+  return `
+## Project Conventions
+
+${content.trim()}
+`;
+}
+function buildDependencyContext(dep) {
+  const fileList = dep.changedFiles.length > 0 ? dep.changedFiles.map((f) => `  - \`${f}\``).join("\n") : "  (no files detected)";
+  return `## Dependency Context
+
+**This branch was created from the branch of issue ${dep.issueId}** (\`${dep.branch}\`), which has an open PR: ${dep.prUrl}
+
+The following files were changed by the dependency and are already available in your working tree:
+${fileList}
+
+**Important:**
+- Do NOT reimplement or modify code that was introduced by ${dep.issueId} \u2014 it already exists in your branch.
+- Your PR must target \`${dep.branch}\` as its base branch (not \`main\`), so the diff only shows YOUR changes.
+- When ${dep.issueId}'s PR is merged, your PR will be automatically re-targeted to \`main\`.
+`;
+}
+function buildPlanningPrompt(issue, config, planPath, globalContextMd) {
+  const workspace = resolve(config.workspace);
+  const repoBlock = config.repos.map((r) => {
+    const absPath = resolve(workspace, r.path);
+    return `- **${r.name}**: \`${absPath}\` (base branch: \`${r.base_branch}\`)`;
+  }).join("\n");
+  const resolvedPlanPath = planPath ?? getPlanPath(workspace);
+  const globalContextBlock = buildContextMdBlock(globalContextMd ?? null);
+  return `You are an issue analysis agent. Your job is to read the issue below, determine which repositories are affected, and produce an execution plan.
+
+**Do NOT implement anything.** Only analyze the issue and produce the plan file.
+
+## Issue
+
+- **ID:** ${issue.id}
+- **Title:** ${issue.title}
+- **URL:** ${issue.url}
+
+### Description
+
+${issue.description}
+
+## Available Repositories
+
+${repoBlock}
+${globalContextBlock}
+## Instructions
+
+1. **Analyze the issue**: Read the title and description carefully. Determine which repositories above are affected by this change.
+   Consider:
+   - File paths or module names mentioned in the description
+   - Technologies and frameworks referenced
+   - Dependencies between repos (e.g., backend API changes needed before frontend can consume them)
+
+2. **Determine execution order**: If multiple repos are affected, decide the order. Repos that produce APIs, schemas, or shared libraries should come first. Repos that consume them should come later.
+
+3. **Write the plan file to disk**: Use a bash command or file-write tool to write the plan to \`${resolvedPlanPath}\`.
+   **You MUST write the file to disk. Do NOT print the JSON to stdout or in a code block.**
+
+   The file must be valid JSON with this structure (replace angle-bracket placeholders with real values):
+   - \`repoPath\`: absolute path to the affected repository
+   - \`scope\`: concise English description of what to implement in that repo
+   - \`order\`: integer starting at 1 (lower = executes first)
+
+   Use your write_file tool, or a bash command such as:
+   \`\`\`bash
+   printf '%s' '{"steps":[{"repoPath":"/absolute/path","scope":"description of work","order":1}]}' > '${resolvedPlanPath}'
+   \`\`\`
+
+## Rules
+
+- Only include repos that are actually affected by the issue. Do NOT include repos that don't need changes.
+- The \`scope\` field should be a concise English description of what needs to be done in that specific repo.
+- Order matters: lower order numbers execute first.
+- Do NOT implement anything. Do NOT create branches, write code, or commit.
+- If only one repo is affected, the plan should have a single step.`;
+}
+function buildContinuationPrompt(opts) {
+  const { issue, diffStat, platform: platform2, baseBranch, manifestPath } = opts;
+  const prCreateBlock = buildPrCreateInstruction(platform2, baseBranch);
+  const outputLines = opts.previousOutput.split("\n");
+  const truncatedOutput = outputLines.length > 50 ? outputLines.slice(-50).join("\n") : opts.previousOutput;
+  return `You are an autonomous implementation agent resuming incomplete work.
+A previous agent session made code changes but did NOT complete the delivery steps (commit, push, PR, manifest).
+You MUST finish the job. Do NOT re-implement or undo existing changes \u2014 they are already in the working tree.
+Do NOT use interactive skills, ask clarifying questions, or wait for user input. You are running unattended. No human will see your output or respond to questions.
+
+## Issue
+
+- **ID:** ${issue.id}
+- **Title:** ${issue.title}
+
+## Current State
+
+The following files have been modified:
+\`\`\`
+${diffStat}
+\`\`\`
+
+## Previous Session Output (last lines)
+
+\`\`\`
+${truncatedOutput}
+\`\`\`
+
+## Instructions
+
+1. **Review**: Run \`git diff\` to understand what was changed. Check if any work is obviously incomplete or broken. If critical files are missing changes, make minimal fixes.
+
+2. **Validate**: Run the project's linter/typecheck/tests if available:
+   - Check \`package.json\` (or equivalent) for lint, typecheck, check, or test scripts.
+   - Run whichever validation scripts exist (e.g., \`npm run lint\`, \`npm run typecheck\`).
+   - Fix any errors before proceeding.
+
+**CRITICAL \u2014 Do NOT stop here. The following steps (commit, push, PR, manifest) are MANDATORY. Skipping them means the task has FAILED.**
+
+3. **Commit**: Make atomic commits with conventional commit messages.
+   **IMPORTANT \u2014 Language rules:**
+   - All commit messages MUST be in English.
+   - Use conventional commits format: \`feat: ...\`, \`fix: ...\`, \`refactor: ...\`, \`chore: ...\`
+
+4. **Push**: Push the branch to origin:
+   \`git push -u origin <branch-name>\`
+   If the push fails due to a pre-push hook, read the error, fix the root cause, amend the commit, and retry. Do NOT use \`--no-verify\`.
+
+5. ${prCreateBlock}
+
+6. **Update tracker**: Call the lisa CLI to mark the issue as done:
+   \`lisa issue done ${issue.id} --pr-url <pr-url>\`
+   Wait 1 second before calling this command.
+
+7. **Write manifest**: Create \`${manifestPath}\` with JSON:
+   \`\`\`json
+   {"branch": "<final English branch name>", "prUrl": "<pull request URL>"}
+   \`\`\`
+   Do NOT commit this file.
+
+## Rules
+
+- **ALL git commits, branch names, PR titles, and PR descriptions MUST be in English.**
+- Do NOT install new dependencies.
+- Do NOT use documentation lookup MCP tools.
+- One issue only. Do not pick up additional issues.
+
+## Completion Checklist
+
+Before finishing, verify ALL of the following are true:
+- [ ] Code changes are committed (no uncommitted changes)
+- [ ] Branch is pushed to origin
+- [ ] Pull request is created and URL is captured
+- [ ] Manifest file is written with \`prUrl\` field
+If ANY item is unchecked, go back and complete it. Do NOT finish with incomplete steps.`;
+}
+
+export {
+  getAllProvidersWithAvailability,
+  createProvider,
+  isCompleteProviderExhaustion,
+  runWithFallback,
+  createSource,
+  getContextPath,
+  contextExists,
+  readContext,
+  WATCH_POLL_INTERVAL_MS,
+  resolveModels,
+  analyzeProject,
+  runValidationCommands,
+  buildValidationRecoveryPrompt,
+  isProofOfWorkEnabled,
+  appendPlatformAttribution,
+  appendPlatformProofOfWork,
+  detectPackageManager,
+  detectTestRunner,
+  buildImplementPrompt,
+  buildNativeWorktreePrompt,
+  buildScopedImplementPrompt,
+  buildContextMdBlock,
+  buildPlanningPrompt,
+  buildContinuationPrompt
+};