@kody-ade/kody-engine-lite 0.1.109 → 0.1.110

package/dist/bin/cli.js

@@ -998,6 +998,180 @@ var init_task_resolution = __esm({
   }
 });
 
+// src/cli/litellm.ts
+import * as fs10 from "fs";
+import * as os from "os";
+import * as path9 from "path";
+import { execFileSync as execFileSync9 } from "child_process";
+async function checkLitellmHealth(url) {
+  try {
+    const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function checkModelHealth(baseUrl, apiKey, model) {
+  try {
+    const res = await fetch(`${baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 4,
+        messages: [{ role: "user", content: "Reply with: ok" }]
+      }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      const body2 = await res.text().catch(() => "");
+      return { ok: false, error: `HTTP ${res.status}: ${body2.slice(0, 200)}` };
+    }
+    const body = await res.json();
+    const hasAnthropicContent = Array.isArray(body.content) && body.content.some((b) => b.type === "text");
+    const hasThinkingContent = Array.isArray(body.content) && body.content.some((b) => b.type === "thinking");
+    const hasOpenAIContent = !!body.choices?.[0]?.message?.content;
+    if (!hasAnthropicContent && !hasThinkingContent && !hasOpenAIContent) {
+      return { ok: false, error: `Unexpected response format: ${JSON.stringify(body).slice(0, 200)}` };
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function generateLitellmConfig(provider, modelMap) {
+  const apiKeyVar = providerApiKeyEnvVar(provider);
+  const entries = ["model_list:"];
+  const seen = /* @__PURE__ */ new Set();
+  for (const providerModel of Object.values(modelMap)) {
+    if (seen.has(providerModel)) continue;
+    seen.add(providerModel);
+    entries.push(`  - model_name: ${providerModel}`);
+    entries.push(`    litellm_params:`);
+    entries.push(`      model: ${provider}/${providerModel}`);
+    entries.push(`      api_key: os.environ/${apiKeyVar}`);
+  }
+  return entries.join("\n") + "\n";
+}
+function generateLitellmConfigFromStages(defaultConfig, stages) {
+  const proxyModels = [];
+  if (defaultConfig && defaultConfig.provider !== "claude" && defaultConfig.provider !== "anthropic") {
+    proxyModels.push(defaultConfig);
+  }
+  if (stages) {
+    for (const sc of Object.values(stages)) {
+      if (sc.provider !== "claude" && sc.provider !== "anthropic") {
+        proxyModels.push(sc);
+      }
+    }
+  }
+  if (proxyModels.length === 0) return void 0;
+  const entries = ["model_list:"];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { provider, model } of proxyModels) {
+    const key = `${provider}/${model}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const apiKeyVar = providerApiKeyEnvVar(provider);
+    entries.push(`  - model_name: ${model}`);
+    entries.push(`    litellm_params:`);
+    entries.push(`      model: ${provider}/${model}`);
+    entries.push(`      api_key: os.environ/${apiKeyVar}`);
+  }
+  return entries.join("\n") + "\n";
+}
+async function tryStartLitellm(url, projectDir, generatedConfig) {
+  if (!generatedConfig) {
+    logger.warn("No provider configured in kody.config.json \u2014 cannot start LiteLLM proxy");
+    return null;
+  }
+  const configPath = path9.join(os.tmpdir(), "kody-litellm-config.yaml");
+  fs10.writeFileSync(configPath, generatedConfig);
+  const portMatch = url.match(/:(\d+)/);
+  const port = portMatch ? portMatch[1] : "4000";
+  let litellmFound = false;
+  try {
+    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    litellmFound = true;
+  } catch {
+    try {
+      execFileSync9("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      litellmFound = true;
+    } catch {
+    }
+  }
+  if (!litellmFound) {
+    logger.warn("litellm not installed (pip install 'litellm[proxy]')");
+    return null;
+  }
+  logger.info(`Starting LiteLLM proxy on port ${port}...`);
+  let cmd;
+  let args2;
+  try {
+    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    cmd = "litellm";
+    args2 = ["--config", configPath, "--port", port];
+  } catch {
+    cmd = "python3";
+    args2 = ["-m", "litellm", "--config", configPath, "--port", port];
+  }
+  const dotenvPath = path9.join(projectDir, ".env");
+  const dotenvVars = {};
+  if (fs10.existsSync(dotenvPath)) {
+    for (const rawLine of fs10.readFileSync(dotenvPath, "utf-8").split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
+      if (match) {
+        let value = match[2].trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        const commentIdx = value.indexOf(" #");
+        if (commentIdx !== -1) value = value.slice(0, commentIdx).trim();
+        if (value) dotenvVars[match[1]] = value;
+      }
+    }
+    if (Object.keys(dotenvVars).length > 0) {
+      logger.info(`  Loaded API keys: ${Object.keys(dotenvVars).join(", ")}`);
+    }
+  }
+  const { spawn: spawn2 } = await import("child_process");
+  const child = spawn2(cmd, args2, {
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    env: { ...process.env, ...dotenvVars }
+  });
+  let proxyStderr = "";
+  child.stderr?.on("data", (chunk) => {
+    proxyStderr += chunk.toString();
+  });
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    if (await checkLitellmHealth(url)) {
+      logger.info(`LiteLLM proxy ready at ${url}`);
+      return child;
+    }
+  }
+  if (proxyStderr) {
+    logger.warn(`LiteLLM stderr: ${proxyStderr.slice(-1e3)}`);
+  }
+  logger.warn("LiteLLM proxy failed to start within 60s");
+  child.kill();
+  return null;
+}
+var init_litellm = __esm({
+  "src/cli/litellm.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+  }
+});
+
 // src/cli/taskify-command.ts
 var taskify_command_exports = {};
 __export(taskify_command_exports, {
@@ -1007,8 +1181,8 @@ __export(taskify_command_exports, {
   taskifyCommand: () => taskifyCommand,
   topoSort: () => topoSort
 });
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
 function topoSort(tasks) {
@@ -1052,10 +1226,10 @@ function hasFlag(args2, flag) {
 async function runTaskifyCommand() {
   const args2 = process.argv.slice(3);
   const cwdArg = getArg(args2, "--cwd") ?? process.cwd();
-  const projectDir = path9.resolve(cwdArg);
+  const projectDir = path10.resolve(cwdArg);
   const ticketId = getArg(args2, "--ticket") ?? process.env.TICKET_ID;
   const prdFileArg = getArg(args2, "--file") ?? process.env.PRD_FILE;
-  const prdFile = prdFileArg ? path9.resolve(projectDir, prdFileArg) : void 0;
+  const prdFile = prdFileArg ? path10.resolve(projectDir, prdFileArg) : void 0;
   const issueNumberStr = getArg(args2, "--issue-number") ?? process.env.ISSUE_NUMBER ?? "";
   const issueNumber = issueNumberStr ? parseInt(issueNumberStr, 10) : void 0;
   const feedback = getArg(args2, "--feedback") ?? process.env.FEEDBACK;
@@ -1066,19 +1240,40 @@ async function runTaskifyCommand() {
     logger.error("Usage: kody taskify --ticket <ticket-id>  OR  kody taskify --file <prd.md>");
     process.exit(1);
   }
-  if (prdFile && !fs10.existsSync(prdFile)) {
+  if (prdFile && !fs11.existsSync(prdFile)) {
     logger.error(`File not found: ${prdFile}`);
     process.exit(1);
   }
   setConfigDir(projectDir);
   setGhCwd(projectDir);
-  await taskifyCommand({ ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId });
+  const config = getProjectConfig();
+  let litellmProcess = null;
+  let runnerEnv;
+  if (anyStageNeedsProxy(config)) {
+    const litellmUrl = getLitellmUrl();
+    const proxyRunning = await checkLitellmHealth(litellmUrl);
+    if (!proxyRunning) {
+      let generatedConfig;
+      if (config.agent.stages || config.agent.default) {
+        generatedConfig = generateLitellmConfigFromStages(config.agent.default, config.agent.stages);
+      } else if (config.agent.provider && config.agent.provider !== "anthropic") {
+        generatedConfig = generateLitellmConfig(config.agent.provider, config.agent.modelMap);
+      }
+      litellmProcess = await tryStartLitellm(litellmUrl, projectDir, generatedConfig);
+    }
+    runnerEnv = {
+      ANTHROPIC_BASE_URL: litellmUrl,
+      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "dummy"
+    };
+  }
+  await taskifyCommand({ ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId, runnerEnv });
+  litellmProcess?.kill();
 }
 async function taskifyCommand(opts) {
   const { ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId } = opts;
   const config = getProjectConfig();
-  const taskDir = path9.join(projectDir, ".kody", "tasks", taskId);
-  fs10.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path10.join(projectDir, ".kody", "tasks", taskId);
+  fs11.mkdirSync(taskDir, { recursive: true });
   const mode = prdFile ? "file" : "ticket";
   logger.info(`[taskify] mode=${mode} source=${ticketId ?? prdFile} issue=${issueNumber ?? "none"} task=${taskId}`);
   let mcpConfigJson;
@@ -1103,14 +1298,14 @@ Add the required MCP server config to \`kody.config.json\` and try again.`
   }
   const sc = resolveStageConfig(config, "taskify", "strong");
   const model = sc.model;
-  const fileContent = prdFile ? fs10.readFileSync(prdFile, "utf-8") : void 0;
+  const fileContent = prdFile ? fs11.readFileSync(prdFile, "utf-8") : void 0;
   let projectContext;
   {
     const parts = [];
-    const memoryPath = path9.join(projectDir, ".kody", "memory.md");
-    if (fs10.existsSync(memoryPath)) {
+    const memoryPath = path10.join(projectDir, ".kody", "memory.md");
+    if (fs11.existsSync(memoryPath)) {
       try {
-        const content = fs10.readFileSync(memoryPath, "utf-8").slice(0, 2e3);
+        const content = fs11.readFileSync(memoryPath, "utf-8").slice(0, 2e3);
         if (content.trim()) parts.push(`### Project Memory
 ${content}`);
       } catch {
@@ -1129,16 +1324,17 @@ ${lines.join("\n")}
   }
   const prompt = buildPrompt({ ticketId, fileContent, taskDir, feedback, projectContext });
   if (issueNumber && !local) {
-    const src = mode === "file" ? `file \`${path9.basename(prdFile)}\`` : `ticket **${ticketId}**`;
+    const src = mode === "file" ? `file \`${path10.basename(prdFile)}\`` : `ticket **${ticketId}**`;
     postComment(issueNumber, `Kody is decomposing ${src} into tasks...`);
     setLifecycleLabel(issueNumber, "planning");
   }
-  fs10.writeFileSync(path9.join(taskDir, MARKER_FILE), JSON.stringify({ ticketId, prdFile, issueNumber }));
+  fs11.writeFileSync(path10.join(taskDir, MARKER_FILE), JSON.stringify({ ticketId, prdFile, issueNumber }));
   const runner = opts.runner ?? createClaudeCodeRunner();
   logger.info(`  model=${model} timeout=${TASKIFY_TIMEOUT_MS / 1e3}s`);
   const result = await runner.run("taskify", prompt, model, TASKIFY_TIMEOUT_MS, taskDir, {
     cwd: projectDir,
-    mcpConfigJson
+    mcpConfigJson,
+    env: opts.runnerEnv
   });
   if (result.outcome !== "completed") {
     const errMsg = result.outcome === "timed_out" ? "Taskify timed out after 5 minutes." : `Taskify failed: ${result.error}`;
@@ -1151,8 +1347,8 @@ ${lines.join("\n")}
     }
     process.exit(1);
   }
-  const resultPath = path9.join(taskDir, RESULT_FILE);
-  if (!fs10.existsSync(resultPath)) {
+  const resultPath = path10.join(taskDir, RESULT_FILE);
+  if (!fs11.existsSync(resultPath)) {
     const errMsg = `Claude did not write ${RESULT_FILE}. Output:
 
 ${result.output?.slice(0, 500) ?? "(none)"}`;
@@ -1167,7 +1363,7 @@ ${errMsg}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs10.readFileSync(resultPath, "utf-8"));
+    parsed = JSON.parse(fs11.readFileSync(resultPath, "utf-8"));
   } catch {
     const errMsg = `Could not parse ${RESULT_FILE} as JSON.`;
     logger.error(`[taskify] ${errMsg}`);
@@ -1177,7 +1373,7 @@ ${errMsg}`);
     }
     process.exit(1);
   }
-  const sourceLabel = ticketId ?? (prdFile ? path9.basename(prdFile) : "spec");
+  const sourceLabel = ticketId ?? (prdFile ? path10.basename(prdFile) : "spec");
   if (parsed.status === "questions") {
     handleQuestions(parsed, sourceLabel, issueNumber, local ?? false);
   } else if (parsed.status === "ready") {
@@ -1272,15 +1468,15 @@ function buildPrompt(opts) {
   const { ticketId, fileContent, taskDir, feedback, projectContext } = opts;
   const scriptDir = new URL(".", import.meta.url).pathname;
   const candidates = [
-    path9.resolve(scriptDir, "..", "prompts", "taskify-ticket.md"),
-    path9.resolve(scriptDir, "..", "..", "prompts", "taskify-ticket.md"),
-    path9.resolve(__dirname, "..", "..", "prompts", "taskify-ticket.md"),
-    path9.resolve(__dirname, "..", "prompts", "taskify-ticket.md")
+    path10.resolve(scriptDir, "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(scriptDir, "..", "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(__dirname, "..", "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(__dirname, "..", "prompts", "taskify-ticket.md")
   ];
   let template = "";
   for (const candidate of candidates) {
-    if (fs10.existsSync(candidate)) {
-      template = fs10.readFileSync(candidate, "utf-8");
+    if (fs11.existsSync(candidate)) {
+      template = fs11.readFileSync(candidate, "utf-8");
       break;
     }
   }
@@ -1303,13 +1499,13 @@ function buildPrompt(opts) {
   return template;
 }
 function isTaskifyRun(taskDir) {
-  return fs10.existsSync(path9.join(taskDir, MARKER_FILE));
+  return fs11.existsSync(path10.join(taskDir, MARKER_FILE));
 }
 function readTaskifyMarker(taskDir) {
-  const markerPath = path9.join(taskDir, MARKER_FILE);
-  if (!fs10.existsSync(markerPath)) return null;
+  const markerPath = path10.join(taskDir, MARKER_FILE);
+  if (!fs11.existsSync(markerPath)) return null;
   try {
-    return JSON.parse(fs10.readFileSync(markerPath, "utf-8"));
+    return JSON.parse(fs11.readFileSync(markerPath, "utf-8"));
   } catch {
     return null;
   }
@@ -1324,7 +1520,8 @@ var init_taskify_command = __esm({
     init_github_api();
     init_logger();
     init_task_resolution();
-    __dirname = path9.dirname(fileURLToPath(import.meta.url));
+    init_litellm();
+    __dirname = path10.dirname(fileURLToPath(import.meta.url));
     AUTO_TRIGGER_THRESHOLD = 5;
     MAX_TASKS_GUARD = 20;
     TASKIFY_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -1340,7 +1537,7 @@ __export(parse_inputs_exports, {
   runCiParse: () => runCiParse,
   writeOutputs: () => writeOutputs
 });
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 function generateTimestamp() {
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => String(n).padStart(2, "0");
@@ -1506,12 +1703,12 @@ function writeOutputs(result) {
   function output(key, value) {
     if (outputFile) {
       if (value.includes("\n")) {
-        fs11.appendFileSync(outputFile, `${key}<<KODY_EOF
+        fs12.appendFileSync(outputFile, `${key}<<KODY_EOF
 ${value}
 KODY_EOF
 `);
       } else {
-        fs11.appendFileSync(outputFile, `${key}=${value}
+        fs12.appendFileSync(outputFile, `${key}=${value}
 `);
       }
     }
@@ -1636,7 +1833,7 @@ var init_definitions = __esm({
 });
 
 // src/git-utils.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 function getHookSafeEnv() {
   if (!_hookSafeEnv) {
     _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
@@ -1644,7 +1841,7 @@ function getHookSafeEnv() {
   return _hookSafeEnv;
 }
 function git(args2, options) {
-  return execFileSync9("git", args2, {
+  return execFileSync10("git", args2, {
     encoding: "utf-8",
     timeout: options?.timeout ?? 3e4,
     cwd: options?.cwd,
@@ -1830,14 +2027,14 @@ var init_git_utils = __esm({
 });
 
 // src/pipeline/state.ts
-import * as fs12 from "fs";
-import * as path10 from "path";
+import * as fs13 from "fs";
+import * as path11 from "path";
 function loadState(taskId, taskDir) {
-  const p = path10.join(taskDir, "status.json");
-  if (!fs12.existsSync(p)) return null;
+  const p = path11.join(taskDir, "status.json");
+  if (!fs13.existsSync(p)) return null;
   try {
     const result = parseJsonSafe(
-      fs12.readFileSync(p, "utf-8"),
+      fs13.readFileSync(p, "utf-8"),
       ["taskId", "state", "stages", "createdAt", "updatedAt"]
     );
     if (!result.ok) {
@@ -1855,10 +2052,10 @@ function writeState(state, taskDir) {
     ...state,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const target = path10.join(taskDir, "status.json");
+  const target = path11.join(taskDir, "status.json");
   const tmp = target + ".tmp";
-  fs12.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-  fs12.renameSync(tmp, target);
+  fs13.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs13.renameSync(tmp, target);
   return updated;
 }
 function initState(taskId) {
@@ -1899,16 +2096,16 @@ var init_complexity = __esm({
 });
 
 // src/memory.ts
-import * as fs13 from "fs";
-import * as path11 from "path";
+import * as fs14 from "fs";
+import * as path12 from "path";
 function readProjectMemory(projectDir) {
-  const memoryDir = path11.join(projectDir, ".kody", "memory");
-  if (!fs13.existsSync(memoryDir)) return "";
-  const files = fs13.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path12.join(projectDir, ".kody", "memory");
+  if (!fs14.existsSync(memoryDir)) return "";
+  const files = fs14.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
   const sections = [];
   for (const file of files) {
-    const content = fs13.readFileSync(path11.join(memoryDir, file), "utf-8").trim();
+    const content = fs14.readFileSync(path12.join(memoryDir, file), "utf-8").trim();
     if (content) {
       sections.push(`## ${file.replace(".md", "")}
 ${content}`);
@@ -1927,8 +2124,8 @@ var init_memory = __esm({
 });
 
 // src/context-tiers.ts
-import * as fs14 from "fs";
-import * as path12 from "path";
+import * as fs15 from "fs";
+import * as path13 from "path";
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
@@ -2019,7 +2216,7 @@ function generateL1Json(content) {
   }
 }
 function getTieredContent(filePath, content) {
-  const key = path12.basename(filePath);
+  const key = path13.basename(filePath);
   return {
     source: filePath,
     L0: generateL0(content, key),
@@ -2031,15 +2228,15 @@ function selectTier(tiered, tier) {
   return tiered[tier];
 }
 function readProjectMemoryTiered(projectDir, tier) {
-  const memoryDir = path12.join(projectDir, ".kody", "memory");
-  if (!fs14.existsSync(memoryDir)) return "";
-  const files = fs14.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  const memoryDir = path13.join(projectDir, ".kody", "memory");
+  if (!fs15.existsSync(memoryDir)) return "";
+  const files = fs15.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
   const tierLabel2 = tier === "L2" ? "full" : tier === "L1" ? "overview" : "abstract";
   const sections = [];
   for (const file of files) {
-    const filePath = path12.join(memoryDir, file);
-    const content = fs14.readFileSync(filePath, "utf-8").trim();
+    const filePath = path13.join(memoryDir, file);
+    const content = fs15.readFileSync(filePath, "utf-8").trim();
     if (!content) continue;
     const tiered = getTieredContent(filePath, content);
     const selected = selectTier(tiered, tier);
@@ -2062,9 +2259,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path12.join(taskDir, "task.md");
-  if (fs14.existsSync(taskMdPath)) {
-    const content = fs14.readFileSync(taskMdPath, "utf-8");
+  const taskMdPath = path13.join(taskDir, "task.md");
+  if (fs15.existsSync(taskMdPath)) {
+    const content = fs15.readFileSync(taskMdPath, "utf-8");
     const selected = selectContent(taskMdPath, content, policy.taskDescription);
     const label = tierLabel("Task Description", policy.taskDescription);
     context += `
@@ -2072,9 +2269,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 ${selected}
 `;
   }
-  const taskJsonPath = path12.join(taskDir, "task.json");
-  if (fs14.existsSync(taskJsonPath)) {
-    const content = fs14.readFileSync(taskJsonPath, "utf-8");
+  const taskJsonPath = path13.join(taskDir, "task.json");
+  if (fs15.existsSync(taskJsonPath)) {
+    const content = fs15.readFileSync(taskJsonPath, "utf-8");
     if (policy.taskClassification === "L2") {
       try {
         const taskDef = JSON.parse(content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, ""));
@@ -2100,9 +2297,9 @@ ${selected}
       }
     }
   }
-  const specPath = path12.join(taskDir, "spec.md");
-  if (fs14.existsSync(specPath)) {
-    const content = fs14.readFileSync(specPath, "utf-8");
+  const specPath = path13.join(taskDir, "spec.md");
+  if (fs15.existsSync(specPath)) {
+    const content = fs15.readFileSync(specPath, "utf-8");
     const selected = selectContent(specPath, content, policy.spec);
     const label = tierLabel("Spec", policy.spec);
     context += `
@@ -2110,9 +2307,9 @@ ${selected}
 ${selected}
 `;
   }
-  const planPath = path12.join(taskDir, "plan.md");
-  if (fs14.existsSync(planPath)) {
-    const content = fs14.readFileSync(planPath, "utf-8");
+  const planPath = path13.join(taskDir, "plan.md");
+  if (fs15.existsSync(planPath)) {
+    const content = fs15.readFileSync(planPath, "utf-8");
     const selected = selectContent(planPath, content, policy.plan);
     const label = tierLabel("Plan", policy.plan);
     context += `
@@ -2120,9 +2317,9 @@ ${selected}
 ${selected}
 `;
   }
-  const contextMdPath = path12.join(taskDir, "context.md");
-  if (fs14.existsSync(contextMdPath)) {
-    const content = fs14.readFileSync(contextMdPath, "utf-8");
+  const contextMdPath = path13.join(taskDir, "context.md");
+  if (fs15.existsSync(contextMdPath)) {
+    const content = fs15.readFileSync(contextMdPath, "utf-8");
     const selected = selectContent(contextMdPath, content, policy.accumulatedContext);
     const label = tierLabel("Previous Stage Context", policy.accumulatedContext);
     context += `
@@ -2208,24 +2405,24 @@ var init_context_tiers = __esm({
 });
 
 // src/context.ts
-import * as fs15 from "fs";
-import * as path13 from "path";
+import * as fs16 from "fs";
+import * as path14 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
-    const stepFile = path13.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs15.existsSync(stepFile)) {
-      return fs15.readFileSync(stepFile, "utf-8");
+    const stepFile = path14.join(projectDir, ".kody", "steps", `${stageName}.md`);
+    if (fs16.existsSync(stepFile)) {
+      return fs16.readFileSync(stepFile, "utf-8");
     }
     console.warn(`  \u26A0 No step file at ${stepFile}, falling back to engine defaults. Run 'kody-engine-lite init --force' to generate step files.`);
   }
   const scriptDir = new URL(".", import.meta.url).pathname;
   const candidates = [
-    path13.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path13.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+    path14.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path14.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs15.existsSync(candidate)) {
-      return fs15.readFileSync(candidate, "utf-8");
+    if (fs16.existsSync(candidate)) {
+      return fs16.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -2237,18 +2434,18 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path13.join(taskDir, "task.md");
-  if (fs15.existsSync(taskMdPath)) {
-    const taskMd = fs15.readFileSync(taskMdPath, "utf-8");
+  const taskMdPath = path14.join(taskDir, "task.md");
+  if (fs16.existsSync(taskMdPath)) {
+    const taskMd = fs16.readFileSync(taskMdPath, "utf-8");
     context += `
 ## Task Description
 ${taskMd}
 `;
   }
-  const taskJsonPath = path13.join(taskDir, "task.json");
-  if (fs15.existsSync(taskJsonPath)) {
+  const taskJsonPath = path14.join(taskDir, "task.json");
+  if (fs16.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs15.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs16.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -2261,27 +2458,27 @@ ${taskMd}
     } catch {
     }
   }
-  const specPath = path13.join(taskDir, "spec.md");
-  if (fs15.existsSync(specPath)) {
-    const spec = fs15.readFileSync(specPath, "utf-8");
+  const specPath = path14.join(taskDir, "spec.md");
+  if (fs16.existsSync(specPath)) {
+    const spec = fs16.readFileSync(specPath, "utf-8");
     const truncated = spec.slice(0, MAX_TASK_CONTEXT_SPEC);
     context += `
 ## Spec Summary
 ${truncated}${spec.length > MAX_TASK_CONTEXT_SPEC ? "\n..." : ""}
 `;
   }
-  const planPath = path13.join(taskDir, "plan.md");
-  if (fs15.existsSync(planPath)) {
-    const plan = fs15.readFileSync(planPath, "utf-8");
+  const planPath = path14.join(taskDir, "plan.md");
+  if (fs16.existsSync(planPath)) {
+    const plan = fs16.readFileSync(planPath, "utf-8");
     const truncated = plan.slice(0, MAX_TASK_CONTEXT_PLAN);
     context += `
 ## Plan Summary
 ${truncated}${plan.length > MAX_TASK_CONTEXT_PLAN ? "\n..." : ""}
 `;
   }
-  const contextMdPath = path13.join(taskDir, "context.md");
-  if (fs15.existsSync(contextMdPath)) {
-    const accumulated = fs15.readFileSync(contextMdPath, "utf-8");
+  const contextMdPath = path14.join(taskDir, "context.md");
+  if (fs16.existsSync(contextMdPath)) {
+    const accumulated = fs16.readFileSync(contextMdPath, "utf-8");
     const truncated = accumulated.slice(-MAX_ACCUMULATED_CONTEXT);
     const prefix = accumulated.length > MAX_ACCUMULATED_CONTEXT ? "...(earlier context truncated)\n" : "";
     context += `
@@ -2299,17 +2496,17 @@ ${feedback}
 }
 function inferHasUIFromScope(scope) {
   return scope.some((filePath) => {
-    const ext = path13.extname(filePath).toLowerCase();
+    const ext = path14.extname(filePath).toLowerCase();
     if (UI_EXTENSIONS.has(ext)) return true;
     const normalized = filePath.replace(/\\/g, "/");
     return UI_PATH_SEGMENTS.some((seg) => normalized.includes(seg));
   });
 }
 function taskHasUI(taskDir) {
-  const taskJsonPath = path13.join(taskDir, "task.json");
-  if (!fs15.existsSync(taskJsonPath)) return true;
+  const taskJsonPath = path14.join(taskDir, "task.json");
+  if (!fs16.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs15.readFileSync(taskJsonPath, "utf-8"));
+    const taskDef = JSON.parse(fs16.readFileSync(taskJsonPath, "utf-8"));
     const scope = Array.isArray(taskDef.scope) ? taskDef.scope : [];
     if (scope.length === 0) return true;
     return inferHasUIFromScope(scope);
@@ -2431,9 +2628,9 @@ ${prompt}` : prompt;
   }
   if (isMcpEnabledForStage(stageName, config.mcp) && taskHasUI(taskDir)) {
     assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
-    const qaGuidePath = path13.join(projectDir, ".kody", "qa-guide.md");
-    if (fs15.existsSync(qaGuidePath)) {
-      const qaGuide = fs15.readFileSync(qaGuidePath, "utf-8").trim();
+    const qaGuidePath = path14.join(projectDir, ".kody", "qa-guide.md");
+    if (fs16.existsSync(qaGuidePath)) {
+      const qaGuide = fs16.readFileSync(qaGuidePath, "utf-8").trim();
       assembled = assembled + "\n\n" + qaGuide;
     }
   }
@@ -2528,8 +2725,8 @@ var init_runner_selection = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs16 from "fs";
-import * as path14 from "path";
+import * as fs17 from "fs";
+import * as path15 from "path";
 function getSessionInfo(stageName, sessions) {
   const group = SESSION_GROUP[stageName];
   if (!group) return void 0;
@@ -2616,27 +2813,27 @@ async function executeAgentStage(ctx, def) {
   }
   const result = lastResult;
   if (def.outputFile && result.output) {
-    fs16.writeFileSync(path14.join(ctx.taskDir, def.outputFile), result.output);
+    fs17.writeFileSync(path15.join(ctx.taskDir, def.outputFile), result.output);
   }
   if (def.outputFile) {
-    const outputPath = path14.join(ctx.taskDir, def.outputFile);
-    if (!fs16.existsSync(outputPath)) {
-      const ext = path14.extname(def.outputFile);
-      const base = path14.basename(def.outputFile, ext);
-      const files = fs16.readdirSync(ctx.taskDir);
+    const outputPath = path15.join(ctx.taskDir, def.outputFile);
+    if (!fs17.existsSync(outputPath)) {
+      const ext = path15.extname(def.outputFile);
+      const base = path15.basename(def.outputFile, ext);
+      const files = fs17.readdirSync(ctx.taskDir);
       const variant = files.find(
         (f) => f.startsWith(base + "-") && f.endsWith(ext)
       );
       if (variant) {
-        fs16.renameSync(path14.join(ctx.taskDir, variant), outputPath);
+        fs17.renameSync(path15.join(ctx.taskDir, variant), outputPath);
         logger.info(`  Renamed variant ${variant} \u2192 ${def.outputFile}`);
       }
     }
   }
   if (def.outputFile) {
-    const outputPath = path14.join(ctx.taskDir, def.outputFile);
-    if (fs16.existsSync(outputPath)) {
-      const content = fs16.readFileSync(outputPath, "utf-8");
+    const outputPath = path15.join(ctx.taskDir, def.outputFile);
+    if (fs17.existsSync(outputPath)) {
+      const content = fs17.readFileSync(outputPath, "utf-8");
       const validation = validateStageOutput(def.name, content);
       if (!validation.valid) {
         if (def.name === "taskify") {
@@ -2650,7 +2847,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs16.writeFileSync(outputPath, retryResult.output);
+              fs17.writeFileSync(outputPath, retryResult.output);
               logger.info(`  taskify retry produced valid JSON`);
             } else {
               logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
@@ -2663,7 +2860,7 @@ async function executeAgentStage(ctx, def) {
                 risk_level: "low",
                 questions: []
               }, null, 2);
-              fs16.writeFileSync(outputPath, fallback);
+              fs17.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -2677,7 +2874,7 @@ async function executeAgentStage(ctx, def) {
   return { outcome: "completed", outputFile: def.outputFile, retries };
 }
 function appendStageContext(taskDir, stageName, output) {
-  const contextPath = path14.join(taskDir, "context.md");
+  const contextPath = path15.join(taskDir, "context.md");
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19);
   let summary;
   if (output && output.trim()) {
@@ -2690,7 +2887,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs16.appendFileSync(contextPath, entry);
+  fs17.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -2713,7 +2910,7 @@ var init_agent = __esm({
 });
 
 // src/verify-runner.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 function isExecError(err) {
   return typeof err === "object" && err !== null;
 }
@@ -2749,7 +2946,7 @@ function runCommand(cmd, cwd, timeout) {
     return { success: true, output: "", timedOut: false };
   }
   try {
-    const output = execFileSync10(parts[0], parts.slice(1), {
+    const output = execFileSync11(parts[0], parts.slice(1), {
       cwd,
       timeout,
       encoding: "utf-8",
@@ -2820,7 +3017,7 @@ var init_verify_runner = __esm({
 });
 
 // src/observer.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, model, options) {
   const context = [
     `Stage: ${stageName}`,
@@ -2880,13 +3077,13 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
 }
 function getModifiedFiles(projectDir) {
   try {
-    const staged = execFileSync11("git", ["diff", "--name-only", "--cached"], {
+    const staged = execFileSync12("git", ["diff", "--name-only", "--cached"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const unstaged = execFileSync11("git", ["diff", "--name-only"], {
+    const unstaged = execFileSync12("git", ["diff", "--name-only"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -2929,8 +3126,8 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs17 from "fs";
-import * as path15 from "path";
+import * as fs18 from "fs";
+import * as path16 from "path";
 function executeGateStage(ctx, def) {
   if (ctx.input.dryRun) {
     logger.info(`  [dry-run] skipping ${def.name}`);
@@ -2973,7 +3170,7 @@ ${output}
 `);
     }
   }
-  fs17.writeFileSync(path15.join(ctx.taskDir, "verify.md"), lines.join(""));
+  fs18.writeFileSync(path16.join(ctx.taskDir, "verify.md"), lines.join(""));
   return {
     outcome: verifyResult.pass ? "completed" : "failed",
     retries: 0
@@ -2988,9 +3185,9 @@ var init_gate = __esm({
 });
 
 // src/stages/verify.ts
-import * as fs18 from "fs";
-import * as path16 from "path";
-import { execFileSync as execFileSync12 } from "child_process";
+import * as fs19 from "fs";
+import * as path17 from "path";
+import { execFileSync as execFileSync13 } from "child_process";
 async function executeVerifyWithAutofix(ctx, def) {
   const maxAttempts = def.maxRetries ?? 2;
   for (let attempt = 0; attempt <= maxAttempts; attempt++) {
@@ -3000,8 +3197,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      const verifyPath = path16.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs18.existsSync(verifyPath) ? fs18.readFileSync(verifyPath, "utf-8") : "Unknown error";
+      const verifyPath = path17.join(ctx.taskDir, "verify.md");
+      const errorOutput = fs19.existsSync(verifyPath) ? fs19.readFileSync(verifyPath, "utf-8") : "Unknown error";
       const modifiedFiles = getModifiedFiles(ctx.projectDir);
       const defaultRunner = getRunnerForStage(ctx, "taskify");
       const diagConfig = getProjectConfig();
@@ -3044,7 +3241,7 @@ ${diagnosis.resolution}`);
         const parts = parseCommand(cmd);
         if (parts.length === 0) return;
         try {
-          execFileSync12(parts[0], parts.slice(1), {
+          execFileSync13(parts[0], parts.slice(1), {
             stdio: "pipe",
             timeout: FIX_COMMAND_TIMEOUT_MS
           });
@@ -3097,8 +3294,8 @@ var init_verify = __esm({
 });
 
 // src/review-standalone.ts
-import * as fs19 from "fs";
-import * as path17 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -3122,8 +3319,8 @@ Or comment on the specific PR: \`@kody review\``
 }
 async function runStandaloneReview(input) {
   const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path17.join(input.projectDir, ".kody", "tasks", taskId);
-  fs19.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path18.join(input.projectDir, ".kody", "tasks", taskId);
+  fs20.mkdirSync(taskDir, { recursive: true });
   let diffInstruction = "";
   let filesChangedSection = "";
   if (input.baseBranch) {
@@ -3150,7 +3347,7 @@ ${fileList}`;
   const taskContent = `# ${input.prTitle}
 
 ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
-  fs19.writeFileSync(path17.join(taskDir, "task.md"), taskContent);
+  fs20.writeFileSync(path18.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -3172,10 +3369,10 @@ ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
       error: result.error ?? "Review stage failed"
     };
   }
-  const reviewPath = path17.join(taskDir, "review.md");
+  const reviewPath = path18.join(taskDir, "review.md");
   let reviewContent;
-  if (fs19.existsSync(reviewPath)) {
-    reviewContent = fs19.readFileSync(reviewPath, "utf-8");
+  if (fs20.existsSync(reviewPath)) {
+    reviewContent = fs20.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -3215,8 +3412,8 @@ var init_review_standalone = __esm({
 });
 
 // src/stages/review.ts
-import * as fs20 from "fs";
-import * as path18 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
@@ -3230,11 +3427,11 @@ async function executeReviewWithFix(ctx, def) {
     if (reviewResult.outcome !== "completed") {
       return reviewResult;
     }
-    const reviewFile = path18.join(ctx.taskDir, "review.md");
-    if (!fs20.existsSync(reviewFile)) {
+    const reviewFile = path19.join(ctx.taskDir, "review.md");
+    if (!fs21.existsSync(reviewFile)) {
       return { outcome: "failed", retries: iteration, error: "review.md not found" };
     }
-    const content = fs20.readFileSync(reviewFile, "utf-8");
+    const content = fs21.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -3263,15 +3460,15 @@ var init_review = __esm({
 });
 
 // src/stages/ship.ts
-import * as fs21 from "fs";
-import * as path19 from "path";
-import { execFileSync as execFileSync13 } from "child_process";
+import * as fs22 from "fs";
+import * as path20 from "path";
+import { execFileSync as execFileSync14 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path19.join(ctx.taskDir, "task.json");
-  if (fs21.existsSync(taskJsonPath)) {
+  const taskJsonPath = path20.join(ctx.taskDir, "task.json");
+  if (fs22.existsSync(taskJsonPath)) {
     try {
-      const raw = fs21.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs22.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -3290,9 +3487,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path19.join(ctx.taskDir, "review.md");
-  if (fs21.existsSync(reviewPath)) {
-    const review = fs21.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path20.join(ctx.taskDir, "review.md");
+  if (fs22.existsSync(reviewPath)) {
+    const review = fs22.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -3309,14 +3506,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path19.join(ctx.taskDir, "verify.md");
-  if (fs21.existsSync(verifyPath)) {
-    const verify = fs21.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path20.join(ctx.taskDir, "verify.md");
+  if (fs22.existsSync(verifyPath)) {
+    const verify = fs22.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path19.join(ctx.taskDir, "plan.md");
-  if (fs21.existsSync(planPath)) {
-    const plan = fs21.readFileSync(planPath, "utf-8").trim();
+  const planPath = path20.join(ctx.taskDir, "plan.md");
+  if (fs22.existsSync(planPath)) {
+    const plan = fs22.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -3336,25 +3533,25 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path19.join(ctx.taskDir, "ship.md");
+  const shipPath = path20.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs21.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs22.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   if (ctx.input.local && !ctx.input.issueNumber) {
-    fs21.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs22.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   try {
     const head = getCurrentBranch(ctx.projectDir);
     const base = getDefaultBranch(ctx.projectDir);
     try {
-      execFileSync13("git", ["add", ctx.taskDir], {
+      execFileSync14("git", ["add", ctx.taskDir], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
       });
-      execFileSync13("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
+      execFileSync14("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
@@ -3368,7 +3565,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync13("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync14("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -3389,28 +3586,28 @@ function executeShipStage(ctx, _def) {
       chore: "chore"
     };
     let prefix = "chore";
-    const taskJsonPath = path19.join(ctx.taskDir, "task.json");
-    if (fs21.existsSync(taskJsonPath)) {
+    const taskJsonPath = path20.join(ctx.taskDir, "task.json");
+    if (fs22.existsSync(taskJsonPath)) {
       try {
-        const raw = fs21.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs22.readFileSync(taskJsonPath, "utf-8");
         const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
         const task = JSON.parse(cleaned);
         prefix = TYPE_PREFIX[task.task_type] ?? "chore";
       } catch {
       }
     }
-    const taskMdPath = path19.join(ctx.taskDir, "task.md");
-    if (fs21.existsSync(taskMdPath)) {
-      const content = fs21.readFileSync(taskMdPath, "utf-8");
+    const taskMdPath = path20.join(ctx.taskDir, "task.md");
+    if (fs22.existsSync(taskMdPath)) {
+      const content = fs22.readFileSync(taskMdPath, "utf-8");
       const heading = content.split("\n").find((l) => l.startsWith("# "));
       if (heading) {
         title = `${prefix}: ${heading.replace(/^#\s*/, "").trim()}`.slice(0, 72);
       }
     }
     if (title === "Update") {
-      if (fs21.existsSync(taskJsonPath)) {
+      if (fs22.existsSync(taskJsonPath)) {
         try {
-          const raw = fs21.readFileSync(taskJsonPath, "utf-8");
+          const raw = fs22.readFileSync(taskJsonPath, "utf-8");
           const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
           const task = JSON.parse(cleaned);
           if (task.title) title = `${prefix}: ${task.title}`.slice(0, 72);
@@ -3433,7 +3630,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs21.writeFileSync(shipPath, `# Ship
+      fs22.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -3454,20 +3651,20 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs21.writeFileSync(shipPath, `# Ship
+        fs22.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs21.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs22.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
       }
     }
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     try {
-      fs21.writeFileSync(shipPath, `# Ship
+      fs22.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
@@ -3516,15 +3713,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 function checkForQuestions(ctx, stageName) {
   if (ctx.input.local || !ctx.input.issueNumber) return false;
   try {
     if (stageName === "taskify") {
-      const taskJsonPath = path20.join(ctx.taskDir, "task.json");
-      if (!fs22.existsSync(taskJsonPath)) return false;
-      const raw = fs22.readFileSync(taskJsonPath, "utf-8");
+      const taskJsonPath = path21.join(ctx.taskDir, "task.json");
+      if (!fs23.existsSync(taskJsonPath)) return false;
+      const raw = fs23.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const taskJson = JSON.parse(cleaned);
       if (taskJson.questions && Array.isArray(taskJson.questions) && taskJson.questions.length > 0) {
@@ -3539,9 +3736,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path20.join(ctx.taskDir, "plan.md");
-      if (!fs22.existsSync(planPath)) return false;
-      const plan = fs22.readFileSync(planPath, "utf-8");
+      const planPath = path21.join(ctx.taskDir, "plan.md");
+      if (!fs23.existsSync(planPath)) return false;
+      const plan = fs23.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -3570,8 +3767,8 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
   if (def.name === "build") setLifecycleLabel(ctx.input.issueNumber, "building");
@@ -3609,9 +3806,9 @@ function autoDetectComplexity(ctx, def) {
     return { complexity, activeStages };
   }
   try {
-    const taskJsonPath = path21.join(ctx.taskDir, "task.json");
-    if (!fs23.existsSync(taskJsonPath)) return null;
-    const raw = fs23.readFileSync(taskJsonPath, "utf-8");
+    const taskJsonPath = path22.join(ctx.taskDir, "task.json");
+    if (!fs24.existsSync(taskJsonPath)) return null;
+    const raw = fs24.readFileSync(taskJsonPath, "utf-8");
     const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const taskJson = JSON.parse(cleaned);
     if (!taskJson.risk_level || !isValidComplexity(taskJson.risk_level)) return null;
@@ -3641,8 +3838,8 @@ function checkRiskGate(ctx, def, state, complexity) {
   if (ctx.input.dryRun || ctx.input.local) return null;
   if (ctx.input.mode === "rerun") return null;
   if (!ctx.input.issueNumber) return null;
-  const planPath = path21.join(ctx.taskDir, "plan.md");
-  const plan = fs23.existsSync(planPath) ? fs23.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const planPath = path22.join(ctx.taskDir, "plan.md");
+  const plan = fs24.existsSync(planPath) ? fs24.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -3709,22 +3906,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function autoLearn(ctx) {
   try {
-    const memoryDir = path22.join(ctx.projectDir, ".kody", "memory");
-    if (!fs24.existsSync(memoryDir)) {
-      fs24.mkdirSync(memoryDir, { recursive: true });
+    const memoryDir = path23.join(ctx.projectDir, ".kody", "memory");
+    if (!fs25.existsSync(memoryDir)) {
+      fs25.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path22.join(ctx.taskDir, "verify.md");
-    if (fs24.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs24.readFileSync(verifyPath, "utf-8"));
+    const verifyPath = path23.join(ctx.taskDir, "verify.md");
+    if (fs25.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs25.readFileSync(verifyPath, "utf-8"));
       if (/vitest/i.test(verify)) learnings.push("- Uses vitest for testing");
       if (/jest/i.test(verify)) learnings.push("- Uses jest for testing");
       if (/eslint/i.test(verify)) learnings.push("- Uses eslint for linting");
@@ -3733,18 +3930,18 @@ function autoLearn(ctx) {
       if (/jsdom/i.test(verify)) learnings.push("- Test environment: jsdom");
       if (/node/i.test(verify) && /environment/i.test(verify)) learnings.push("- Test environment: node");
     }
-    const reviewPath = path22.join(ctx.taskDir, "review.md");
-    if (fs24.existsSync(reviewPath)) {
-      const review = fs24.readFileSync(reviewPath, "utf-8");
+    const reviewPath = path23.join(ctx.taskDir, "review.md");
+    if (fs25.existsSync(reviewPath)) {
+      const review = fs25.readFileSync(reviewPath, "utf-8");
       if (/\.js extension/i.test(review)) learnings.push("- Imports use .js extensions (ESM)");
       if (/barrel export/i.test(review)) learnings.push("- Uses barrel exports (index.ts)");
       if (/timezone/i.test(review)) learnings.push("- Timezone handling is a concern in this codebase");
       if (/UTC/i.test(review)) learnings.push("- Date operations should consider UTC vs local time");
     }
-    const taskJsonPath = path22.join(ctx.taskDir, "task.json");
-    if (fs24.existsSync(taskJsonPath)) {
+    const taskJsonPath = path23.join(ctx.taskDir, "task.json");
+    if (fs25.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs24.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs25.readFileSync(taskJsonPath, "utf-8"));
         const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
         const task = JSON.parse(cleaned);
         if (task.scope && Array.isArray(task.scope)) {
@@ -3755,12 +3952,12 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path22.join(memoryDir, "conventions.md");
+      const conventionsPath = path23.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs24.appendFileSync(conventionsPath, entry);
+      fs25.appendFileSync(conventionsPath, entry);
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
@@ -3768,8 +3965,8 @@ ${learnings.join("\n")}
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path22.join(memoryDir, "architecture.md");
-  if (fs24.existsSync(archPath)) return;
+  const archPath = path23.join(memoryDir, "architecture.md");
+  if (fs25.existsSync(archPath)) return;
   const detected = detectArchitectureBasic(projectDir);
   if (detected.length > 0) {
     const content = `# Architecture (auto-detected ${timestamp2})
@@ -3777,7 +3974,7 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs24.writeFileSync(archPath, content);
+    fs25.writeFileSync(archPath, content);
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
@@ -3790,13 +3987,13 @@ var init_auto_learn = __esm({
 });
 
 // src/retrospective.ts
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path23.join(taskDir, filename);
-  if (!fs25.existsSync(p)) return null;
+  const p = path24.join(taskDir, filename);
+  if (!fs26.existsSync(p)) return null;
   try {
-    const content = fs25.readFileSync(p, "utf-8");
+    const content = fs26.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -3849,13 +4046,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path23.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+  return path24.join(projectDir, ".kody", "memory", "observer-log.jsonl");
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs25.existsSync(logPath)) return [];
+  if (!fs26.existsSync(logPath)) return [];
   try {
-    const content = fs25.readFileSync(logPath, "utf-8");
+    const content = fs26.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -3882,11 +4079,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path23.dirname(logPath);
-  if (!fs25.existsSync(dir)) {
-    fs25.mkdirSync(dir, { recursive: true });
+  const dir = path24.dirname(logPath);
+  if (!fs26.existsSync(dir)) {
+    fs26.mkdirSync(dir, { recursive: true });
   }
-  fs25.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs26.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -4054,8 +4251,8 @@ var init_summary = __esm({
 });
 
 // src/pipeline.ts
-import * as fs26 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -4068,8 +4265,8 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
   if (!ctx.input.issueNumber) return;
   try {
-    const taskMdPath = path24.join(ctx.taskDir, "task.md");
-    const title = fs26.existsSync(taskMdPath) ? fs26.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const taskMdPath = path25.join(ctx.taskDir, "task.md");
+    const title = fs27.existsSync(taskMdPath) ? fs27.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
@@ -4083,10 +4280,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path24.join(taskDir, ".lock");
-  if (fs26.existsSync(lockPath)) {
+  const lockPath = path25.join(taskDir, ".lock");
+  if (fs27.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs26.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs27.readFileSync(lockPath, "utf-8").trim(), 10);
       if (!isNaN(pid)) {
         try {
           process.kill(pid, 0);
@@ -4103,14 +4300,14 @@ function acquireLock(taskDir) {
       logger.warn(`  Corrupt lock file \u2014 overwriting`);
     }
     try {
-      fs26.unlinkSync(lockPath);
+      fs27.unlinkSync(lockPath);
     } catch {
     }
   }
   try {
-    const fd = fs26.openSync(lockPath, fs26.constants.O_WRONLY | fs26.constants.O_CREAT | fs26.constants.O_EXCL);
-    fs26.writeSync(fd, String(process.pid));
-    fs26.closeSync(fd);
+    const fd = fs27.openSync(lockPath, fs27.constants.O_WRONLY | fs27.constants.O_CREAT | fs27.constants.O_EXCL);
+    fs27.writeSync(fd, String(process.pid));
+    fs27.closeSync(fd);
   } catch (err) {
     if (err.code === "EEXIST") {
       throw new Error("Pipeline already running (lock acquired by another process)");
@@ -4120,7 +4317,7 @@ function acquireLock(taskDir) {
 }
 function releaseLock(taskDir) {
   try {
-    fs26.unlinkSync(path24.join(taskDir, ".lock"));
+    fs27.unlinkSync(path25.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -4328,8 +4525,8 @@ var init_pipeline = __esm({
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync14 } from "child_process";
-import * as fs27 from "fs";
+import { execFileSync as execFileSync15 } from "child_process";
+import * as fs28 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -4341,7 +4538,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync14("claude", ["--version"], {
+      const v = execFileSync15("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -4349,14 +4546,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync14("git", ["rev-parse", "--is-inside-work-tree"], {
+      execFileSync15("git", ["rev-parse", "--is-inside-work-tree"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
     }),
     check("pnpm", () => {
-      const v = execFileSync14("pnpm", ["--version"], {
+      const v = execFileSync15("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -4364,7 +4561,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync14("node", ["--version"], {
+      const v = execFileSync15("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -4374,7 +4571,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync14("gh", ["--version"], {
+      const v = execFileSync15("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -4382,7 +4579,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs27.existsSync("package.json")) throw new Error("not found");
+      if (!fs28.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -4458,180 +4655,6 @@ var init_args = __esm({
   }
 });
 
-// src/cli/litellm.ts
-import * as fs28 from "fs";
-import * as os from "os";
-import * as path25 from "path";
-import { execFileSync as execFileSync15 } from "child_process";
-async function checkLitellmHealth(url) {
-  try {
-    const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-async function checkModelHealth(baseUrl, apiKey, model) {
-  try {
-    const res = await fetch(`${baseUrl}/v1/messages`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model,
-        max_tokens: 4,
-        messages: [{ role: "user", content: "Reply with: ok" }]
-      }),
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!res.ok) {
-      const body2 = await res.text().catch(() => "");
-      return { ok: false, error: `HTTP ${res.status}: ${body2.slice(0, 200)}` };
-    }
-    const body = await res.json();
-    const hasAnthropicContent = Array.isArray(body.content) && body.content.some((b) => b.type === "text");
-    const hasThinkingContent = Array.isArray(body.content) && body.content.some((b) => b.type === "thinking");
-    const hasOpenAIContent = !!body.choices?.[0]?.message?.content;
-    if (!hasAnthropicContent && !hasThinkingContent && !hasOpenAIContent) {
-      return { ok: false, error: `Unexpected response format: ${JSON.stringify(body).slice(0, 200)}` };
-    }
-    return { ok: true };
-  } catch (err) {
-    return { ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-function generateLitellmConfig(provider, modelMap) {
-  const apiKeyVar = providerApiKeyEnvVar(provider);
-  const entries = ["model_list:"];
-  const seen = /* @__PURE__ */ new Set();
-  for (const providerModel of Object.values(modelMap)) {
-    if (seen.has(providerModel)) continue;
-    seen.add(providerModel);
-    entries.push(`  - model_name: ${providerModel}`);
-    entries.push(`    litellm_params:`);
-    entries.push(`      model: ${provider}/${providerModel}`);
-    entries.push(`      api_key: os.environ/${apiKeyVar}`);
-  }
-  return entries.join("\n") + "\n";
-}
-function generateLitellmConfigFromStages(defaultConfig, stages) {
-  const proxyModels = [];
-  if (defaultConfig && defaultConfig.provider !== "claude" && defaultConfig.provider !== "anthropic") {
-    proxyModels.push(defaultConfig);
-  }
-  if (stages) {
-    for (const sc of Object.values(stages)) {
-      if (sc.provider !== "claude" && sc.provider !== "anthropic") {
-        proxyModels.push(sc);
-      }
-    }
-  }
-  if (proxyModels.length === 0) return void 0;
-  const entries = ["model_list:"];
-  const seen = /* @__PURE__ */ new Set();
-  for (const { provider, model } of proxyModels) {
-    const key = `${provider}/${model}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    const apiKeyVar = providerApiKeyEnvVar(provider);
-    entries.push(`  - model_name: ${model}`);
-    entries.push(`    litellm_params:`);
-    entries.push(`      model: ${provider}/${model}`);
-    entries.push(`      api_key: os.environ/${apiKeyVar}`);
-  }
-  return entries.join("\n") + "\n";
-}
-async function tryStartLitellm(url, projectDir, generatedConfig) {
-  if (!generatedConfig) {
-    logger.warn("No provider configured in kody.config.json \u2014 cannot start LiteLLM proxy");
-    return null;
-  }
-  const configPath = path25.join(os.tmpdir(), "kody-litellm-config.yaml");
-  fs28.writeFileSync(configPath, generatedConfig);
-  const portMatch = url.match(/:(\d+)/);
-  const port = portMatch ? portMatch[1] : "4000";
-  let litellmFound = false;
-  try {
-    execFileSync15("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
-    litellmFound = true;
-  } catch {
-    try {
-      execFileSync15("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
-      litellmFound = true;
-    } catch {
-    }
-  }
-  if (!litellmFound) {
-    logger.warn("litellm not installed (pip install 'litellm[proxy]')");
-    return null;
-  }
-  logger.info(`Starting LiteLLM proxy on port ${port}...`);
-  let cmd;
-  let args2;
-  try {
-    execFileSync15("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
-    cmd = "litellm";
-    args2 = ["--config", configPath, "--port", port];
-  } catch {
-    cmd = "python3";
-    args2 = ["-m", "litellm", "--config", configPath, "--port", port];
-  }
-  const dotenvPath = path25.join(projectDir, ".env");
-  const dotenvVars = {};
-  if (fs28.existsSync(dotenvPath)) {
-    for (const rawLine of fs28.readFileSync(dotenvPath, "utf-8").split("\n")) {
-      const line = rawLine.trim();
-      if (!line || line.startsWith("#")) continue;
-      const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
-      if (match) {
-        let value = match[2].trim();
-        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-          value = value.slice(1, -1);
-        }
-        const commentIdx = value.indexOf(" #");
-        if (commentIdx !== -1) value = value.slice(0, commentIdx).trim();
-        if (value) dotenvVars[match[1]] = value;
-      }
-    }
-    if (Object.keys(dotenvVars).length > 0) {
-      logger.info(`  Loaded API keys: ${Object.keys(dotenvVars).join(", ")}`);
-    }
-  }
-  const { spawn: spawn2 } = await import("child_process");
-  const child = spawn2(cmd, args2, {
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: true,
-    env: { ...process.env, ...dotenvVars }
-  });
-  let proxyStderr = "";
-  child.stderr?.on("data", (chunk) => {
-    proxyStderr += chunk.toString();
-  });
-  for (let i = 0; i < 30; i++) {
-    await new Promise((r) => setTimeout(r, 2e3));
-    if (await checkLitellmHealth(url)) {
-      logger.info(`LiteLLM proxy ready at ${url}`);
-      return child;
-    }
-  }
-  if (proxyStderr) {
-    logger.warn(`LiteLLM stderr: ${proxyStderr.slice(-1e3)}`);
-  }
-  logger.warn("LiteLLM proxy failed to start within 60s");
-  child.kill();
-  return null;
-}
-var init_litellm = __esm({
-  "src/cli/litellm.ts"() {
-    "use strict";
-    init_logger();
-    init_config();
-  }
-});
-
 // src/cli/task-state.ts
 import * as fs29 from "fs";
 import * as path26 from "path";