@tarcisiopgs/lisa 1.26.2 → 1.28.0

package/dist/chunk-W73XGHD4.js

@@ -0,0 +1,3059 @@
+#!/usr/bin/env node
+import {
+  WATCH_POLL_INTERVAL_MS,
+  analyzeProject,
+  appendPlatformAttribution,
+  appendPlatformProofOfWork,
+  buildContinuationPrompt,
+  buildImplementPrompt,
+  buildNativeWorktreePrompt,
+  buildPlanningPrompt,
+  buildScopedImplementPrompt,
+  buildValidationRecoveryPrompt,
+  contextExists,
+  createProvider,
+  createSource,
+  detectPackageManager,
+  detectTestRunner,
+  getContextPath,
+  isCompleteProviderExhaustion,
+  isProofOfWorkEnabled,
+  readContext,
+  resolveModels,
+  runValidationCommands,
+  runWithFallback
+} from "./chunk-UXVSQQID.js";
+import {
+  divider,
+  error,
+  initLogFile,
+  kanbanEmitter,
+  log,
+  ok,
+  warn
+} from "./chunk-5N4BWHIT.js";
+import {
+  appendRawEntry,
+  migrateGuardrails
+} from "./chunk-3EOEDL3T.js";
+import {
+  ensureCacheDir,
+  getLogsDir,
+  getManifestPath,
+  getPlanPath,
+  getPrCachePath,
+  rotateLogFiles
+} from "./chunk-7OCDGYDM.js";
+import {
+  notify,
+  resetTitle,
+  setTitle,
+  startSpinner,
+  stopSpinner
+} from "./chunk-72CYGBT4.js";
+import {
+  formatError
+} from "./chunk-2TW2MJXF.js";
+import {
+  fetchPrFeedback,
+  formatPrFeedbackEntry
+} from "./chunk-DGL33SDZ.js";
+
+// src/loop/index.ts
+import { join as join3, resolve as resolve11 } from "path";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { parse, stringify } from "yaml";
+import { literal, object, string, union } from "zod";
+var VALID_PROVIDERS = [
+  "claude",
+  "gemini",
+  "opencode",
+  "copilot",
+  "cursor",
+  "goose",
+  "aider",
+  "codex"
+];
+var VALID_SOURCES = [
+  "linear",
+  "trello",
+  "plane",
+  "shortcut",
+  "gitlab-issues",
+  "github-issues",
+  "jira"
+];
+var VALID_PLATFORMS = ["cli", "token", "gitlab", "bitbucket"];
+var VALID_WORKFLOWS = ["worktree", "branch"];
+function enumOrEmpty(values) {
+  return union([literal(""), ...values.map((v) => literal(v))]);
+}
+var configSchema = object({
+  provider: enumOrEmpty(VALID_PROVIDERS),
+  source: enumOrEmpty(VALID_SOURCES),
+  platform: enumOrEmpty(VALID_PLATFORMS),
+  workflow: union(
+    VALID_WORKFLOWS.map((w) => literal(w))
+  ),
+  base_branch: string().optional(),
+  workspace: string().optional()
+}).passthrough();
+var ConfigValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigValidationError";
+  }
+};
+function validateConfig(config) {
+  if (!config.provider && !config.source) return;
+  const result = configSchema.safeParse(config);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => {
+      const path = issue.path.join(".");
+      if (issue.code === "invalid_union") {
+        if (path === "provider")
+          return `  provider: "${config.provider}" is not valid. Must be one of: ${VALID_PROVIDERS.join(", ")}`;
+        if (path === "source")
+          return `  source: "${config.source}" is not valid. Must be one of: ${VALID_SOURCES.join(", ")}`;
+        if (path === "platform")
+          return `  platform: "${config.platform}" is not valid. Must be one of: ${VALID_PLATFORMS.join(", ")}`;
+        if (path === "workflow")
+          return `  workflow: "${config.workflow}" is not valid. Must be one of: ${VALID_WORKFLOWS.join(", ")}`;
+      }
+      return `  ${path}: ${issue.message}`;
+    });
+    throw new ConfigValidationError(`Invalid configuration:
+${issues.join("\n")}`);
+  }
+  if (config.provider && config.provider_options?.[config.provider]?.models) {
+    const models = config.provider_options[config.provider]?.models ?? [];
+    for (const model of models) {
+      if (typeof model !== "string" || !model.trim()) {
+        throw new ConfigValidationError(
+          `Invalid configuration:
+  provider_options.${config.provider}.models contains an empty or non-string value`
+        );
+      }
+    }
+  }
+}
+var DEFAULT_OVERSEER_CONFIG = {
+  enabled: true,
+  check_interval: 30,
+  stuck_threshold: 300
+};
+var CONFIG_DIR = ".lisa";
+var CONFIG_FILE = "config.yaml";
+var DEFAULT_CONFIG = {
+  provider: "",
+  provider_options: {},
+  source: "",
+  source_config: {
+    scope: "",
+    project: "",
+    label: "",
+    pick_from: "",
+    in_progress: "",
+    done: ""
+  },
+  platform: "cli",
+  workflow: "branch",
+  workspace: "",
+  base_branch: "main",
+  repos: [],
+  loop: {
+    cooldown: 0,
+    max_sessions: 0
+  },
+  overseer: { ...DEFAULT_OVERSEER_CONFIG }
+};
+function getConfigPath(cwd = process.cwd()) {
+  return resolve(cwd, CONFIG_DIR, CONFIG_FILE);
+}
+function configExists(cwd = process.cwd()) {
+  return existsSync(getConfigPath(cwd));
+}
+function findConfigDir(startDir = process.cwd()) {
+  let dir = startDir;
+  while (true) {
+    if (existsSync(getConfigPath(dir))) return dir;
+    const parent = resolve(dir, "..");
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const parsed = parse(raw);
+  const rawSource = parsed.source_config ?? {};
+  const rawLabel = rawSource.label;
+  const label = Array.isArray(rawLabel) ? rawLabel : typeof rawLabel === "string" ? rawLabel : "";
+  const sourceConfig = {
+    scope: (rawSource.scope ?? rawSource.team ?? rawSource.board) || "",
+    project: (rawSource.project ?? rawSource.list ?? rawSource.pick_from) || "",
+    label,
+    remove_label: rawSource.remove_label || void 0,
+    pick_from: (rawSource.pick_from ?? rawSource.initial_status) || "",
+    in_progress: (rawSource.in_progress ?? rawSource.active_status) || "",
+    done: (rawSource.done ?? rawSource.done_status) || ""
+  };
+  if (parsed.source === "trello" && !sourceConfig.pick_from) {
+    sourceConfig.pick_from = sourceConfig.project;
+  }
+  if (parsed.source === "plane" && !sourceConfig.scope && process.env.PLANE_WORKSPACE) {
+    sourceConfig.scope = process.env.PLANE_WORKSPACE;
+  }
+  if (parsed.source === "gitlab-issues" && !sourceConfig.scope && rawSource.project) {
+    sourceConfig.scope = rawSource.project;
+  }
+  if (parsed.source === "github-issues" && !sourceConfig.scope && rawSource.project) {
+    sourceConfig.scope = rawSource.project;
+  }
+  if (parsed.source === "jira" && !sourceConfig.scope && rawSource.project) {
+    sourceConfig.scope = rawSource.project;
+  }
+  const { logs: _ignoredLogs, ...parsedWithoutLogs } = parsed;
+  const rawLifecycle = parsed.lifecycle ?? void 0;
+  const rawHooks = parsed.hooks;
+  const rawProofOfWork = parsed.proof_of_work;
+  const rawReconciliation = parsed.reconciliation;
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...parsedWithoutLogs,
+    platform: parsed.platform ?? parsed.github ?? "cli",
+    source_config: sourceConfig,
+    loop: { ...DEFAULT_CONFIG.loop, ...parsed.loop ?? {} },
+    overseer: {
+      ...DEFAULT_OVERSEER_CONFIG,
+      ...parsed.overseer ?? {}
+    },
+    lifecycle: rawLifecycle ? {
+      mode: rawLifecycle.mode,
+      timeout: rawLifecycle.timeout
+    } : void 0,
+    hooks: rawHooks ? {
+      before_run: rawHooks.before_run,
+      after_run: rawHooks.after_run,
+      after_create: rawHooks.after_create,
+      before_remove: rawHooks.before_remove,
+      timeout: rawHooks.timeout
+    } : void 0,
+    proof_of_work: rawProofOfWork ? {
+      enabled: rawProofOfWork.enabled ?? false,
+      commands: Array.isArray(rawProofOfWork.commands) ? rawProofOfWork.commands : [],
+      max_retries: rawProofOfWork.max_retries,
+      timeout: rawProofOfWork.timeout
+    } : void 0,
+    reconciliation: rawReconciliation ? {
+      enabled: rawReconciliation.enabled ?? false,
+      check_interval: rawReconciliation.check_interval
+    } : void 0,
+    provider_options: {
+      ...DEFAULT_CONFIG.provider_options || {},
+      ...parsed.provider_options ?? {}
+    }
+  };
+  if (!config.base_branch) config.base_branch = "main";
+  for (const repo of config.repos) {
+    if (!repo.base_branch) repo.base_branch = config.base_branch;
+  }
+  if (!config.provider_options) {
+    config.provider_options = {};
+  }
+  if (!config.provider_options[config.provider]) {
+    config.provider_options[config.provider] = {};
+  }
+  if (parsed.models && Array.isArray(parsed.models)) {
+    config.provider_options[config.provider] = {
+      ...config.provider_options[config.provider],
+      models: parsed.models
+    };
+  }
+  if (!config.provider_options[config.provider]?.models?.length && config.provider) {
+    config.provider_options[config.provider] = {
+      ...config.provider_options[config.provider],
+      models: [config.provider]
+    };
+  }
+  validateConfig(config);
+  return config;
+}
+function saveConfig(config, cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  const dir = resolve(cwd, CONFIG_DIR);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const sc = config.source_config;
+  const removeLabelEntry = sc.remove_label ? { remove_label: sc.remove_label } : {};
+  const sourceYaml = config.source === "trello" ? {
+    board: sc.scope,
+    pick_from: sc.pick_from || sc.project,
+    label: sc.label,
+    ...removeLabelEntry,
+    in_progress: sc.in_progress,
+    done: sc.done
+  } : config.source === "gitlab-issues" ? {
+    scope: sc.scope,
+    label: sc.label,
+    ...removeLabelEntry,
+    in_progress: sc.in_progress,
+    done: sc.done
+  } : config.source === "github-issues" ? {
+    scope: sc.scope,
+    label: sc.label,
+    ...removeLabelEntry,
+    in_progress: sc.in_progress,
+    done: sc.done
+  } : config.source === "jira" ? {
+    scope: sc.scope,
+    label: sc.label,
+    ...removeLabelEntry,
+    pick_from: sc.pick_from,
+    in_progress: sc.in_progress,
+    done: sc.done
+  } : {
+    scope: sc.scope,
+    project: sc.project,
+    label: sc.label,
+    ...removeLabelEntry,
+    pick_from: sc.pick_from,
+    in_progress: sc.in_progress,
+    done: sc.done
+  };
+  const output = { ...config, source_config: sourceYaml };
+  writeFileSync(configPath, stringify(output), "utf-8");
+}
+function mergeWithFlags(config, flags) {
+  const merged = { ...config };
+  if (flags.provider) merged.provider = flags.provider;
+  if (flags.source) merged.source = flags.source;
+  if (flags.platform) merged.platform = flags.platform;
+  if (flags.bell !== void 0) merged.bell = flags.bell;
+  if (flags.lifecycle) {
+    merged.lifecycle = { ...merged.lifecycle, ...flags.lifecycle };
+  }
+  if (flags.label) {
+    const parts = flags.label.split(",").map((s) => s.trim()).filter(Boolean);
+    const label = parts.length === 1 ? parts[0] : parts;
+    merged.source_config = { ...merged.source_config, label };
+  }
+  return merged;
+}
+function getRemoveLabel(sc) {
+  if (sc.remove_label) return sc.remove_label;
+  if (typeof sc.label === "string" && sc.label) return sc.label;
+  return void 0;
+}
+function getLabelsArray(sc) {
+  if (Array.isArray(sc.label)) return sc.label;
+  return sc.label ? [sc.label] : [];
+}
+function formatLabels(sc) {
+  const labels = getLabelsArray(sc);
+  return labels.length === 0 ? "(none)" : labels.join(", ");
+}
+
+// src/loop/concurrent.ts
+import { resolve as resolve7 } from "path";
+
+// src/session/pr-cache.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname } from "path";
+function readCache(cwd) {
+  const path = getPrCachePath(cwd);
+  if (!existsSync2(path)) return {};
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeCacheSafe(cwd, cache) {
+  const path = getPrCachePath(cwd);
+  const dir = dirname(path);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const tmpPath = `${path}.tmp.${process.pid}`;
+  const data = JSON.stringify(cache, null, 2);
+  writeFileSync2(tmpPath, data, "utf-8");
+  try {
+    renameSync(tmpPath, path);
+  } catch {
+    writeFileSync2(path, data, "utf-8");
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+  }
+}
+function storePrUrls(cwd, issueId, prUrls) {
+  const cache = readCache(cwd);
+  cache[issueId] = prUrls;
+  writeCacheSafe(cwd, cache);
+}
+function loadPrUrls(cwd, issueId) {
+  const entry = readCache(cwd)[issueId];
+  if (!entry) return [];
+  return Array.isArray(entry) ? entry : [entry];
+}
+function clearPrUrl(cwd, issueId) {
+  const cache = readCache(cwd);
+  delete cache[issueId];
+  writeCacheSafe(cwd, cache);
+}
+
+// src/loop/helpers.ts
+import { appendFileSync } from "fs";
+import { resolve as resolve3 } from "path";
+import { execa } from "execa";
+
+// src/session/discovery.ts
+import { copyFileSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join } from "path";
+import { parse as parse2 } from "yaml";
+var DOCKER_COMPOSE_FILES = [
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "compose.yml",
+  "compose.yaml"
+];
+function parseHostPort(port) {
+  const raw = String(port).split("/")[0] ?? "";
+  const parts = raw.split(":");
+  if (parts.length === 1) {
+    const n = Number.parseInt(parts[0] ?? "", 10);
+    return Number.isNaN(n) ? null : n;
+  }
+  if (parts.length === 2) {
+    const n = Number.parseInt(parts[0] ?? "", 10);
+    return Number.isNaN(n) ? null : n;
+  }
+  if (parts.length === 3) {
+    const n = Number.parseInt(parts[1] ?? "", 10);
+    return Number.isNaN(n) ? null : n;
+  }
+  return null;
+}
+function discoverDockerCompose(cwd) {
+  let composeFile = null;
+  for (const name of DOCKER_COMPOSE_FILES) {
+    const candidate = join(cwd, name);
+    if (existsSync3(candidate)) {
+      composeFile = candidate;
+      break;
+    }
+  }
+  if (!composeFile) return [];
+  let content;
+  try {
+    content = readFileSync3(composeFile, "utf-8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = parse2(content);
+  } catch {
+    warn("Failed to parse docker-compose file. Skipping auto-discovery for Docker.");
+    return [];
+  }
+  if (!parsed?.services) return [];
+  const resources = [];
+  for (const [serviceName, service] of Object.entries(parsed.services)) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(serviceName)) {
+      warn(`Skipping Docker service with unsafe name: ${serviceName}`);
+      continue;
+    }
+    const firstPort = service.ports?.[0];
+    if (firstPort === void 0) continue;
+    const hostPort = parseHostPort(firstPort);
+    if (hostPort === null) continue;
+    resources.push({
+      name: serviceName,
+      check_port: hostPort,
+      up: `docker compose up -d ${serviceName}`,
+      down: `docker compose stop ${serviceName}`,
+      startup_timeout: 30
+    });
+  }
+  return resources;
+}
+function discoverEnvFile(cwd) {
+  const envExample = join(cwd, ".env.example");
+  const envFile = join(cwd, ".env");
+  if (existsSync3(envExample) && !existsSync3(envFile)) {
+    try {
+      copyFileSync(envExample, envFile);
+      ok("Copied .env.example \u2192 .env");
+    } catch (err) {
+      warn(`Failed to copy .env.example: ${formatError(err)}`);
+    }
+  }
+}
+function discoverInfra(cwd) {
+  discoverEnvFile(cwd);
+  const resources = discoverDockerCompose(cwd);
+  if (resources.length === 0) return null;
+  log(`Auto-discovered infrastructure: ${resources.length} resource(s)`);
+  return { resources, setup: [] };
+}
+
+// src/session/lifecycle.ts
+import { spawn } from "child_process";
+import { createConnection } from "net";
+import { resolve as resolve2 } from "path";
+var managedResources = [];
+var cleanupRegistered = false;
+function isPortInUse(port) {
+  return new Promise((resolve12) => {
+    const socket = createConnection({ port }, () => {
+      socket.destroy();
+      resolve12(true);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve12(false);
+    });
+  });
+}
+function waitForPort(port, timeoutMs) {
+  return new Promise((resolve12) => {
+    const deadline = Date.now() + timeoutMs;
+    const check = () => {
+      if (Date.now() > deadline) {
+        resolve12(false);
+        return;
+      }
+      isPortInUse(port).then((inUse) => {
+        if (inUse) {
+          resolve12(true);
+        } else {
+          setTimeout(check, 500);
+        }
+      });
+    };
+    check();
+  });
+}
+async function allocatePort(basePort, range) {
+  for (let offset = 0; offset < range; offset++) {
+    const port = basePort + offset;
+    const inUse = await isPortInUse(port);
+    if (!inUse) {
+      return port;
+    }
+  }
+  return null;
+}
+function spawnResource(config, baseCwd, allocatedPort) {
+  const cwd = config.cwd ? resolve2(baseCwd, config.cwd) : baseCwd;
+  const env = { ...process.env };
+  if (config.port_env_var) {
+    env[config.port_env_var] = String(allocatedPort);
+  }
+  const child = spawn("sh", ["-c", config.up], {
+    cwd,
+    env,
+    stdio: "ignore",
+    detached: true
+  });
+  return child;
+}
+function runSetupCommand(command, cwd, env) {
+  return new Promise((resolve12, reject) => {
+    const child = spawn("sh", ["-c", command], {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: "inherit"
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve12();
+      } else {
+        reject(new Error(`Setup command failed with exit code ${code}: ${command}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Setup command error: ${err.message}`));
+    });
+  });
+}
+async function startResources(infra, baseCwd) {
+  registerCleanup();
+  const allocatedEnv = {};
+  for (const resource of infra.resources) {
+    let allocatedPort;
+    if (resource.port_range && resource.port_range > 0) {
+      const found = await allocatePort(resource.check_port, resource.port_range);
+      if (found === null) {
+        error(
+          `No free port found for "${resource.name}" in range ${resource.check_port}\u2013${resource.check_port + resource.port_range - 1}`
+        );
+        await stopResources();
+        return { success: false, env: allocatedEnv };
+      }
+      allocatedPort = found;
+      log(`Allocated port ${allocatedPort} for "${resource.name}"`);
+    } else {
+      allocatedPort = resource.check_port;
+    }
+    if (resource.port_env_var) {
+      allocatedEnv[resource.port_env_var] = String(allocatedPort);
+    }
+    const alreadyRunning = await isPortInUse(allocatedPort);
+    if (alreadyRunning) {
+      ok(`Resource "${resource.name}" already running on port ${allocatedPort}`);
+      continue;
+    }
+    log(`Starting resource "${resource.name}" on port ${allocatedPort}...`);
+    const child = spawnResource(resource, baseCwd, allocatedPort);
+    managedResources.push({
+      name: resource.name,
+      config: resource,
+      process: child
+    });
+    const timeoutMs = (resource.startup_timeout || 30) * 1e3;
+    const ready = await waitForPort(allocatedPort, timeoutMs);
+    if (!ready) {
+      error(
+        `Resource "${resource.name}" failed to start within ${resource.startup_timeout}s`
+      );
+      await stopResources();
+      return { success: false, env: allocatedEnv };
+    }
+    ok(`Resource "${resource.name}" is ready on port ${allocatedPort}`);
+  }
+  for (const command of infra.setup) {
+    log(`Running setup: ${command}`);
+    try {
+      await runSetupCommand(command, baseCwd, allocatedEnv);
+      ok(`Setup complete: ${command}`);
+    } catch (err) {
+      error(`Setup failed: ${formatError(err)}`);
+      await stopResources();
+      return { success: false, env: allocatedEnv };
+    }
+  }
+  return { success: true, env: allocatedEnv };
+}
+async function runLifecycle(infra, lifecycle, baseCwd) {
+  const mode = lifecycle?.mode ?? "skip";
+  if (mode === "skip") {
+    return { success: true, env: {} };
+  }
+  if (mode === "validate-only") {
+    for (const resource of infra.resources) {
+      const inUse = await isPortInUse(resource.check_port);
+      if (!inUse) {
+        error(
+          `Resource "${resource.name}" is not running on port ${resource.check_port}. Start it manually or use lifecycle: auto.`
+        );
+        return { success: false, env: {} };
+      }
+    }
+    return { success: true, env: {} };
+  }
+  if (lifecycle?.timeout !== void 0) {
+    const patchedInfra = {
+      ...infra,
+      resources: infra.resources.map((r) => ({
+        ...r,
+        startup_timeout: lifecycle.timeout
+      }))
+    };
+    return startResources(patchedInfra, baseCwd);
+  }
+  return startResources(infra, baseCwd);
+}
+async function stopResources() {
+  for (const managed of managedResources) {
+    const { name, config, process: child } = managed;
+    log(`Stopping resource "${name}"...`);
+    try {
+      if (config.down === "auto") {
+        if (child?.pid) {
+          try {
+            process.kill(-child.pid, "SIGTERM");
+          } catch {
+          }
+        }
+      } else {
+        await new Promise((resolve12) => {
+          const down = spawn("sh", ["-c", config.down], {
+            stdio: "ignore"
+          });
+          down.on("close", () => resolve12());
+          down.on("error", () => resolve12());
+        });
+      }
+      ok(`Resource "${name}" stopped`);
+    } catch (err) {
+      warn(`Failed to stop resource "${name}": ${formatError(err)}`);
+    }
+  }
+  managedResources.length = 0;
+}
+function registerCleanup() {
+  if (cleanupRegistered) return;
+  cleanupRegistered = true;
+  const cleanup = () => {
+    for (const managed of managedResources) {
+      const { config, process: child } = managed;
+      try {
+        if (config.down === "auto") {
+          if (child?.pid) {
+            process.kill(-child.pid, "SIGTERM");
+          }
+        }
+      } catch {
+      }
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+}
+
+// src/loop/state.ts
+var activeCleanups = /* @__PURE__ */ new Map();
+var activeProviderPids = /* @__PURE__ */ new Map();
+var providerPausedSet = /* @__PURE__ */ new Set();
+var userKilledSet = /* @__PURE__ */ new Set();
+var userSkippedSet = /* @__PURE__ */ new Set();
+var reconciliationSet = /* @__PURE__ */ new Set();
+var _shuttingDown = false;
+var _loopPaused = false;
+var _userQuitFromWatchPrompt = false;
+var _loopIdle = false;
+var _idleResolve = null;
+function isShuttingDown() {
+  return _shuttingDown;
+}
+function setShuttingDown(value) {
+  _shuttingDown = value;
+}
+function isLoopPaused() {
+  return _loopPaused;
+}
+function hasUserQuitFromWatchPrompt() {
+  return _userQuitFromWatchPrompt;
+}
+function waitForResume() {
+  if (_shuttingDown || _userQuitFromWatchPrompt) return Promise.resolve();
+  _loopIdle = true;
+  return new Promise((resolve12) => {
+    _idleResolve = resolve12;
+  });
+}
+function resolveIdle() {
+  _loopIdle = false;
+  if (_idleResolve) {
+    _idleResolve();
+    _idleResolve = null;
+  }
+}
+function killProviderForIssue(issueId) {
+  const pid = activeProviderPids.get(issueId);
+  if (!pid) return;
+  if (providerPausedSet.has(issueId)) {
+    try {
+      process.kill(pid, "SIGCONT");
+    } catch {
+    }
+    providerPausedSet.delete(issueId);
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  setTimeout(() => {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }, 5e3);
+}
+function setupEventListeners() {
+  kanbanEmitter.on("loop:pause", () => {
+    _loopPaused = true;
+  });
+  kanbanEmitter.on("loop:resume", () => {
+    _loopPaused = false;
+  });
+  kanbanEmitter.on("loop:pause-provider", (issueId) => {
+    if (issueId) {
+      const pid = activeProviderPids.get(issueId);
+      if (pid) {
+        try {
+          process.kill(pid, "SIGSTOP");
+        } catch {
+        }
+        providerPausedSet.add(issueId);
+      }
+    } else {
+      for (const [id, pid] of activeProviderPids) {
+        try {
+          process.kill(pid, "SIGSTOP");
+        } catch {
+        }
+        providerPausedSet.add(id);
+      }
+    }
+    kanbanEmitter.emit("provider:paused", issueId);
+  });
+  kanbanEmitter.on("loop:resume-provider", (issueId) => {
+    if (issueId) {
+      const pid = activeProviderPids.get(issueId);
+      if (pid && providerPausedSet.has(issueId)) {
+        try {
+          process.kill(pid, "SIGCONT");
+        } catch {
+        }
+        providerPausedSet.delete(issueId);
+      }
+    } else {
+      for (const id of providerPausedSet) {
+        const pid = activeProviderPids.get(id);
+        if (pid) {
+          try {
+            process.kill(pid, "SIGCONT");
+          } catch {
+          }
+        }
+      }
+      providerPausedSet.clear();
+    }
+    kanbanEmitter.emit("provider:resumed", issueId);
+  });
+  kanbanEmitter.on("loop:kill", (issueId) => {
+    if (issueId) {
+      userKilledSet.add(issueId);
+      killProviderForIssue(issueId);
+    } else {
+      const firstId = activeProviderPids.keys().next().value;
+      if (firstId) {
+        userKilledSet.add(firstId);
+        killProviderForIssue(firstId);
+      }
+    }
+  });
+  kanbanEmitter.on("loop:skip", (issueId) => {
+    if (issueId) {
+      userSkippedSet.add(issueId);
+      killProviderForIssue(issueId);
+    } else {
+      const firstId = activeProviderPids.keys().next().value;
+      if (firstId) {
+        userSkippedSet.add(firstId);
+        killProviderForIssue(firstId);
+      }
+    }
+  });
+  kanbanEmitter.on("loop:run", () => {
+    resolveIdle();
+  });
+  kanbanEmitter.on("loop:quit", () => {
+    _userQuitFromWatchPrompt = true;
+    setShuttingDown(true);
+    resolveIdle();
+  });
+}
+
+// src/session/reconciliation.ts
+var DEFAULT_CHECK_INTERVAL = 30;
+function startReconciliation(source, issueId, config, sourceConfig) {
+  if (!config.enabled) {
+    return { stop() {
+    }, wasReconciled: () => false };
+  }
+  let reconciled = false;
+  let paused = false;
+  const intervalMs = (config.check_interval ?? DEFAULT_CHECK_INTERVAL) * 1e3;
+  const onPause = () => {
+    paused = true;
+  };
+  const onResume = () => {
+    paused = false;
+  };
+  kanbanEmitter.on("loop:pause-provider", onPause);
+  kanbanEmitter.on("loop:resume-provider", onResume);
+  const check = async () => {
+    if (reconciled || paused) return;
+    try {
+      const issue = await source.fetchIssueById(issueId);
+      if (!issue) {
+        reconciled = true;
+        reconciliationSet.add(issueId);
+        warn(`Issue ${issueId} no longer found in tracker. Killing provider.`);
+        killProviderForIssue(issueId);
+        cleanup();
+        return;
+      }
+      if (issue.status) {
+        const currentStatus = issue.status.toLowerCase();
+        const inProgress = sourceConfig.in_progress.toLowerCase();
+        const done = sourceConfig.done.toLowerCase();
+        if (currentStatus === done || inProgress && currentStatus !== inProgress) {
+          reconciled = true;
+          reconciliationSet.add(issueId);
+          warn(
+            `Issue ${issueId} status changed to "${issue.status}" externally. Killing provider.`
+          );
+          killProviderForIssue(issueId);
+          cleanup();
+        }
+      }
+    } catch {
+    }
+  };
+  let timer = setInterval(check, intervalMs);
+  if (timer && typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+  function cleanup() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    kanbanEmitter.off("loop:pause-provider", onPause);
+    kanbanEmitter.off("loop:resume-provider", onResume);
+  }
+  return {
+    stop() {
+      cleanup();
+    },
+    wasReconciled() {
+      return reconciled;
+    }
+  };
+}
+
+// src/validation.ts
+var ACCEPTANCE_CRITERIA_PATTERNS = [
+  /- \[ \]/,
+  // Markdown checklist item: - [ ]
+  /critérios/i,
+  // Portuguese: "critérios de aceite"
+  /acceptance criteria/i,
+  // English
+  /expected behavior/i,
+  // English alternative
+  /\bexpected\b/i,
+  // English: "expected output", etc.
+  /\bdeve\b/i,
+  // Portuguese: "deve fazer X"
+  /\bshould\b/i
+  // English: "should do X"
+];
+function validateIssueSpec(issue, config) {
+  if (config?.require_acceptance_criteria === false) {
+    return { valid: true };
+  }
+  const description = issue.description?.trim() ?? "";
+  if (!description) {
+    return {
+      valid: false,
+      reason: "issue has no description"
+    };
+  }
+  const hasAcceptanceCriteria = ACCEPTANCE_CRITERIA_PATTERNS.some(
+    (pattern) => pattern.test(description)
+  );
+  if (!hasAcceptanceCriteria) {
+    return {
+      valid: false,
+      reason: "issue description has no detectable acceptance criteria (missing checklist `- [ ]`, 'acceptance criteria', 'expected', 'deve', 'should', or 'crit\xE9rios')"
+    };
+  }
+  return { valid: true };
+}
+
+// src/loop/helpers.ts
+async function checkIssueSpec(issue, config, source) {
+  const specResult = validateIssueSpec(issue, config.validation);
+  if (!specResult.valid) {
+    warn(`Issue ${issue.id}: ${specResult.reason} \u2014 proceeding with incomplete spec`);
+    try {
+      await source.addLabel?.(issue.id, "needs-spec");
+      ok(`Added label "needs-spec" to ${issue.id}`);
+    } catch (err) {
+      warn(`Failed to add label "needs-spec": ${formatError(err)}`);
+    }
+    issue.specWarning = specResult.reason;
+    return false;
+  }
+  return true;
+}
+async function moveToInProgress(issue, source, config) {
+  try {
+    await source.updateStatus(issue.id, config.source_config.in_progress, config.source_config);
+    ok(`Moved ${issue.id} to "${config.source_config.in_progress}"`);
+  } catch (err) {
+    warn(`Failed to update status: ${formatError(err)}`);
+  }
+}
+async function revertIssueStatus(issue, source, config) {
+  const previousStatus = config.source_config.pick_from;
+  try {
+    await source.updateStatus(issue.id, previousStatus, config.source_config);
+    ok(`Reverted ${issue.id} to "${previousStatus}"`);
+  } catch (revertErr) {
+    error(`Failed to revert status: ${formatError(revertErr)}`);
+  }
+}
+function resolveProviderOptions(config) {
+  const opts = config.provider_options?.[config.provider];
+  if (!opts?.effort) return void 0;
+  return { effort: opts.effort };
+}
+function resolveBaseBranch(config, repoPath) {
+  const workspace = resolve3(config.workspace);
+  const repo = config.repos.find((r) => resolve3(workspace, r.path) === repoPath);
+  return repo?.base_branch ?? config.base_branch;
+}
+async function checkoutBaseBranches(config, workspace) {
+  const targets = [
+    { cwd: workspace, branch: config.base_branch },
+    ...config.repos.map((r) => ({
+      cwd: resolve3(workspace, r.path),
+      branch: r.base_branch
+    }))
+  ];
+  for (const { cwd, branch } of targets) {
+    try {
+      await execa("git", ["checkout", branch], { cwd });
+      ok(`Checked out ${branch} in ${cwd}`);
+    } catch (err) {
+      warn(`Could not checkout ${branch} in ${cwd}: ${formatError(err)}`);
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
+}
+async function waitIfPaused() {
+  while (isLoopPaused()) {
+    await sleep(500);
+  }
+}
+async function refreshKanban(source, config) {
+  if (kanbanEmitter.listenerCount("issue:queued") === 0) return;
+  try {
+    const allIssues = await source.listIssues(config.source_config);
+    for (const issue of allIssues) {
+      kanbanEmitter.emit("issue:queued", issue);
+    }
+  } catch {
+  }
+}
+function defaultProvider(models) {
+  return models[0]?.provider ?? "claude";
+}
+function failureResult(providerUsed, fallback) {
+  return { success: false, providerUsed, prUrls: [], fallback };
+}
+function hookFailure(providerUsed, message) {
+  return failureResult(providerUsed, {
+    success: false,
+    output: message,
+    duration: 0,
+    providerUsed,
+    attempts: []
+  });
+}
+function emptyCommitFailure(result) {
+  error("Provider reported success but no code changes detected. Treating as failure.");
+  return failureResult(result.providerUsed, {
+    success: false,
+    output: "Provider reported success but no code changes detected",
+    duration: result.duration,
+    providerUsed: result.providerUsed,
+    attempts: [
+      {
+        provider: result.providerUsed,
+        model: "",
+        success: false,
+        error: "Eligible error (empty commit)",
+        duration: result.duration
+      }
+    ]
+  });
+}
+function appendSessionLog(logFile, result) {
+  try {
+    appendFileSync(
+      logFile,
+      `
+${"=".repeat(80)}
+Provider used: ${result.providerUsed}
+Full output:
+${result.output}
+`
+    );
+  } catch {
+  }
+}
+function checkReconciliation(issueId, result) {
+  if (reconciliationSet.has(issueId)) {
+    reconciliationSet.delete(issueId);
+    warn(`Issue ${issueId} was closed/cancelled externally. Skipping.`);
+    return failureResult(result.providerUsed, result);
+  }
+  return null;
+}
+function buildRunOptions(config, issue, cwd, logFile, workspace, lifecycleEnv, extra) {
+  return {
+    logFile,
+    cwd,
+    guardrailsDir: workspace,
+    issueId: issue.id,
+    overseer: config.overseer,
+    sessionTimeout: config.loop.session_timeout,
+    outputStallTimeout: config.loop.output_stall_timeout,
+    providerOptions: resolveProviderOptions(config),
+    env: Object.keys(lifecycleEnv).length > 0 ? lifecycleEnv : void 0,
+    onProcess: (pid) => {
+      activeProviderPids.set(issue.id, pid);
+    },
+    shouldAbort: () => userKilledSet.has(issue.id) || userSkippedSet.has(issue.id),
+    ...extra
+  };
+}
+async function startInfra(issueId, cwd, config) {
+  const infra = discoverInfra(cwd);
+  if (!infra) return {};
+  startSpinner(`${issueId} \u2014 starting resources...`);
+  const started = await runLifecycle(infra, config.lifecycle, cwd);
+  stopSpinner();
+  if (!started.success) {
+    warn(
+      `Lifecycle startup failed for ${issueId}. Continuing with manual resource instructions.`
+    );
+  }
+  return started.env;
+}
+function startReconciliationMonitor(source, issueId, config) {
+  return source && config.reconciliation?.enabled ? startReconciliation(source, issueId, config.reconciliation, config.source_config) : null;
+}
+async function runProofOfWork(config, issue, models, cwd, logFile, workspace, lifecycleEnv, result) {
+  if (!isProofOfWorkEnabled(config.proof_of_work)) return {};
+  const pow = config.proof_of_work;
+  let retriesLeft = pow?.max_retries ?? 2;
+  while (true) {
+    if (reconciliationSet.has(issue.id)) {
+      reconciliationSet.delete(issue.id);
+      warn(`Issue ${issue.id} was closed/cancelled during validation. Skipping.`);
+      return { reconciled: true };
+    }
+    startSpinner(`${issue.id} \u2014 validating...`);
+    const results = await runValidationCommands(pow?.commands ?? [], cwd, pow?.timeout);
+    stopSpinner();
+    const failures = results.filter((r) => !r.success);
+    if (failures.length === 0) {
+      ok(`All validation checks passed for ${issue.id}`);
+      return { results };
+    }
+    if (retriesLeft <= 0) {
+      error(
+        `Validation failed after max retries for ${issue.id}. Creating PR with failures noted.`
+      );
+      return { results };
+    }
+    retriesLeft--;
+    warn(
+      `Validation failed for ${issue.id} (${retriesLeft} retries left). Re-invoking agent...`
+    );
+    const recoveryPrompt = buildValidationRecoveryPrompt(issue, failures);
+    startSpinner(`${issue.id} \u2014 fixing validation failures...`);
+    const recoveryResult = await runWithFallback(
+      models,
+      recoveryPrompt,
+      buildRunOptions(config, issue, cwd, logFile, workspace, lifecycleEnv)
+    );
+    stopSpinner();
+    if (!recoveryResult.success) {
+      error(`Validation recovery failed for ${issue.id}. Creating PR with failures noted.`);
+      return { results };
+    }
+  }
+}
+
+// src/loop/recovery.ts
+async function injectRejectedPrFeedback(workspace, issueId, prUrls) {
+  for (const prUrl of prUrls) {
+    try {
+      const feedback = await fetchPrFeedback(prUrl);
+      if (feedback.state !== "closed") continue;
+      const hasAnyFeedback = feedback.reviews.length > 0 || feedback.comments.length > 0;
+      if (!hasAnyFeedback) continue;
+      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const entryText = formatPrFeedbackEntry(feedback, issueId, date);
+      appendRawEntry(workspace, entryText);
+      ok(`Injected PR review feedback for ${issueId} into guardrails`);
+    } catch (err) {
+      warn(`Could not check PR feedback for ${issueId}: ${formatError(err)}`);
+    }
+  }
+  clearPrUrl(workspace, issueId);
+}
+async function recoverOrphanIssues(source, config) {
+  if (!config.source_config.in_progress) return;
+  if (config.source_config.in_progress === config.source_config.pick_from) return;
+  const orphanConfig = {
+    ...config.source_config,
+    pick_from: config.source_config.in_progress
+  };
+  while (true) {
+    let orphan;
+    try {
+      orphan = await source.fetchNextIssue(orphanConfig);
+    } catch (err) {
+      warn(`Failed to check for orphan issues: ${formatError(err)}`);
+      break;
+    }
+    if (!orphan) break;
+    warn(
+      `Found orphan issue ${orphan.id} stuck in "${config.source_config.in_progress}". Reverting to "${config.source_config.pick_from}".`
+    );
+    try {
+      await source.updateStatus(orphan.id, config.source_config.pick_from, config.source_config);
+      ok(`Recovered orphan ${orphan.id}`);
+    } catch (err) {
+      error(`Failed to recover orphan ${orphan.id}: ${formatError(err)}`);
+      break;
+    }
+  }
+}
+
+// src/loop/result.ts
+import { resolve as resolve4 } from "path";
+async function handleSessionResult(sessionResult, issue, previousStatus, source, config, opts) {
+  if (!sessionResult.success) {
+    if (userKilledSet.has(issue.id)) {
+      providerPausedSet.delete(issue.id);
+      warn(`Issue ${issue.id} killed by user.`);
+      try {
+        await source.updateStatus(issue.id, previousStatus, config.source_config);
+        ok(`Reverted ${issue.id} to "${previousStatus}"`);
+      } catch (err) {
+        error(`Failed to revert status: ${formatError(err)}`);
+      }
+      kanbanEmitter.emit("issue:killed", issue.id);
+      activeCleanups.delete(issue.id);
+      if (config.bell !== false) {
+        const { notify: notify2 } = await import("./terminal-X7O55P6E.js");
+        notify2();
+      }
+      return false;
+    }
+    if (userSkippedSet.has(issue.id)) {
+      providerPausedSet.delete(issue.id);
+      warn(`Issue ${issue.id} skipped by user.`);
+      try {
+        await source.updateStatus(issue.id, previousStatus, config.source_config);
+        ok(`Reverted ${issue.id} to "${previousStatus}"`);
+      } catch (err) {
+        error(`Failed to revert status: ${formatError(err)}`);
+      }
+      kanbanEmitter.emit("issue:skipped", issue.id);
+      activeCleanups.delete(issue.id);
+      if (config.bell !== false) {
+        const { notify: notify2 } = await import("./terminal-X7O55P6E.js");
+        notify2();
+      }
+      return false;
+    }
+    if (reconciliationSet.has(issue.id)) {
+      reconciliationSet.delete(issue.id);
+      warn(`Issue ${issue.id} was reconciled (status changed externally). Not reverting.`);
+      kanbanEmitter.emit("issue:skipped", issue.id);
+      activeCleanups.delete(issue.id);
+      return false;
+    }
+    error(`All models failed for ${issue.id}. Reverting to "${previousStatus}".`);
+    logAttemptHistory(sessionResult);
+    try {
+      await source.updateStatus(issue.id, previousStatus, config.source_config);
+      ok(`Reverted ${issue.id} to "${previousStatus}"`);
+      kanbanEmitter.emit("issue:reverted", issue.id);
+    } catch (err) {
+      error(`Failed to revert status: ${formatError(err)}`);
+    }
+    if (!opts.issueId) {
+      const labelToRemove = getRemoveLabel(config.source_config);
+      if (labelToRemove) {
+        try {
+          await source.removeLabel(issue.id, labelToRemove);
+          ok(`Removed label "${labelToRemove}" from ${issue.id} to prevent retry`);
+        } catch (err) {
+          warn(`Failed to remove label: ${formatError(err)}`);
+        }
+      }
+    }
+    activeCleanups.delete(issue.id);
+    return false;
+  }
+  ok(`Completed with provider: ${sessionResult.providerUsed}`);
+  if (sessionResult.prUrls.length === 0) {
+    warn(
+      `Session succeeded but no PRs created for ${issue.id}. Reverting to "${previousStatus}".`
+    );
+    try {
+      await source.updateStatus(issue.id, previousStatus, config.source_config);
+      ok(`Reverted ${issue.id} to "${previousStatus}"`);
+      kanbanEmitter.emit("issue:reverted", issue.id);
+    } catch (err) {
+      error(`Failed to revert status: ${formatError(err)}`);
+    }
+    activeCleanups.delete(issue.id);
+    return false;
+  }
+  const workspace = resolve4(config.workspace);
+  for (const prUrl of sessionResult.prUrls) {
+    try {
+      await source.attachPullRequest(issue.id, prUrl);
+      ok(`Attached PR to ${issue.id}`);
+    } catch (err) {
+      warn(`Failed to attach PR: ${formatError(err)}`);
+    }
+  }
+  try {
+    storePrUrls(workspace, issue.id, sessionResult.prUrls);
+  } catch {
+  }
+  kanbanEmitter.emit("issue:done", issue.id, sessionResult.prUrls);
+  try {
+    const doneStatus = config.source_config.done;
+    const labelToRemove = opts.issueId ? void 0 : getRemoveLabel(config.source_config);
+    await source.completeIssue(issue.id, doneStatus, labelToRemove, config.source_config);
+    ok(`Updated ${issue.id} status to "${doneStatus}"`);
+    if (labelToRemove) {
+      ok(`Removed label "${labelToRemove}" from ${issue.id}`);
+    }
+  } catch (err) {
+    error(`Failed to complete issue: ${formatError(err)}`);
+  }
+  activeCleanups.delete(issue.id);
+  stopSpinner(`\u2713 Lisa \u2014 ${issue.id} \u2014 PR created`);
+  return true;
+}
+function logAttemptHistory(result) {
+  for (const [i, attempt] of result.fallback.attempts.entries()) {
+    const status = attempt.success ? "OK" : "FAILED";
+    const error2 = attempt.error ? ` \u2014 ${attempt.error}` : "";
+    const duration = attempt.duration > 0 ? ` (${Math.round(attempt.duration / 1e3)}s)` : "";
+    warn(`  Attempt ${i + 1}: ${attempt.provider} ${status}${error2}${duration}`);
+  }
+}
+
+// src/loop/worktree-session.ts
+import { resolve as resolve6 } from "path";
+import { execa as execa3 } from "execa";
+
+// src/git/worktree.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync4, readFileSync as readFileSync4, rmSync } from "fs";
+import { join as join2 } from "path";
+import { execa as execa2 } from "execa";
+var WORKTREES_DIR = ".worktrees";
+function generateBranchName(issueId, title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").substring(0, 40).replace(/^-|-$/g, "");
+  const safeId = issueId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  return `feat/${safeId}-${slug}`;
+}
+async function cleanupOrphanedWorktree(repoRoot, branchName) {
+  const { stdout: branchList } = await execa2("git", ["branch", "--list", branchName], {
+    cwd: repoRoot,
+    reject: false
+  });
+  if (!branchList.trim()) {
+    return false;
+  }
+  const worktreePath = join2(repoRoot, WORKTREES_DIR, branchName);
+  const { stdout: worktreeList } = await execa2("git", ["worktree", "list", "--porcelain"], {
+    cwd: repoRoot,
+    reject: false
+  });
+  if (worktreeList.includes(worktreePath)) {
+    await execa2("git", ["worktree", "remove", worktreePath, "--force"], { cwd: repoRoot });
+    await execa2("git", ["worktree", "prune"], { cwd: repoRoot });
+  }
+  await execa2("git", ["branch", "-D", branchName], { cwd: repoRoot });
+  return true;
+}
+async function createWorktree(repoRoot, branchName, baseBranch) {
+  const worktreePath = join2(repoRoot, WORKTREES_DIR, branchName);
+  await cleanupOrphanedWorktree(repoRoot, branchName);
+  if (existsSync4(worktreePath)) {
+    await execa2("git", ["worktree", "remove", worktreePath, "--force"], {
+      cwd: repoRoot,
+      reject: false
+    });
+    await execa2("git", ["worktree", "prune"], { cwd: repoRoot, reject: false });
+    if (existsSync4(worktreePath)) {
+      rmSync(worktreePath, { recursive: true, force: true });
+    }
+  }
+  await execa2("git", ["fetch", "origin", baseBranch], { cwd: repoRoot });
+  await execa2("git", ["worktree", "add", "-b", branchName, worktreePath, `origin/${baseBranch}`], {
+    cwd: repoRoot
+  });
+  return worktreePath;
+}
+async function removeWorktree(repoRoot, worktreePath) {
+  await execa2("git", ["worktree", "remove", worktreePath, "--force"], {
+    cwd: repoRoot
+  });
+  await execa2("git", ["worktree", "prune"], { cwd: repoRoot });
+}
+function ensureWorktreeGitignore(repoRoot) {
+  const gitignorePath = join2(repoRoot, ".gitignore");
+  if (!existsSync4(gitignorePath)) {
+    appendFileSync2(gitignorePath, `${WORKTREES_DIR}
+`);
+    return;
+  }
+  const content = readFileSync4(gitignorePath, "utf-8");
+  if (!content.split("\n").some((line) => line.trim() === WORKTREES_DIR)) {
+    const separator = content.endsWith("\n") ? "" : "\n";
+    appendFileSync2(gitignorePath, `${separator}${WORKTREES_DIR}
+`);
+  }
+}
+async function findBranchByIssueId(repoRoot, issueId) {
+  const needle = issueId.toLowerCase();
+  const { stdout: local } = await execa2(
+    "git",
+    ["for-each-ref", "--sort=-committerdate", "--format=%(refname:short)", "refs/heads/"],
+    { cwd: repoRoot }
+  );
+  const localMatch = local.split("\n").map((b) => b.trim()).filter(Boolean).find((b) => b.toLowerCase().includes(needle));
+  if (localMatch) return localMatch;
+  const { stdout: remote } = await execa2(
+    "git",
+    ["for-each-ref", "--sort=-committerdate", "--format=%(refname:short)", "refs/remotes/origin/"],
+    { cwd: repoRoot }
+  );
+  const remoteMatch = remote.split("\n").map((b) => b.trim()).filter(Boolean).find((b) => b.toLowerCase().includes(needle));
+  if (remoteMatch) return remoteMatch.replace("origin/", "");
+  const { stdout: lsRemote } = await execa2("git", ["ls-remote", "--heads", "origin"], {
+    cwd: repoRoot
+  });
+  const lsMatch = lsRemote.split("\n").map((l) => l.trim()).filter(Boolean).map((l) => l.split("	")[1]?.replace("refs/heads/", "") ?? "").find((b) => b.toLowerCase().includes(needle));
+  if (lsMatch) return lsMatch;
+  return void 0;
+}
+function determineRepoPath(repos, issue, workspace) {
+  if (repos.length === 0) return void 0;
+  if (issue.repo) {
+    const match = repos.find((r) => r.name === issue.repo);
+    if (match) return join2(workspace, match.path);
+  }
+  for (const r of repos) {
+    if (r.match && issue.title.startsWith(r.match)) {
+      return join2(workspace, r.path);
+    }
+  }
+  const first = repos[0];
+  return first ? join2(workspace, first.path) : void 0;
+}
+async function hasCodeChanges(repoPath, baseBranch) {
+  try {
+    const { stdout } = await execa2("git", ["diff", "--stat", `${baseBranch}..HEAD`], {
+      cwd: repoPath,
+      reject: false
+    });
+    const trimmed = stdout.trim();
+    return trimmed.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function getDiffStat(repoPath, baseBranch) {
+  try {
+    const { stdout } = await execa2("git", ["diff", "--stat", `${baseBranch}..HEAD`], {
+      cwd: repoPath,
+      reject: false
+    });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+
+// src/session/hooks.ts
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_HOOK_TIMEOUT = 6e4;
+function runHook(hookName, command, cwd, env, timeoutMs) {
+  const timeout = timeoutMs ?? DEFAULT_HOOK_TIMEOUT;
+  return new Promise((resolve12) => {
+    const proc = spawn2("sh", ["-c", command], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, ...env }
+    });
+    let output = "";
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+      }, 1e3);
+    }, timeout);
+    proc.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (killed) {
+        resolve12({
+          success: false,
+          output: `${output}
+[lisa-hooks] Hook "${hookName}" timed out after ${timeout}ms`
+        });
+      } else {
+        resolve12({ success: code === 0, output });
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      resolve12({ success: false, output: `Hook spawn error: ${err.message}` });
+    });
+  });
+}
+async function executeHook(hookName, hooks, cwd, issueEnv) {
+  if (!hooks) return true;
+  const command = hooks[hookName];
+  if (!command) return true;
+  const critical = hookName === "before_run" || hookName === "after_create";
+  log(`Running hook "${hookName}": ${command}`);
+  const result = await runHook(hookName, command, cwd, issueEnv, hooks.timeout);
+  if (!result.success) {
+    const trimmed = result.output.trim().slice(-500);
+    if (critical) {
+      error(`Hook "${hookName}" failed:
+${trimmed}`);
+      return false;
+    }
+    warn(`Hook "${hookName}" failed (non-critical):
+${trimmed}`);
+  }
+  return true;
+}
+function buildHookEnv(issueId, issueTitle, branch, workspace) {
+  return {
+    LISA_ISSUE_ID: issueId,
+    LISA_ISSUE_TITLE: issueTitle,
+    LISA_BRANCH: branch,
+    LISA_WORKSPACE: workspace
+  };
+}
+
+// src/loop/manifest.ts
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5, rmdirSync, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+function readLisaManifest(cwd, issueId) {
+  const manifestPath = getManifestPath(cwd, issueId);
+  if (!existsSync5(manifestPath)) return null;
+  try {
+    return JSON.parse(readFileSync5(manifestPath, "utf-8").trim());
+  } catch {
+    warn(`Failed to parse manifest at ${manifestPath} \u2014 agent may not have written it correctly`);
+    return null;
+  }
+}
+function cleanupManifest(cwd, issueId) {
+  try {
+    unlinkSync2(getManifestPath(cwd, issueId));
+  } catch {
+  }
+}
+function readManifestFile(filePath) {
+  if (!existsSync5(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync5(filePath, "utf-8").trim());
+  } catch {
+    return null;
+  }
+}
+function extractPrUrlFromOutput(output) {
+  const patterns = [
+    /https?:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+/,
+    /https?:\/\/[^/]*gitlab[^/]*\/[^/].+?\/-\/merge_requests\/\d+/,
+    /https?:\/\/bitbucket\.org\/[^/]+\/[^/]+\/pull-requests\/\d+/
+  ];
+  for (const pattern of patterns) {
+    const match = output.match(pattern);
+    if (match) return match[0];
+  }
+  return null;
+}
+function readPlanFile(filePath) {
+  if (!existsSync5(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync5(filePath, "utf-8").trim());
+  } catch {
+    return null;
+  }
+}
+function cleanupPlanFile(filePath) {
+  try {
+    unlinkSync2(filePath);
+  } catch {
+  }
+  try {
+    const dir = dirname2(filePath);
+    if (existsSync5(dir) && readdirSync(dir).length === 0) {
+      rmdirSync(dir);
+    }
+  } catch {
+  }
+}
+
+// src/loop/multi-repo-session.ts
+import { appendFileSync as appendFileSync3 } from "fs";
+import { resolve as resolve5 } from "path";
+async function runWorktreeMultiRepoSession(config, issue, logFile, session, models, source) {
+  const workspace = resolve5(config.workspace);
+  const planPath = getPlanPath(workspace, issue.id);
+  initLogFile(logFile);
+  kanbanEmitter.emit("issue:log-file", issue.id, logFile);
+  const cachedPlan = readPlanFile(planPath);
+  let planProviderUsed = defaultProvider(models);
+  let planFallback = null;
+  let sortedSteps;
+  if (cachedPlan?.steps && cachedPlan.steps.length > 0) {
+    sortedSteps = [...cachedPlan.steps].sort((a, b) => a.order - b.order);
+    ok(
+      `Reusing cached plan for ${issue.id}: ${sortedSteps.length} step(s) \u2014 ${sortedSteps.map((s) => s.repoPath).join(" \u2192 ")}`
+    );
+  } else {
+    startSpinner(`${issue.id} \u2014 analyzing issue...`);
+    log(`Multi-repo planning phase for ${issue.id}`);
+    const globalContextMd = readContext(workspace);
+    const planPrompt = buildPlanningPrompt(issue, config, planPath, globalContextMd);
+    const planResult = await runWithFallback(
+      models,
+      planPrompt,
+      buildRunOptions(
+        config,
+        issue,
+        workspace,
+        logFile,
+        workspace,
+        {},
+        {
+          earlySuccess: () => {
+            const p = readPlanFile(planPath);
+            return !!(p?.steps && p.steps.length > 0);
+          }
+        }
+      )
+    );
+    stopSpinner();
+    planProviderUsed = planResult.providerUsed;
+    planFallback = planResult;
+    try {
+      appendFileSync3(
+        logFile,
+        `
+${"=".repeat(80)}
+Planning phase \u2014 provider: ${planResult.providerUsed}
+${planResult.output}
+`
+      );
+    } catch {
+    }
+    const plan = readPlanFile(planPath);
+    if (!plan?.steps || plan.steps.length === 0) {
+      if (!planResult.success) {
+        error(`Planning phase failed for ${issue.id}. Check ${logFile}`);
+      } else {
+        error(`Agent did not produce a valid execution plan for ${issue.id}. Aborting.`);
+      }
+      cleanupPlanFile(planPath);
+      activeProviderPids.delete(issue.id);
+      return {
+        success: false,
+        providerUsed: planResult.providerUsed,
+        prUrls: [],
+        fallback: planResult
+      };
+    }
+    if (!planResult.success) {
+      warn(
+        `Planning provider exited with error but plan file was written for ${issue.id}. Proceeding.`
+      );
+    }
+    sortedSteps = [...plan.steps].sort((a, b) => a.order - b.order);
+    ok(
+      `Plan produced ${sortedSteps.length} step(s): ${sortedSteps.map((s) => s.repoPath).join(" \u2192 ")}`
+    );
+  }
+  const defaultFallback = planFallback ?? {
+    success: true,
+    output: "",
+    duration: 0,
+    providerUsed: planProviderUsed,
+    attempts: []
+  };
+  const reconciliation = source && config.reconciliation?.enabled ? startReconciliation(source, issue.id, config.reconciliation, config.source_config) : null;
+  const prUrls = [];
+  const previousResults = [];
+  let lastFallback = defaultFallback;
+  let lastProvider = planProviderUsed;
+  for (const [i, step] of sortedSteps.entries()) {
+    if (reconciliationSet.has(issue.id)) {
+      reconciliation?.stop();
+      reconciliationSet.delete(issue.id);
+      warn(`Issue ${issue.id} was closed/cancelled externally. Skipping remaining steps.`);
+      activeProviderPids.delete(issue.id);
+      return { success: false, providerUsed: lastProvider, prUrls, fallback: lastFallback };
+    }
+    const stepNum = i + 1;
+    const isLastStep = i === sortedSteps.length - 1;
+    divider(stepNum);
+    log(`Step ${stepNum}/${sortedSteps.length}: ${step.repoPath} \u2014 ${step.scope}`);
+    const stepResult = await runMultiRepoStep(
+      config,
+      issue,
+      step,
+      previousResults,
+      logFile,
+      models,
+      stepNum,
+      isLastStep
+    );
+    lastFallback = stepResult.fallback;
+    lastProvider = stepResult.providerUsed;
+    if (!stepResult.success) {
+      error(`Step ${stepNum} failed for ${step.repoPath}. Aborting remaining steps.`);
+      activeProviderPids.delete(issue.id);
+      return {
+        success: false,
+        providerUsed: lastProvider,
+        prUrls,
+        fallback: lastFallback
+      };
+    }
+    if (stepResult.prUrl) {
+      prUrls.push(stepResult.prUrl);
+    }
+    previousResults.push({
+      repoPath: step.repoPath,
+      branch: stepResult.branch,
+      prUrl: stepResult.prUrl
+    });
+  }
+  reconciliation?.stop();
+  activeProviderPids.delete(issue.id);
+  cleanupPlanFile(planPath);
+  ok(`Session ${session} complete for ${issue.id} \u2014 ${prUrls.length} PR(s) created`);
+  return { success: true, providerUsed: lastProvider, prUrls, fallback: lastFallback };
+}
+async function runMultiRepoStep(config, issue, step, previousResults, logFile, models, stepNum, isLastStep) {
+  const repoPath = step.repoPath;
+  const defaultBranch = resolveBaseBranch(config, repoPath);
+  const branchName = generateBranchName(issue.id, issue.title);
+  const baseBranch = issue.dependency?.branch ?? defaultBranch;
+  const failResult = (providerUsed, fallback) => ({
+    success: false,
+    providerUsed,
+    branch: branchName,
+    fallback: fallback ?? { success: false, output: "", duration: 0, providerUsed, attempts: [] }
+  });
+  startSpinner(`${issue.id} step ${stepNum} \u2014 creating worktree...`);
+  let worktreePath;
+  try {
+    worktreePath = await createWorktree(repoPath, branchName, baseBranch);
+  } catch (err) {
+    stopSpinner();
+    error(`Failed to create worktree: ${formatError(err)}`);
+    return failResult(defaultProvider(models));
+  }
+  stopSpinner();
+  ok(`Worktree created at ${worktreePath}`);
+  const hookEnv = buildHookEnv(issue.id, issue.title, branchName, worktreePath);
+  if (!await executeHook("after_create", config.hooks, worktreePath, hookEnv)) {
+    await cleanupWorktree(repoPath, worktreePath);
+    return failResult(defaultProvider(models));
+  }
+  const testRunner = detectTestRunner(worktreePath);
+  if (testRunner) log(`Detected test runner: ${testRunner}`);
+  const pm = detectPackageManager(worktreePath);
+  const projectContext = analyzeProject(worktreePath);
+  const repoContextMd = readContext(repoPath);
+  const infra = discoverInfra(worktreePath);
+  let lifecycleEnv = {};
+  if (infra) {
+    startSpinner(`${issue.id} step ${stepNum} \u2014 starting resources...`);
+    const started = await runLifecycle(infra, config.lifecycle, worktreePath);
+    stopSpinner();
+    if (!started.success) {
+      warn(
+        `Lifecycle startup failed for step ${stepNum}. Continuing with manual resource instructions.`
+      );
+    }
+    lifecycleEnv = started.env;
+  }
+  if (!await executeHook("before_run", config.hooks, worktreePath, hookEnv)) {
+    await cleanupWorktree(repoPath, worktreePath);
+    return failResult(defaultProvider(models));
+  }
+  const workspace = resolve5(config.workspace);
+  const manifestPath = getManifestPath(worktreePath, issue.id);
+  const prompt = buildScopedImplementPrompt(
+    issue,
+    step,
+    previousResults,
+    testRunner,
+    pm,
+    isLastStep,
+    defaultBranch,
+    projectContext,
+    manifestPath,
+    worktreePath,
+    config.platform,
+    repoContextMd
+  );
+  startSpinner(`${issue.id} step ${stepNum} \u2014 implementing...`);
+  const result = await runWithFallback(
+    models,
+    prompt,
+    buildRunOptions(config, issue, worktreePath, logFile, workspace, lifecycleEnv)
+  );
+  stopSpinner();
+  if (infra) await stopResources();
+  try {
+    appendFileSync3(
+      logFile,
+      `
+${"=".repeat(80)}
+Step ${stepNum} \u2014 provider: ${result.providerUsed}
+${result.output}
+`
+    );
+  } catch {
+  }
+  await executeHook("after_run", config.hooks, worktreePath, hookEnv);
+  if (!result.success) {
+    error(`Step ${stepNum} implementation failed. Check ${logFile}`);
+    await executeHook("before_remove", config.hooks, worktreePath, hookEnv);
+    await cleanupWorktree(repoPath, worktreePath);
+    return { ...failResult(result.providerUsed, result), branch: branchName };
+  }
+  const manifest = readManifestFile(manifestPath);
+  let prUrl = manifest?.prUrl;
+  if (!prUrl) {
+    const extractedUrl = extractPrUrlFromOutput(result.output);
+    if (extractedUrl) {
+      warn(
+        `Manifest missing prUrl for step ${stepNum}, extracted from output: ${extractedUrl}`
+      );
+      prUrl = extractedUrl;
+    } else {
+      warn(
+        `Agent completed with code changes but no PR for step ${stepNum}. Attempting continuation...`
+      );
+      const diffStat = await getDiffStat(worktreePath, baseBranch);
+      const continuationPrompt = buildContinuationPrompt({
+        issue: { id: issue.id, title: issue.title },
+        diffStat,
+        previousOutput: result.output,
+        platform: config.platform,
+        baseBranch,
+        manifestPath
+      });
+      startSpinner(`${issue.id} step ${stepNum} \u2014 continuation...`);
+      const contResult = await runWithFallback(
+        models,
+        continuationPrompt,
+        buildRunOptions(config, issue, worktreePath, logFile, workspace, lifecycleEnv)
+      );
+      stopSpinner();
+      try {
+        appendFileSync3(
+          logFile,
+          `
+${"=".repeat(80)}
+Step ${stepNum} continuation \u2014 provider: ${contResult.providerUsed}
+${contResult.output}
+`
+        );
+      } catch {
+      }
+      if (contResult.success) {
+        const contManifest = readManifestFile(manifestPath);
+        prUrl = contManifest?.prUrl;
+        if (!prUrl) {
+          prUrl = extractPrUrlFromOutput(contResult.output) ?? void 0;
+        }
+      }
+      if (!prUrl) {
+        error(`Continuation also failed to produce PR for step ${stepNum}. Aborting.`);
+        await cleanupWorktree(repoPath, worktreePath);
+        return { ...failResult(result.providerUsed, result), branch: branchName };
+      }
+    }
+  }
+  await executeHook("before_remove", config.hooks, worktreePath, hookEnv);
+  await cleanupWorktree(repoPath, worktreePath);
+  await appendPlatformAttribution(prUrl, result.providerUsed, config.platform);
+  ok(`Step ${stepNum} complete: ${repoPath} \u2014 PR: ${prUrl}`);
+  return {
+    success: true,
+    providerUsed: result.providerUsed,
+    branch: manifest?.branch ?? branchName,
+    prUrl,
+    fallback: result
+  };
+}
+
+// src/loop/worktree-session.ts
+async function findWorktree(repoRoot, predicate) {
+  try {
+    const { stdout } = await execa3("git", ["worktree", "list", "--porcelain"], { cwd: repoRoot });
+    const lines = stdout.split("\n");
+    let currentPath = null;
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        currentPath = line.slice("worktree ".length);
+      }
+      if (line.startsWith("branch ") && predicate(line)) {
+        return currentPath;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function findWorktreeForBranch(repoRoot, branch) {
+  return findWorktree(repoRoot, (line) => line.endsWith(`/${branch}`));
+}
+async function findWorktreeByIssueId(repoRoot, issueId) {
+  if (!issueId) return null;
+  const needle = issueId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  return findWorktree(repoRoot, (line) => line.toLowerCase().includes(needle));
+}
+async function cleanupWorktree(repoRoot, worktreePath) {
+  try {
+    await removeWorktree(repoRoot, worktreePath);
+    log("Worktree cleaned up.");
+  } catch (err) {
+    warn(`Failed to clean up worktree: ${formatError(err)}`);
+  }
+}
+async function runWorktreeSession(config, issue, logFile, session, models, source) {
+  if (config.repos.length > 1) {
+    return runWorktreeMultiRepoSession(config, issue, logFile, session, models, source);
+  }
+  const workspace = resolve6(config.workspace);
+  const repoPath = determineRepoPath(config.repos, issue, workspace) ?? workspace;
+  const defaultBranch = resolveBaseBranch(config, repoPath);
+  const primaryProvider = createProvider(models[0]?.provider ?? "claude");
+  const useNativeWorktree = primaryProvider.supportsNativeWorktree === true;
+  if (useNativeWorktree) {
+    return runNativeWorktreeSession(
+      config,
+      issue,
+      logFile,
+      session,
+      models,
+      repoPath,
+      defaultBranch,
+      source
+    );
+  }
+  return runManualWorktreeSession(
+    config,
+    issue,
+    logFile,
+    session,
+    models,
+    repoPath,
+    defaultBranch,
+    source
+  );
+}
+async function runNativeWorktreeSession(config, issue, logFile, session, models, repoPath, _defaultBranch, source) {
+  const testRunner = detectTestRunner(repoPath);
+  if (testRunner) log(`Detected test runner: ${testRunner}`);
+  const pm = detectPackageManager(repoPath);
+  const projectContext = analyzeProject(repoPath);
+  const repoContextMd = readContext(repoPath);
+  const workspace = resolve6(config.workspace);
+  const hookEnv = buildHookEnv(issue.id, issue.title, "", repoPath);
+  const lifecycleEnv = await startInfra(issue.id, repoPath, config);
+  cleanupManifest(workspace, issue.id);
+  if (!await executeHook("before_run", config.hooks, repoPath, hookEnv)) {
+    return hookFailure(defaultProvider(models), "before_run hook failed");
+  }
+  const prompt = buildNativeWorktreePrompt(
+    issue,
+    repoPath,
+    testRunner,
+    pm,
+    _defaultBranch,
+    projectContext,
+    getManifestPath(workspace, issue.id),
+    config.platform,
+    repoContextMd
+  );
+  initLogFile(logFile);
+  kanbanEmitter.emit("issue:log-file", issue.id, logFile);
+  startSpinner(`${issue.id} \u2014 implementing (native worktree)...`);
+  log(`Implementing with native worktree... (log: ${logFile})`);
+  const reconciliation = startReconciliationMonitor(source, issue.id, config);
+  const result = await runWithFallback(
+    models,
+    prompt,
+    buildRunOptions(config, issue, repoPath, logFile, workspace, lifecycleEnv, {
+      useNativeWorktree: true
+    })
+  );
+  stopSpinner();
+  reconciliation?.stop();
+  if (Object.keys(lifecycleEnv).length > 0) await stopResources();
+  await executeHook("after_run", config.hooks, repoPath, hookEnv);
+  const reconciled = checkReconciliation(issue.id, result);
+  if (reconciled) {
+    cleanupManifest(workspace, issue.id);
+    return reconciled;
+  }
+  appendSessionLog(logFile, result);
+  if (!result.success) {
+    error(`Session ${session} failed for ${issue.id}. Check ${logFile}`);
+    cleanupManifest(workspace, issue.id);
+    return failureResult(result.providerUsed, result);
+  }
+  const hasChanges = await hasCodeChanges(repoPath, _defaultBranch);
+  if (!hasChanges) {
+    cleanupManifest(workspace, issue.id);
+    return emptyCommitFailure(result);
+  }
+  const manifest = readLisaManifest(workspace, issue.id);
+  cleanupManifest(workspace, issue.id);
+  let prUrl = manifest?.prUrl;
+  if (!prUrl) {
+    const extractedUrl = extractPrUrlFromOutput(result.output);
+    if (extractedUrl) {
+      warn(`Manifest missing prUrl for ${issue.id}, extracted from output: ${extractedUrl}`);
+      prUrl = extractedUrl;
+    } else {
+      error(`Agent did not produce a manifest with prUrl for ${issue.id}. Aborting.`);
+      const worktreePath2 = manifest?.branch ? await findWorktreeForBranch(repoPath, manifest.branch) : null;
+      if (worktreePath2) await cleanupWorktree(repoPath, worktreePath2);
+      return failureResult(result.providerUsed, result);
+    }
+  }
+  let worktreePath = manifest?.branch ? await findWorktreeForBranch(repoPath, manifest.branch) : null;
+  if (!worktreePath) {
+    worktreePath = await findWorktreeByIssueId(repoPath, issue.id);
+  }
+  ok(`PR created by provider: ${prUrl}`);
+  await appendPlatformAttribution(prUrl, result.providerUsed, config.platform);
+  if (worktreePath) await cleanupWorktree(repoPath, worktreePath);
+  ok(`Session ${session} complete for ${issue.id}`);
+  return {
+    success: true,
+    providerUsed: result.providerUsed,
+    prUrls: [prUrl],
+    fallback: result
+  };
+}
+async function runManualWorktreeSession(config, issue, logFile, session, models, repoPath, defaultBranch, source) {
+  const branchName = generateBranchName(issue.id, issue.title);
+  const baseBranch = issue.dependency?.branch ?? defaultBranch;
+  startSpinner(`${issue.id} \u2014 creating worktree...`);
+  log(`Creating worktree for ${branchName} (base: ${baseBranch})...`);
+  let worktreePath;
+  try {
+    worktreePath = await createWorktree(repoPath, branchName, baseBranch);
+  } catch (err) {
+    stopSpinner();
+    error(`Failed to create worktree: ${formatError(err)}`);
+    return hookFailure(defaultProvider(models), "");
+  }
+  stopSpinner();
+  ok(`Worktree created at ${worktreePath}`);
+  const hookEnv = buildHookEnv(issue.id, issue.title, branchName, worktreePath);
+  if (!await executeHook("after_create", config.hooks, worktreePath, hookEnv)) {
+    await cleanupWorktree(repoPath, worktreePath);
+    return hookFailure(defaultProvider(models), "after_create hook failed");
+  }
+  const testRunner = detectTestRunner(worktreePath);
+  if (testRunner) {
+    log(`Detected test runner: ${testRunner}`);
+  }
+  const pm = detectPackageManager(worktreePath);
+  const projectContext = analyzeProject(worktreePath);
+  const repoContextMd = readContext(repoPath);
+  const lifecycleEnv = await startInfra(issue.id, worktreePath, config);
+  const workspace = resolve6(config.workspace);
+  const manifestPath = getManifestPath(worktreePath, issue.id);
+  if (!await executeHook("before_run", config.hooks, worktreePath, hookEnv)) {
+    await cleanupWorktree(repoPath, worktreePath);
+    return hookFailure(defaultProvider(models), "before_run hook failed");
+  }
+  const prompt = buildImplementPrompt(
+    issue,
+    config,
+    testRunner,
+    pm,
+    projectContext,
+    worktreePath,
+    manifestPath,
+    repoContextMd
+  );
+  initLogFile(logFile);
+  kanbanEmitter.emit("issue:log-file", issue.id, logFile);
+  startSpinner(`${issue.id} \u2014 implementing...`);
+  log(`Implementing in worktree... (log: ${logFile})`);
+  const reconciliation = startReconciliationMonitor(source, issue.id, config);
+  const result = await runWithFallback(
+    models,
+    prompt,
+    buildRunOptions(config, issue, worktreePath, logFile, workspace, lifecycleEnv)
+  );
+  stopSpinner();
+  reconciliation?.stop();
+  if (Object.keys(lifecycleEnv).length > 0) await stopResources();
+  await executeHook("after_run", config.hooks, worktreePath, hookEnv);
+  const reconciled = checkReconciliation(issue.id, result);
+  if (reconciled) {
+    await cleanupWorktree(repoPath, worktreePath);
+    return reconciled;
+  }
+  appendSessionLog(logFile, result);
+  if (!result.success) {
+    error(`Session ${session} failed for ${issue.id}. Check ${logFile}`);
+    await executeHook("before_remove", config.hooks, worktreePath, hookEnv);
+    await cleanupWorktree(repoPath, worktreePath);
+    return failureResult(result.providerUsed, result);
+  }
+  const hasChanges = await hasCodeChanges(worktreePath, baseBranch);
+  if (!hasChanges) {
+    await executeHook("before_remove", config.hooks, worktreePath, hookEnv);
+    await cleanupWorktree(repoPath, worktreePath);
+    return emptyCommitFailure(result);
+  }
+  const powResult = await runProofOfWork(
+    config,
+    issue,
+    models,
+    worktreePath,
+    logFile,
+    workspace,
+    lifecycleEnv,
+    result
+  );
+  if (powResult.reconciled) {
+    await cleanupWorktree(repoPath, worktreePath);
+    return failureResult(result.providerUsed, result);
+  }
+  const validationResults = powResult.results;
+  const manifest = readManifestFile(manifestPath);
+  let prUrl = manifest?.prUrl;
+  if (!prUrl) {
+    const extractedUrl = extractPrUrlFromOutput(result.output);
+    if (extractedUrl) {
+      warn(`Manifest missing prUrl for ${issue.id}, extracted from output: ${extractedUrl}`);
+      prUrl = extractedUrl;
+    } else {
+      warn(
+        `Agent completed with code changes but no PR for ${issue.id}. Attempting continuation...`
+      );
+      const diffStat = await getDiffStat(worktreePath, baseBranch);
+      const continuationPrompt = buildContinuationPrompt({
+        issue: { id: issue.id, title: issue.title },
+        diffStat,
+        previousOutput: result.output,
+        platform: config.platform,
+        baseBranch,
+        manifestPath
+      });
+      startSpinner(`${issue.id} \u2014 continuation...`);
+      const contResult = await runWithFallback(
+        models,
+        continuationPrompt,
+        buildRunOptions(config, issue, worktreePath, logFile, workspace, lifecycleEnv)
+      );
+      stopSpinner();
+      appendSessionLog(logFile, contResult);
+      if (contResult.success) {
+        const contManifest = readManifestFile(manifestPath);
+        prUrl = contManifest?.prUrl;
+        if (!prUrl) {
+          prUrl = extractPrUrlFromOutput(contResult.output) ?? void 0;
+        }
+      }
+      if (!prUrl) {
+        error(`Continuation also failed to produce PR for ${issue.id}. Aborting.`);
+        await executeHook("before_remove", config.hooks, worktreePath, hookEnv);
+        await cleanupWorktree(repoPath, worktreePath);
+        return {
+          success: false,
+          providerUsed: result.providerUsed,
+          prUrls: [],
+          fallback: contResult
+        };
+      }
+    }
+  }
+  ok(`PR created by provider: ${prUrl}`);
+  await appendPlatformAttribution(prUrl, result.providerUsed, config.platform);
+  if (validationResults) {
+    await appendPlatformProofOfWork(prUrl, validationResults, config.platform);
+  }
+  await executeHook("before_remove", config.hooks, worktreePath, hookEnv);
+  await cleanupWorktree(repoPath, worktreePath);
+  ok(`Session ${session} complete for ${issue.id}`);
+  return {
+    success: true,
+    providerUsed: result.providerUsed,
+    prUrls: [prUrl],
+    fallback: result
+  };
+}
+
+// src/loop/concurrent.ts
+async function runConcurrentLoop(config, source, models, workspace, opts) {
+  const concurrency = opts.concurrency;
+  const loopStart = Date.now();
+  let completedCount = 0;
+  let sessionCounter = 0;
+  let noMoreIssues = false;
+  let exhausted = false;
+  let consecutiveFetchErrors = 0;
+  const MAX_CONSECUTIVE_FETCH_ERRORS = 3;
+  const activeWorkers = /* @__PURE__ */ new Map();
+  const claimedIssueIds = /* @__PURE__ */ new Set();
+  let consecutiveExhaustions = 0;
+  const MAX_CONSECUTIVE_EXHAUSTIONS = 3;
+  const processIssue = async (issue, session) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
+    const logFile = resolve7(getLogsDir(workspace), `session_${session}_${timestamp}.log`);
+    ok(`Picked up: ${issue.id} \u2014 ${issue.title}`);
+    const cachedPrUrls = loadPrUrls(workspace, issue.id);
+    if (cachedPrUrls.length > 0) {
+      await injectRejectedPrFeedback(workspace, issue.id, cachedPrUrls);
+    }
+    await checkIssueSpec(issue, config, source);
+    kanbanEmitter.emit("issue:queued", issue);
+    const previousStatus = config.source_config.pick_from;
+    kanbanEmitter.emit("issue:started", issue.id);
+    await moveToInProgress(issue, source, config);
+    activeCleanups.set(issue.id, { previousStatus, source, sourceConfig: config.source_config });
+    let sessionResult;
+    try {
+      sessionResult = await runWorktreeSession(config, issue, logFile, session, models, source);
+    } catch (err) {
+      error(`Unhandled error in session for ${issue.id}: ${formatError(err)}`);
+      await revertIssueStatus(issue, source, config);
+      activeCleanups.delete(issue.id);
+      activeProviderPids.delete(issue.id);
+      if (config.bell !== false) notify(2);
+      return;
+    }
+    const completed = await handleSessionResult(
+      sessionResult,
+      issue,
+      previousStatus,
+      source,
+      config,
+      opts
+    );
+    if (completed) completedCount++;
+    if (!sessionResult.success && !userKilledSet.has(issue.id) && !userSkippedSet.has(issue.id) && isCompleteProviderExhaustion(sessionResult.fallback.attempts)) {
+      consecutiveExhaustions++;
+      if (consecutiveExhaustions >= MAX_CONSECUTIVE_EXHAUSTIONS) {
+        exhausted = true;
+        error(
+          "All providers exhausted due to infrastructure issues. Fix your provider configuration and restart lisa."
+        );
+      } else {
+        warn(
+          `Provider exhausted for ${issue.id} (${consecutiveExhaustions}/${MAX_CONSECUTIVE_EXHAUSTIONS}). Continuing with next issue.`
+        );
+      }
+    } else if (sessionResult.success) {
+      consecutiveExhaustions = 0;
+    }
+    userKilledSet.delete(issue.id);
+    userSkippedSet.delete(issue.id);
+    providerPausedSet.delete(issue.id);
+    activeProviderPids.delete(issue.id);
+    activeCleanups.delete(issue.id);
+    claimedIssueIds.delete(issue.id);
+  };
+  while (!noMoreIssues && !exhausted) {
+    await waitIfPaused();
+    while (activeWorkers.size < concurrency && !noMoreIssues && !exhausted) {
+      const tentativeSession = sessionCounter + 1;
+      if (opts.limit > 0 && tentativeSession > opts.limit) {
+        ok(`Reached limit of ${opts.limit} issues. Stopping.`);
+        noMoreIssues = true;
+        break;
+      }
+      let issue;
+      try {
+        issue = await source.fetchNextIssue(config.source_config);
+        consecutiveFetchErrors = 0;
+      } catch (err) {
+        consecutiveFetchErrors++;
+        error(`Failed to fetch issues: ${formatError(err)}`);
+        if (consecutiveFetchErrors >= MAX_CONSECUTIVE_FETCH_ERRORS) {
+          error(
+            `Stopping after ${MAX_CONSECUTIVE_FETCH_ERRORS} consecutive fetch failures.`
+          );
+          noMoreIssues = true;
+        } else {
+          await sleep(config.loop.cooldown * 1e3);
+        }
+        break;
+      }
+      if (issue && claimedIssueIds.has(issue.id)) {
+        log(`Issue ${issue.id} already claimed by another worker. Skipping.`);
+        break;
+      }
+      if (!issue) {
+        if (opts.watch) {
+          if (activeWorkers.size === 0) {
+            if (completedCount > 0) {
+              ok(`All issues resolved. Prompting user to continue watching...`);
+              kanbanEmitter.emit("work:watch-prompt");
+              setTitle("Lisa \u2014 all resolved");
+              await waitIfPaused();
+              if (hasUserQuitFromWatchPrompt() || isShuttingDown()) {
+                noMoreIssues = true;
+                break;
+              }
+              kanbanEmitter.emit("work:watch-prompt-resumed");
+              ok(`Resuming watch mode (polling every ${WATCH_POLL_INTERVAL_MS / 1e3}s)...`);
+            }
+            ok(
+              `No issues ready. Watching for new issues (polling every ${WATCH_POLL_INTERVAL_MS / 1e3}s)...`
+            );
+            kanbanEmitter.emit("work:watching");
+            setTitle("Lisa \u2014 watching...");
+            await sleep(WATCH_POLL_INTERVAL_MS);
+            kanbanEmitter.emit("work:watch-resume");
+          }
+          break;
+        }
+        if (activeWorkers.size === 0) {
+          ok(`No more issues with label '${formatLabels(config.source_config)}'.`);
+          await refreshKanban(source, config);
+          kanbanEmitter.emit("work:empty");
+          setTitle("Lisa \u2014 idle");
+          await waitForResume();
+          if (isShuttingDown() || hasUserQuitFromWatchPrompt()) {
+            noMoreIssues = true;
+            break;
+          }
+          kanbanEmitter.emit("work:resumed");
+        }
+        break;
+      }
+      sessionCounter = tentativeSession;
+      const session = sessionCounter;
+      claimedIssueIds.add(issue.id);
+      const promise = processIssue(issue, session).finally(() => {
+        activeWorkers.delete(issue.id);
+      });
+      activeWorkers.set(issue.id, promise);
+    }
+    if (activeWorkers.size === 0 && !opts.watch) break;
+    if (activeWorkers.size === 0) continue;
+    await Promise.race([...activeWorkers.values()]);
+    if (!noMoreIssues && !exhausted && activeWorkers.size < concurrency) {
+      await sleep(1e3);
+    }
+  }
+  if (activeWorkers.size > 0) {
+    log(`Waiting for ${activeWorkers.size} active worker(s) to finish...`);
+    await Promise.allSettled([...activeWorkers.values()]);
+  }
+  if (completedCount > 0) {
+    await checkoutBaseBranches(config, workspace);
+    kanbanEmitter.emit("work:complete", {
+      total: completedCount,
+      duration: Date.now() - loopStart
+    });
+  }
+  resetTitle();
+  ok(`lisa finished. ${sessionCounter} session(s) run, ${completedCount} completed.`);
+}
+
+// src/loop/context-generation.ts
+import { resolve as resolve8 } from "path";
+function buildContextGenerationPrompt(repoPath, outputPath) {
+  return `You are a project analyst. Your job is to document this repository so that future autonomous agents can work in it correctly.
+
+Repository path: \`${repoPath}\`
+
+Read the project files and write \`${outputPath}\` with a concise markdown document covering:
+
+1. **Stack & Tools**: tools detected in this project and the EXACT commands to use (e.g., if package.json has a \`generate\` script, say "run \`pnpm run generate\` \u2014 not \`npx orval\` directly")
+2. **File conventions**: where generated files live, migration naming patterns, any naming conventions observed from existing files
+3. **Constraints**: anything an agent should NOT do (e.g., "do not run migrations manually \u2014 always use the \`db:push\` script")
+
+Rules:
+- Be concise \u2014 max 300 words. This is injected into every agent prompt.
+- Write only what is non-obvious. Do NOT explain what tools are \u2014 only how they are used in THIS project.
+- If nothing non-obvious exists (e.g., a plain Node.js project with no special tooling), write a single line: "No special tooling conventions."
+- Do NOT create branches, commit, or make any changes other than writing \`${outputPath}\`.`;
+}
+function buildGlobalContextGenerationPrompt(repos, outputPath) {
+  const repoList = repos.map((r) => `- **${r.name}**: \`${r.path}\``).join("\n");
+  return `You are a project analyst for a multi-repo workspace. Your job is to document the relationships between repositories so that future autonomous agents can coordinate work across them correctly.
+
+Repositories:
+${repoList}
+
+Read the relevant config files in each repository and write \`${outputPath}\` with a concise markdown document covering:
+
+1. **Repo relationships**: how repos depend on each other (e.g., "frontend reads backend OpenAPI spec from http://localhost:3000/openapi.json")
+2. **Execution ordering rules**: which repo must be implemented first when multiple repos are affected (e.g., "backend changes must precede frontend API client regeneration")
+3. **Shared conventions**: anything that applies across all repos
+
+Rules:
+- Be concise \u2014 max 200 words.
+- Document only the relationship and ordering information. Repo-specific tooling goes in each repo's own context.md.
+- If repos are independent (no API sharing, no codegen), write: "Repos are independent \u2014 no cross-repo execution ordering constraints."
+- Do NOT create branches, commit, or make any changes other than writing \`${outputPath}\`.`;
+}
+async function generateRepoContext(repoPath, models, logFile, guardrailsDir) {
+  if (contextExists(repoPath)) return;
+  log(`Generating context for ${repoPath}...`);
+  const outputPath = getContextPath(repoPath);
+  const prompt = buildContextGenerationPrompt(repoPath, outputPath);
+  try {
+    await runWithFallback(models, prompt, {
+      logFile,
+      cwd: repoPath,
+      guardrailsDir,
+      issueId: "__context_gen__"
+    });
+    ok(`Context generated: ${outputPath}`);
+  } catch (err) {
+    warn(
+      `Context generation failed for ${repoPath}: ${formatError(err)}. Proceeding without context.md.`
+    );
+  }
+}
+async function generateGlobalContext(workspacePath, repos, models, logFile) {
+  if (contextExists(workspacePath)) return;
+  log("Generating global workspace context...");
+  const outputPath = getContextPath(workspacePath);
+  const prompt = buildGlobalContextGenerationPrompt(repos, outputPath);
+  try {
+    await runWithFallback(models, prompt, {
+      logFile,
+      cwd: workspacePath,
+      guardrailsDir: workspacePath,
+      issueId: "__context_gen_global__"
+    });
+    ok(`Global context generated: ${outputPath}`);
+  } catch (err) {
+    warn(
+      `Global context generation failed: ${formatError(err)}. Proceeding without global context.md.`
+    );
+  }
+}
+async function ensureWorkspaceContext(config, models, workspace, logFile) {
+  const isMultiRepo = config.repos.length > 1;
+  if (isMultiRepo) {
+    const repoList = config.repos.map((r) => ({
+      name: r.name,
+      path: resolve8(workspace, r.path)
+    }));
+    await generateGlobalContext(workspace, repoList, models, logFile);
+    for (const repo of config.repos) {
+      const absPath = resolve8(workspace, repo.path);
+      await generateRepoContext(absPath, models, logFile, workspace);
+    }
+  } else {
+    await generateRepoContext(workspace, models, logFile, workspace);
+  }
+}
+
+// src/loop/sequential.ts
+import { resolve as resolve10 } from "path";
+
+// src/git/dependency.ts
+import { execa as execa4 } from "execa";
+async function resolveDependency(repoPath, blockerIssueId, baseBranch) {
+  const branch = await findBranchByIssueId(repoPath, blockerIssueId);
+  if (!branch) return null;
+  const prInfo = await findOpenPr(branch);
+  if (!prInfo) return null;
+  const changedFiles = await getChangedFiles(repoPath, baseBranch, branch);
+  return {
+    issueId: blockerIssueId,
+    branch,
+    prUrl: prInfo.url,
+    changedFiles
+  };
+}
+async function resolveFirstDependency(repoPath, blockerIds, baseBranch) {
+  for (const blockerId of blockerIds) {
+    const dep = await resolveDependency(repoPath, blockerId, baseBranch);
+    if (dep) return dep;
+  }
+  return null;
+}
+async function findOpenPr(branch) {
+  try {
+    const { stdout } = await execa4("gh", [
+      "pr",
+      "list",
+      "--head",
+      branch,
+      "--state",
+      "open",
+      "--json",
+      "url,state",
+      "--limit",
+      "1"
+    ]);
+    const prs = JSON.parse(stdout);
+    if (prs.length === 0) return null;
+    return prs[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getChangedFiles(repoPath, baseBranch, dependencyBranch) {
+  try {
+    await execa4("git", ["fetch", "origin", dependencyBranch], {
+      cwd: repoPath,
+      reject: false
+    });
+    const { stdout } = await execa4(
+      "git",
+      ["diff", "--name-only", `origin/${baseBranch}...origin/${dependencyBranch}`],
+      { cwd: repoPath }
+    );
+    return stdout.split("\n").map((f) => f.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// src/loop/branch-session.ts
+import { unlinkSync as unlinkSync3 } from "fs";
+import { resolve as resolve9 } from "path";
+async function runBranchSession(config, issue, logFile, session, models, source) {
+  const workspace = resolve9(config.workspace);
+  const manifestPath = getManifestPath(workspace, issue.id);
+  const hookEnv = buildHookEnv(issue.id, issue.title, "", workspace);
+  try {
+    unlinkSync3(manifestPath);
+  } catch {
+  }
+  const testRunner = detectTestRunner(workspace);
+  if (testRunner) {
+    log(`Detected test runner: ${testRunner}`);
+  }
+  const pm = detectPackageManager(workspace);
+  const projectContext = analyzeProject(workspace);
+  const repoContextMd = readContext(workspace);
+  const lifecycleEnv = await startInfra(issue.id, workspace, config);
+  if (!await executeHook("before_run", config.hooks, workspace, hookEnv)) {
+    return hookFailure(defaultProvider(models), "before_run hook failed");
+  }
+  const prompt = buildImplementPrompt(
+    issue,
+    config,
+    testRunner,
+    pm,
+    projectContext,
+    workspace,
+    manifestPath,
+    repoContextMd
+  );
+  initLogFile(logFile);
+  kanbanEmitter.emit("issue:log-file", issue.id, logFile);
+  startSpinner(`${issue.id} \u2014 implementing...`);
+  log(`Implementing... (log: ${logFile})`);
+  const reconciliation = startReconciliationMonitor(source, issue.id, config);
+  const result = await runWithFallback(
+    models,
+    prompt,
+    buildRunOptions(config, issue, workspace, logFile, workspace, lifecycleEnv)
+  );
+  stopSpinner();
+  reconciliation?.stop();
+  await stopResources();
+  await executeHook("after_run", config.hooks, workspace, hookEnv);
+  const reconciled = checkReconciliation(issue.id, result);
+  if (reconciled) return reconciled;
+  appendSessionLog(logFile, result);
+  if (!result.success) {
+    error(`Session ${session} failed for ${issue.id}. Check ${logFile}`);
+    return failureResult(result.providerUsed, result);
+  }
+  const hasChanges = await hasCodeChanges(workspace, config.base_branch);
+  if (!hasChanges) {
+    return emptyCommitFailure(result);
+  }
+  const pow = await runProofOfWork(
+    config,
+    issue,
+    models,
+    workspace,
+    logFile,
+    workspace,
+    lifecycleEnv,
+    result
+  );
+  if (pow.reconciled) {
+    return failureResult(result.providerUsed, result);
+  }
+  const validationResults = pow.results;
+  const manifest = readManifestFile(manifestPath);
+  try {
+    unlinkSync3(manifestPath);
+  } catch {
+  }
+  let prUrl = manifest?.prUrl;
+  if (!prUrl) {
+    const extractedUrl = extractPrUrlFromOutput(result.output);
+    if (extractedUrl) {
+      warn(`Manifest missing prUrl for ${issue.id}, extracted from output: ${extractedUrl}`);
+      prUrl = extractedUrl;
+    } else {
+      error(`Agent did not produce a manifest with prUrl for ${issue.id}.`);
+      return failureResult(result.providerUsed, result);
+    }
+  }
+  ok(`PR created by provider: ${prUrl}`);
+  await appendPlatformAttribution(prUrl, result.providerUsed, config.platform);
+  if (validationResults) {
+    await appendPlatformProofOfWork(prUrl, validationResults, config.platform);
+  }
+  ok(`Session ${session} complete for ${issue.id}`);
+  return {
+    success: true,
+    providerUsed: result.providerUsed,
+    prUrls: [prUrl],
+    fallback: result
+  };
+}
+
+// src/loop/sequential.ts
+async function runSequentialLoop(config, source, models, workspace, opts) {
+  let session = 0;
+  const loopStart = Date.now();
+  let completedCount = 0;
+  let consecutiveFetchErrors = 0;
+  const MAX_CONSECUTIVE_FETCH_ERRORS = 3;
+  let consecutiveExhaustions = 0;
+  const MAX_CONSECUTIVE_EXHAUSTIONS = 3;
+  while (true) {
+    session++;
+    if (opts.limit > 0 && session > opts.limit) {
+      ok(`Reached limit of ${opts.limit} issues. Stopping.`);
+      break;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
+    const logFile = resolve10(getLogsDir(workspace), `session_${session}_${timestamp}.log`);
+    divider(session);
+    await waitIfPaused();
+    startSpinner("fetching issue...");
+    if (opts.issueId) {
+      log(`Fetching issue '${opts.issueId}' from ${config.source}...`);
+    } else {
+      log(
+        `Fetching next '${formatLabels(config.source_config)}' issue from ${config.source}...`
+      );
+    }
+    if (opts.dryRun) {
+      stopSpinner();
+      if (opts.issueId) {
+        log(`[dry-run] Would fetch issue '${opts.issueId}' from ${config.source}`);
+      } else {
+        log(
+          `[dry-run] Would fetch issue from ${config.source} (${config.source_config.scope}/${config.source_config.project})`
+        );
+      }
+      log(`[dry-run] Workflow mode: ${config.workflow}`);
+      log(
+        `[dry-run] Models priority: ${models.map((m) => m.model ? `${m.provider}/${m.model}` : m.provider).join(" \u2192 ")}`
+      );
+      log("[dry-run] Then implement, push, create PR, and update issue status");
+      break;
+    }
+    let issue;
+    try {
+      issue = opts.issueId ? await source.fetchIssueById(opts.issueId) : await source.fetchNextIssue(config.source_config);
+      consecutiveFetchErrors = 0;
+    } catch (err) {
+      stopSpinner();
+      consecutiveFetchErrors++;
+      error(`Failed to fetch issues: ${formatError(err)}`);
+      if (opts.once || consecutiveFetchErrors >= MAX_CONSECUTIVE_FETCH_ERRORS) {
+        if (consecutiveFetchErrors >= MAX_CONSECUTIVE_FETCH_ERRORS) {
+          error(
+            `Stopping after ${MAX_CONSECUTIVE_FETCH_ERRORS} consecutive fetch failures.`
+          );
+        }
+        break;
+      }
+      setTitle("Lisa \u2014 cooling down...");
+      await sleep(config.loop.cooldown * 1e3);
+      continue;
+    }
+    stopSpinner();
+    if (!issue) {
+      if (opts.issueId) {
+        error(`Issue '${opts.issueId}' not found.`);
+        break;
+      }
+      if (opts.watch) {
+        if (completedCount > 0) {
+          ok(`All issues resolved. Prompting user to continue watching...`);
+          kanbanEmitter.emit("work:watch-prompt");
+          setTitle("Lisa \u2014 all resolved");
+          await waitIfPaused();
+          if (hasUserQuitFromWatchPrompt() || isShuttingDown()) {
+            break;
+          }
+          kanbanEmitter.emit("work:watch-prompt-resumed");
+          ok(`Resuming watch mode (polling every ${WATCH_POLL_INTERVAL_MS / 1e3}s)...`);
+          kanbanEmitter.emit("work:watching");
+          setTitle("Lisa \u2014 watching...");
+          await sleep(WATCH_POLL_INTERVAL_MS);
+          kanbanEmitter.emit("work:watch-resume");
+          session--;
+          continue;
+        }
+        ok(
+          `No issues ready. Watching for new issues (polling every ${WATCH_POLL_INTERVAL_MS / 1e3}s)...`
+        );
+        kanbanEmitter.emit("work:watching");
+        setTitle("Lisa \u2014 watching...");
+        await sleep(WATCH_POLL_INTERVAL_MS);
+        kanbanEmitter.emit("work:watch-resume");
+        session--;
+        continue;
+      }
+      ok(`No more issues with label '${formatLabels(config.source_config)}'.`);
+      await refreshKanban(source, config);
+      kanbanEmitter.emit("work:empty");
+      setTitle("Lisa \u2014 idle");
+      await waitForResume();
+      if (isShuttingDown() || hasUserQuitFromWatchPrompt()) {
+        break;
+      }
+      kanbanEmitter.emit("work:resumed");
+      session--;
+      continue;
+    }
+    ok(`Picked up: ${issue.id} \u2014 ${issue.title}`);
+    setTitle(`Lisa \u2014 ${issue.id}`);
+    const cachedPrUrls = loadPrUrls(workspace, issue.id);
+    if (cachedPrUrls.length > 0) {
+      await injectRejectedPrFeedback(workspace, issue.id, cachedPrUrls);
+    }
+    await checkIssueSpec(issue, config, source);
+    if (issue.completedBlockerIds && issue.completedBlockerIds.length > 0) {
+      const repoPath = determineRepoPath(config.repos, issue, workspace) ?? workspace;
+      const baseBranch = resolveBaseBranch(config, repoPath);
+      startSpinner(`${issue.id} \u2014 resolving dependency...`);
+      const dep = await resolveFirstDependency(repoPath, issue.completedBlockerIds, baseBranch);
+      stopSpinner();
+      if (dep) {
+        issue.dependency = dep;
+        ok(
+          `Dependency resolved: ${dep.issueId} \u2192 branch ${dep.branch} (${dep.changedFiles.length} changed files)`
+        );
+      }
+    }
+    kanbanEmitter.emit("issue:queued", issue);
+    const previousStatus = config.source_config.pick_from;
+    kanbanEmitter.emit("issue:started", issue.id);
+    await moveToInProgress(issue, source, config);
+    activeCleanups.set(issue.id, { previousStatus, source, sourceConfig: config.source_config });
+    let sessionResult;
+    try {
+      sessionResult = config.workflow === "worktree" ? await runWorktreeSession(config, issue, logFile, session, models, source) : await runBranchSession(config, issue, logFile, session, models, source);
+    } catch (err) {
+      stopSpinner();
+      error(`Unhandled error in session for ${issue.id}: ${formatError(err)}`);
+      await revertIssueStatus(issue, source, config);
+      activeCleanups.delete(issue.id);
+      if (config.bell !== false) notify(2);
+      if (opts.once) break;
+      log(`Cooling down ${config.loop.cooldown}s before next issue...`);
+      setTitle("Lisa \u2014 cooling down...");
+      await sleep(config.loop.cooldown * 1e3);
+      continue;
+    }
+    const completed = await handleSessionResult(
+      sessionResult,
+      issue,
+      previousStatus,
+      source,
+      config,
+      opts
+    );
+    if (completed) completedCount++;
+    if (opts.once) {
+      log("Single iteration mode. Exiting.");
+      break;
+    }
+    if (!sessionResult.success && !userKilledSet.has(issue.id) && !userSkippedSet.has(issue.id) && isCompleteProviderExhaustion(sessionResult.fallback.attempts)) {
+      consecutiveExhaustions++;
+      if (consecutiveExhaustions >= MAX_CONSECUTIVE_EXHAUSTIONS) {
+        error(
+          "All providers exhausted due to infrastructure issues (quota, plan limits, or not installed). Fix your provider configuration and restart lisa."
+        );
+        break;
+      }
+      warn(
+        `Provider exhausted for ${issue.id} (${consecutiveExhaustions}/${MAX_CONSECUTIVE_EXHAUSTIONS}). Continuing with next issue.`
+      );
+    } else if (sessionResult.success) {
+      consecutiveExhaustions = 0;
+    }
+    userKilledSet.delete(issue.id);
+    userSkippedSet.delete(issue.id);
+    providerPausedSet.delete(issue.id);
+    log(`Cooling down ${config.loop.cooldown}s before next issue...`);
+    setTitle("Lisa \u2014 cooling down...");
+    await sleep(config.loop.cooldown * 1e3);
+  }
+  if (completedCount > 0) {
+    await checkoutBaseBranches(config, workspace);
+    kanbanEmitter.emit("work:complete", {
+      total: completedCount,
+      duration: Date.now() - loopStart
+    });
+  }
+  resetTitle();
+  ok(`lisa finished. ${session} session(s) run.`);
+}
+
+// src/loop/signals.ts
+function installSignalHandlers(onBeforeExit) {
+  const cleanup = async (signal) => {
+    if (isShuttingDown()) {
+      warn("Force exiting...");
+      process.exit(1);
+    }
+    setShuttingDown(true);
+    stopSpinner();
+    resetTitle();
+    warn(`Received ${signal}. Reverting active issues...`);
+    for (const [, pid] of activeProviderPids) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    const revertPromises = [...activeCleanups.entries()].map(
+      async ([issueId, { previousStatus, source, sourceConfig }]) => {
+        try {
+          await Promise.race([
+            source.updateStatus(issueId, previousStatus, sourceConfig),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("Revert timed out")), 5e3)
+            )
+          ]);
+          ok(`Reverted ${issueId} to "${previousStatus}"`);
+        } catch (err) {
+          error(`Failed to revert ${issueId}: ${formatError(err)}`);
+        }
+        kanbanEmitter.emit("issue:reverted", issueId);
+      }
+    );
+    await Promise.allSettled(revertPromises);
+    const hasTUI = kanbanEmitter.listenerCount("tui:exit") > 0;
+    kanbanEmitter.emit("tui:exit");
+    if (hasTUI) {
+      await new Promise((resolve12) => setTimeout(resolve12, 250));
+    }
+    onBeforeExit?.();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => {
+    cleanup("SIGINT");
+  });
+  process.on("SIGTERM", () => {
+    cleanup("SIGTERM");
+  });
+}
+
+// src/loop/demo.ts
+async function runDemoLoop() {
+  const demoIssues = [
+    { id: "INT-514", title: "Dark mode UI" },
+    { id: "INT-513", title: "WebSocket leak fix" },
+    { id: "INT-512", title: "Rate limiter middleware" },
+    { id: "INT-511", title: "Sidebar navigation icons" },
+    { id: "INT-510", title: "Blog post CRUD" },
+    { id: "INT-509", title: "Admin FAQ management" },
+    { id: "INT-508", title: "Changelog CRUD" }
+  ];
+  await sleep(3e3);
+  kanbanEmitter.emit("provider:model-changed", "claude-sonnet-4-6");
+  await sleep(400);
+  for (const issue of demoIssues) {
+    kanbanEmitter.emit("issue:queued", {
+      id: issue.id,
+      title: issue.title,
+      description: "",
+      url: ""
+    });
+    await sleep(200);
+  }
+  await sleep(1e3);
+  const issue1 = demoIssues[0];
+  kanbanEmitter.emit("issue:started", issue1.id);
+  const outputs1 = [
+    "Reading issue description...\n",
+    "Analyzing codebase structure...\n",
+    "Creating src/theme/dark-mode.ts...\n",
+    "Updating CSS variables for dark palette...\n",
+    "Adding toggle component...\n",
+    "Running tests... all passing \u2713\n",
+    "Pushing branch int-514-dark-mode-ui...\n"
+  ];
+  for (const line of outputs1) {
+    kanbanEmitter.emit("issue:output", issue1.id, line);
+    await sleep(500);
+  }
+  kanbanEmitter.emit("issue:done", issue1.id, ["https://github.com/acme/webapp/pull/91"]);
+  await sleep(1e3);
+  const issue2 = demoIssues[1];
+  kanbanEmitter.emit("issue:started", issue2.id);
+  const outputs2 = [
+    "Reading issue description...\n",
+    "Locating WebSocket connection handler...\n",
+    "Patching connection lifecycle in src/ws/handler.ts...\n",
+    "Adding cleanup in disconnect callback...\n",
+    "Running tests... all passing \u2713\n",
+    "Pushing branch int-513-fix-ws-leak...\n"
+  ];
+  for (const line of outputs2) {
+    kanbanEmitter.emit("issue:output", issue2.id, line);
+    await sleep(500);
+  }
+  kanbanEmitter.emit("issue:done", issue2.id, ["https://github.com/acme/webapp/pull/92"]);
+  await sleep(1e3);
+  const issue3 = demoIssues[2];
+  kanbanEmitter.emit("issue:started", issue3.id);
+  const outputs3 = [
+    "Reading issue description...\n",
+    "Creating src/middleware/rateLimiter.ts...\n",
+    "Writing sliding window rate limiter...\n",
+    "Adding tests in rateLimiter.test.ts...\n",
+    "Running tests... all passing \u2713\n",
+    "Pushing branch int-512-rate-limiting...\n"
+  ];
+  for (const line of outputs3) {
+    kanbanEmitter.emit("issue:output", issue3.id, line);
+    await sleep(500);
+  }
+  kanbanEmitter.emit("issue:done", issue3.id, ["https://github.com/acme/webapp/pull/93"]);
+  await sleep(1e3);
+  kanbanEmitter.emit("work:complete", { total: 3, duration: 127e3 });
+  await sleep(4e3);
+  kanbanEmitter.emit("tui:exit");
+}
+
+// src/loop/index.ts
+setupEventListeners();
+async function runLoop(config, opts) {
+  const source = createSource(config.source);
+  const models = resolveModels(config);
+  const workspace = resolve11(config.workspace);
+  const concurrency = opts.concurrency;
+  installSignalHandlers(opts.onBeforeExit);
+  ensureCacheDir(workspace);
+  migrateGuardrails(workspace);
+  rotateLogFiles(workspace);
+  if (!opts.dryRun) {
+    const contextLogFile = join3(workspace, ".lisa", "context-generation.log");
+    ensureWorkspaceContext(config, models, workspace, contextLogFile).catch((err) => {
+      warn(`Background context generation failed: ${formatError(err)}`);
+    });
+  }
+  log(
+    `Starting loop (models: ${models.map((m) => m.model ? `${m.provider}/${m.model}` : m.provider).join(" \u2192 ")}, source: ${config.source}, label: ${formatLabels(config.source_config)}, workflow: ${config.workflow}${concurrency > 1 ? `, concurrency: ${concurrency}` : ""})`
+  );
+  if (!opts.dryRun) {
+    await recoverOrphanIssues(source, config);
+  }
+  if (kanbanEmitter.listenerCount("issue:queued") > 0) {
+    try {
+      const allIssues = await source.listIssues(config.source_config);
+      const activeIssueIds = new Set(allIssues.map((i) => i.id));
+      if (opts.initialCards) {
+        for (const card of opts.initialCards) {
+          if (card.column === "backlog" && !activeIssueIds.has(card.id)) {
+            kanbanEmitter.emit("issue:reconcile-remove", card.id);
+            log(`Reconciled ${card.id}: no longer in source queue \u2014 removed from kanban`);
+          }
+        }
+      }
+      for (const issue of allIssues) {
+        kanbanEmitter.emit("issue:queued", issue);
+      }
+    } catch {
+    }
+  }
+  if (concurrency <= 1) {
+    await runSequentialLoop(config, source, models, workspace, opts);
+  } else {
+    await runConcurrentLoop(config, source, models, workspace, opts);
+  }
+}
+
+export {
+  validateConfig,
+  configExists,
+  findConfigDir,
+  loadConfig,
+  saveConfig,
+  mergeWithFlags,
+  getRemoveLabel,
+  formatLabels,
+  ensureWorktreeGitignore,
+  buildContextGenerationPrompt,
+  buildGlobalContextGenerationPrompt,
+  checkoutBaseBranches,
+  runDemoLoop,
+  runLoop
+};