@kody-ade/kody-engine-lite 0.1.116 → 0.1.117

package/dist/bin/cli.js

@@ -180,8 +180,8 @@ var init_validators = __esm({
 });
 
 // src/config.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 function resolveStageConfig(config, stageName, modelTier) {
   const stageOverride = config.agent.stages?.[stageName];
   if (stageOverride) return stageOverride;
@@ -214,9 +214,7 @@ function getLitellmUrl() {
   return LITELLM_DEFAULT_URL;
 }
 function providerApiKeyEnvVar(provider) {
-  if (provider === "anthropic" || provider === "claude") return "ANTHROPIC_API_KEY";
-  const derived = `${provider.toUpperCase()}_API_KEY`;
-  if (process.env[derived]) return derived;
+  if (provider === "anthropic") return "ANTHROPIC_API_KEY";
   return "ANTHROPIC_COMPATIBLE_API_KEY";
 }
 function setConfigDir(dir) {
@@ -225,16 +223,16 @@ function setConfigDir(dir) {
 }
 function getProjectConfig() {
   if (_config) return _config;
-  const configPath = path6.join(_configDir ?? process.cwd(), "kody.config.json");
-  if (fs7.existsSync(configPath)) {
+  const configPath = path7.join(_configDir ?? process.cwd(), "kody.config.json");
+  if (fs8.existsSync(configPath)) {
     try {
-      const result2 = parseJsonSafe(fs7.readFileSync(configPath, "utf-8"));
-      if (!result2.ok) {
-        logger.warn(`kody.config.json: ${result2.error} \u2014 using defaults`);
+      const result = parseJsonSafe(fs8.readFileSync(configPath, "utf-8"));
+      if (!result.ok) {
+        logger.warn(`kody.config.json: ${result.error} \u2014 using defaults`);
         _config = { ...DEFAULT_CONFIG };
         return _config;
       }
-      const raw = result2.data;
+      const raw = result.data;
       _config = {
         quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
         git: { ...DEFAULT_CONFIG.git, ...raw.git },
@@ -285,7 +283,7 @@ var init_config = __esm({
         repo: ""
       },
       agent: {
-        modelMap: { cheap: "claude-haiku-4-5-20251001", mid: "claude-sonnet-4-6", strong: "claude-opus-4-6" }
+        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
       },
       contextTiers: {
         enabled: true,
@@ -391,11 +389,10 @@ function createClaudeCodeRunner() {
         model,
         "--dangerously-skip-permissions"
       ];
-      const baseTools = "Bash,Edit,Read,Write,Glob,Grep";
       if (options?.mcpConfigJson) {
         args2.push("--mcp-config", options.mcpConfigJson);
       } else {
-        args2.push("--allowedTools", baseTools);
+        args2.push("--allowedTools", "Bash,Edit,Read,Write,Glob,Grep");
       }
       if (options?.sessionId) {
         if (options.resumeSession) {
@@ -968,8 +965,8 @@ function findLatestTaskForIssue(issueNumber, projectDir) {
 }
 function generateTaskId() {
   const now = /* @__PURE__ */ new Date();
-  const pad2 = (n) => String(n).padStart(2, "0");
-  return `${String(now.getFullYear()).slice(2)}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}-${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}`;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${String(now.getFullYear()).slice(2)}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
 }
 function resolveTaskIdFromComments(issueNumber) {
   try {
@@ -1195,7 +1192,6 @@ var init_litellm = __esm({
 // src/cli/taskify-command.ts
 var taskify_command_exports = {};
 __export(taskify_command_exports, {
-  TaskifyError: () => TaskifyError,
   isTaskifyRun: () => isTaskifyRun,
   readTaskifyMarker: () => readTaskifyMarker,
   runTaskifyCommand: () => runTaskifyCommand,
@@ -1287,17 +1283,8 @@ async function runTaskifyCommand() {
       ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "dummy"
     };
   }
-  try {
-    await taskifyCommand({ ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId, runnerEnv });
-  } catch (err) {
-    if (err instanceof TaskifyError) {
-      logger.error(`[taskify] ${err.message}`);
-      process.exit(1);
-    }
-    throw err;
-  } finally {
-    litellmProcess?.kill();
-  }
+  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;
@@ -1312,6 +1299,7 @@ async function taskifyCommand(opts) {
       mcpConfigJson = buildTaskifyMcpConfigJson(config);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
+      logger.error(`[taskify] MCP config error: ${msg}`);
       if (issueNumber && !local) {
         postComment(
           issueNumber,
@@ -1322,7 +1310,7 @@ async function taskifyCommand(opts) {
 Add the required MCP server config to \`kody.config.json\` and try again.`
         );
       }
-      throw new TaskifyError(`MCP config error: ${msg}`);
+      process.exit(1);
     }
   }
   const sc = resolveStageConfig(config, "taskify", "strong");
@@ -1363,44 +1351,47 @@ Kody is decomposing ${src} into tasks...`);
   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 result2 = await runner.run("taskify", prompt, model, TASKIFY_TIMEOUT_MS, taskDir, {
+  const result = await runner.run("taskify", prompt, model, TASKIFY_TIMEOUT_MS, taskDir, {
     cwd: projectDir,
     mcpConfigJson,
     env: opts.runnerEnv
   });
-  if (result2.outcome !== "completed") {
-    const errMsg = result2.outcome === "timed_out" ? "Taskify timed out after 5 minutes." : `Taskify failed: ${result2.error}`;
+  if (result.outcome !== "completed") {
+    const errMsg = result.outcome === "timed_out" ? "Taskify timed out after 5 minutes." : `Taskify failed: ${result.error}`;
+    logger.error(`[taskify] ${errMsg}`);
     if (issueNumber && !local) {
       postComment(issueNumber, `Kody taskify failed:
 
 > ${errMsg}`);
       setLifecycleLabel(issueNumber, "failed");
     }
-    throw new TaskifyError(errMsg);
+    process.exit(1);
   }
   const resultPath = path10.join(taskDir, RESULT_FILE);
   if (!fs11.existsSync(resultPath)) {
     const errMsg = `Claude did not write ${RESULT_FILE}. Output:
 
-${result2.output?.slice(0, 500) ?? "(none)"}`;
+${result.output?.slice(0, 500) ?? "(none)"}`;
+    logger.error(`[taskify] ${errMsg}`);
     if (issueNumber && !local) {
       postComment(issueNumber, `Kody taskify failed: result file not found.
 
 ${errMsg}`);
       setLifecycleLabel(issueNumber, "failed");
     }
-    throw new TaskifyError(errMsg);
+    process.exit(1);
   }
   let parsed;
   try {
     parsed = JSON.parse(fs11.readFileSync(resultPath, "utf-8"));
   } catch {
     const errMsg = `Could not parse ${RESULT_FILE} as JSON.`;
+    logger.error(`[taskify] ${errMsg}`);
     if (issueNumber && !local) {
       postComment(issueNumber, `Kody taskify failed: ${errMsg}`);
       setLifecycleLabel(issueNumber, "failed");
     }
-    throw new TaskifyError(errMsg);
+    process.exit(1);
   }
   const sourceLabel = ticketId ?? (prdFile ? path10.basename(prdFile) : "spec");
   if (parsed.status === "questions") {
@@ -1409,11 +1400,12 @@ ${errMsg}`);
     await handleTasks(parsed, sourceLabel, issueNumber, local ?? false);
   } else {
     const errMsg = `Unexpected status in ${RESULT_FILE}: ${JSON.stringify(parsed)}`;
+    logger.error(`[taskify] ${errMsg}`);
     if (issueNumber && !local) {
       postComment(issueNumber, `Kody taskify failed: ${errMsg}`);
       setLifecycleLabel(issueNumber, "failed");
     }
-    throw new TaskifyError(errMsg);
+    process.exit(1);
   }
 }
 function handleQuestions(parsed, ticketId, issueNumber, local) {
@@ -1544,7 +1536,7 @@ function readTaskifyMarker(taskDir) {
     return null;
   }
 }
-var __dirname, TaskifyError, AUTO_TRIGGER_THRESHOLD, MAX_TASKS_GUARD, TASKIFY_TIMEOUT_MS, MARKER_FILE, RESULT_FILE;
+var __dirname, AUTO_TRIGGER_THRESHOLD, MAX_TASKS_GUARD, TASKIFY_TIMEOUT_MS, MARKER_FILE, RESULT_FILE;
 var init_taskify_command = __esm({
   "src/cli/taskify-command.ts"() {
     "use strict";
@@ -1556,12 +1548,6 @@ var init_taskify_command = __esm({
     init_task_resolution();
     init_litellm();
     __dirname = path10.dirname(fileURLToPath(import.meta.url));
-    TaskifyError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "TaskifyError";
-      }
-    };
     AUTO_TRIGGER_THRESHOLD = 5;
     MAX_TASKS_GUARD = 20;
     TASKIFY_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -1570,1161 +1556,6 @@ var init_taskify_command = __esm({
   }
 });
 
-// src/cli/test-model-tests.ts
-import * as fs12 from "fs";
-import * as os2 from "os";
-import * as path11 from "path";
-import * as zlib from "zlib";
-import { spawnSync, execSync as execSync2 } from "child_process";
-function canRunApiTests(ctx) {
-  return !!ctx.apiKey;
-}
-async function apiCall(ctx, body) {
-  try {
-    const res = await fetch(`${ctx.proxyUrl}/v1/messages`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": ctx.apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({ model: ctx.model, ...body }),
-      signal: AbortSignal.timeout(6e4)
-    });
-    const data = await res.json();
-    if (!res.ok) {
-      return { ok: false, data, status: res.status, errorMsg: data?.error?.message ?? `HTTP ${res.status}` };
-    }
-    return { ok: true, data, status: res.status };
-  } catch (err) {
-    return { ok: false, data: null, status: 0, errorMsg: err instanceof Error ? err.message : String(err) };
-  }
-}
-function extractText(data) {
-  if (!data?.content) return "";
-  return data.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
-}
-async function runToolConversation(ctx, tools, userPrompt, simulate, opts) {
-  const messages = [{ role: "user", content: userPrompt }];
-  const allCalls = [];
-  for (let turn = 0; turn < (opts?.maxTurns ?? 5); turn++) {
-    const body = {
-      max_tokens: 1024,
-      temperature: 0,
-      messages,
-      tools
-    };
-    if (opts?.system) body.system = opts.system;
-    const res = await apiCall(ctx, body);
-    if (!res.ok) return { finalText: "", toolCalls: allCalls, error: res.errorMsg };
-    const content = res.data.content ?? [];
-    const toolBlocks = content.filter((b) => b.type === "tool_use");
-    const textBlocks = content.filter((b) => b.type === "text");
-    if (toolBlocks.length === 0) {
-      return { finalText: textBlocks.map((b) => b.text ?? "").join(""), toolCalls: allCalls };
-    }
-    for (const tc of toolBlocks) allCalls.push({ name: tc.name, input: tc.input });
-    messages.push({ role: "assistant", content });
-    messages.push({
-      role: "user",
-      content: toolBlocks.map((tc) => ({
-        type: "tool_result",
-        tool_use_id: tc.id,
-        content: simulate(tc.name, tc.input)
-      }))
-    });
-  }
-  return { finalText: "", toolCalls: allCalls, error: "Max turns reached" };
-}
-function filterStderr(stderr) {
-  return stderr.split("\n").filter((l) => !l.includes("CPU lacks AVX") && !l.includes("bun-darwin") && !l.includes("Warning: no stdin data") && l.trim().length > 0).join("\n").trim();
-}
-function runClaudeTest(ctx, prompt, extraFlags = [], timeout = 9e4) {
-  try {
-    const isDirectAnthropic = ctx.proxyUrl.includes("api.anthropic.com");
-    const envOverrides = isDirectAnthropic ? {} : { ANTHROPIC_BASE_URL: ctx.proxyUrl, ANTHROPIC_API_KEY: ctx.apiKey };
-    const result2 = spawnSync("claude", [
-      "--print",
-      "--model",
-      ctx.model,
-      "--dangerously-skip-permissions",
-      ...extraFlags,
-      "-p",
-      prompt
-    ], {
-      env: { ...process.env, ...envOverrides },
-      timeout,
-      encoding: "utf-8",
-      cwd: ctx.projectDir
-    });
-    return {
-      stdout: result2.stdout ?? "",
-      stderr: filterStderr(result2.stderr ?? ""),
-      exitCode: result2.status ?? 1
-    };
-  } catch (err) {
-    return { stdout: "", stderr: String(err), exitCode: 1 };
-  }
-}
-function isGitClean(dir) {
-  try {
-    const out = execSync2("git diff --name-only", { cwd: dir, encoding: "utf-8", timeout: 5e3 });
-    return out.trim().length === 0;
-  } catch {
-    return false;
-  }
-}
-function revertChanges(dir) {
-  try {
-    execSync2("git checkout -- src/logger.ts", { cwd: dir, timeout: 5e3, stdio: "pipe" });
-  } catch {
-  }
-}
-function result(name, category, status, accuracy, durationMs, detail, metrics) {
-  return { name, category, status, accuracy, durationMs, detail, metrics };
-}
-function crc32(buf) {
-  let c = 4294967295;
-  for (const b of buf) c = CRC_TABLE[(c ^ b) & 255] ^ c >>> 8;
-  return (c ^ 4294967295) >>> 0;
-}
-function createRedPng() {
-  const w = 4, h = 4;
-  const scanlines = Buffer.alloc(h * (1 + w * 3));
-  for (let y = 0; y < h; y++) {
-    const off = y * (1 + w * 3);
-    scanlines[off] = 0;
-    for (let x = 0; x < w; x++) {
-      scanlines[off + 1 + x * 3] = 255;
-      scanlines[off + 1 + x * 3 + 1] = 0;
-      scanlines[off + 1 + x * 3 + 2] = 0;
-    }
-  }
-  function chunk(type, data) {
-    const tb = Buffer.from(type, "ascii");
-    const merged = Buffer.concat([tb, data]);
-    const len = Buffer.alloc(4);
-    len.writeUInt32BE(data.length);
-    const crcBuf = Buffer.alloc(4);
-    crcBuf.writeUInt32BE(crc32(merged));
-    return Buffer.concat([len, tb, data, crcBuf]);
-  }
-  const sig = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-  const ihdr = Buffer.alloc(13);
-  ihdr.writeUInt32BE(w, 0);
-  ihdr.writeUInt32BE(h, 4);
-  ihdr[8] = 8;
-  ihdr[9] = 2;
-  return Buffer.concat([sig, chunk("IHDR", ihdr), chunk("IDAT", zlib.deflateSync(scanlines)), chunk("IEND", Buffer.alloc(0))]);
-}
-async function testSimplePrompt(ctx) {
-  const t = Date.now();
-  if (!canRunApiTests(ctx)) {
-    const r = runClaudeTest(ctx, "Reply with exactly: KODY_TEST_OK");
-    const ok2 = r.stdout.includes("KODY_TEST_OK");
-    return result(
-      "simple_prompt",
-      "basic",
-      ok2 ? "pass" : "fail",
-      ok2 ? 100 : 0,
-      Date.now() - t,
-      ok2 ? "Model responded correctly (via CLI)" : `Got: ${r.stdout.slice(0, 80)}`
-    );
-  }
-  const res = await apiCall(ctx, {
-    max_tokens: 50,
-    temperature: 0,
-    messages: [{ role: "user", content: "Reply with exactly: KODY_TEST_OK" }]
-  });
-  if (!res.ok) return result("simple_prompt", "basic", "fail", 0, Date.now() - t, `API error: ${res.errorMsg}`);
-  const text = extractText(res.data);
-  const ok = text.includes("KODY_TEST_OK");
-  return result(
-    "simple_prompt",
-    "basic",
-    ok ? "pass" : "fail",
-    ok ? 100 : 0,
-    Date.now() - t,
-    ok ? "Model responded correctly" : `Expected KODY_TEST_OK, got: ${text.slice(0, 80)}`
-  );
-}
-async function testJsonOutput(ctx) {
-  if (!canRunApiTests(ctx)) {
-    const t2 = Date.now();
-    const r = runClaudeTest(ctx, 'Respond with ONLY valid JSON, no markdown fences. Return: {"status":"ok","model":"your name"}');
-    let text2 = r.stdout.trim().replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
-    try {
-      JSON.parse(text2);
-      return result("json_output", "basic", "pass", 100, Date.now() - t2, "Valid JSON via CLI");
-    } catch {
-      return result("json_output", "basic", "fail", 0, Date.now() - t2, `Invalid JSON: ${text2.slice(0, 80)}`);
-    }
-  }
-  const t = Date.now();
-  const res = await apiCall(ctx, {
-    max_tokens: 200,
-    temperature: 0,
-    system: "Respond with ONLY valid JSON. No markdown fences, no explanation. Just raw JSON.",
-    messages: [{ role: "user", content: 'Return a JSON object with keys "status" (string "ok") and "model" (string, your model name).' }]
-  });
-  if (!res.ok) return result("json_output", "basic", "fail", 0, Date.now() - t, `API error: ${res.errorMsg}`);
-  let text = extractText(res.data).trim();
-  text = text.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
-  try {
-    const parsed = JSON.parse(text);
-    const hasKeys = typeof parsed.status === "string" && typeof parsed.model === "string";
-    return result(
-      "json_output",
-      "basic",
-      "pass",
-      hasKeys ? 100 : 70,
-      Date.now() - t,
-      hasKeys ? "Valid JSON with correct keys" : "Valid JSON but missing expected keys"
-    );
-  } catch {
-    return result("json_output", "basic", "fail", 0, Date.now() - t, `Invalid JSON: ${text.slice(0, 80)}`);
-  }
-}
-function scoreRules(text) {
-  let score = 0;
-  const checks = [];
-  if (text.startsWith("KODY:") || text.startsWith("kody:")) {
-    score += 20;
-    checks.push("starts-with-kody");
-  }
-  if (!text.toLowerCase().split(/\s+/).includes("the")) {
-    score += 20;
-    checks.push("no-the");
-  }
-  if (text.split(/\s+/).length <= 55) {
-    score += 20;
-    checks.push("under-50-words");
-  }
-  if (text.endsWith("END") || text.endsWith("end")) {
-    score += 20;
-    checks.push("ends-with-end");
-  }
-  if (text === text.toLowerCase()) {
-    score += 20;
-    checks.push("all-lowercase");
-  }
-  return { score, checks };
-}
-async function testSystemPromptRules(ctx) {
-  const rulesPrompt = [
-    "STRICT RULES \u2014 violating ANY will crash the system:",
-    "1) Start every response with 'KODY:'",
-    "2) Never use the word 'the'",
-    "3) Keep response under 50 words",
-    "4) End your response with 'END'",
-    "5) Use ONLY lowercase letters (no uppercase anywhere)"
-  ].join("\n");
-  if (!canRunApiTests(ctx)) {
-    const t2 = Date.now();
-    const r = runClaudeTest(ctx, [
-      "Follow ALL these rules in your response:",
-      "1) Your response must start with the word 'KODY:'",
-      "2) Do not use the word 'the' anywhere",
-      "3) Keep your response under 50 words total",
-      "4) End your response with the word 'END'",
-      "5) Use only lowercase letters throughout",
-      "",
-      "Now describe what a compiler does. Remember: follow ALL 5 rules above exactly."
-    ].join("\n"));
-    const { score: score2, checks: checks2 } = scoreRules(r.stdout.trim());
-    const status2 = score2 >= 80 ? "pass" : score2 >= 40 ? "warn" : "fail";
-    return result(
-      "system_prompt_rules",
-      "basic",
-      status2,
-      score2,
-      Date.now() - t2,
-      `${score2 / 20}/5 rules followed: ${checks2.join(", ")}`,
-      { instructionCompliance: score2 }
-    );
-  }
-  const t = Date.now();
-  const res = await apiCall(ctx, {
-    max_tokens: 200,
-    temperature: 0,
-    system: rulesPrompt,
-    messages: [{ role: "user", content: "Describe what a compiler does." }]
-  });
-  if (!res.ok) return result("system_prompt_rules", "basic", "fail", 0, Date.now() - t, `API error: ${res.errorMsg}`);
-  const text = extractText(res.data).trim();
-  const { score, checks } = scoreRules(text);
-  const status = score >= 80 ? "pass" : score >= 40 ? "warn" : "fail";
-  return result(
-    "system_prompt_rules",
-    "basic",
-    status,
-    score,
-    Date.now() - t,
-    `${score / 20}/5 rules followed: ${checks.join(", ")}`,
-    { instructionCompliance: score }
-  );
-}
-async function testExtendedThinking(ctx) {
-  if (!canRunApiTests(ctx)) {
-    const t2 = Date.now();
-    const r = runClaudeTest(ctx, "What is 15 * 23? Reply with just the number.");
-    const ok = r.stdout.includes("345");
-    return result(
-      "extended_thinking",
-      "infrastructure",
-      ok ? "pass" : "warn",
-      ok ? 100 : 50,
-      Date.now() - t2,
-      ok ? "Model responded correctly (thinking assumed via CLI)" : `Got: ${r.stdout.slice(0, 80)}`
-    );
-  }
-  const t = Date.now();
-  const res = await apiCall(ctx, {
-    max_tokens: 200,
-    thinking: { type: "enabled", budget_tokens: 2e3 },
-    messages: [{ role: "user", content: "What is 15 * 23?" }]
-  });
-  if (!res.ok) return result(
-    "extended_thinking",
-    "infrastructure",
-    "warn",
-    50,
-    Date.now() - t,
-    `Request failed (model may not support thinking): ${res.errorMsg?.slice(0, 80)}`
-  );
-  const hasThinking = Array.isArray(res.data.content) && res.data.content.some((b) => b.type === "thinking");
-  const hasText = extractText(res.data).length > 0;
-  if (hasThinking) return result("extended_thinking", "infrastructure", "pass", 100, Date.now() - t, "Thinking block present in response");
-  if (hasText) return result("extended_thinking", "infrastructure", "warn", 70, Date.now() - t, "Response OK but no thinking block");
-  return result("extended_thinking", "infrastructure", "fail", 0, Date.now() - t, "No content in response");
-}
-async function testToolRead(ctx) {
-  if (!canRunApiTests(ctx)) {
-    const t2 = Date.now();
-    const testFile2 = path11.join(os2.tmpdir(), "kody-test-model-read.txt");
-    fs12.writeFileSync(testFile2, "KODY_SECRET_CONTENT_42");
-    try {
-      const r = runClaudeTest(ctx, `Read the file ${testFile2} and tell me its exact contents. Reply with ONLY the file contents.`);
-      const ok = r.stdout.includes("KODY_SECRET_CONTENT_42");
-      return result(
-        "tool_read",
-        "tool-use",
-        ok ? "pass" : "fail",
-        ok ? 100 : 0,
-        Date.now() - t2,
-        ok ? "Read tool works via CLI" : `Got: ${r.stdout.slice(0, 80)}`,
-        { toolSelection: ok ? 100 : 0 }
-      );
-    } finally {
-      fs12.rmSync(testFile2, { force: true });
-    }
-  }
-  const t = Date.now();
-  const testFile = path11.join(os2.tmpdir(), "kody-test-model-read.txt");
-  fs12.writeFileSync(testFile, "KODY_SECRET_CONTENT_42");
-  try {
-    const conv = await runToolConversation(
-      ctx,
-      [TOOL_READ],
-      `Read the file ${testFile} and tell me what it contains.`,
-      (name, input) => {
-        if (name === "Read" && input.path === testFile) return "KODY_SECRET_CONTENT_42";
-        return "Error: File not found";
-      }
-    );
-    if (conv.error) return result("tool_read", "tool-use", "fail", 0, Date.now() - t, `Error: ${conv.error}`);
-    const calledRead = conv.toolCalls.some((tc) => tc.name === "Read");
-    const correctPath = conv.toolCalls.some((tc) => tc.name === "Read" && tc.input.path === testFile);
-    const mentionsContent = conv.finalText.includes("KODY_SECRET_CONTENT_42") || conv.finalText.includes("42");
-    let acc = 0;
-    if (calledRead) acc += 30;
-    if (correctPath) acc += 30;
-    if (mentionsContent) acc += 40;
-    return result(
-      "tool_read",
-      "tool-use",
-      acc >= 60 ? "pass" : "fail",
-      acc,
-      Date.now() - t,
-      `Read called: ${calledRead}, correct path: ${correctPath}, content referenced: ${mentionsContent}`,
-      { toolSelection: calledRead ? 100 : 0 }
-    );
-  } finally {
-    fs12.rmSync(testFile, { force: true });
-  }
-}
-async function testToolEdit(ctx) {
-  if (!canRunApiTests(ctx)) {
-    const t2 = Date.now();
-    const testFile = path11.join(os2.tmpdir(), "kody-test-model-edit.txt");
-    fs12.writeFileSync(testFile, "hello world");
-    try {
-      const r = runClaudeTest(ctx, `Use the Edit tool to replace "hello" with "goodbye" in ${testFile}. Do nothing else.`);
-      const content = fs12.existsSync(testFile) ? fs12.readFileSync(testFile, "utf-8") : "";
-      const ok = content.includes("goodbye");
-      return result(
-        "tool_edit",
-        "tool-use",
-        ok ? "pass" : "fail",
-        ok ? 100 : 0,
-        Date.now() - t2,
-        ok ? "Edit tool works via CLI" : `File content: ${content.slice(0, 80)}`,
-        { toolSelection: ok ? 100 : 0 }
-      );
-    } finally {
-      fs12.rmSync(testFile, { force: true });
-    }
-  }
-  const t = Date.now();
-  const conv = await runToolConversation(
-    ctx,
-    [TOOL_READ, TOOL_EDIT],
-    'Read the file /tmp/kody-edit-test.txt, then use Edit to replace "hello" with "goodbye" in it.',
-    (name, input) => {
-      if (name === "Read") return "hello world";
-      if (name === "Edit") return "File edited successfully";
-      return "Unknown tool";
-    }
-  );
-  if (conv.error) return result("tool_edit", "tool-use", "fail", 0, Date.now() - t, `Error: ${conv.error}`);
-  const editCall = conv.toolCalls.find((tc) => tc.name === "Edit");
-  let acc = 0;
-  if (editCall) {
-    acc += 40;
-    if (editCall.input.old_string === "hello") acc += 30;
-    if (editCall.input.new_string === "goodbye") acc += 30;
-  }
-  return result(
-    "tool_edit",
-    "tool-use",
-    acc >= 70 ? "pass" : acc > 0 ? "warn" : "fail",
-    acc,
-    Date.now() - t,
-    editCall ? `Edit called with old="${editCall.input.old_string}" new="${editCall.input.new_string}"` : "Edit tool was not called",
-    { toolSelection: editCall ? 100 : 0 }
-  );
-}
-async function testToolBash(ctx) {
-  if (!canRunApiTests(ctx)) {
-    const t2 = Date.now();
-    const r = runClaudeTest(ctx, "Run this bash command and tell me its output: echo KODY_BASH_OK");
-    const ok = r.stdout.includes("KODY_BASH_OK");
-    return result(
-      "tool_bash",
-      "tool-use",
-      ok ? "pass" : "fail",
-      ok ? 100 : 0,
-      Date.now() - t2,
-      ok ? "Bash tool works via CLI" : `Got: ${r.stdout.slice(0, 80)}`,
-      { toolSelection: ok ? 100 : 0 }
-    );
-  }
-  const t = Date.now();
-  const conv = await runToolConversation(
-    ctx,
-    [TOOL_BASH],
-    "Run this exact bash command: echo KODY_BASH_OK",
-    (name, input) => {
-      if (name === "Bash") return "KODY_BASH_OK\n";
-      return "Error";
-    }
-  );
-  if (conv.error) return result("tool_bash", "tool-use", "fail", 0, Date.now() - t, `Error: ${conv.error}`);
-  const bashCall = conv.toolCalls.find((tc) => tc.name === "Bash");
-  const correctCmd = bashCall && String(bashCall.input.command).includes("echo KODY_BASH_OK");
-  const acc = bashCall ? correctCmd ? 100 : 50 : 0;
-  return result(
-    "tool_bash",
-    "tool-use",
-    acc >= 50 ? "pass" : "fail",
-    acc,
-    Date.now() - t,
-    bashCall ? `Bash called: ${bashCall.input.command}` : "Bash tool was not called",
-    { toolSelection: bashCall ? 100 : 0 }
-  );
-}
-async function testImageAttachment(ctx) {
-  if (!canRunApiTests(ctx)) {
-    const t2 = Date.now();
-    const tmpPng = path11.join(os2.tmpdir(), "kody-test-image.png");
-    fs12.writeFileSync(tmpPng, createRedPng());
-    try {
-      const r = runClaudeTest(ctx, `Read the image file at ${tmpPng} and tell me what color it is. Reply with just the color name.`);
-      const text2 = r.stdout.toLowerCase();
-      const ok = text2.includes("red");
-      return result(
-        "image_attachment",
-        "tool-use",
-        ok ? "pass" : "warn",
-        ok ? 100 : 50,
-        Date.now() - t2,
-        ok ? "Image processed correctly via CLI" : `Got: ${text2.slice(0, 80)}`
-      );
-    } finally {
-      fs12.rmSync(tmpPng, { force: true });
-    }
-  }
-  const t = Date.now();
-  const pngData = createRedPng().toString("base64");
-  const res = await apiCall(ctx, {
-    max_tokens: 100,
-    temperature: 0,
-    messages: [{
-      role: "user",
-      content: [
-        { type: "image", source: { type: "base64", media_type: "image/png", data: pngData } },
-        { type: "text", text: "What color is this image? Reply with just the color name." }
-      ]
-    }]
-  });
-  if (!res.ok) return result(
-    "image_attachment",
-    "tool-use",
-    "fail",
-    0,
-    Date.now() - t,
-    `API error (model may not support vision): ${res.errorMsg?.slice(0, 80)}`
-  );
-  const text = extractText(res.data).toLowerCase();
-  const mentionsRed = text.includes("red");
-  const mentionsColor = mentionsRed || text.includes("color") || text.includes("image") || text.includes("pixel");
-  const acc = mentionsRed ? 100 : mentionsColor ? 50 : 20;
-  return result(
-    "image_attachment",
-    "tool-use",
-    mentionsRed ? "pass" : mentionsColor ? "warn" : "fail",
-    acc,
-    Date.now() - t,
-    `Response: ${text.slice(0, 80)}`
-  );
-}
-async function testErrorRecovery(ctx) {
-  if (!canRunApiTests(ctx)) {
-    const t2 = Date.now();
-    const r = runClaudeTest(ctx, "Read the file /tmp/kody-nonexistent-test-file-xyz.txt and tell me what's in it. If it doesn't exist, say 'FILE_NOT_FOUND'.");
-    const ok = r.stdout.includes("FILE_NOT_FOUND") || r.stdout.toLowerCase().includes("not found") || r.stdout.toLowerCase().includes("does not exist") || r.stdout.toLowerCase().includes("doesn't exist");
-    return result(
-      "error_recovery",
-      "advanced",
-      ok ? "pass" : "warn",
-      ok ? 100 : 50,
-      Date.now() - t2,
-      ok ? "Graceful error handling via CLI" : `Got: ${r.stdout.slice(0, 80)}`
-    );
-  }
-  const t = Date.now();
-  let errorGiven = false;
-  const conv = await runToolConversation(
-    ctx,
-    [TOOL_READ, TOOL_BASH],
-    "Read the file /tmp/nonexistent-kody-file.txt and tell me what's in it. If the file doesn't exist, say so.",
-    (name, input) => {
-      if (name === "Read" && !errorGiven) {
-        errorGiven = true;
-        return "Error: ENOENT: no such file or directory";
-      }
-      if (name === "Bash") return "ls: /tmp/nonexistent-kody-file.txt: No such file or directory";
-      return "Error: File not found";
-    }
-  );
-  if (conv.error) return result("error_recovery", "advanced", "fail", 0, Date.now() - t, `Error: ${conv.error}`);
-  const reported = conv.finalText.toLowerCase().includes("not found") || conv.finalText.toLowerCase().includes("doesn't exist") || conv.finalText.toLowerCase().includes("does not exist") || conv.finalText.toLowerCase().includes("no such file");
-  const tried = conv.toolCalls.length >= 1;
-  const acc = reported ? tried ? 100 : 70 : 20;
-  return result(
-    "error_recovery",
-    "advanced",
-    reported ? "pass" : "warn",
-    acc,
-    Date.now() - t,
-    reported ? "Gracefully reported missing file" : `Response: ${conv.finalText.slice(0, 80)}`
-  );
-}
-async function testToolMultiStep(ctx) {
-  const t = Date.now();
-  const r = runClaudeTest(
-    ctx,
-    "Do these steps in order: 1) Read kody.config.json 2) Tell me the value of git.defaultBranch. Reply with ONLY the branch name, nothing else."
-  );
-  if (!r.stdout.trim() && r.exitCode !== 0) return result(
-    "tool_multi_step",
-    "tool-use",
-    "fail",
-    0,
-    Date.now() - t,
-    `CLI failed: ${r.stderr.slice(0, 200) || "no output"}`
-  );
-  const out = r.stdout.trim().toLowerCase();
-  const correct = out.includes("main");
-  return result(
-    "tool_multi_step",
-    "tool-use",
-    correct ? "pass" : "fail",
-    correct ? 100 : 20,
-    Date.now() - t,
-    correct ? "Correct: main" : `Got: ${out.slice(0, 80)}`
-  );
-}
-async function testPlanStage(ctx) {
-  const t = Date.now();
-  const wasClean = isGitClean(ctx.projectDir);
-  const r = runClaudeTest(ctx, [
-    "You are a planning agent. Your ONLY job is to output a markdown plan.",
-    "CRITICAL: Do NOT use Edit, Write, or Bash tools. Do NOT modify any files. ONLY use Read, Glob, and Grep for research.",
-    "If you modify any files, the system will crash.",
-    "",
-    "Task: Plan adding a /health endpoint to an Express app.",
-    "Output a markdown plan with ## Step N sections. Each step must have File, Change, and Why fields.",
-    "Keep it to 3 steps maximum."
-  ].join("\n"), [], 12e4);
-  const filesModified = wasClean && !isGitClean(ctx.projectDir);
-  if (filesModified) revertChanges(ctx.projectDir);
-  if (!r.stdout.trim() && r.exitCode !== 0) return result(
-    "plan_stage",
-    "stage-simulation",
-    "fail",
-    0,
-    Date.now() - t,
-    `CLI failed: ${r.stderr.slice(0, 200) || "no output"}`
-  );
-  const out = r.stdout;
-  const hasStepFormat = /##\s*Step/i.test(out);
-  const hasStructure = hasStepFormat || /\*\*File\*\*/i.test(out) && /\*\*Change\*\*/i.test(out);
-  const boundary = filesModified ? 0 : 100;
-  const format = hasStructure ? 100 : hasStepFormat ? 70 : out.length > 50 ? 30 : 0;
-  const acc = Math.round(boundary * 0.6 + format * 0.4);
-  const status = filesModified ? "fail" : hasStructure ? "pass" : "warn";
-  return result(
-    "plan_stage",
-    "stage-simulation",
-    status,
-    acc,
-    Date.now() - t,
-    filesModified ? "FAIL: Model modified files during plan stage (instruction violation)" : hasStructure ? "Plan output with correct structure, no files modified" : "Output lacks expected ## Step structure",
-    { boundaryRespect: boundary, outputFormat: format, instructionCompliance: boundary }
-  );
-}
-async function testBuildStage(ctx) {
-  const t = Date.now();
-  const r = runClaudeTest(ctx, "Add a comment '// kody-build-test' as the very first line of src/logger.ts. That is your only task.");
-  const diff = (() => {
-    try {
-      return execSync2("git diff src/logger.ts", { cwd: ctx.projectDir, encoding: "utf-8", timeout: 5e3 });
-    } catch {
-      return "";
-    }
-  })();
-  const edited = diff.includes("kody-build-test");
-  revertChanges(ctx.projectDir);
-  if (!r.stdout.trim() && r.exitCode !== 0 && !edited) return result(
-    "build_stage",
-    "stage-simulation",
-    "fail",
-    0,
-    Date.now() - t,
-    `CLI failed: ${r.stderr.slice(0, 200) || "no output"}`
-  );
-  return result(
-    "build_stage",
-    "stage-simulation",
-    edited ? "pass" : "fail",
-    edited ? 100 : 0,
-    Date.now() - t,
-    edited ? "File correctly modified with expected comment" : "File was not modified as expected"
-  );
-}
-async function testReviewStage(ctx) {
-  const t = Date.now();
-  const wasClean = isGitClean(ctx.projectDir);
-  const r = runClaudeTest(ctx, [
-    "You are a code review agent. Review the file src/logger.ts.",
-    "CRITICAL: Do NOT modify any files. Only READ and analyze.",
-    "Output your review as markdown with this exact format:",
-    "## Summary",
-    "<1-2 sentence summary>",
-    "## Issues Found",
-    "- <issues>",
-    "## Verdict",
-    "APPROVE or REQUEST_CHANGES"
-  ].join("\n"));
-  const filesModified = wasClean && !isGitClean(ctx.projectDir);
-  if (filesModified) revertChanges(ctx.projectDir);
-  if (!r.stdout.trim() && r.exitCode !== 0) return result(
-    "review_stage",
-    "stage-simulation",
-    "fail",
-    0,
-    Date.now() - t,
-    `CLI failed: ${r.stderr.slice(0, 200) || "no output"}`
-  );
-  const out = r.stdout;
-  const hasVerdict = /verdict/i.test(out);
-  const hasSummary = /summary/i.test(out);
-  const boundary = filesModified ? 0 : 100;
-  const format = (hasVerdict ? 50 : 0) + (hasSummary ? 50 : 0);
-  const acc = Math.round(boundary * 0.5 + format * 0.5);
-  const status = filesModified ? "fail" : hasVerdict && hasSummary ? "pass" : "warn";
-  return result(
-    "review_stage",
-    "stage-simulation",
-    status,
-    acc,
-    Date.now() - t,
-    filesModified ? "FAIL: Model modified files during review (instruction violation)" : `Summary: ${hasSummary}, Verdict: ${hasVerdict}, no files modified`,
-    { boundaryRespect: boundary, outputFormat: format }
-  );
-}
-async function testMcpTools(ctx) {
-  const t = Date.now();
-  const mcpConfig = path11.join(os2.tmpdir(), `kody-test-mcp-${Date.now()}.json`);
-  const testFile = path11.join(ctx.projectDir, "kody-mcp-compat-test.txt");
-  try {
-    fs12.writeFileSync(mcpConfig, JSON.stringify({
-      mcpServers: {
-        filesystem: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", ctx.projectDir] }
-      }
-    }));
-    const r = runClaudeTest(
-      ctx,
-      `Use the MCP filesystem write_file tool to create a file at ${testFile} with the content 'mcp-ok'. Do not use the built-in Write tool.`,
-      ["--mcp-config", mcpConfig],
-      12e4
-    );
-    const created = fs12.existsSync(testFile);
-    const content = created ? fs12.readFileSync(testFile, "utf-8").trim() : "";
-    const correct = content.includes("mcp-ok");
-    return result(
-      "mcp_tools",
-      "advanced",
-      created ? "pass" : "fail",
-      correct ? 100 : created ? 70 : 0,
-      Date.now() - t,
-      created ? `File created, content: ${content.slice(0, 50)}` : `MCP test failed: ${r.stderr.slice(0, 80)}`
-    );
-  } catch (err) {
-    return result("mcp_tools", "advanced", "warn", 0, Date.now() - t, `MCP test error: ${err instanceof Error ? err.message : String(err)}`);
-  } finally {
-    fs12.rmSync(mcpConfig, { force: true });
-    fs12.rmSync(testFile, { force: true });
-    revertChanges(ctx.projectDir);
-  }
-}
-var TOOL_READ, TOOL_EDIT, TOOL_BASH, CRC_TABLE, ALL_TESTS;
-var init_test_model_tests = __esm({
-  "src/cli/test-model-tests.ts"() {
-    "use strict";
-    TOOL_READ = {
-      name: "Read",
-      description: "Read a file from the filesystem",
-      input_schema: {
-        type: "object",
-        properties: { path: { type: "string", description: "Absolute file path" } },
-        required: ["path"]
-      }
-    };
-    TOOL_EDIT = {
-      name: "Edit",
-      description: "Replace old_string with new_string in a file",
-      input_schema: {
-        type: "object",
-        properties: {
-          file_path: { type: "string" },
-          old_string: { type: "string" },
-          new_string: { type: "string" }
-        },
-        required: ["file_path", "old_string", "new_string"]
-      }
-    };
-    TOOL_BASH = {
-      name: "Bash",
-      description: "Execute a bash command and return output",
-      input_schema: {
-        type: "object",
-        properties: { command: { type: "string", description: "The command to run" } },
-        required: ["command"]
-      }
-    };
-    CRC_TABLE = new Uint32Array(256);
-    for (let n = 0; n < 256; n++) {
-      let c = n;
-      for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-      CRC_TABLE[n] = c >>> 0;
-    }
-    ALL_TESTS = [
-      // Infrastructure
-      { name: "extended_thinking", category: "infrastructure", description: "Extended thinking parameter support", run: testExtendedThinking },
-      // Basic
-      { name: "simple_prompt", category: "basic", description: "Basic text prompt and response", run: testSimplePrompt },
-      { name: "json_output", category: "basic", description: "JSON-only output constraint", run: testJsonOutput },
-      { name: "system_prompt_rules", category: "basic", description: "Multi-rule system prompt adherence", run: testSystemPromptRules },
-      // Tool use
-      { name: "tool_read", category: "tool-use", description: "Read tool: file reading", run: testToolRead },
-      { name: "tool_edit", category: "tool-use", description: "Edit tool: old/new string replacement", run: testToolEdit },
-      { name: "tool_bash", category: "tool-use", description: "Bash tool: command execution", run: testToolBash },
-      { name: "tool_multi_step", category: "tool-use", description: "Multi-step tool chain via CLI", run: testToolMultiStep },
-      { name: "image_attachment", category: "tool-use", description: "Vision: image content processing", run: testImageAttachment },
-      // Stage simulation
-      { name: "plan_stage", category: "stage-simulation", description: "Plan stage: read-only research + structured output", run: testPlanStage },
-      { name: "build_stage", category: "stage-simulation", description: "Build stage: code editing", run: testBuildStage },
-      { name: "review_stage", category: "stage-simulation", description: "Review stage: read-only + structured verdict", run: testReviewStage },
-      // Advanced
-      { name: "mcp_tools", category: "advanced", description: "MCP server tool integration", run: testMcpTools },
-      { name: "error_recovery", category: "advanced", description: "Graceful error handling on tool failure", run: testErrorRecovery }
-    ];
-  }
-});
-
-// src/cli/test-model-report.ts
-function pad(str, len) {
-  return str.padEnd(len);
-}
-function fmtDuration(ms) {
-  return `${(ms / 1e3).toFixed(1)}s`;
-}
-function formatReport(report) {
-  const W = 74;
-  const lines = [];
-  lines.push("=".repeat(W));
-  lines.push("");
-  lines.push("  Model Compatibility Report");
-  lines.push(`  Provider: ${report.provider} | Model: ${report.model}`);
-  lines.push(`  Date: ${report.timestamp}`);
-  lines.push(`  Duration: ${fmtDuration(report.totalDurationMs)}`);
-  lines.push("");
-  lines.push("-".repeat(W));
-  for (const cat of CATEGORY_ORDER) {
-    const catResults = report.results.filter((r) => r.category === cat);
-    if (catResults.length === 0) continue;
-    lines.push("");
-    lines.push(`  ${CATEGORY_LABELS[cat]}`);
-    lines.push("");
-    for (const r of catResults) {
-      const icon = r.status === "pass" ? "+" : r.status === "fail" ? "x" : "!";
-      const name = pad(r.name, 28);
-      const status = pad(r.status.toUpperCase(), 6);
-      const acc = pad(`${r.accuracy}%`, 5);
-      const dur = fmtDuration(r.durationMs);
-      lines.push(`  [${icon}] ${name} ${status} ${acc} ${dur}`);
-      if (r.status !== "pass" && r.detail) {
-        lines.push(`      ${r.detail.slice(0, W - 8)}`);
-      }
-    }
-  }
-  const passed = report.results.filter((r) => r.status === "pass").length;
-  const failed = report.results.filter((r) => r.status === "fail").length;
-  const skipped = report.results.filter((r) => r.status === "warn" && r.durationMs === 0 && r.detail.includes("Skipped")).length;
-  const warned = report.results.filter((r) => r.status === "warn").length - skipped;
-  const total = report.results.length;
-  const scored = report.results.filter((r) => !(r.status === "warn" && r.durationMs === 0 && r.detail.includes("Skipped")));
-  const avgAccuracy = scored.length > 0 ? Math.round(scored.reduce((s, r) => s + r.accuracy, 0) / scored.length) : 0;
-  lines.push("");
-  lines.push("-".repeat(W));
-  lines.push("");
-  lines.push(`  RESULTS: ${passed}/${total - skipped} PASS | ${failed} FAIL | ${warned} WARN${skipped > 0 ? ` | ${skipped} SKIPPED` : ""}`);
-  lines.push(`  OVERALL ACCURACY: ${avgAccuracy}%`);
-  lines.push(`  drop_params required: ${report.dropParamsRequired ? "YES" : "NO"}`);
-  lines.push("");
-  lines.push("  ACCURACY BY CATEGORY:");
-  for (const cat of CATEGORY_ORDER) {
-    const cr = report.results.filter((r) => r.category === cat && !(r.status === "warn" && r.durationMs === 0 && r.detail.includes("Skipped")));
-    if (cr.length === 0) continue;
-    const avg = Math.round(cr.reduce((s, r) => s + r.accuracy, 0) / cr.length);
-    lines.push(`    ${pad(CATEGORY_LABELS[cat], 22)} ${avg}%`);
-  }
-  lines.push("");
-  lines.push("  RECOMMENDATION:");
-  for (const line of getRecommendation(report)) {
-    lines.push(`  ${line}`);
-  }
-  lines.push("");
-  lines.push("=".repeat(W));
-  return lines.join("\n");
-}
-function getRecommendation(report) {
-  const lines = [];
-  const failedTests = report.results.filter((r) => r.status === "fail");
-  const avg = report.results.length > 0 ? Math.round(report.results.reduce((s, r) => s + r.accuracy, 0) / report.results.length) : 0;
-  if (avg >= 90 && failedTests.length === 0) {
-    lines.push("[+] Fully compatible -- suitable for all pipeline stages");
-    return lines;
-  }
-  const stageResults = report.results.filter((r) => r.category === "stage-simulation");
-  const workingStages = stageResults.filter((r) => r.status === "pass").map((r) => r.name.replace("_stage", ""));
-  const failingStages = stageResults.filter((r) => r.status !== "pass").map((r) => r.name.replace("_stage", ""));
-  if (workingStages.length > 0) {
-    lines.push(`[+] Suitable for: ${workingStages.join(", ")} stages`);
-  }
-  if (failingStages.length > 0) {
-    lines.push(`[x] Not recommended for: ${failingStages.join(", ")} stages`);
-  }
-  if (failedTests.length > 0) {
-    lines.push("");
-    lines.push("Failed tests:");
-    for (const t of failedTests) {
-      lines.push(`  - ${t.name}: ${t.detail.slice(0, 60)}`);
-    }
-  }
-  return lines;
-}
-var CATEGORY_ORDER, CATEGORY_LABELS;
-var init_test_model_report = __esm({
-  "src/cli/test-model-report.ts"() {
-    "use strict";
-    CATEGORY_ORDER = ["infrastructure", "basic", "tool-use", "stage-simulation", "advanced"];
-    CATEGORY_LABELS = {
-      infrastructure: "INFRASTRUCTURE",
-      basic: "BASIC CAPABILITIES",
-      "tool-use": "TOOL USE",
-      "stage-simulation": "STAGE SIMULATION",
-      advanced: "ADVANCED"
-    };
-  }
-});
-
-// src/cli/test-model-command.ts
-var test_model_command_exports = {};
-__export(test_model_command_exports, {
-  runTestModelCommand: () => runTestModelCommand
-});
-import * as fs13 from "fs";
-import * as os3 from "os";
-import * as path12 from "path";
-import { execFileSync as execFileSync10 } from "child_process";
-function parseTestModelArgs() {
-  const args2 = process.argv.slice(3);
-  function getArg3(flag) {
-    const idx = args2.indexOf(flag);
-    if (idx !== -1 && args2[idx + 1] && !args2[idx + 1].startsWith("--")) return args2[idx + 1];
-    return void 0;
-  }
-  const hasFlag3 = (f) => args2.includes(f);
-  if (hasFlag3("--help") || hasFlag3("-h")) {
-    logger.info([
-      "Usage: kody test-model --provider <provider> --model <model> --key <api-key> [options]",
-      "",
-      "Options:",
-      "  --provider     LLM provider name (e.g. gemini, openai, claude)",
-      "  --model        Model identifier (e.g. gemini-2.5-flash, claude-sonnet-4-6)",
-      "  --key          API key (optional for claude/anthropic \u2014 uses CLI auth)",
-      "  --key-env      Read API key from this environment variable",
-      "  --skip-proxy   Use an already-running LiteLLM proxy (don't start one)",
-      "  --litellm-url  LiteLLM proxy URL (default: http://localhost:4099)",
-      "  --filter       Comma-separated test names to run (default: all)",
-      "  --list         List all available tests and exit"
-    ].join("\n"));
-    process.exit(0);
-  }
-  if (hasFlag3("--list")) {
-    for (const t of ALL_TESTS) {
-      logger.info(`  ${t.name.padEnd(24)} [${t.category}] ${t.description}`);
-    }
-    process.exit(0);
-  }
-  const provider = getArg3("--provider");
-  const model = getArg3("--model");
-  const key = getArg3("--key");
-  const keyEnv = getArg3("--key-env");
-  if (!provider || !model) {
-    logger.error("Required: --provider <provider> --model <model> --key <key>");
-    logger.error("Run with --help for usage.");
-    process.exit(1);
-  }
-  const isDirectAnthropic = provider === "claude" || provider === "anthropic";
-  let apiKey = key;
-  if (!apiKey && keyEnv) apiKey = process.env[keyEnv];
-  if (!apiKey && !isDirectAnthropic) {
-    logger.error("API key required: use --key <value> or --key-env <ENV_VAR>");
-    logger.error("(For claude/anthropic provider, --key is optional \u2014 uses Claude Code auth)");
-    process.exit(1);
-  }
-  return {
-    provider,
-    model,
-    apiKey: apiKey ?? "",
-    proxyUrl: isDirectAnthropic ? "https://api.anthropic.com" : getArg3("--litellm-url") ?? TEST_URL,
-    skipProxy: isDirectAnthropic || hasFlag3("--skip-proxy"),
-    filter: getArg3("--filter")?.split(",")
-  };
-}
-function generateConfig(provider, model, dropParams) {
-  const lines = [];
-  if (dropParams) {
-    lines.push("litellm_settings:");
-    lines.push("  drop_params: true");
-    lines.push("");
-  }
-  lines.push("model_list:");
-  lines.push(`  - model_name: ${model}`);
-  lines.push("    litellm_params:");
-  lines.push(`      model: ${provider}/${model}`);
-  lines.push("      api_key: os.environ/ANTHROPIC_COMPATIBLE_API_KEY");
-  return lines.join("\n") + "\n";
-}
-async function startProxy(config, url) {
-  try {
-    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
-  } catch {
-    try {
-      execFileSync10("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
-    } catch {
-      logger.error("litellm not installed. Install: pip install 'litellm[proxy]'");
-      return null;
-    }
-  }
-  fs13.writeFileSync(CONFIG_PATH, config);
-  const portMatch = url.match(/:(\d+)/);
-  const port = portMatch ? portMatch[1] : "4099";
-  const { spawn: spawn2 } = await import("child_process");
-  const child = spawn2("litellm", ["--config", CONFIG_PATH, "--port", port], {
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: true,
-    env: process.env
-  });
-  for (let i = 0; i < 30; i++) {
-    await delay(2e3);
-    if (await checkLitellmHealth(url)) {
-      logger.info(`LiteLLM proxy ready at ${url}`);
-      return child;
-    }
-  }
-  child.kill();
-  return null;
-}
-async function quickApiTest(url, model, apiKey) {
-  try {
-    const res = await fetch(`${url}/v1/messages`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
-      body: JSON.stringify({
-        model,
-        max_tokens: 32,
-        messages: [{ role: "user", content: "Say ok" }],
-        context_management: { policy: "smart" }
-      }),
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      return { ok: false, error: body.slice(0, 200) };
-    }
-    return { ok: true };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-function delay(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
-}
-async function runTestModelCommand() {
-  const opts = parseTestModelArgs();
-  const startTime = Date.now();
-  logger.info(`Testing model compatibility: ${opts.provider}/${opts.model}`);
-  logger.info("");
-  let proxyProcess = null;
-  let dropParamsRequired = false;
-  const cleanup = () => {
-    if (proxyProcess) {
-      proxyProcess.kill();
-      proxyProcess = null;
-    }
-    fs13.rmSync(CONFIG_PATH, { force: true });
-  };
-  process.on("SIGINT", () => {
-    cleanup();
-    process.exit(1);
-  });
-  process.on("SIGTERM", () => {
-    cleanup();
-    process.exit(1);
-  });
-  try {
-    if (!opts.skipProxy) {
-      process.env.ANTHROPIC_COMPATIBLE_API_KEY = opts.apiKey;
-      logger.info("Starting LiteLLM proxy (without drop_params)...");
-      proxyProcess = await startProxy(generateConfig(opts.provider, opts.model, false), opts.proxyUrl);
-      if (!proxyProcess) {
-        logger.error("Failed to start LiteLLM proxy");
-        process.exit(1);
-      }
-      const quickRes = await quickApiTest(opts.proxyUrl, opts.model, opts.apiKey);
-      if (!quickRes.ok) {
-        logger.info("Model needs drop_params: true -- restarting proxy...");
-        proxyProcess.kill();
-        proxyProcess = null;
-        await delay(2e3);
-        proxyProcess = await startProxy(generateConfig(opts.provider, opts.model, true), opts.proxyUrl);
-        dropParamsRequired = true;
-        if (!proxyProcess) {
-          logger.error("Failed to start LiteLLM proxy with drop_params");
-          process.exit(1);
-        }
-        const retry = await quickApiTest(opts.proxyUrl, opts.model, opts.apiKey);
-        if (!retry.ok) {
-          logger.error(`Model not accessible: ${retry.error}`);
-          process.exit(1);
-        }
-        logger.info("Proxy restarted with drop_params: true");
-      } else {
-        logger.info("drop_params not required");
-      }
-    } else {
-      logger.info(`Using existing proxy at ${opts.proxyUrl}`);
-    }
-    const tests = opts.filter ? ALL_TESTS.filter((t) => opts.filter.includes(t.name)) : ALL_TESTS;
-    logger.info(`Running ${tests.length} compatibility tests...`);
-    logger.info("");
-    const ctx = { proxyUrl: opts.proxyUrl, model: opts.model, apiKey: opts.apiKey, projectDir: process.cwd() };
-    const results = [];
-    for (const test of tests) {
-      process.stdout.write(`  ${test.name.padEnd(28)} `);
-      try {
-        const r = await test.run(ctx);
-        results.push(r);
-        const icon = r.status === "pass" ? "+" : r.status === "fail" ? "x" : "!";
-        logger.info(`[${icon}] ${r.status.toUpperCase()} ${r.accuracy}% (${(r.durationMs / 1e3).toFixed(1)}s)`);
-      } catch (err) {
-        const r = {
-          name: test.name,
-          category: test.category,
-          status: "fail",
-          accuracy: 0,
-          durationMs: 0,
-          detail: `Crash: ${err instanceof Error ? err.message : String(err)}`
-        };
-        results.push(r);
-        logger.info("[x] CRASH");
-      }
-    }
-    const report = {
-      provider: opts.provider,
-      model: opts.model,
-      results,
-      totalDurationMs: Date.now() - startTime,
-      dropParamsRequired,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
-    };
-    console.log("");
-    console.log(formatReport(report));
-    const failed = results.filter((r) => r.status === "fail").length;
-    process.exit(failed > 0 ? 1 : 0);
-  } finally {
-    cleanup();
-  }
-}
-var TEST_PORT, TEST_URL, CONFIG_PATH;
-var init_test_model_command = __esm({
-  "src/cli/test-model-command.ts"() {
-    "use strict";
-    init_logger();
-    init_litellm();
-    init_test_model_tests();
-    init_test_model_report();
-    TEST_PORT = 4099;
-    TEST_URL = `http://localhost:${TEST_PORT}`;
-    CONFIG_PATH = path12.join(os3.tmpdir(), "kody-test-model-config.yaml");
-  }
-});
-
 // src/ci/parse-inputs.ts
 var parse_inputs_exports = {};
 __export(parse_inputs_exports, {
@@ -2732,16 +1563,16 @@ __export(parse_inputs_exports, {
   runCiParse: () => runCiParse,
   writeOutputs: () => writeOutputs
 });
-import * as fs14 from "fs";
+import * as fs12 from "fs";
 function generateTimestamp() {
   const now = /* @__PURE__ */ new Date();
-  const pad2 = (n) => String(n).padStart(2, "0");
+  const pad = (n) => String(n).padStart(2, "0");
   const y = String(now.getFullYear()).slice(2);
-  const m = pad2(now.getMonth() + 1);
-  const d = pad2(now.getDate());
-  const H = pad2(now.getHours());
-  const M = pad2(now.getMinutes());
-  const S = pad2(now.getSeconds());
+  const m = pad(now.getMonth() + 1);
+  const d = pad(now.getDate());
+  const H = pad(now.getHours());
+  const M = pad(now.getMinutes());
+  const S = pad(now.getSeconds());
   return `${y}${m}${d}-${H}${M}${S}`;
 }
 function parseCommentInputs() {
@@ -2893,40 +1724,40 @@ function parseCommentInputs() {
     trigger_type: "comment"
   };
 }
-function writeOutputs(result2) {
+function writeOutputs(result) {
   const outputFile = process.env.GITHUB_OUTPUT;
   function output(key, value) {
     if (outputFile) {
       if (value.includes("\n")) {
-        fs14.appendFileSync(outputFile, `${key}<<KODY_EOF
+        fs12.appendFileSync(outputFile, `${key}<<KODY_EOF
 ${value}
 KODY_EOF
 `);
       } else {
-        fs14.appendFileSync(outputFile, `${key}=${value}
+        fs12.appendFileSync(outputFile, `${key}=${value}
 `);
       }
     }
     const display = value.includes("\n") ? value.split("\n")[0] + "..." : value;
     console.log(`${key}=${display}`);
   }
-  output("task_id", result2.task_id);
-  output("mode", result2.mode);
-  output("from_stage", result2.from_stage);
-  output("issue_number", result2.issue_number);
-  output("pr_number", result2.pr_number);
-  output("feedback", result2.feedback);
-  output("complexity", result2.complexity);
-  output("ci_run_id", result2.ci_run_id);
-  output("ticket_id", result2.ticket_id);
-  output("prd_file", result2.prd_file);
-  output("dry_run", result2.dry_run ? "true" : "false");
-  output("valid", result2.valid ? "true" : "false");
-  output("trigger_type", result2.trigger_type);
+  output("task_id", result.task_id);
+  output("mode", result.mode);
+  output("from_stage", result.from_stage);
+  output("issue_number", result.issue_number);
+  output("pr_number", result.pr_number);
+  output("feedback", result.feedback);
+  output("complexity", result.complexity);
+  output("ci_run_id", result.ci_run_id);
+  output("ticket_id", result.ticket_id);
+  output("prd_file", result.prd_file);
+  output("dry_run", result.dry_run ? "true" : "false");
+  output("valid", result.valid ? "true" : "false");
+  output("trigger_type", result.trigger_type);
 }
 function runCiParse() {
-  const result2 = parseCommentInputs();
-  writeOutputs(result2);
+  const result = parseCommentInputs();
+  writeOutputs(result);
 }
 var VALID_MODES;
 var init_parse_inputs = __esm({
@@ -3028,7 +1859,7 @@ var init_definitions = __esm({
 });
 
 // src/git-utils.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 function getHookSafeEnv() {
   if (!_hookSafeEnv) {
     _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
@@ -3036,7 +1867,7 @@ function getHookSafeEnv() {
   return _hookSafeEnv;
 }
 function git(args2, options) {
-  return execFileSync11("git", args2, {
+  return execFileSync10("git", args2, {
     encoding: "utf-8",
     timeout: options?.timeout ?? 3e4,
     cwd: options?.cwd,
@@ -3222,22 +2053,22 @@ var init_git_utils = __esm({
 });
 
 // src/pipeline/state.ts
-import * as fs15 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path11 from "path";
 function loadState(taskId, taskDir) {
-  const p = path13.join(taskDir, "status.json");
-  if (!fs15.existsSync(p)) return null;
+  const p = path11.join(taskDir, "status.json");
+  if (!fs13.existsSync(p)) return null;
   try {
-    const result2 = parseJsonSafe(
-      fs15.readFileSync(p, "utf-8"),
+    const result = parseJsonSafe(
+      fs13.readFileSync(p, "utf-8"),
       ["taskId", "state", "stages", "createdAt", "updatedAt"]
     );
-    if (!result2.ok) {
-      logger.warn(`  Corrupt status.json: ${result2.error}`);
+    if (!result.ok) {
+      logger.warn(`  Corrupt status.json: ${result.error}`);
       return null;
     }
-    if (result2.data.taskId !== taskId) return null;
-    return result2.data;
+    if (result.data.taskId !== taskId) return null;
+    return result.data;
   } catch {
     return null;
   }
@@ -3247,10 +2078,10 @@ function writeState(state, taskDir) {
     ...state,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const target = path13.join(taskDir, "status.json");
+  const target = path11.join(taskDir, "status.json");
   const tmp = target + ".tmp";
-  fs15.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-  fs15.renameSync(tmp, target);
+  fs13.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs13.renameSync(tmp, target);
   return updated;
 }
 function initState(taskId) {
@@ -3291,16 +2122,16 @@ var init_complexity = __esm({
 });
 
 // src/memory.ts
-import * as fs16 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path12 from "path";
 function readProjectMemory(projectDir) {
-  const memoryDir = path14.join(projectDir, ".kody", "memory");
-  if (!fs16.existsSync(memoryDir)) return "";
-  const files = fs16.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 = fs16.readFileSync(path14.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}`);
@@ -3319,8 +2150,8 @@ var init_memory = __esm({
 });
 
 // src/context-tiers.ts
-import * as fs17 from "fs";
-import * as path15 from "path";
+import * as fs15 from "fs";
+import * as path13 from "path";
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
@@ -3347,8 +2178,8 @@ function generateL0(content, filename) {
       break;
     }
   }
-  const result2 = parts.join("\n");
-  return result2.slice(0, L0_MAX_CHARS);
+  const result = parts.join("\n");
+  return result.slice(0, L0_MAX_CHARS);
 }
 function generateL0Json(content) {
   try {
@@ -3390,8 +2221,8 @@ function generateL1(content, filename) {
       inSection = false;
     }
   }
-  const result2 = parts.join("\n");
-  return result2.slice(0, L1_MAX_CHARS);
+  const result = parts.join("\n");
+  return result.slice(0, L1_MAX_CHARS);
 }
 function generateL1Json(content) {
   try {
@@ -3411,7 +2242,7 @@ function generateL1Json(content) {
   }
 }
 function getTieredContent(filePath, content) {
-  const key = path15.basename(filePath);
+  const key = path13.basename(filePath);
   return {
     source: filePath,
     L0: generateL0(content, key),
@@ -3423,15 +2254,15 @@ function selectTier(tiered, tier) {
   return tiered[tier];
 }
 function readProjectMemoryTiered(projectDir, tier) {
-  const memoryDir = path15.join(projectDir, ".kody", "memory");
-  if (!fs17.existsSync(memoryDir)) return "";
-  const files = fs17.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 = path15.join(memoryDir, file);
-    const content = fs17.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);
@@ -3454,9 +2285,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path15.join(taskDir, "task.md");
-  if (fs17.existsSync(taskMdPath)) {
-    const content = fs17.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 += `
@@ -3464,9 +2295,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 ${selected}
 `;
   }
-  const taskJsonPath = path15.join(taskDir, "task.json");
-  if (fs17.existsSync(taskJsonPath)) {
-    const content = fs17.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, ""));
@@ -3492,9 +2323,9 @@ ${selected}
       }
     }
   }
-  const specPath = path15.join(taskDir, "spec.md");
-  if (fs17.existsSync(specPath)) {
-    const content = fs17.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 += `
@@ -3502,9 +2333,9 @@ ${selected}
 ${selected}
 `;
   }
-  const planPath = path15.join(taskDir, "plan.md");
-  if (fs17.existsSync(planPath)) {
-    const content = fs17.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 += `
@@ -3512,9 +2343,9 @@ ${selected}
 ${selected}
 `;
   }
-  const contextMdPath = path15.join(taskDir, "context.md");
-  if (fs17.existsSync(contextMdPath)) {
-    const content = fs17.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 += `
@@ -3600,24 +2431,24 @@ var init_context_tiers = __esm({
 });
 
 // src/context.ts
-import * as fs18 from "fs";
-import * as path16 from "path";
+import * as fs16 from "fs";
+import * as path14 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
-    const stepFile = path16.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs18.existsSync(stepFile)) {
-      return fs18.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 = [
-    path16.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path16.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+    path14.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path14.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs18.existsSync(candidate)) {
-      return fs18.readFileSync(candidate, "utf-8");
+    if (fs16.existsSync(candidate)) {
+      return fs16.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -3629,18 +2460,18 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path16.join(taskDir, "task.md");
-  if (fs18.existsSync(taskMdPath)) {
-    const taskMd = fs18.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 = path16.join(taskDir, "task.json");
-  if (fs18.existsSync(taskJsonPath)) {
+  const taskJsonPath = path14.join(taskDir, "task.json");
+  if (fs16.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs18.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs16.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -3653,27 +2484,27 @@ ${taskMd}
     } catch {
     }
   }
-  const specPath = path16.join(taskDir, "spec.md");
-  if (fs18.existsSync(specPath)) {
-    const spec = fs18.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 = path16.join(taskDir, "plan.md");
-  if (fs18.existsSync(planPath)) {
-    const plan = fs18.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 = path16.join(taskDir, "context.md");
-  if (fs18.existsSync(contextMdPath)) {
-    const accumulated = fs18.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 += `
@@ -3691,17 +2522,17 @@ ${feedback}
 }
 function inferHasUIFromScope(scope) {
   return scope.some((filePath) => {
-    const ext = path16.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 = path16.join(taskDir, "task.json");
-  if (!fs18.existsSync(taskJsonPath)) return true;
+  const taskJsonPath = path14.join(taskDir, "task.json");
+  if (!fs16.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs18.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);
@@ -3823,9 +2654,9 @@ ${prompt}` : prompt;
   }
   if (isMcpEnabledForStage(stageName, config.mcp) && taskHasUI(taskDir)) {
     assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
-    const qaGuidePath = path16.join(projectDir, ".kody", "qa-guide.md");
-    if (fs18.existsSync(qaGuidePath)) {
-      const qaGuide = fs18.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;
     }
   }
@@ -3855,12 +2686,10 @@ function escalateModelTier(currentTier) {
 function resolveModel(modelTier, stageName) {
   const config = getProjectConfig();
   const mapped = config.agent.modelMap[modelTier];
-  if (!mapped) {
-    throw new Error(`No model configured for tier '${modelTier}'. Set agent.modelMap.${modelTier} in kody.config.json`);
-  }
-  return mapped;
+  if (mapped) return mapped;
+  return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
 }
-var MAX_TASK_CONTEXT_PLAN, MAX_TASK_CONTEXT_SPEC, MAX_ACCUMULATED_CONTEXT, UI_EXTENSIONS, UI_PATH_SEGMENTS, TIER_ESCALATION;
+var MAX_TASK_CONTEXT_PLAN, MAX_TASK_CONTEXT_SPEC, MAX_ACCUMULATED_CONTEXT, UI_EXTENSIONS, UI_PATH_SEGMENTS, TIER_ESCALATION, DEFAULT_MODEL_MAP;
 var init_context = __esm({
   "src/context.ts"() {
     "use strict";
@@ -3894,6 +2723,11 @@ var init_context = __esm({
       mid: "strong",
       strong: "strong"
     };
+    DEFAULT_MODEL_MAP = {
+      cheap: "haiku",
+      mid: "sonnet",
+      strong: "opus"
+    };
   }
 });
 
@@ -3917,8 +2751,8 @@ var init_runner_selection = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs19 from "fs";
-import * as path17 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;
@@ -4003,29 +2837,29 @@ async function executeAgentStage(ctx, def) {
   if (lastResult.outcome !== "completed") {
     return { outcome: lastResult.outcome, error: lastResult.error, retries };
   }
-  const result2 = lastResult;
-  if (def.outputFile && result2.output) {
-    fs19.writeFileSync(path17.join(ctx.taskDir, def.outputFile), result2.output);
+  const result = lastResult;
+  if (def.outputFile && result.output) {
+    fs17.writeFileSync(path15.join(ctx.taskDir, def.outputFile), result.output);
   }
   if (def.outputFile) {
-    const outputPath = path17.join(ctx.taskDir, def.outputFile);
-    if (!fs19.existsSync(outputPath)) {
-      const ext = path17.extname(def.outputFile);
-      const base = path17.basename(def.outputFile, ext);
-      const files = fs19.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) {
-        fs19.renameSync(path17.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 = path17.join(ctx.taskDir, def.outputFile);
-    if (fs19.existsSync(outputPath)) {
-      const content = fs19.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") {
@@ -4039,7 +2873,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs19.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}`);
@@ -4052,7 +2886,7 @@ async function executeAgentStage(ctx, def) {
                 risk_level: "low",
                 questions: []
               }, null, 2);
-              fs19.writeFileSync(outputPath, fallback);
+              fs17.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -4062,11 +2896,11 @@ async function executeAgentStage(ctx, def) {
       }
     }
   }
-  appendStageContext(ctx.taskDir, def.name, result2.output);
+  appendStageContext(ctx.taskDir, def.name, result.output);
   return { outcome: "completed", outputFile: def.outputFile, retries };
 }
 function appendStageContext(taskDir, stageName, output) {
-  const contextPath = path17.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()) {
@@ -4079,7 +2913,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs19.appendFileSync(contextPath, entry);
+  fs17.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -4102,7 +2936,7 @@ var init_agent = __esm({
 });
 
 // src/verify-runner.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 function isExecError(err) {
   return typeof err === "object" && err !== null;
 }
@@ -4138,7 +2972,7 @@ function runCommand(cmd, cwd, timeout) {
     return { success: true, output: "", timedOut: false };
   }
   try {
-    const output = execFileSync12(parts[0], parts.slice(1), {
+    const output = execFileSync11(parts[0], parts.slice(1), {
       cwd,
       timeout,
       encoding: "utf-8",
@@ -4184,19 +3018,19 @@ function runQualityGates(taskDir, projectRoot) {
   for (const { name, cmd } of commands) {
     if (!cmd) continue;
     logger.info(`  Running ${name}: ${cmd}`);
-    const result2 = runCommand(cmd, cwd, VERIFY_COMMAND_TIMEOUT_MS);
-    if (result2.timedOut) {
+    const result = runCommand(cmd, cwd, VERIFY_COMMAND_TIMEOUT_MS);
+    if (result.timedOut) {
       allErrors.push(`${name}: timed out after ${VERIFY_COMMAND_TIMEOUT_MS / 1e3}s`);
       allPass = false;
       continue;
     }
-    if (!result2.success) {
+    if (!result.success) {
       allPass = false;
-      const errors = parseErrors(result2.output);
+      const errors = parseErrors(result.output);
       allErrors.push(...errors.map((e) => `[${name}] ${e}`));
-      rawOutputs.push({ name, output: result2.output.slice(-3e3) });
+      rawOutputs.push({ name, output: result.output.slice(-3e3) });
     }
-    allSummary.push(...extractSummary(result2.output, name));
+    allSummary.push(...extractSummary(result.output, name));
   }
   return { pass: allPass, errors: allErrors, summary: allSummary, rawOutputs };
 }
@@ -4209,7 +3043,7 @@ var init_verify_runner = __esm({
 });
 
 // src/observer.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, model, options) {
   const context = [
     `Stage: ${stageName}`,
@@ -4223,17 +3057,17 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
   ].join("\n");
   const prompt = DIAGNOSIS_PROMPT + context;
   try {
-    const result2 = await runner.run(
+    const result = await runner.run(
       "diagnosis",
       prompt,
       model,
-      3e4,
-      // 30s timeout — this should be fast
+      9e4,
+      // 90s timeout — MiniMax can be slow to respond
       "",
       options
     );
-    if (result2.outcome === "completed" && result2.output) {
-      const cleaned = result2.output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+    if (result.outcome === "completed" && result.output) {
+      const cleaned = result.output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
       const parseResult = parseJsonSafe(cleaned, ["classification"]);
       if (parseResult.ok) {
         const { data } = parseResult;
@@ -4260,6 +3094,29 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
   } catch (err) {
     logger.warn(`  Diagnosis error: ${err instanceof Error ? err.message : err}`);
   }
+  if (modifiedFiles.length > 0) {
+    const errorLines = errorOutput.split("\n").filter(
+      (l) => /error|Error|ERROR|failed|Failed|FAIL/i.test(l)
+    );
+    const errorFilePaths = errorLines.flatMap((line) => {
+      const matches = line.match(/src\/[^\s(:]+\.[a-z]+/g);
+      return matches ?? [];
+    });
+    if (errorFilePaths.length > 0) {
+      const modifiedSet = new Set(modifiedFiles);
+      const allPreExisting = errorFilePaths.every(
+        (f) => !modifiedSet.has(f) && !modifiedFiles.some((m) => m.endsWith(f))
+      );
+      if (allPreExisting) {
+        logger.warn("  Diagnosis fallback: all errors in unmodified files \u2192 pre-existing");
+        return {
+          classification: "pre-existing",
+          reason: "All errors are in files not modified by the build stage",
+          resolution: `The following files have pre-existing errors not introduced by this task: ${[...new Set(errorFilePaths)].join(", ")}`
+        };
+      }
+    }
+  }
   logger.warn("  Diagnosis failed \u2014 defaulting to retry");
   return {
     classification: "retry",
@@ -4269,13 +3126,13 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
 }
 function getModifiedFiles(projectDir) {
   try {
-    const staged = execFileSync13("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 = execFileSync13("git", ["diff", "--name-only"], {
+    const unstaged = execFileSync12("git", ["diff", "--name-only"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -4318,8 +3175,8 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs20 from "fs";
-import * as path18 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}`);
@@ -4362,7 +3219,7 @@ ${output}
 `);
     }
   }
-  fs20.writeFileSync(path18.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
@@ -4377,9 +3234,9 @@ var init_gate = __esm({
 });
 
 // src/stages/verify.ts
-import * as fs21 from "fs";
-import * as path19 from "path";
-import { execFileSync as execFileSync14 } 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++) {
@@ -4389,8 +3246,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      const verifyPath = path19.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs21.existsSync(verifyPath) ? fs21.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();
@@ -4433,7 +3290,7 @@ ${diagnosis.resolution}`);
         const parts = parseCommand(cmd);
         if (parts.length === 0) return;
         try {
-          execFileSync14(parts[0], parts.slice(1), {
+          execFileSync13(parts[0], parts.slice(1), {
             stdio: "pipe",
             timeout: FIX_COMMAND_TIMEOUT_MS
           });
@@ -4486,8 +3343,8 @@ var init_verify = __esm({
 });
 
 // src/review-standalone.ts
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -4511,8 +3368,8 @@ Or comment on the specific PR: \`@kody review\``
 }
 async function runStandaloneReview(input) {
   const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path20.join(input.projectDir, ".kody", "tasks", taskId);
-  fs22.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) {
@@ -4539,7 +3396,7 @@ ${fileList}`;
   const taskContent = `# ${input.prTitle}
 
 ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
-  fs22.writeFileSync(path20.join(taskDir, "task.md"), taskContent);
+  fs20.writeFileSync(path18.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -4553,18 +3410,18 @@ ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
     }
   };
   logger.info(`[review] standalone review for: ${input.prTitle}`);
-  const result2 = await executeAgentStage(ctx, reviewDef);
-  if (result2.outcome !== "completed") {
+  const result = await executeAgentStage(ctx, reviewDef);
+  if (result.outcome !== "completed") {
     return {
       outcome: "failed",
       taskDir,
-      error: result2.error ?? "Review stage failed"
+      error: result.error ?? "Review stage failed"
     };
   }
-  const reviewPath = path20.join(taskDir, "review.md");
+  const reviewPath = path18.join(taskDir, "review.md");
   let reviewContent;
-  if (fs22.existsSync(reviewPath)) {
-    reviewContent = fs22.readFileSync(reviewPath, "utf-8");
+  if (fs20.existsSync(reviewPath)) {
+    reviewContent = fs20.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -4604,8 +3461,8 @@ var init_review_standalone = __esm({
 });
 
 // src/stages/review.ts
-import * as fs23 from "fs";
-import * as path21 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 };
@@ -4619,11 +3476,11 @@ async function executeReviewWithFix(ctx, def) {
     if (reviewResult.outcome !== "completed") {
       return reviewResult;
     }
-    const reviewFile = path21.join(ctx.taskDir, "review.md");
-    if (!fs23.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 = fs23.readFileSync(reviewFile, "utf-8");
+    const content = fs21.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -4652,15 +3509,15 @@ var init_review = __esm({
 });
 
 // src/stages/ship.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
-import { execFileSync as execFileSync15 } 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 = path22.join(ctx.taskDir, "task.json");
-  if (fs24.existsSync(taskJsonPath)) {
+  const taskJsonPath = path20.join(ctx.taskDir, "task.json");
+  if (fs22.existsSync(taskJsonPath)) {
     try {
-      const raw = fs24.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) {
@@ -4679,9 +3536,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path22.join(ctx.taskDir, "review.md");
-  if (fs24.existsSync(reviewPath)) {
-    const review = fs24.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();
@@ -4698,14 +3555,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path22.join(ctx.taskDir, "verify.md");
-  if (fs24.existsSync(verifyPath)) {
-    const verify = fs24.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 = path22.join(ctx.taskDir, "plan.md");
-  if (fs24.existsSync(planPath)) {
-    const plan = fs24.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(`
@@ -4725,25 +3582,25 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path22.join(ctx.taskDir, "ship.md");
+  const shipPath = path20.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs24.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) {
-    fs24.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 {
-      execFileSync15("git", ["add", ctx.taskDir], {
+      execFileSync14("git", ["add", ctx.taskDir], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
       });
-      execFileSync15("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"
@@ -4757,7 +3614,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync15("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync14("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -4778,28 +3635,28 @@ function executeShipStage(ctx, _def) {
       chore: "chore"
     };
     let prefix = "chore";
-    const taskJsonPath = path22.join(ctx.taskDir, "task.json");
-    if (fs24.existsSync(taskJsonPath)) {
+    const taskJsonPath = path20.join(ctx.taskDir, "task.json");
+    if (fs22.existsSync(taskJsonPath)) {
       try {
-        const raw = fs24.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 = path22.join(ctx.taskDir, "task.md");
-    if (fs24.existsSync(taskMdPath)) {
-      const content = fs24.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 (fs24.existsSync(taskJsonPath)) {
+      if (fs22.existsSync(taskJsonPath)) {
         try {
-          const raw = fs24.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);
@@ -4822,7 +3679,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs24.writeFileSync(shipPath, `# Ship
+      fs22.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -4843,20 +3700,20 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs24.writeFileSync(shipPath, `# Ship
+        fs22.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs24.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 {
-      fs24.writeFileSync(shipPath, `# Ship
+      fs22.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
@@ -4905,15 +3762,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs25 from "fs";
-import * as path23 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 = path23.join(ctx.taskDir, "task.json");
-      if (!fs25.existsSync(taskJsonPath)) return false;
-      const raw = fs25.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) {
@@ -4928,9 +3785,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path23.join(ctx.taskDir, "plan.md");
-      if (!fs25.existsSync(planPath)) return false;
-      const plan = fs25.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();
@@ -4959,8 +3816,8 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs26 from "fs";
-import * as path24 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");
@@ -4998,9 +3855,9 @@ function autoDetectComplexity(ctx, def) {
     return { complexity, activeStages };
   }
   try {
-    const taskJsonPath = path24.join(ctx.taskDir, "task.json");
-    if (!fs26.existsSync(taskJsonPath)) return null;
-    const raw = fs26.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;
@@ -5030,8 +3887,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 = path24.join(ctx.taskDir, "plan.md");
-  const plan = fs26.existsSync(planPath) ? fs26.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,
@@ -5098,22 +3955,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs27 from "fs";
-import * as path25 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 = path25.join(ctx.projectDir, ".kody", "memory");
-    if (!fs27.existsSync(memoryDir)) {
-      fs27.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 = path25.join(ctx.taskDir, "verify.md");
-    if (fs27.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs27.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");
@@ -5122,18 +3979,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 = path25.join(ctx.taskDir, "review.md");
-    if (fs27.existsSync(reviewPath)) {
-      const review = fs27.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 = path25.join(ctx.taskDir, "task.json");
-    if (fs27.existsSync(taskJsonPath)) {
+    const taskJsonPath = path23.join(ctx.taskDir, "task.json");
+    if (fs25.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs27.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)) {
@@ -5144,12 +4001,12 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path25.join(memoryDir, "conventions.md");
+      const conventionsPath = path23.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs27.appendFileSync(conventionsPath, entry);
+      fs25.appendFileSync(conventionsPath, entry);
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
@@ -5157,8 +4014,8 @@ ${learnings.join("\n")}
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path25.join(memoryDir, "architecture.md");
-  if (fs27.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})
@@ -5166,7 +4023,7 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs27.writeFileSync(archPath, content);
+    fs25.writeFileSync(archPath, content);
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
@@ -5179,13 +4036,13 @@ var init_auto_learn = __esm({
 });
 
 // src/retrospective.ts
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path26.join(taskDir, filename);
-  if (!fs28.existsSync(p)) return null;
+  const p = path24.join(taskDir, filename);
+  if (!fs26.existsSync(p)) return null;
   try {
-    const content = fs28.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;
@@ -5238,13 +4095,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path26.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 (!fs28.existsSync(logPath)) return [];
+  if (!fs26.existsSync(logPath)) return [];
   try {
-    const content = fs28.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);
@@ -5271,11 +4128,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path26.dirname(logPath);
-  if (!fs28.existsSync(dir)) {
-    fs28.mkdirSync(dir, { recursive: true });
+  const dir = path24.dirname(logPath);
+  if (!fs26.existsSync(dir)) {
+    fs26.mkdirSync(dir, { recursive: true });
   }
-  fs28.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs26.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -5297,7 +4154,7 @@ ${previousText}
     if (needsLitellmProxy(config)) {
       extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
     }
-    const result2 = await runner.run("retrospective", prompt, model, 3e4, "", {
+    const result = await runner.run("retrospective", prompt, model, 3e4, "", {
       cwd: ctx.projectDir,
       env: extraEnv
     });
@@ -5305,8 +4162,8 @@ ${previousText}
     let patternMatch = null;
     let suggestion = "No suggestion";
     let pipelineFlaw = null;
-    if (result2.outcome === "completed" && result2.output) {
-      const cleaned = result2.output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+    if (result.outcome === "completed" && result.output) {
+      const cleaned = result.output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
       try {
         const parsed = JSON.parse(cleaned);
         observation = parsed.observation ?? observation;
@@ -5443,8 +4300,8 @@ var init_summary = __esm({
 });
 
 // src/pipeline.ts
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -5457,8 +4314,8 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
   if (!ctx.input.issueNumber) return;
   try {
-    const taskMdPath = path27.join(ctx.taskDir, "task.md");
-    const title = fs29.existsSync(taskMdPath) ? fs29.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) {
@@ -5472,10 +4329,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path27.join(taskDir, ".lock");
-  if (fs29.existsSync(lockPath)) {
+  const lockPath = path25.join(taskDir, ".lock");
+  if (fs27.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs29.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs27.readFileSync(lockPath, "utf-8").trim(), 10);
       if (!isNaN(pid)) {
         try {
           process.kill(pid, 0);
@@ -5492,14 +4349,14 @@ function acquireLock(taskDir) {
       logger.warn(`  Corrupt lock file \u2014 overwriting`);
     }
     try {
-      fs29.unlinkSync(lockPath);
+      fs27.unlinkSync(lockPath);
     } catch {
     }
   }
   try {
-    const fd = fs29.openSync(lockPath, fs29.constants.O_WRONLY | fs29.constants.O_CREAT | fs29.constants.O_EXCL);
-    fs29.writeSync(fd, String(process.pid));
-    fs29.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)");
@@ -5509,7 +4366,7 @@ function acquireLock(taskDir) {
 }
 function releaseLock(taskDir) {
   try {
-    fs29.unlinkSync(path27.join(taskDir, ".lock"));
+    fs27.unlinkSync(path25.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -5598,23 +4455,23 @@ async function runPipelineInner(ctx) {
     writeState(state, ctx.taskDir);
     logger.info(`[${def.name}] starting...`);
     applyPreStageLabel(ctx, def);
-    let result2;
+    let result;
     try {
-      result2 = await getExecutor(def.name)(ctx, def);
+      result = await getExecutor(def.name)(ctx, def);
     } catch (error) {
-      result2 = {
+      result = {
         outcome: "failed",
         retries: 0,
         error: error instanceof Error ? error.message : String(error)
       };
     }
     ciGroupEnd();
-    if (result2.outcome === "completed") {
+    if (result.outcome === "completed") {
       state.stages[def.name] = {
         state: "completed",
         completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        retries: result2.retries,
-        outputFile: result2.outputFile
+        retries: result.retries,
+        outputFile: result.outputFile
       };
       logger.info(`[${def.name}] \u2713 completed`);
       const detected = autoDetectComplexity(ctx, def);
@@ -5628,16 +4485,16 @@ async function runPipelineInner(ctx) {
       if (gated) return gated;
       commitAfterStage(ctx, def);
     } else {
-      const isTimeout = result2.outcome === "timed_out";
+      const isTimeout = result.outcome === "timed_out";
       state.stages[def.name] = {
         state: isTimeout ? "timeout" : "failed",
-        retries: result2.retries,
-        error: isTimeout ? "Stage timed out" : result2.error ?? "Stage failed"
+        retries: result.retries,
+        error: isTimeout ? "Stage timed out" : result.error ?? "Stage failed"
       };
       state.state = "failed";
       state.sessions = ctx.sessions;
       writeState(state, ctx.taskDir);
-      logger.error(`[${def.name}] ${isTimeout ? "\u23F1 timed out" : `\u2717 failed: ${result2.error}`}`);
+      logger.error(`[${def.name}] ${isTimeout ? "\u23F1 timed out" : `\u2717 failed: ${result.error}`}`);
       if (ctx.input.issueNumber && !ctx.input.local) {
         setLifecycleLabel(ctx.input.issueNumber, "failed");
       }
@@ -5717,8 +4574,8 @@ var init_pipeline = __esm({
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync16 } from "child_process";
-import * as fs30 from "fs";
+import { execFileSync as execFileSync15 } from "child_process";
+import * as fs28 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -5730,7 +4587,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync16("claude", ["--version"], {
+      const v = execFileSync15("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -5738,14 +4595,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync16("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 = execFileSync16("pnpm", ["--version"], {
+      const v = execFileSync15("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -5753,7 +4610,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync16("node", ["--version"], {
+      const v = execFileSync15("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -5763,7 +4620,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync16("gh", ["--version"], {
+      const v = execFileSync15("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -5771,7 +4628,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs30.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);
@@ -5848,8 +4705,8 @@ var init_args = __esm({
 });
 
 // src/cli/task-state.ts
-import * as fs31 from "fs";
-import * as path28 from "path";
+import * as fs29 from "fs";
+import * as path26 from "path";
 function resolveTaskAction(issueNumber, existingTaskId, existingState) {
   if (!existingTaskId || !existingState) {
     return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
@@ -5881,11 +4738,11 @@ function resolveTaskAction(issueNumber, existingTaskId, existingState) {
 function resolveForIssue(issueNumber, projectDir) {
   const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
   if (existingTaskId) {
-    const statusPath = path28.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
+    const statusPath = path26.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs31.existsSync(statusPath)) {
+    if (fs29.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs31.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs29.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -5918,12 +4775,12 @@ var resolve_exports = {};
 __export(resolve_exports, {
   runResolve: () => runResolve
 });
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 function getConflictContext(cwd, files) {
   const parts = [];
   for (const file of files.slice(0, 10)) {
     try {
-      const content = execFileSync17("git", ["diff", file], {
+      const content = execFileSync16("git", ["diff", file], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -5973,12 +4830,12 @@ async function runResolve(options) {
     extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
   }
   logger.info(`  Running agent to resolve conflicts (model=${model})...`);
-  const result2 = await runner.run("resolve", prompt, model, 3e5, projectDir, {
+  const result = await runner.run("resolve", prompt, model, 3e5, projectDir, {
     cwd: projectDir,
     env: extraEnv
   });
-  if (result2.outcome !== "completed") {
-    return { outcome: "failed", error: `Agent failed: ${result2.error}` };
+  if (result.outcome !== "completed") {
+    return { outcome: "failed", error: `Agent failed: ${result.error}` };
   }
   logger.info("  Verifying resolution...");
   const verify = runQualityGates(projectDir, projectDir);
@@ -6042,8 +4899,8 @@ var init_resolve = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs32 from "fs";
-import * as path29 from "path";
+import * as fs30 from "fs";
+import * as path27 from "path";
 async function ensureLitellmProxy(config, projectDir) {
   if (!anyStageNeedsProxy(config)) return null;
   const litellmUrl = getLitellmUrl();
@@ -6078,7 +4935,7 @@ async function ensureLitellmProxy(config, projectDir) {
   return litellmProcess;
 }
 async function runModelHealthCheck(config) {
-  const usesProxy = anyStageNeedsProxy(config);
+  const usesProxy = needsLitellmProxy(config);
   const baseUrl = usesProxy ? getLitellmUrl() : "https://api.anthropic.com";
   const apiKey = usesProxy ? process.env.ANTHROPIC_COMPATIBLE_API_KEY : process.env.ANTHROPIC_API_KEY;
   if (!apiKey) {
@@ -6088,19 +4945,19 @@ async function runModelHealthCheck(config) {
   }
   const model = config.agent.modelMap.cheap;
   logger.info(`Model health check (${model} via ${usesProxy ? "LiteLLM" : "Anthropic"})...`);
-  const result2 = await checkModelHealth(baseUrl, apiKey, model);
-  if (result2.ok) {
+  const result = await checkModelHealth(baseUrl, apiKey, model);
+  if (result.ok) {
     logger.info("  \u2713 Model responded");
   } else {
-    logger.error(`  \u2717 Model health check failed: ${result2.error}`);
+    logger.error(`  \u2717 Model health check failed: ${result.error}`);
     process.exit(1);
   }
 }
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path29.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path27.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs32.existsSync(projectDir)) {
+    if (!fs30.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -6109,7 +4966,7 @@ async function main() {
     logger.info(`Working directory: ${projectDir}`);
   }
   const isPRFix = (input.command === "fix" || input.command === "fix-ci") && !!input.prNumber;
-  const skipStateCheck = input.command === "review" || input.command === "resolve" || input.command === "rerun" || input.command === "status";
+  const skipStateCheck = input.command === "review" || input.command === "resolve" || input.command === "rerun";
   if (input.issueNumber && !skipStateCheck && !isPRFix) {
     const taskAction = resolveForIssue(input.issueNumber, projectDir);
     logger.info(`Task action: ${taskAction.action}`);
@@ -6166,8 +5023,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path29.join(projectDir, ".kody", "tasks", taskId);
-  fs32.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path27.join(projectDir, ".kody", "tasks", taskId);
+  fs30.mkdirSync(taskDir, { recursive: true });
   if (input.command === "rerun" && isTaskifyRun(taskDir)) {
     const marker = readTaskifyMarker(taskDir);
     if (marker) {
@@ -6232,7 +5089,7 @@ async function main() {
       console.error(`Runner "${defaultRunnerName2}" health check failed`);
       process.exit(1);
     }
-    const result2 = await runStandaloneReview({
+    const result = await runStandaloneReview({
       projectDir,
       runners: runners2,
       prTitle,
@@ -6242,15 +5099,15 @@ async function main() {
       taskId
     });
     if (litellmProcess2) litellmProcess2.kill();
-    if (result2.outcome === "failed") {
-      console.error(`Review failed: ${result2.error}`);
+    if (result.outcome === "failed") {
+      console.error(`Review failed: ${result.error}`);
       process.exit(1);
     }
-    if (result2.reviewContent) {
-      console.log(result2.reviewContent);
+    if (result.reviewContent) {
+      console.log(result.reviewContent);
       if (!input.local && prNumber) {
-        const comment = formatReviewComment(result2.reviewContent, taskId);
-        const verdict = detectReviewVerdict(result2.reviewContent);
+        const comment = formatReviewComment(result.reviewContent, taskId);
+        const verdict = detectReviewVerdict(result.reviewContent);
         const event = verdict === "fail" ? "request-changes" : "approve";
         const posted = submitPRReview(prNumber, comment, event);
         if (!posted) {
@@ -6282,48 +5139,48 @@ async function main() {
       process.exit(1);
     }
     const { runResolve: runResolve2 } = await Promise.resolve().then(() => (init_resolve(), resolve_exports));
-    const result2 = await runResolve2({
+    const result = await runResolve2({
       prNumber: input.prNumber,
       projectDir,
       runners: runners2,
       local: input.local ?? true
     });
     if (litellmProcess2) litellmProcess2.kill();
-    if (result2.outcome === "failed") {
-      console.error(`Resolve failed: ${result2.error}`);
+    if (result.outcome === "failed") {
+      console.error(`Resolve failed: ${result.error}`);
       process.exit(1);
     }
-    console.log(`Resolve: ${result2.outcome}`);
+    console.log(`Resolve: ${result.outcome}`);
     process.exit(0);
   }
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs32.writeFileSync(path29.join(taskDir, "task.md"), input.task);
+    fs30.writeFileSync(path27.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path29.join(taskDir, "task.md");
-  if (!fs32.existsSync(taskMdPath) && isPRFix && input.prNumber) {
+  const taskMdPath = path27.join(taskDir, "task.md");
+  if (!fs30.existsSync(taskMdPath) && isPRFix && input.prNumber) {
     logger.info(`Fetching PR #${input.prNumber} details as task context...`);
     const prDetails = getPRDetails(input.prNumber);
     if (prDetails) {
       const taskContent = `# ${prDetails.title}
 
 ${prDetails.body ?? ""}`;
-      fs32.writeFileSync(taskMdPath, taskContent);
+      fs30.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs32.existsSync(taskMdPath) && input.issueNumber) {
+  } else if (!fs30.existsSync(taskMdPath) && input.issueNumber) {
     logger.info(`Fetching issue #${input.issueNumber} body as task...`);
     const issue = getIssue(input.issueNumber);
     if (issue) {
       const taskContent = `# ${issue.title}
 
 ${issue.body ?? ""}`;
-      fs32.writeFileSync(taskMdPath, taskContent);
+      fs30.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs32.existsSync(taskMdPath)) {
+  if (!fs30.existsSync(taskMdPath)) {
     console.error("No task.md found. Provide --task, --issue-number, or ensure .kody/tasks/<id>/task.md exists.");
     process.exit(1);
   }
@@ -6461,7 +5318,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs32.readdirSync(taskDir);
+  const files = fs30.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -6526,8 +5383,8 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs33 from "fs";
-import * as path30 from "path";
+import * as fs31 from "fs";
+import * as path28 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/bin/commands/init.ts
@@ -6699,7 +5556,7 @@ function buildConfig(cwd, basic) {
     github: { owner: basic.owner, repo: basic.repo },
     agent: {
       provider: "anthropic",
-      modelMap: { cheap: "claude-haiku-4-5-20251001", mid: "claude-sonnet-4-6", strong: "claude-opus-4-6" }
+      modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
     }
   };
   const mcp = detectMcpConfig(cwd, basic.pm, pkg);
@@ -6899,15 +5756,15 @@ function initCommand(opts, pkgRoot) {
 
 // src/bin/commands/bootstrap.ts
 init_architecture_detection();
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 import { execFileSync as execFileSync5 } from "child_process";
 
 // src/bin/qa-guide.ts
 import * as fs5 from "fs";
 import * as path4 from "path";
 function discoverQaContext(cwd) {
-  const result2 = {
+  const result = {
     routes: [],
     authFiles: [],
     loginPage: null,
@@ -6920,21 +5777,21 @@ function discoverQaContext(cwd) {
     const pkg = JSON.parse(fs5.readFileSync(path4.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     const pm = fs5.existsSync(path4.join(cwd, "pnpm-lock.yaml")) ? "pnpm" : fs5.existsSync(path4.join(cwd, "yarn.lock")) ? "yarn" : "npm";
-    if (pkg.scripts?.dev) result2.devCommand = `${pm} dev`;
-    if (allDeps.next || allDeps.nuxt) result2.devPort = 3e3;
-    else if (allDeps.vite) result2.devPort = 5173;
+    if (pkg.scripts?.dev) result.devCommand = `${pm} dev`;
+    if (allDeps.next || allDeps.nuxt) result.devPort = 3e3;
+    else if (allDeps.vite) result.devPort = 5173;
   } catch {
   }
   const appDirs = ["src/app", "app"];
   for (const appDir of appDirs) {
     const fullAppDir = path4.join(cwd, appDir);
     if (!fs5.existsSync(fullAppDir)) continue;
-    scanRoutes(fullAppDir, appDir, "", result2);
+    scanRoutes(fullAppDir, appDir, "", result);
     break;
   }
   const authPatterns = ["middleware.ts", "middleware.js", "src/middleware.ts", "src/middleware.js"];
   for (const p of authPatterns) {
-    if (fs5.existsSync(path4.join(cwd, p))) result2.authFiles.push(p);
+    if (fs5.existsSync(path4.join(cwd, p))) result.authFiles.push(p);
   }
   const authConfigGlobs = [
     "src/app/api/auth",
@@ -6945,7 +5802,7 @@ function discoverQaContext(cwd) {
     "src/app/api/oauth"
   ];
   for (const g of authConfigGlobs) {
-    if (fs5.existsSync(path4.join(cwd, g))) result2.authFiles.push(g);
+    if (fs5.existsSync(path4.join(cwd, g))) result.authFiles.push(g);
   }
   try {
     const rolePaths = [
@@ -6967,7 +5824,7 @@ function discoverQaContext(cwd) {
           if (roleMatches) {
             for (const m of roleMatches) {
               const val = m.match(/['"](\w+)['"]/);
-              if (val && !result2.roles.includes(val[1])) result2.roles.push(val[1]);
+              if (val && !result.roles.includes(val[1])) result.roles.push(val[1]);
             }
           }
           const enumMatch = content.match(/(?:enum|type)\s+\w*[Rr]ole\w*\s*[={]([^}]+)/s);
@@ -6976,7 +5833,7 @@ function discoverQaContext(cwd) {
             if (vals) {
               for (const v of vals) {
                 const clean = v.replace(/['"]/g, "");
-                if (!result2.roles.includes(clean)) result2.roles.push(clean);
+                if (!result.roles.includes(clean)) result.roles.push(clean);
               }
             }
           }
@@ -6986,9 +5843,9 @@ function discoverQaContext(cwd) {
     }
   } catch {
   }
-  return result2;
+  return result;
 }
-function scanRoutes(dir, baseDir, prefix, result2) {
+function scanRoutes(dir, baseDir, prefix, result) {
   let entries;
   try {
     entries = fs5.readdirSync(dir, { withFileTypes: true });
@@ -6999,16 +5856,16 @@ function scanRoutes(dir, baseDir, prefix, result2) {
   if (hasPage) {
     const routePath = prefix || "/";
     const group = prefix.startsWith("/admin") ? "admin" : prefix.includes("/login") ? "auth" : prefix.includes("/signup") ? "auth" : prefix.includes("/api") ? "api" : "frontend";
-    result2.routes.push({ path: routePath, group });
-    if (prefix.includes("/login")) result2.loginPage = routePath;
-    if (prefix.startsWith("/admin") && !result2.adminPath) result2.adminPath = prefix;
+    result.routes.push({ path: routePath, group });
+    if (prefix.includes("/login")) result.loginPage = routePath;
+    if (prefix.startsWith("/admin") && !result.adminPath) result.adminPath = prefix;
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === "node_modules" || entry.name === ".next") continue;
     let segment = entry.name;
     if (segment.startsWith("(") && segment.endsWith(")")) {
-      scanRoutes(path4.join(dir, entry.name), baseDir, prefix, result2);
+      scanRoutes(path4.join(dir, entry.name), baseDir, prefix, result);
       continue;
     }
     if (segment.startsWith("[") && segment.endsWith("]")) {
@@ -7017,7 +5874,7 @@ function scanRoutes(dir, baseDir, prefix, result2) {
     if (segment.startsWith("[[") && segment.endsWith("]]")) {
       segment = `:${segment.slice(2, -2)}?`;
     }
-    scanRoutes(path4.join(dir, entry.name), baseDir, `${prefix}/${segment}`, result2);
+    scanRoutes(path4.join(dir, entry.name), baseDir, `${prefix}/${segment}`, result);
   }
 }
 function generateQaGuide(discovery) {
@@ -7174,23 +6031,22 @@ function installSkillsForProject(cwd) {
 }
 
 // src/bin/commands/bootstrap.ts
-init_config();
 var STEP_STAGES = ["taskify", "plan", "build", "autofix", "review", "review-fix"];
 function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
-  const srcDir = path7.join(cwd, "src");
-  const baseDir = fs8.existsSync(srcDir) ? srcDir : cwd;
+  const srcDir = path6.join(cwd, "src");
+  const baseDir = fs7.existsSync(srcDir) ? srcDir : cwd;
   const results = [];
   function walk(dir) {
     const entries = [];
     try {
-      for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of fs7.readdirSync(dir, { withFileTypes: true })) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-        const full = path7.join(dir, entry.name);
+        const full = path6.join(dir, entry.name);
         if (entry.isDirectory()) {
           entries.push(...walk(full));
         } else if (/\.(ts|js)$/.test(entry.name) && !/\.(test|spec|config|d)\.(ts|js)$/.test(entry.name)) {
           try {
-            const stat = fs8.statSync(full);
+            const stat = fs7.statSync(full);
             if (stat.size >= 200 && stat.size <= 5e3) {
               entries.push({ filePath: full, size: stat.size });
             }
@@ -7204,8 +6060,8 @@ function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
   }
   const files = walk(baseDir).sort((a, b) => b.size - a.size).slice(0, maxFiles);
   for (const { filePath } of files) {
-    const rel = path7.relative(cwd, filePath);
-    const content = fs8.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
+    const rel = path6.relative(cwd, filePath);
+    const content = fs7.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
     results.push(`### File: ${rel}
 \`\`\`typescript
 ${content}
@@ -7217,9 +6073,9 @@ function ghComment(issueNumber, body, cwd) {
   try {
     let repoSlug = "";
     try {
-      const configPath = path7.join(cwd, "kody.config.json");
-      if (fs8.existsSync(configPath)) {
-        const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+      const configPath = path6.join(cwd, "kody.config.json");
+      if (fs7.existsSync(configPath)) {
+        const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
         if (config.github?.owner && config.github?.repo) {
           repoSlug = `${config.github.owner}/${config.github.repo}`;
         }
@@ -7246,9 +6102,7 @@ function ghComment(issueNumber, body, cwd) {
 }
 function bootstrapCommand(opts, pkgRoot) {
   const cwd = process.cwd();
-  setConfigDir(cwd);
   const issueNumber = parseInt(process.env.ISSUE_NUMBER ?? "", 10) || 0;
-  const bootstrapModel = resolveStageConfig(getProjectConfig(), "bootstrap", "cheap").model;
   console.log(`
 \u{1F527} Kody Bootstrap \u2014 Generating project memory + step files
 `);
@@ -7256,8 +6110,8 @@ function bootstrapCommand(opts, pkgRoot) {
     ghComment(issueNumber, "\u{1F527} **Bootstrap started** \u2014 analyzing project and generating configuration...", cwd);
   }
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path7.join(cwd, rel);
-    if (fs8.existsSync(p)) return fs8.readFileSync(p, "utf-8").slice(0, maxChars);
+    const p = path6.join(cwd, rel);
+    if (fs7.existsSync(p)) return fs7.readFileSync(p, "utf-8").slice(0, maxChars);
     return null;
   };
   let repoContext = "";
@@ -7292,14 +6146,14 @@ ${sampleFiles}
 
 `;
   try {
-    const topDirs = fs8.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs7.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
     repoContext += `## Top-level directories
 ${topDirs.join(", ")}
 
 `;
-    const srcDir = path7.join(cwd, "src");
-    if (fs8.existsSync(srcDir)) {
-      const srcDirs = fs8.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const srcDir = path6.join(cwd, "src");
+    if (fs7.existsSync(srcDir)) {
+      const srcDirs = fs7.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       if (srcDirs.length > 0) repoContext += `## src/ subdirectories
 ${srcDirs.join(", ")}
 
@@ -7309,19 +6163,19 @@ ${srcDirs.join(", ")}
   }
   const existingFiles = [];
   for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
-    if (fs8.existsSync(path7.join(cwd, f))) existingFiles.push(f);
+    if (fs7.existsSync(path6.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) repoContext += `## Config files present
 ${existingFiles.join(", ")}
 
 `;
   console.log("\u2500\u2500 Project Memory \u2500\u2500");
-  const memoryDir = path7.join(cwd, ".kody", "memory");
-  fs8.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path7.join(memoryDir, "architecture.md");
-  const conventionsPath = path7.join(memoryDir, "conventions.md");
-  const existingArch = fs8.existsSync(archPath) ? fs8.readFileSync(archPath, "utf-8") : "";
-  const existingConv = fs8.existsSync(conventionsPath) ? fs8.readFileSync(conventionsPath, "utf-8") : "";
+  const memoryDir = path6.join(cwd, ".kody", "memory");
+  fs7.mkdirSync(memoryDir, { recursive: true });
+  const archPath = path6.join(memoryDir, "architecture.md");
+  const conventionsPath = path6.join(memoryDir, "conventions.md");
+  const existingArch = fs7.existsSync(archPath) ? fs7.readFileSync(archPath, "utf-8") : "";
+  const existingConv = fs7.existsSync(conventionsPath) ? fs7.readFileSync(conventionsPath, "utf-8") : "";
   const hasExisting = !!(existingArch || existingConv);
   const extendInstruction = hasExisting && !opts.force ? `
 ## Existing Documentation (EXTEND, do not replace)
@@ -7365,7 +6219,7 @@ ${repoContext}`;
     const output = execFileSync5("claude", [
       "--print",
       "--model",
-      bootstrapModel,
+      "claude-haiku-4-5-20251001",
       "--dangerously-skip-permissions",
       memoryPrompt
     ], {
@@ -7377,12 +6231,12 @@ ${repoContext}`;
     const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
     const parsed = JSON.parse(cleaned);
     if (parsed.architecture) {
-      fs8.writeFileSync(archPath, parsed.architecture);
+      fs7.writeFileSync(archPath, parsed.architecture);
       const lineCount = parsed.architecture.split("\n").length;
       console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines)`);
     }
     if (parsed.conventions) {
-      fs8.writeFileSync(conventionsPath, parsed.conventions);
+      fs7.writeFileSync(conventionsPath, parsed.conventions);
       const lineCount = parsed.conventions.split("\n").length;
       console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines)`);
     }
@@ -7391,39 +6245,39 @@ ${repoContext}`;
     const detected = detectArchitectureBasic(cwd);
     if (detected.length > 0) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs8.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs7.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${detected.join("\n")}
 `);
       console.log(`  \u2713 .kody/memory/architecture.md (${detected.length} items, basic detection)`);
     }
-    fs8.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs7.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }
   console.log("\n\u2500\u2500 Step Files \u2500\u2500");
-  const stepsDir = path7.join(cwd, ".kody", "steps");
-  fs8.mkdirSync(stepsDir, { recursive: true });
-  const arch = fs8.existsSync(archPath) ? fs8.readFileSync(archPath, "utf-8") : "";
-  const conv = fs8.existsSync(conventionsPath) ? fs8.readFileSync(conventionsPath, "utf-8") : "";
+  const stepsDir = path6.join(cwd, ".kody", "steps");
+  fs7.mkdirSync(stepsDir, { recursive: true });
+  const arch = fs7.existsSync(archPath) ? fs7.readFileSync(archPath, "utf-8") : "";
+  const conv = fs7.existsSync(conventionsPath) ? fs7.readFileSync(conventionsPath, "utf-8") : "";
   console.log("  \u23F3 Customizing step files...");
   let stepCount = 0;
   for (const stage of STEP_STAGES) {
-    const templatePath = path7.join(pkgRoot, "prompts", `${stage}.md`);
-    if (!fs8.existsSync(templatePath)) {
+    const templatePath = path6.join(pkgRoot, "prompts", `${stage}.md`);
+    if (!fs7.existsSync(templatePath)) {
       console.log(`  \u2717 ${stage}.md \u2014 template not found in engine`);
       continue;
     }
-    const stepOutputPath = path7.join(stepsDir, `${stage}.md`);
-    if (fs8.existsSync(stepOutputPath) && !opts.force) {
+    const stepOutputPath = path6.join(stepsDir, `${stage}.md`);
+    if (fs7.existsSync(stepOutputPath) && !opts.force) {
       console.log(`  \u25CB ${stage}.md \u2014 already exists (use --force to regenerate)`);
       continue;
     }
-    const defaultPrompt = fs8.readFileSync(templatePath, "utf-8");
+    const defaultPrompt = fs7.readFileSync(templatePath, "utf-8");
     const contextPlaceholder = "{{TASK_CONTEXT}}";
     const placeholderIdx = defaultPrompt.indexOf(contextPlaceholder);
     if (placeholderIdx === -1) {
-      fs8.copyFileSync(templatePath, stepOutputPath);
+      fs7.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
       continue;
@@ -7468,7 +6322,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       const output = execFileSync5("claude", [
         "--print",
         "--model",
-        bootstrapModel,
+        "claude-haiku-4-5-20251001",
         "--dangerously-skip-permissions",
         customizationPrompt
       ], {
@@ -7480,23 +6334,23 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       let cleaned = output.replace(/^```(?:markdown|md)?\s*\n?/, "").replace(/\n?```\s*$/, "");
       cleaned = cleaned.replace(/\n*\{\{TASK_CONTEXT\}\}\s*$/, "").trimEnd();
       const finalPrompt = cleaned + "\n\n" + afterPlaceholder;
-      fs8.writeFileSync(stepOutputPath, finalPrompt);
+      fs7.writeFileSync(stepOutputPath, finalPrompt);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
     } catch {
       console.log(`  \u26A0 ${stage}.md \u2014 customization failed, using default template`);
-      fs8.copyFileSync(templatePath, stepOutputPath);
+      fs7.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
     }
   }
   console.log(`  \u2713 Generated ${stepCount} step files in .kody/steps/`);
   console.log("\n\u2500\u2500 QA Guide \u2500\u2500");
-  const qaGuidePath = path7.join(cwd, ".kody", "qa-guide.md");
-  if (!fs8.existsSync(qaGuidePath) || opts.force) {
+  const qaGuidePath = path6.join(cwd, ".kody", "qa-guide.md");
+  if (!fs7.existsSync(qaGuidePath) || opts.force) {
     const discovery = discoverQaContext(cwd);
     if (discovery.routes.length > 0) {
       const qaGuide = generateQaGuide(discovery);
-      fs8.writeFileSync(qaGuidePath, qaGuide);
+      fs7.writeFileSync(qaGuidePath, qaGuide);
       console.log(`  \u2713 .kody/qa-guide.md (${discovery.routes.length} routes, ${discovery.roles.length} roles)`);
       if (discovery.loginPage) console.log(`  \u2713 Login page detected: ${discovery.loginPage}`);
       if (discovery.adminPath) console.log(`  \u2713 Admin panel detected: ${discovery.adminPath}`);
@@ -7511,9 +6365,9 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
   try {
     let repoSlug = "";
     try {
-      const configPath = path7.join(cwd, "kody.config.json");
-      if (fs8.existsSync(configPath)) {
-        const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+      const configPath = path6.join(cwd, "kody.config.json");
+      if (fs7.existsSync(configPath)) {
+        const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
         if (config.github?.owner && config.github?.repo) {
           repoSlug = `${config.github.owner}/${config.github.repo}`;
         }
@@ -7586,19 +6440,19 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
     ".kody/memory/conventions.md",
     ".kody/qa-guide.md",
     ...installedSkillPaths
-  ].filter((f) => fs8.existsSync(path7.join(cwd, f)));
-  if (fs8.existsSync(path7.join(cwd, "skills-lock.json"))) {
+  ].filter((f) => fs7.existsSync(path6.join(cwd, f)));
+  if (fs7.existsSync(path6.join(cwd, "skills-lock.json"))) {
     filesToCommit.push("skills-lock.json");
   }
   for (const stage of STEP_STAGES) {
     const stepFile = `.kody/steps/${stage}.md`;
-    if (fs8.existsSync(path7.join(cwd, stepFile))) {
+    if (fs7.existsSync(path6.join(cwd, stepFile))) {
       filesToCommit.push(stepFile);
     }
   }
   if (filesToCommit.length > 0) {
     try {
-      const fullPaths = filesToCommit.map((f) => path7.join(cwd, f));
+      const fullPaths = filesToCommit.map((f) => path6.join(cwd, f));
       for (let pass = 0; pass < 2; pass++) {
         execFileSync5("npx", ["prettier", "--write", ...fullPaths], {
           cwd,
@@ -7625,9 +6479,9 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
           console.log(`  \u2713 Pushed branch: ${branchName}`);
           let baseBranch = "main";
           try {
-            const configPath = path7.join(cwd, "kody.config.json");
-            if (fs8.existsSync(configPath)) {
-              const config = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+            const configPath = path6.join(cwd, "kody.config.json");
+            if (fs7.existsSync(configPath)) {
+              const config = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
               baseBranch = config.git?.defaultBranch ?? "main";
             }
           } catch {
@@ -7701,11 +6555,11 @@ Create it manually.`, cwd);
 
 // src/bin/cli.ts
 init_architecture_detection();
-var __dirname2 = path30.dirname(fileURLToPath2(import.meta.url));
-var PKG_ROOT = path30.resolve(__dirname2, "..", "..");
+var __dirname2 = path28.dirname(fileURLToPath2(import.meta.url));
+var PKG_ROOT = path28.resolve(__dirname2, "..", "..");
 function getVersion() {
-  const pkgPath = path30.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs33.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path28.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs31.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 var args = process.argv.slice(2);
@@ -7716,8 +6570,6 @@ if (command === "init") {
   bootstrapCommand({ force: args.includes("--force") }, PKG_ROOT);
 } else if (command === "taskify") {
   Promise.resolve().then(() => (init_taskify_command(), taskify_command_exports)).then(({ runTaskifyCommand: runTaskifyCommand2 }) => runTaskifyCommand2());
-} else if (command === "test-model") {
-  Promise.resolve().then(() => (init_test_model_command(), test_model_command_exports)).then(({ runTestModelCommand: runTestModelCommand2 }) => runTestModelCommand2());
 } else if (command === "ci-parse") {
   Promise.resolve().then(() => (init_parse_inputs(), parse_inputs_exports)).then(({ runCiParse: runCiParse2 }) => runCiParse2());
 } else if (command === "version" || command === "--version" || command === "-v") {