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

package/dist/bin/cli.js

@@ -64,212 +64,260 @@ var init_architecture_detection = __esm({
   }
 });
 
-// src/ci/parse-inputs.ts
-var parse_inputs_exports = {};
-__export(parse_inputs_exports, {
-  parseCommentInputs: () => parseCommentInputs,
-  runCiParse: () => runCiParse,
-  writeOutputs: () => writeOutputs
-});
-import * as fs8 from "fs";
-function generateTimestamp() {
-  const now = /* @__PURE__ */ new Date();
-  const pad = (n) => String(n).padStart(2, "0");
-  const y = String(now.getFullYear()).slice(2);
-  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}`;
+// src/logger.ts
+function getLevel() {
+  const env = process.env.LOG_LEVEL;
+  return LEVELS[env ?? "info"] ?? LEVELS.info;
 }
-function parseCommentInputs() {
-  const triggerType = process.env.TRIGGER_TYPE ?? "dispatch";
-  if (triggerType === "dispatch") {
-    const taskId2 = process.env.INPUT_TASK_ID ?? "";
-    return {
-      task_id: taskId2,
-      mode: process.env.INPUT_MODE ?? "full",
-      from_stage: process.env.INPUT_FROM_STAGE ?? "",
-      issue_number: process.env.INPUT_ISSUE_NUMBER ?? "",
-      pr_number: "",
-      feedback: process.env.INPUT_FEEDBACK ?? "",
-      complexity: "",
-      ci_run_id: "",
-      dry_run: false,
-      valid: !!taskId2,
-      trigger_type: "dispatch"
-    };
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+}
+function log(level, msg) {
+  if (LEVELS[level] < getLevel()) return;
+  const prefix = `[${timestamp()}] ${level.toUpperCase().padEnd(5)}`;
+  if (level === "error") {
+    console.error(`${prefix} ${msg}`);
+  } else if (level === "warn") {
+    console.warn(`${prefix} ${msg}`);
+  } else {
+    console.log(`${prefix} ${msg}`);
   }
-  const commentBody = (process.env.COMMENT_BODY ?? "").replace(/\r/g, "");
-  const issueNumber = process.env.ISSUE_NUMBER ?? "";
-  const isPR = !!process.env.ISSUE_IS_PR;
-  const kodyMatch = commentBody.match(/(?:@kody|\/kody)\s*(.*)/i);
-  if (!kodyMatch) {
-    return {
-      task_id: "",
-      mode: "full",
-      from_stage: "",
-      issue_number: issueNumber,
-      pr_number: "",
-      feedback: "",
-      complexity: "",
-      ci_run_id: "",
-      dry_run: false,
-      valid: false,
-      trigger_type: "comment"
+}
+function ciGroup(title) {
+  if (isCI) process.stdout.write(`::group::${title}
+`);
+}
+function ciGroupEnd() {
+  if (isCI) process.stdout.write(`::endgroup::
+`);
+}
+var isCI, LEVELS, logger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    isCI = !!process.env.GITHUB_ACTIONS;
+    LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    logger = {
+      debug: (msg) => log("debug", msg),
+      info: (msg) => log("info", msg),
+      warn: (msg) => log("warn", msg),
+      error: (msg) => log("error", msg)
     };
   }
-  const argsLine = kodyMatch[1].trim();
-  let fromStage = "";
-  let feedback = "";
-  let complexity = "";
-  let dryRun = false;
-  let ciRunId = "";
-  const fromMatch = argsLine.match(/--from\s+(\S+)/);
-  if (fromMatch) fromStage = fromMatch[1];
-  const feedbackMatch = argsLine.match(/--feedback\s+"([^"]*)"/);
-  if (feedbackMatch) feedback = feedbackMatch[1];
-  const complexityMatch = argsLine.match(/--complexity\s+(\S+)/);
-  if (complexityMatch) complexity = complexityMatch[1];
-  if (/--dry-run/.test(argsLine)) dryRun = true;
-  const ciRunIdMatch = argsLine.match(/--ci-run-id\s+(\S+)/);
-  if (ciRunIdMatch) ciRunId = ciRunIdMatch[1];
-  const positional = argsLine.replace(/--from\s+\S+/g, "").replace(/--feedback\s+"[^"]*"/g, "").replace(/--complexity\s+\S+/g, "").replace(/--dry-run/g, "").replace(/--ci-run-id\s+\S+/g, "").replace(/\s+/g, " ").trim();
-  const parts = positional ? positional.split(/\s+/) : [];
-  let mode = "full";
-  let taskId = "";
-  let idx = 0;
-  if (parts[idx] && VALID_MODES.includes(parts[idx])) {
-    mode = parts[idx];
-    idx++;
-  }
-  if (parts[idx] && !parts[idx].startsWith("--")) {
-    taskId = parts[idx];
-    idx++;
-  } else if (parts[0] && !VALID_MODES.includes(parts[0]) && !parts[0].startsWith("--")) {
-    taskId = parts[0];
+});
+
+// src/validators.ts
+function stripFences(content) {
+  return content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+}
+function parseJsonSafe(raw, requiredFields) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return { ok: false, error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}` };
   }
-  const kodyLineIdx = commentBody.search(/(?:@kody|\/kody)/i);
-  const afterKodyLine = commentBody.slice(kodyLineIdx);
-  const newlineIdx = afterKodyLine.indexOf("\n");
-  const bodyAfterCommand = newlineIdx !== -1 ? afterKodyLine.slice(newlineIdx + 1) : "";
-  if (mode === "approve") {
-    mode = "rerun";
-    if (bodyAfterCommand) {
-      feedback = bodyAfterCommand;
-    }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { ok: false, error: `Expected JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}` };
   }
-  if (mode === "fix") {
-    if (bodyAfterCommand) {
-      feedback = bodyAfterCommand;
+  if (requiredFields) {
+    for (const field of requiredFields) {
+      if (!(field in parsed)) {
+        return { ok: false, error: `Missing required field: ${field}` };
+      }
     }
   }
-  if (mode === "fix-ci") {
-    if (bodyAfterCommand) {
-      feedback = bodyAfterCommand;
-      const runIdFromBody = bodyAfterCommand.match(/Run ID:\s*(\d+)/);
-      if (runIdFromBody) {
-        ciRunId = runIdFromBody[1];
+  return { ok: true, data: parsed };
+}
+function validateTaskJson(content) {
+  try {
+    const parsed = JSON.parse(stripFences(content));
+    for (const field of REQUIRED_TASK_FIELDS) {
+      if (!(field in parsed)) {
+        return { valid: false, error: `Missing field: ${field}` };
       }
     }
+    return { valid: true };
+  } catch (err) {
+    return {
+      valid: false,
+      error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
-  if (mode === "bootstrap") {
-    taskId = `bootstrap-${generateTimestamp()}`;
-  }
-  const prNumber = isPR ? issueNumber : "";
-  if (mode === "review" && prNumber) {
-    taskId = `review-pr-${prNumber}-${generateTimestamp()}`;
+}
+function validatePlanMd(content) {
+  if (content.length < 10) {
+    return { valid: false, error: "Plan is too short (< 10 chars)" };
   }
-  if (!taskId && mode === "full") {
-    taskId = `${issueNumber}-${generateTimestamp()}`;
+  if (!/^##\s+\w+/m.test(content)) {
+    return { valid: false, error: "Plan has no markdown h2 sections" };
   }
-  const modesWithoutTaskId = ["fix", "fix-ci", "status", "review", "resolve", "rerun"];
-  const valid = !!taskId || modesWithoutTaskId.includes(mode);
-  return {
-    task_id: taskId,
-    mode,
-    from_stage: fromStage,
-    issue_number: issueNumber,
-    pr_number: prNumber,
-    feedback,
-    complexity,
-    ci_run_id: ciRunId,
-    dry_run: dryRun,
-    valid,
-    trigger_type: "comment"
-  };
+  return { valid: true };
 }
-function writeOutputs(result) {
-  const outputFile = process.env.GITHUB_OUTPUT;
-  function output(key, value) {
-    if (outputFile) {
-      if (value.includes("\n")) {
-        fs8.appendFileSync(outputFile, `${key}<<KODY_EOF
-${value}
-KODY_EOF
-`);
-      } else {
-        fs8.appendFileSync(outputFile, `${key}=${value}
-`);
-      }
-    }
-    const display = value.includes("\n") ? value.split("\n")[0] + "..." : value;
-    console.log(`${key}=${display}`);
+function validateReviewMd(content) {
+  if (/pass/i.test(content) || /fail/i.test(content)) {
+    return { valid: true };
   }
-  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("dry_run", result.dry_run ? "true" : "false");
-  output("valid", result.valid ? "true" : "false");
-  output("trigger_type", result.trigger_type);
-}
-function runCiParse() {
-  const result = parseCommentInputs();
-  writeOutputs(result);
+  return { valid: false, error: "Review must contain 'pass' or 'fail'" };
 }
-var VALID_MODES;
-var init_parse_inputs = __esm({
-  "src/ci/parse-inputs.ts"() {
+var REQUIRED_TASK_FIELDS;
+var init_validators = __esm({
+  "src/validators.ts"() {
     "use strict";
-    VALID_MODES = [
-      "full",
-      "rerun",
-      "fix",
-      "fix-ci",
-      "status",
-      "approve",
-      "review",
-      "resolve",
-      "bootstrap"
+    REQUIRED_TASK_FIELDS = [
+      "task_type",
+      "title",
+      "description",
+      "scope",
+      "risk_level"
     ];
   }
 });
 
+// src/config.ts
+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;
+  if (config.agent.default) return config.agent.default;
+  const model = config.agent.modelMap[modelTier];
+  if (!model) {
+    throw new Error(`No model configured for stage '${stageName}' (tier: ${modelTier}). Set agent.stages.${stageName} or agent.default in kody.config.json`);
+  }
+  return {
+    provider: config.agent.provider ?? "claude",
+    model
+  };
+}
+function needsLitellmProxy(config) {
+  return !!(config.agent.provider && config.agent.provider !== "anthropic");
+}
+function stageNeedsProxy(stageConfig) {
+  return stageConfig.provider !== "claude" && stageConfig.provider !== "anthropic";
+}
+function anyStageNeedsProxy(config) {
+  if (config.agent.stages) {
+    for (const sc of Object.values(config.agent.stages)) {
+      if (stageNeedsProxy(sc)) return true;
+    }
+  }
+  if (config.agent.default && stageNeedsProxy(config.agent.default)) return true;
+  return needsLitellmProxy(config);
+}
+function getLitellmUrl() {
+  return LITELLM_DEFAULT_URL;
+}
+function providerApiKeyEnvVar(provider) {
+  if (provider === "anthropic") return "ANTHROPIC_API_KEY";
+  return "ANTHROPIC_COMPATIBLE_API_KEY";
+}
+function setConfigDir(dir) {
+  _configDir = dir;
+  _config = null;
+}
+function getProjectConfig() {
+  if (_config) return _config;
+  const configPath = path7.join(_configDir ?? process.cwd(), "kody.config.json");
+  if (fs8.existsSync(configPath)) {
+    try {
+      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 = result.data;
+      _config = {
+        quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
+        git: { ...DEFAULT_CONFIG.git, ...raw.git },
+        github: { ...DEFAULT_CONFIG.github, ...raw.github },
+        agent: {
+          ...DEFAULT_CONFIG.agent,
+          ...raw.agent,
+          modelMap: { ...DEFAULT_CONFIG.agent.modelMap, ...raw.agent?.modelMap }
+        },
+        timeouts: raw.timeouts ?? void 0,
+        contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers,
+        mcp: raw.mcp ? {
+          servers: {},
+          stages: ["build", "verify", "review", "review-fix"],
+          ...raw.mcp,
+          // Auto-enable when devServer is configured (user can still set enabled: false to override)
+          enabled: raw.mcp.enabled ?? !!raw.mcp.devServer
+        } : void 0
+      };
+    } catch {
+      logger.warn("kody.config.json is invalid JSON \u2014 using defaults");
+      _config = { ...DEFAULT_CONFIG };
+    }
+  } else {
+    _config = { ...DEFAULT_CONFIG };
+  }
+  return _config;
+}
+var DEFAULT_CONFIG, LITELLM_DEFAULT_PORT, LITELLM_DEFAULT_URL, VERIFY_COMMAND_TIMEOUT_MS, FIX_COMMAND_TIMEOUT_MS, _config, _configDir;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_logger();
+    init_validators();
+    DEFAULT_CONFIG = {
+      quality: {
+        typecheck: "pnpm -s tsc --noEmit",
+        lint: "pnpm -s lint",
+        lintFix: "pnpm lint:fix",
+        formatFix: "pnpm format:fix",
+        testUnit: "pnpm -s test"
+      },
+      git: {
+        defaultBranch: "dev"
+      },
+      github: {
+        owner: "",
+        repo: ""
+      },
+      agent: {
+        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+      },
+      contextTiers: {
+        enabled: true,
+        tokenBudget: 8e3
+      }
+    };
+    LITELLM_DEFAULT_PORT = 4e3;
+    LITELLM_DEFAULT_URL = `http://localhost:${LITELLM_DEFAULT_PORT}`;
+    VERIFY_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
+    FIX_COMMAND_TIMEOUT_MS = 2 * 60 * 1e3;
+    _config = null;
+    _configDir = null;
+  }
+});
+
 // src/agent-runner.ts
 import { spawn, execFileSync as execFileSync6 } from "child_process";
 function writeStdin(child, prompt) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     if (!child.stdin) {
-      resolve4();
+      resolve5();
       return;
     }
     child.stdin.write(prompt, (err) => {
       if (err) reject(err);
       else {
         child.stdin.end();
-        resolve4();
+        resolve5();
       }
     });
   });
 }
 function waitForProcess(child, timeout) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
@@ -282,7 +330,7 @@ function waitForProcess(child, timeout) {
     }, timeout);
     child.on("exit", (code) => {
       clearTimeout(timer);
-      resolve4({
+      resolve5({
         code,
         stdout: Buffer.concat(stdoutChunks).toString(),
         stderr: Buffer.concat(stderrChunks).toString()
@@ -290,7 +338,7 @@ function waitForProcess(child, timeout) {
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve4({ code: -1, stdout: "", stderr: err.message });
+      resolve5({ code: -1, stdout: "", stderr: err.message });
     });
   });
 }
@@ -339,12 +387,12 @@ function createClaudeCodeRunner() {
         "--print",
         "--model",
         model,
-        "--dangerously-skip-permissions",
-        "--allowedTools",
-        "Bash,Edit,Read,Write,Glob,Grep"
+        "--dangerously-skip-permissions"
       ];
       if (options?.mcpConfigJson) {
         args2.push("--mcp-config", options.mcpConfigJson);
+      } else {
+        args2.push("--allowedTools", "Bash,Edit,Read,Write,Glob,Grep");
       }
       if (options?.sessionId) {
         if (options.resumeSession) {
@@ -386,923 +434,1607 @@ var init_agent_runner = __esm({
   }
 });
 
-// src/definitions.ts
-var definitions_exports = {};
-__export(definitions_exports, {
-  STAGES: () => STAGES,
-  applyTimeoutOverrides: () => applyTimeoutOverrides,
-  getStage: () => getStage
-});
-function getStage(name) {
-  return STAGES.find((s) => s.name === name);
+// src/mcp-config.ts
+function withPlaywrightIfNeeded(mcpConfig, hasUI) {
+  if (!mcpConfig?.enabled || !hasUI) return mcpConfig;
+  const hasPlaywright = Object.keys(mcpConfig.servers).some(
+    (name) => name.toLowerCase().includes("playwright")
+  );
+  if (hasPlaywright) return mcpConfig;
+  return {
+    ...mcpConfig,
+    servers: {
+      ...mcpConfig.servers,
+      playwright: PLAYWRIGHT_SERVER
+    }
+  };
 }
-function applyTimeoutOverrides(overrides) {
-  for (const stage of STAGES) {
-    if (overrides[stage.name] != null) {
-      stage.timeout = overrides[stage.name] * 1e3;
+function buildMcpConfigJson(mcpConfig) {
+  if (!mcpConfig?.enabled) return void 0;
+  if (Object.keys(mcpConfig.servers).length === 0) return void 0;
+  const config = { mcpServers: {} };
+  const mcpServers = config.mcpServers;
+  for (const [name, server] of Object.entries(mcpConfig.servers)) {
+    mcpServers[name] = {
+      command: server.command,
+      args: server.args ?? [],
+      ...server.env ? { env: server.env } : {}
+    };
+  }
+  return JSON.stringify(config);
+}
+function resolveMcpEnvVars(servers) {
+  const resolved = {};
+  for (const [name, server] of Object.entries(servers)) {
+    const env = {};
+    for (const [k, v] of Object.entries(server.env ?? {})) {
+      env[k] = v.replace(/\$\{(\w+)\}/g, (_, varName) => {
+        const val = process.env[varName];
+        if (!val) {
+          throw new Error(
+            `MCP env var \${${varName}} is not set (required by MCP server '${name}'). Add it as a GitHub secret and it will be forwarded automatically.`
+          );
+        }
+        return val;
+      });
     }
+    resolved[name] = { ...server, ...Object.keys(env).length > 0 ? { env } : {} };
   }
+  return resolved;
 }
-var STAGES;
-var init_definitions = __esm({
-  "src/definitions.ts"() {
+function buildTaskifyMcpConfigJson(config) {
+  const servers = config.mcp?.servers ?? {};
+  if (Object.keys(servers).length === 0) {
+    throw new Error(
+      "kody taskify requires at least one MCP server configured in kody.config.json under mcp.servers. Add your task management tool's MCP server there."
+    );
+  }
+  const resolvedServers = resolveMcpEnvVars(servers);
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(resolvedServers)) {
+    mcpServers[name] = {
+      command: server.command,
+      args: server.args ?? [],
+      ...server.env ? { env: server.env } : {}
+    };
+  }
+  return JSON.stringify({ mcpServers });
+}
+function isMcpEnabledForStage(stageName, mcpConfig) {
+  if (!mcpConfig?.enabled) return false;
+  const allowedStages = mcpConfig.stages ?? DEFAULT_MCP_STAGES;
+  return allowedStages.includes(stageName);
+}
+var DEFAULT_MCP_STAGES, PLAYWRIGHT_SERVER;
+var init_mcp_config = __esm({
+  "src/mcp-config.ts"() {
     "use strict";
-    STAGES = [
-      {
-        name: "taskify",
-        type: "agent",
-        modelTier: "cheap",
-        timeout: 6e5,
-        maxRetries: 1,
-        outputFile: "task.json"
-      },
-      {
-        name: "plan",
-        type: "agent",
-        modelTier: "strong",
-        timeout: 6e5,
-        maxRetries: 1,
-        outputFile: "plan.md"
-      },
-      {
-        name: "build",
-        type: "agent",
-        modelTier: "mid",
-        timeout: 24e5,
-        maxRetries: 1
-      },
-      {
-        name: "verify",
-        type: "gate",
-        modelTier: "cheap",
-        timeout: 3e5,
-        maxRetries: 2,
-        retryWithAgent: "autofix"
-      },
-      {
-        name: "review",
-        type: "agent",
-        modelTier: "strong",
-        timeout: 6e5,
-        maxRetries: 1,
-        outputFile: "review.md"
-      },
-      {
-        name: "review-fix",
-        type: "agent",
-        modelTier: "mid",
-        timeout: 12e5,
-        maxRetries: 1
-      },
-      {
-        name: "ship",
-        type: "deterministic",
-        modelTier: "cheap",
-        timeout: 24e4,
-        maxRetries: 1,
-        outputFile: "ship.md"
-      }
-    ];
+    DEFAULT_MCP_STAGES = ["build", "verify", "review", "review-fix"];
+    PLAYWRIGHT_SERVER = {
+      command: "npx",
+      args: ["-y", "@anthropic-ai/mcp-playwright"]
+    };
   }
 });
 
-// src/logger.ts
-function getLevel() {
-  const env = process.env.LOG_LEVEL;
-  return LEVELS[env ?? "info"] ?? LEVELS.info;
-}
-function timestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+// src/github-api.ts
+import { execFileSync as execFileSync7 } from "child_process";
+function isGhExecError(err) {
+  return typeof err === "object" && err !== null;
 }
-function log(level, msg) {
-  if (LEVELS[level] < getLevel()) return;
-  const prefix = `[${timestamp()}] ${level.toUpperCase().padEnd(5)}`;
-  if (level === "error") {
-    console.error(`${prefix} ${msg}`);
-  } else if (level === "warn") {
-    console.warn(`${prefix} ${msg}`);
-  } else {
-    console.log(`${prefix} ${msg}`);
+function ghErrorMessage(err) {
+  if (isGhExecError(err)) {
+    const stderr = err.stderr?.toString().trim();
+    if (stderr) return stderr;
   }
+  return err instanceof Error ? err.message : String(err);
 }
-function ciGroup(title) {
-  if (isCI) process.stdout.write(`::group::${title}
-`);
+function isNotFoundError(err) {
+  const msg = ghErrorMessage(err).toLowerCase();
+  return msg.includes("not found") || msg.includes("no pull requests") || msg.includes("could not resolve");
 }
-function ciGroupEnd() {
-  if (isCI) process.stdout.write(`::endgroup::
-`);
+function setGhCwd(cwd) {
+  _ghCwd = cwd;
 }
-var isCI, LEVELS, logger;
-var init_logger = __esm({
-  "src/logger.ts"() {
-    "use strict";
-    isCI = !!process.env.GITHUB_ACTIONS;
-    LEVELS = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3
-    };
-    logger = {
-      debug: (msg) => log("debug", msg),
-      info: (msg) => log("info", msg),
-      warn: (msg) => log("warn", msg),
-      error: (msg) => log("error", msg)
-    };
-  }
-});
-
-// src/validators.ts
-function stripFences(content) {
-  return content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+function ghToken() {
+  return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
 }
-function parseJsonSafe(raw, requiredFields) {
-  let parsed;
+function gh(args2, options) {
+  const token = ghToken();
+  const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
+  return execFileSync7("gh", args2, {
+    encoding: "utf-8",
+    timeout: API_TIMEOUT_MS,
+    cwd: _ghCwd,
+    env,
+    input: options?.input,
+    stdio: options?.input ? ["pipe", "pipe", "pipe"] : ["inherit", "pipe", "pipe"]
+  }).trim();
+}
+function getIssue(issueNumber) {
   try {
-    parsed = JSON.parse(raw);
+    const output = gh([
+      "issue",
+      "view",
+      String(issueNumber),
+      "--json",
+      "body,title"
+    ]);
+    const parsed = JSON.parse(output);
+    if (!parsed || typeof parsed.title !== "string") {
+      logger.warn(`  Issue #${issueNumber}: unexpected response shape`);
+      return null;
+    }
+    return { body: parsed.body ?? "", title: parsed.title };
   } catch (err) {
-    return { ok: false, error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}` };
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return { ok: false, error: `Expected JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}` };
-  }
-  if (requiredFields) {
-    for (const field of requiredFields) {
-      if (!(field in parsed)) {
-        return { ok: false, error: `Missing required field: ${field}` };
-      }
+    if (isNotFoundError(err)) {
+      logger.info(`  Issue #${issueNumber} not found`);
+    } else {
+      logger.error(`  Failed to get issue #${issueNumber}: ${ghErrorMessage(err)}`);
     }
+    return null;
   }
-  return { ok: true, data: parsed };
 }
-function validateTaskJson(content) {
+function getIssueComments(issueNumber) {
   try {
-    const parsed = JSON.parse(stripFences(content));
-    for (const field of REQUIRED_TASK_FIELDS) {
-      if (!(field in parsed)) {
-        return { valid: false, error: `Missing field: ${field}` };
-      }
-    }
-    return { valid: true };
-  } catch (err) {
-    return {
-      valid: false,
-      error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
-    };
+    const output = gh([
+      "api",
+      `repos/{owner}/{repo}/issues/${issueNumber}/comments`,
+      "--jq",
+      "[.[] | {body, created_at}]"
+    ]);
+    return output ? JSON.parse(output) : [];
+  } catch {
+    return [];
   }
 }
-function validatePlanMd(content) {
-  if (content.length < 10) {
-    return { valid: false, error: "Plan is too short (< 10 chars)" };
-  }
-  if (!/^##\s+\w+/m.test(content)) {
-    return { valid: false, error: "Plan has no markdown h2 sections" };
+function getIssueLabels(issueNumber) {
+  try {
+    const output = gh(["issue", "view", String(issueNumber), "--json", "labels", "--jq", ".labels[].name"]);
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
   }
-  return { valid: true };
 }
-function validateReviewMd(content) {
-  if (/pass/i.test(content) || /fail/i.test(content)) {
-    return { valid: true };
+function setLabel(issueNumber, label) {
+  try {
+    gh(["issue", "edit", String(issueNumber), "--add-label", label]);
+    logger.info(`  Label added: ${label}`);
+  } catch (err) {
+    logger.warn(`  Failed to set label ${label}: ${err}`);
   }
-  return { valid: false, error: "Review must contain 'pass' or 'fail'" };
 }
-var REQUIRED_TASK_FIELDS;
-var init_validators = __esm({
-  "src/validators.ts"() {
-    "use strict";
-    REQUIRED_TASK_FIELDS = [
-      "task_type",
-      "title",
-      "description",
-      "scope",
-      "risk_level"
-    ];
+function postComment(issueNumber, body) {
+  try {
+    gh(
+      ["issue", "comment", String(issueNumber), "--body-file", "-"],
+      { input: body }
+    );
+    logger.info(`  Comment posted on #${issueNumber}`);
+  } catch (err) {
+    logger.warn(`  Failed to post comment: ${err}`);
   }
-});
-
-// src/config.ts
-import * as fs9 from "fs";
-import * as path7 from "path";
-function resolveStageConfig(config, stageName, modelTier) {
-  const stageOverride = config.agent.stages?.[stageName];
-  if (stageOverride) return stageOverride;
-  if (config.agent.default) return config.agent.default;
-  const model = config.agent.modelMap[modelTier];
-  if (!model) {
-    throw new Error(`No model configured for stage '${stageName}' (tier: ${modelTier}). Set agent.stages.${stageName} or agent.default in kody.config.json`);
+}
+function getPRForBranch(branch) {
+  try {
+    const output = gh([
+      "pr",
+      "view",
+      branch,
+      "--json",
+      "number,url"
+    ]);
+    const data = JSON.parse(output);
+    if (typeof data.number !== "number" || typeof data.url !== "string") {
+      logger.warn(`  PR for branch ${branch}: unexpected response shape`);
+      return null;
+    }
+    return { number: data.number, url: data.url };
+  } catch (err) {
+    if (!isNotFoundError(err)) {
+      logger.warn(`  Failed to check PR for branch ${branch}: ${ghErrorMessage(err)}`);
+    }
+    return null;
   }
-  return {
-    provider: config.agent.provider ?? "claude",
-    model
-  };
 }
-function needsLitellmProxy(config) {
-  return !!(config.agent.provider && config.agent.provider !== "anthropic");
+function updatePR(prNumber, body) {
+  try {
+    gh(
+      ["pr", "edit", String(prNumber), "--body-file", "-"],
+      { input: body }
+    );
+    logger.info(`  PR #${prNumber} body updated`);
+  } catch (err) {
+    logger.warn(`  Failed to update PR #${prNumber}: ${err}`);
+  }
 }
-function stageNeedsProxy(stageConfig) {
-  return stageConfig.provider !== "claude" && stageConfig.provider !== "anthropic";
+function createPR(head, base, title, body) {
+  try {
+    const output = gh(
+      [
+        "pr",
+        "create",
+        "--head",
+        head,
+        "--base",
+        base,
+        "--title",
+        title,
+        "--body-file",
+        "-"
+      ],
+      { input: body }
+    );
+    const url = output.trim();
+    const match = url.match(/\/pull\/(\d+)$/);
+    const number = match ? parseInt(match[1], 10) : 0;
+    logger.info(`  PR created: ${url}`);
+    return { number, url };
+  } catch (err) {
+    const reason = ghErrorMessage(err);
+    logger.error(`  Failed to create PR: ${reason}`);
+    return null;
+  }
 }
-function anyStageNeedsProxy(config) {
-  if (config.agent.stages) {
-    for (const sc of Object.values(config.agent.stages)) {
-      if (stageNeedsProxy(sc)) return true;
+function createIssue(title, body, labels) {
+  try {
+    const args2 = ["issue", "create", "--title", title, "--body-file", "-"];
+    if (labels && labels.length > 0) {
+      args2.push("--label", labels.join(","));
     }
+    const output = gh(args2, { input: body });
+    const url = output.trim();
+    const match = url.match(/\/issues\/(\d+)$/);
+    const number = match ? parseInt(match[1], 10) : 0;
+    logger.info(`  Issue created: ${url}`);
+    return { number, url };
+  } catch (err) {
+    const reason = ghErrorMessage(err);
+    logger.error(`  Failed to create issue: ${reason}`);
+    return null;
   }
-  if (config.agent.default && stageNeedsProxy(config.agent.default)) return true;
-  return needsLitellmProxy(config);
-}
-function getLitellmUrl() {
-  return LITELLM_DEFAULT_URL;
 }
-function providerApiKeyEnvVar(provider) {
-  if (provider === "anthropic") return "ANTHROPIC_API_KEY";
-  return "ANTHROPIC_COMPATIBLE_API_KEY";
-}
-function setConfigDir(dir) {
-  _configDir = dir;
-  _config = null;
-}
-function getProjectConfig() {
-  if (_config) return _config;
-  const configPath = path7.join(_configDir ?? process.cwd(), "kody.config.json");
-  if (fs9.existsSync(configPath)) {
+function setLifecycleLabel(issueNumber, phase) {
+  if (!LIFECYCLE_LABELS.includes(phase)) {
+    logger.warn(`  Invalid lifecycle phase: ${phase}`);
+    return;
+  }
+  const othersToRemove = LIFECYCLE_LABELS.filter((l) => l !== phase).map((l) => `kody:${l}`).join(",");
+  if (othersToRemove) {
     try {
-      const result = parseJsonSafe(fs9.readFileSync(configPath, "utf-8"));
-      if (!result.ok) {
-        logger.warn(`kody.config.json: ${result.error} \u2014 using defaults`);
-        _config = { ...DEFAULT_CONFIG };
-        return _config;
-      }
-      const raw = result.data;
-      _config = {
-        quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
-        git: { ...DEFAULT_CONFIG.git, ...raw.git },
-        github: { ...DEFAULT_CONFIG.github, ...raw.github },
-        agent: {
-          ...DEFAULT_CONFIG.agent,
-          ...raw.agent,
-          modelMap: { ...DEFAULT_CONFIG.agent.modelMap, ...raw.agent?.modelMap }
-        },
-        timeouts: raw.timeouts ?? void 0,
-        contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers,
-        mcp: raw.mcp ? {
-          servers: {},
-          stages: ["build", "verify", "review", "review-fix"],
-          ...raw.mcp,
-          // Auto-enable when devServer is configured (user can still set enabled: false to override)
-          enabled: raw.mcp.enabled ?? !!raw.mcp.devServer
-        } : void 0
-      };
+      gh(["issue", "edit", String(issueNumber), "--remove-label", othersToRemove]);
     } catch {
-      logger.warn("kody.config.json is invalid JSON \u2014 using defaults");
-      _config = { ...DEFAULT_CONFIG };
     }
-  } else {
-    _config = { ...DEFAULT_CONFIG };
   }
-  return _config;
+  setLabel(issueNumber, `kody:${phase}`);
 }
-var DEFAULT_CONFIG, LITELLM_DEFAULT_PORT, LITELLM_DEFAULT_URL, VERIFY_COMMAND_TIMEOUT_MS, FIX_COMMAND_TIMEOUT_MS, _config, _configDir;
-var init_config = __esm({
-  "src/config.ts"() {
-    "use strict";
-    init_logger();
-    init_validators();
-    DEFAULT_CONFIG = {
-      quality: {
-        typecheck: "pnpm -s tsc --noEmit",
-        lint: "pnpm -s lint",
-        lintFix: "pnpm lint:fix",
-        formatFix: "pnpm format:fix",
-        testUnit: "pnpm -s test"
-      },
-      git: {
-        defaultBranch: "dev"
-      },
-      github: {
-        owner: "",
-        repo: ""
-      },
-      agent: {
-        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
-      },
-      contextTiers: {
-        enabled: true,
-        tokenBudget: 8e3
+function getPRsForIssue(issueNumber) {
+  try {
+    const output = gh([
+      "pr",
+      "list",
+      "--search",
+      `${issueNumber} in:body`,
+      "--json",
+      "number,title,url,headRefName",
+      "--state",
+      "open"
+    ]);
+    const prs = JSON.parse(output);
+    const branchPrs = (() => {
+      try {
+        const branchOutput = gh([
+          "pr",
+          "list",
+          "--json",
+          "number,title,url,headRefName",
+          "--state",
+          "open"
+        ]);
+        return JSON.parse(branchOutput).filter((pr) => pr.headRefName.startsWith(`${issueNumber}-`));
+      } catch {
+        return [];
       }
-    };
-    LITELLM_DEFAULT_PORT = 4e3;
-    LITELLM_DEFAULT_URL = `http://localhost:${LITELLM_DEFAULT_PORT}`;
-    VERIFY_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
-    FIX_COMMAND_TIMEOUT_MS = 2 * 60 * 1e3;
-    _config = null;
-    _configDir = null;
-  }
-});
-
-// src/git-utils.ts
-import { execFileSync as execFileSync7 } from "child_process";
-function getHookSafeEnv() {
-  if (!_hookSafeEnv) {
-    _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
+    })();
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const pr of [...prs, ...branchPrs]) {
+      if (!seen.has(pr.number)) {
+        seen.add(pr.number);
+        merged.push({ number: pr.number, title: pr.title, url: pr.url, headBranch: pr.headRefName });
+      }
+    }
+    return merged;
+  } catch (err) {
+    logger.error(`  Failed to get PRs for issue #${issueNumber}: ${err}`);
+    return [];
   }
-  return _hookSafeEnv;
-}
-function git(args2, options) {
-  return execFileSync7("git", args2, {
-    encoding: "utf-8",
-    timeout: options?.timeout ?? 3e4,
-    cwd: options?.cwd,
-    env: options?.env ?? getHookSafeEnv(),
-    stdio: ["pipe", "pipe", "pipe"]
-  }).trim();
-}
-function deriveBranchName(issueNumber, title) {
-  const slug = title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50).replace(/-$/, "");
-  return `${issueNumber}-${slug}`;
 }
-function getDefaultBranch(cwd) {
+function getPRDetails(prNumber) {
   try {
-    const config = getProjectConfig();
-    if (config.git?.defaultBranch) {
-      return config.git.defaultBranch;
+    const output = gh([
+      "pr",
+      "view",
+      String(prNumber),
+      "--json",
+      "title,body,headRefName,baseRefName"
+    ]);
+    const data = JSON.parse(output);
+    if (typeof data.title !== "string" || typeof data.headRefName !== "string") {
+      logger.warn(`  PR #${prNumber}: unexpected response shape`);
+      return null;
     }
-  } catch {
-  }
-  try {
-    const ref = git(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd });
-    return ref.replace("refs/remotes/origin/", "");
-  } catch {
-  }
-  try {
-    const output = git(["remote", "show", "origin"], { cwd, timeout: 1e4 });
-    const match = output.match(/HEAD branch:\s*(\S+)/);
-    if (match) return match[1];
-  } catch {
-  }
-  return "dev";
-}
-function getCurrentBranch(cwd) {
-  return git(["branch", "--show-current"], { cwd });
-}
-function ensureFeatureBranch(issueNumber, title, cwd) {
-  const current = getCurrentBranch(cwd);
-  const branchName = deriveBranchName(issueNumber, title);
-  if (current === branchName || current.startsWith(`${issueNumber}-`)) {
-    logger.info(`  Already on feature branch: ${current}`);
-    return current;
-  }
-  if (!BASE_BRANCHES.includes(current) && current !== "") {
-    const defaultBranch2 = getDefaultBranch(cwd);
-    logger.info(`  Switching from ${current} to ${defaultBranch2} before creating ${branchName}`);
-    try {
-      git(["checkout", defaultBranch2], { cwd });
-    } catch {
-      logger.warn(`  Failed to checkout ${defaultBranch2}, aborting branch creation`);
-      return current;
+    return {
+      title: data.title,
+      body: data.body ?? "",
+      headBranch: data.headRefName,
+      baseBranch: data.baseRefName ?? "main"
+    };
+  } catch (err) {
+    if (isNotFoundError(err)) {
+      logger.info(`  PR #${prNumber} not found`);
+    } else {
+      logger.error(`  Failed to get PR #${prNumber}: ${ghErrorMessage(err)}`);
     }
+    return null;
   }
+}
+function postPRComment(prNumber, body) {
   try {
-    git(["fetch", "origin"], { cwd, timeout: 3e4 });
+    gh(
+      ["pr", "comment", String(prNumber), "--body-file", "-"],
+      { input: body }
+    );
+    logger.info(`  Comment posted on PR #${prNumber}`);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.warn(`  Failed to fetch origin: ${msg}`);
+    logger.warn(`  Failed to post PR comment: ${err}`);
   }
+}
+function submitPRReview(prNumber, body, event) {
+  const flag = event === "approve" ? "--approve" : "--request-changes";
   try {
-    git(["rev-parse", "--verify", `origin/${branchName}`], { cwd });
-    git(["checkout", branchName], { cwd });
-    git(["pull", "origin", branchName], { cwd, timeout: 3e4 });
-    logger.info(`  Checked out existing remote branch: ${branchName}`);
-    return branchName;
-  } catch {
+    gh(
+      ["pr", "review", String(prNumber), flag, "--body-file", "-"],
+      { input: body }
+    );
+    logger.info(`  PR review submitted on #${prNumber}: ${event}`);
+    return true;
+  } catch (err) {
+    logger.warn(`  Failed to submit PR review: ${err}`);
+    return false;
   }
+}
+function getCIFailureLogs(runId, maxLength = 8e3) {
   try {
-    git(["rev-parse", "--verify", branchName], { cwd });
-    git(["checkout", branchName], { cwd });
-    logger.info(`  Checked out existing local branch: ${branchName}`);
-    return branchName;
-  } catch {
+    const logsOutput = gh([
+      "run",
+      "view",
+      String(runId),
+      "--log-failed"
+    ]);
+    if (!logsOutput) return null;
+    const truncated = logsOutput.slice(-maxLength);
+    const prefix = logsOutput.length > maxLength ? "...(earlier output truncated)\n" : "";
+    return `${prefix}${truncated}`;
+  } catch (err) {
+    logger.warn(`  Failed to get CI failure logs for run ${runId}: ${ghErrorMessage(err)}`);
+    return null;
   }
-  const defaultBranch = getDefaultBranch(cwd);
+}
+function getLatestFailedRunForBranch(branch) {
   try {
-    git(["checkout", "-b", branchName, `origin/${defaultBranch}`], { cwd });
-  } catch {
-    git(["checkout", "-b", branchName], { cwd });
-  }
-  logger.info(`  Created new branch: ${branchName}`);
-  return branchName;
-}
-function syncWithDefault(cwd, branch) {
-  const defaultBranch = branch ?? getDefaultBranch(cwd);
-  const current = getCurrentBranch(cwd);
-  if (current === defaultBranch) return;
-  try {
-    git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
+    const output = gh([
+      "run",
+      "list",
+      "--branch",
+      branch,
+      "--status",
+      "failure",
+      "--limit",
+      "1",
+      "--json",
+      "databaseId",
+      "--jq",
+      ".[0].databaseId"
+    ]);
+    return output.trim() || null;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.warn(`  Failed to fetch latest from origin: ${msg}`);
-    return;
-  }
-  try {
-    git(["merge", `origin/${defaultBranch}`, "--no-edit"], { cwd, timeout: 3e4 });
-    logger.info(`  Synced with origin/${defaultBranch}`);
-  } catch {
-    try {
-      git(["merge", "--abort"], { cwd });
-    } catch (abortErr) {
-      logger.warn(`  Failed to abort merge: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}`);
-    }
-    logger.warn(`  Merge conflict with origin/${defaultBranch} \u2014 skipping sync`);
+    logger.warn(`  Failed to get latest failed run for branch ${branch}: ${ghErrorMessage(err)}`);
+    return null;
   }
 }
-function mergeDefault(cwd) {
-  const defaultBranch = getDefaultBranch(cwd);
-  const current = getCurrentBranch(cwd);
-  if (current === defaultBranch) return "clean";
+function getLatestKodyReviewComment(prNumber) {
   try {
-    git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
+    const output = gh([
+      "api",
+      `repos/{owner}/{repo}/issues/${prNumber}/comments`,
+      "--jq",
+      '[.[] | select(.body | test("Kody Review"))] | last | .body'
+    ]);
+    return output.trim() || null;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.warn(`  Failed to fetch latest from origin: ${msg}`);
-    return "error";
+    logger.warn(`  Failed to get review comments for PR #${prNumber}: ${err}`);
+    return null;
   }
+}
+function getPRFeedbackSinceLastKodyAction(prNumber) {
   try {
-    git(["merge", `origin/${defaultBranch}`, "--no-edit"], { cwd, timeout: 3e4 });
-    logger.info(`  Merged origin/${defaultBranch} cleanly`);
-    return "clean";
-  } catch {
-    try {
-      const unmerged = git(["diff", "--name-only", "--diff-filter=U"], { cwd });
-      if (unmerged.trim()) return "conflict";
-    } catch {
+    const issueCommentsRaw = gh([
+      "api",
+      `repos/{owner}/{repo}/issues/${prNumber}/comments`,
+      "--jq",
+      "[.[] | {body, created_at, user_login: .user.login, user_type: .user.type}]"
+    ]);
+    const issueComments = issueCommentsRaw ? JSON.parse(issueCommentsRaw) : [];
+    const reviewCommentsRaw = gh([
+      "api",
+      `repos/{owner}/{repo}/pulls/${prNumber}/comments`,
+      "--jq",
+      "[.[] | {body, created_at, user_login: .user.login, user_type: .user.type, path, line}]"
+    ]);
+    const reviewComments = reviewCommentsRaw ? JSON.parse(reviewCommentsRaw) : [];
+    const kodyTimestamp = findLastKodyActionTimestamp(issueComments);
+    const humanIssueComments = issueComments.filter(
+      (c) => !isKodyComment(c) && (!kodyTimestamp || c.created_at > kodyTimestamp)
+    );
+    const humanReviewComments = reviewComments.filter(
+      (c) => !isKodyComment(c) && (!kodyTimestamp || c.created_at > kodyTimestamp)
+    );
+    if (humanIssueComments.length === 0 && humanReviewComments.length === 0) {
+      return null;
     }
-    try {
-      git(["merge", "--abort"], { cwd });
-    } catch (abortErr) {
-      logger.warn(`  Failed to abort merge: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}`);
+    const parts = [];
+    if (humanIssueComments.length > 0) {
+      parts.push("### PR Comments");
+      for (const c of humanIssueComments) {
+        parts.push(`**@${c.user_login}:**
+${c.body}`);
+      }
     }
-    return "error";
+    if (humanReviewComments.length > 0) {
+      parts.push("### Code Review Comments");
+      for (const c of humanReviewComments) {
+        const location = c.path ? `\`${c.path}${c.line ? `:${c.line}` : ""}\`` : "";
+        parts.push(`**@${c.user_login}** ${location}:
+${c.body}`);
+      }
+    }
+    return parts.join("\n\n");
+  } catch (err) {
+    logger.warn(`  Failed to get PR feedback for #${prNumber}: ${err}`);
+    return null;
   }
 }
-function getConflictedFiles(cwd) {
-  try {
-    const output = git(["diff", "--name-only", "--diff-filter=U"], { cwd });
-    return output ? output.split("\n") : [];
-  } catch {
-    return [];
-  }
+function isKodyComment(comment) {
+  if (comment.user_type === "Bot") return true;
+  return KODY_MARKERS.some((marker) => comment.body.includes(marker));
 }
-function commitAll(message, cwd) {
-  const status = git(["status", "--porcelain"], { cwd });
-  if (!status) {
-    return { success: false, hash: "", message: "No changes to commit" };
-  }
-  git(["add", "."], { cwd });
-  git(["commit", "--no-gpg-sign", "-m", message], { cwd });
-  const hash = git(["rev-parse", "HEAD"], { cwd }).slice(0, 7);
-  logger.info(`  Committed: ${hash} ${message}`);
-  return { success: true, hash, message };
+function findLastKodyActionTimestamp(comments) {
+  const kodyComments = comments.filter(isKodyComment);
+  if (kodyComments.length === 0) return null;
+  return kodyComments[kodyComments.length - 1].created_at;
 }
-function getDiffFiles(baseBranch, cwd) {
+var API_TIMEOUT_MS, LIFECYCLE_LABELS, _ghCwd, KODY_MARKERS;
+var init_github_api = __esm({
+  "src/github-api.ts"() {
+    "use strict";
+    init_logger();
+    API_TIMEOUT_MS = 3e4;
+    LIFECYCLE_LABELS = ["planning", "building", "review", "shipping", "done", "failed", "waiting", "low", "medium", "high"];
+    KODY_MARKERS = [
+      "Kody Review",
+      "\u{1F916} Generated by Kody",
+      "Kody pipeline started",
+      "Fix pushed to PR",
+      "PR created:",
+      "Pipeline failed at",
+      "Pipeline already running",
+      "already completed"
+    ];
+  }
+});
+
+// src/cli/task-resolution.ts
+import * as fs9 from "fs";
+import * as path8 from "path";
+import { execFileSync as execFileSync8 } from "child_process";
+function findLatestTaskForIssue(issueNumber, projectDir) {
+  const tasksDir = path8.join(projectDir, ".kody", "tasks");
+  if (!fs9.existsSync(tasksDir)) return null;
+  const allDirs = fs9.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  const prefix = `${issueNumber}-`;
+  const direct = allDirs.find((d) => d.startsWith(prefix));
+  if (direct) return direct;
   try {
-    const output = git(["diff", "--name-only", `origin/${baseBranch}...HEAD`], { cwd });
-    if (!output) return [];
-    return output.split("\n").filter((f) => f && !f.startsWith(".kody/"));
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.warn(`  Failed to get diff files: ${msg}`);
-    return [];
+    const branch = execFileSync8("git", ["branch", "--show-current"], {
+      encoding: "utf-8",
+      cwd: projectDir,
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const branchIssueMatch = branch.match(/^(\d+)-/);
+    if (branchIssueMatch) {
+      const branchIssueNum = branchIssueMatch[1];
+      const branchPrefix = `${branchIssueNum}-`;
+      const fromBranch = allDirs.find((d) => d.startsWith(branchPrefix));
+      if (fromBranch) return fromBranch;
+    }
+  } catch {
   }
+  return null;
 }
-function pushBranch(cwd) {
+function generateTaskId() {
+  const now = /* @__PURE__ */ new Date();
+  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 {
-    git(["push", "-u", "origin", "HEAD"], { cwd, timeout: 12e4 });
+    const comments = getIssueComments(issueNumber);
+    const pattern = /pipeline started: `([^`]+)`/;
+    let latestTaskId = null;
+    for (const comment of comments) {
+      const match = comment.body.match(pattern);
+      if (match) {
+        latestTaskId = match[1];
+      }
+    }
+    return latestTaskId;
   } catch {
-    logger.info("  Push rejected (non-fast-forward), retrying with --force-with-lease");
-    git(["push", "--force-with-lease", "-u", "origin", "HEAD"], { cwd, timeout: 12e4 });
+    return null;
   }
-  logger.info("  Pushed to origin");
 }
-var BASE_BRANCHES, _hookSafeEnv;
-var init_git_utils = __esm({
-  "src/git-utils.ts"() {
+function resolveTaskIdForCommand(issueNumber, projectDir) {
+  const fromTasks = findLatestTaskForIssue(issueNumber, projectDir);
+  if (fromTasks) return fromTasks;
+  const fromComments = resolveTaskIdFromComments(issueNumber);
+  if (fromComments) return fromComments;
+  return null;
+}
+var init_task_resolution = __esm({
+  "src/cli/task-resolution.ts"() {
     "use strict";
-    init_logger();
-    init_config();
-    BASE_BRANCHES = ["dev", "main", "master"];
-    _hookSafeEnv = null;
+    init_github_api();
   }
 });
 
-// src/github-api.ts
-import { execFileSync as execFileSync8 } from "child_process";
-function isGhExecError(err) {
-  return typeof err === "object" && err !== null;
-}
-function ghErrorMessage(err) {
-  if (isGhExecError(err)) {
-    const stderr = err.stderr?.toString().trim();
-    if (stderr) return stderr;
+// src/cli/litellm.ts
+import * as fs10 from "fs";
+import * as os from "os";
+import * as path9 from "path";
+import { execFileSync as execFileSync9 } from "child_process";
+async function checkLitellmHealth(url) {
+  try {
+    const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
+    return response.ok;
+  } catch {
+    return false;
   }
-  return err instanceof Error ? err.message : String(err);
-}
-function isNotFoundError(err) {
-  const msg = ghErrorMessage(err).toLowerCase();
-  return msg.includes("not found") || msg.includes("no pull requests") || msg.includes("could not resolve");
 }
-function setGhCwd(cwd) {
-  _ghCwd = cwd;
-}
-function ghToken() {
-  return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
-}
-function gh(args2, options) {
-  const token = ghToken();
-  const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
-  return execFileSync8("gh", args2, {
-    encoding: "utf-8",
-    timeout: API_TIMEOUT_MS,
-    cwd: _ghCwd,
-    env,
-    input: options?.input,
-    stdio: options?.input ? ["pipe", "pipe", "pipe"] : ["inherit", "pipe", "pipe"]
-  }).trim();
-}
-function getIssue(issueNumber) {
+async function checkModelHealth(baseUrl, apiKey, model) {
   try {
-    const output = gh([
-      "issue",
-      "view",
-      String(issueNumber),
-      "--json",
-      "body,title"
-    ]);
-    const parsed = JSON.parse(output);
-    if (!parsed || typeof parsed.title !== "string") {
-      logger.warn(`  Issue #${issueNumber}: unexpected response shape`);
-      return null;
+    const res = await fetch(`${baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 4,
+        messages: [{ role: "user", content: "Reply with: ok" }]
+      }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      const body2 = await res.text().catch(() => "");
+      return { ok: false, error: `HTTP ${res.status}: ${body2.slice(0, 200)}` };
     }
-    return { body: parsed.body ?? "", title: parsed.title };
+    const body = await res.json();
+    const hasAnthropicContent = Array.isArray(body.content) && body.content.some((b) => b.type === "text");
+    const hasThinkingContent = Array.isArray(body.content) && body.content.some((b) => b.type === "thinking");
+    const hasOpenAIContent = !!body.choices?.[0]?.message?.content;
+    if (!hasAnthropicContent && !hasThinkingContent && !hasOpenAIContent) {
+      return { ok: false, error: `Unexpected response format: ${JSON.stringify(body).slice(0, 200)}` };
+    }
+    return { ok: true };
   } catch (err) {
-    if (isNotFoundError(err)) {
-      logger.info(`  Issue #${issueNumber} not found`);
-    } else {
-      logger.error(`  Failed to get issue #${issueNumber}: ${ghErrorMessage(err)}`);
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function generateLitellmConfig(provider, modelMap) {
+  const apiKeyVar = providerApiKeyEnvVar(provider);
+  const entries = ["model_list:"];
+  const seen = /* @__PURE__ */ new Set();
+  for (const providerModel of Object.values(modelMap)) {
+    if (seen.has(providerModel)) continue;
+    seen.add(providerModel);
+    entries.push(`  - model_name: ${providerModel}`);
+    entries.push(`    litellm_params:`);
+    entries.push(`      model: ${provider}/${providerModel}`);
+    entries.push(`      api_key: os.environ/${apiKeyVar}`);
+  }
+  return entries.join("\n") + "\n";
+}
+function generateLitellmConfigFromStages(defaultConfig, stages) {
+  const proxyModels = [];
+  if (defaultConfig && defaultConfig.provider !== "claude" && defaultConfig.provider !== "anthropic") {
+    proxyModels.push(defaultConfig);
+  }
+  if (stages) {
+    for (const sc of Object.values(stages)) {
+      if (sc.provider !== "claude" && sc.provider !== "anthropic") {
+        proxyModels.push(sc);
+      }
     }
-    return null;
   }
+  if (proxyModels.length === 0) return void 0;
+  const entries = ["model_list:"];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { provider, model } of proxyModels) {
+    const key = `${provider}/${model}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const apiKeyVar = providerApiKeyEnvVar(provider);
+    entries.push(`  - model_name: ${model}`);
+    entries.push(`    litellm_params:`);
+    entries.push(`      model: ${provider}/${model}`);
+    entries.push(`      api_key: os.environ/${apiKeyVar}`);
+  }
+  return entries.join("\n") + "\n";
 }
-function getIssueComments(issueNumber) {
+async function tryStartLitellm(url, projectDir, generatedConfig) {
+  if (!generatedConfig) {
+    logger.warn("No provider configured in kody.config.json \u2014 cannot start LiteLLM proxy");
+    return null;
+  }
+  const configPath = path9.join(os.tmpdir(), "kody-litellm-config.yaml");
+  fs10.writeFileSync(configPath, generatedConfig);
+  const portMatch = url.match(/:(\d+)/);
+  const port = portMatch ? portMatch[1] : "4000";
+  let litellmFound = false;
   try {
-    const output = gh([
-      "api",
-      `repos/{owner}/{repo}/issues/${issueNumber}/comments`,
-      "--jq",
-      "[.[] | {body, created_at}]"
-    ]);
-    return output ? JSON.parse(output) : [];
+    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    litellmFound = true;
   } catch {
-    return [];
+    try {
+      execFileSync9("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      litellmFound = true;
+    } catch {
+    }
   }
-}
-function getIssueLabels(issueNumber) {
+  if (!litellmFound) {
+    logger.warn("litellm not installed (pip install 'litellm[proxy]')");
+    return null;
+  }
+  logger.info(`Starting LiteLLM proxy on port ${port}...`);
+  let cmd;
+  let args2;
   try {
-    const output = gh(["issue", "view", String(issueNumber), "--json", "labels", "--jq", ".labels[].name"]);
-    return output.split("\n").filter(Boolean);
+    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    cmd = "litellm";
+    args2 = ["--config", configPath, "--port", port];
   } catch {
-    return [];
+    cmd = "python3";
+    args2 = ["-m", "litellm", "--config", configPath, "--port", port];
   }
-}
-function setLabel(issueNumber, label) {
-  try {
-    gh(["issue", "edit", String(issueNumber), "--add-label", label]);
-    logger.info(`  Label added: ${label}`);
-  } catch (err) {
-    logger.warn(`  Failed to set label ${label}: ${err}`);
+  const dotenvPath = path9.join(projectDir, ".env");
+  const dotenvVars = {};
+  if (fs10.existsSync(dotenvPath)) {
+    for (const rawLine of fs10.readFileSync(dotenvPath, "utf-8").split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
+      if (match) {
+        let value = match[2].trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        const commentIdx = value.indexOf(" #");
+        if (commentIdx !== -1) value = value.slice(0, commentIdx).trim();
+        if (value) dotenvVars[match[1]] = value;
+      }
+    }
+    if (Object.keys(dotenvVars).length > 0) {
+      logger.info(`  Loaded API keys: ${Object.keys(dotenvVars).join(", ")}`);
+    }
   }
-}
-function postComment(issueNumber, body) {
-  try {
-    gh(
-      ["issue", "comment", String(issueNumber), "--body-file", "-"],
-      { input: body }
-    );
-    logger.info(`  Comment posted on #${issueNumber}`);
-  } catch (err) {
-    logger.warn(`  Failed to post comment: ${err}`);
+  const { spawn: spawn2 } = await import("child_process");
+  const child = spawn2(cmd, args2, {
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    env: { ...process.env, ...dotenvVars }
+  });
+  let proxyStderr = "";
+  child.stderr?.on("data", (chunk) => {
+    proxyStderr += chunk.toString();
+  });
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    if (await checkLitellmHealth(url)) {
+      logger.info(`LiteLLM proxy ready at ${url}`);
+      return child;
+    }
+  }
+  if (proxyStderr) {
+    logger.warn(`LiteLLM stderr: ${proxyStderr.slice(-1e3)}`);
   }
+  logger.warn("LiteLLM proxy failed to start within 60s");
+  child.kill();
+  return null;
 }
-function getPRForBranch(branch) {
-  try {
-    const output = gh([
-      "pr",
-      "view",
-      branch,
-      "--json",
-      "number,url"
-    ]);
-    const data = JSON.parse(output);
-    if (typeof data.number !== "number" || typeof data.url !== "string") {
-      logger.warn(`  PR for branch ${branch}: unexpected response shape`);
-      return null;
+var init_litellm = __esm({
+  "src/cli/litellm.ts"() {
+    "use strict";
+    init_logger();
+    init_config();
+  }
+});
+
+// src/cli/taskify-command.ts
+var taskify_command_exports = {};
+__export(taskify_command_exports, {
+  isTaskifyRun: () => isTaskifyRun,
+  readTaskifyMarker: () => readTaskifyMarker,
+  runTaskifyCommand: () => runTaskifyCommand,
+  taskifyCommand: () => taskifyCommand,
+  topoSort: () => topoSort
+});
+import * as fs11 from "fs";
+import * as path10 from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+function topoSort(tasks) {
+  const n = tasks.length;
+  const inDegree = new Array(n).fill(0);
+  const adj = Array.from({ length: n }, () => []);
+  for (let i = 0; i < n; i++) {
+    for (const dep of tasks[i].dependsOn ?? []) {
+      if (dep >= 0 && dep < n && dep !== i) {
+        adj[dep].push(i);
+        inDegree[i]++;
+      }
     }
-    return { number: data.number, url: data.url };
-  } catch (err) {
-    if (!isNotFoundError(err)) {
-      logger.warn(`  Failed to check PR for branch ${branch}: ${ghErrorMessage(err)}`);
+  }
+  const queue = [];
+  for (let i = 0; i < n; i++) {
+    if (inDegree[i] === 0) queue.push(i);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    sorted.push(tasks[node]);
+    for (const neighbor of adj[node]) {
+      inDegree[neighbor]--;
+      if (inDegree[neighbor] === 0) queue.push(neighbor);
     }
-    return null;
   }
+  if (sorted.length !== n) {
+    logger.warn("[taskify] dependency cycle detected \u2014 falling back to original order");
+    return [...tasks];
+  }
+  return sorted;
 }
-function updatePR(prNumber, body) {
-  try {
-    gh(
-      ["pr", "edit", String(prNumber), "--body-file", "-"],
-      { input: body }
-    );
-    logger.info(`  PR #${prNumber} body updated`);
-  } catch (err) {
-    logger.warn(`  Failed to update PR #${prNumber}: ${err}`);
+function getArg(args2, flag) {
+  const idx = args2.indexOf(flag);
+  return idx !== -1 ? args2[idx + 1] : void 0;
+}
+function hasFlag(args2, flag) {
+  return args2.includes(flag);
+}
+async function runTaskifyCommand() {
+  const args2 = process.argv.slice(3);
+  const cwdArg = getArg(args2, "--cwd") ?? process.cwd();
+  const projectDir = path10.resolve(cwdArg);
+  const ticketId = getArg(args2, "--ticket") ?? process.env.TICKET_ID;
+  const prdFileArg = getArg(args2, "--file") ?? process.env.PRD_FILE;
+  const prdFile = prdFileArg ? path10.resolve(projectDir, prdFileArg) : void 0;
+  const issueNumberStr = getArg(args2, "--issue-number") ?? process.env.ISSUE_NUMBER ?? "";
+  const issueNumber = issueNumberStr ? parseInt(issueNumberStr, 10) : void 0;
+  const feedback = getArg(args2, "--feedback") ?? process.env.FEEDBACK;
+  const local = hasFlag(args2, "--local") || !process.env.CI;
+  const taskIdArg = getArg(args2, "--task-id") ?? process.env.TASK_ID;
+  const taskId = taskIdArg ?? (issueNumber ? `taskify-${issueNumber}-${generateTaskId()}` : `taskify-${generateTaskId()}`);
+  if (!ticketId && !prdFile) {
+    logger.error("Usage: kody taskify --ticket <ticket-id>  OR  kody taskify --file <prd.md>");
+    process.exit(1);
+  }
+  if (prdFile && !fs11.existsSync(prdFile)) {
+    logger.error(`File not found: ${prdFile}`);
+    process.exit(1);
+  }
+  setConfigDir(projectDir);
+  setGhCwd(projectDir);
+  const config = getProjectConfig();
+  let litellmProcess = null;
+  let runnerEnv;
+  if (anyStageNeedsProxy(config)) {
+    const litellmUrl = getLitellmUrl();
+    const proxyRunning = await checkLitellmHealth(litellmUrl);
+    if (!proxyRunning) {
+      let generatedConfig;
+      if (config.agent.stages || config.agent.default) {
+        generatedConfig = generateLitellmConfigFromStages(config.agent.default, config.agent.stages);
+      } else if (config.agent.provider && config.agent.provider !== "anthropic") {
+        generatedConfig = generateLitellmConfig(config.agent.provider, config.agent.modelMap);
+      }
+      litellmProcess = await tryStartLitellm(litellmUrl, projectDir, generatedConfig);
+    }
+    runnerEnv = {
+      ANTHROPIC_BASE_URL: litellmUrl,
+      ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "dummy"
+    };
+  }
+  await taskifyCommand({ ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId, runnerEnv });
+  litellmProcess?.kill();
+}
+async function taskifyCommand(opts) {
+  const { ticketId, prdFile, issueNumber, feedback, local, projectDir, taskId } = opts;
+  const config = getProjectConfig();
+  const taskDir = path10.join(projectDir, ".kody", "tasks", taskId);
+  fs11.mkdirSync(taskDir, { recursive: true });
+  const mode = prdFile ? "file" : "ticket";
+  logger.info(`[taskify] mode=${mode} source=${ticketId ?? prdFile} issue=${issueNumber ?? "none"} task=${taskId}`);
+  let mcpConfigJson;
+  if (mode === "ticket") {
+    try {
+      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,
+          `Kody could not start the taskify command:
+
+> ${msg}
+
+Add the required MCP server config to \`kody.config.json\` and try again.`
+        );
+      }
+      process.exit(1);
+    }
+  }
+  const sc = resolveStageConfig(config, "taskify", "strong");
+  const model = sc.model;
+  const fileContent = prdFile ? fs11.readFileSync(prdFile, "utf-8") : void 0;
+  let projectContext;
+  {
+    const parts = [];
+    const memoryPath = path10.join(projectDir, ".kody", "memory.md");
+    if (fs11.existsSync(memoryPath)) {
+      try {
+        const content = fs11.readFileSync(memoryPath, "utf-8").slice(0, 2e3);
+        if (content.trim()) parts.push(`### Project Memory
+${content}`);
+      } catch {
+      }
+    }
+    try {
+      const output = execSync("git ls-files", { cwd: projectDir, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      const lines = output.split("\n").filter(Boolean).slice(0, 150);
+      if (lines.length > 0) parts.push(`### File Tree
+\`\`\`
+${lines.join("\n")}
+\`\`\``);
+    } catch {
+    }
+    if (parts.length > 0) projectContext = parts.join("\n\n");
+  }
+  const prompt = buildPrompt({ ticketId, fileContent, taskDir, feedback, projectContext });
+  if (issueNumber && !local) {
+    const src = mode === "file" ? `file \`${path10.basename(prdFile)}\`` : `ticket **${ticketId}**`;
+    postComment(issueNumber, `Kody is decomposing ${src} into tasks...`);
+    setLifecycleLabel(issueNumber, "planning");
+  }
+  fs11.writeFileSync(path10.join(taskDir, MARKER_FILE), JSON.stringify({ ticketId, prdFile, issueNumber }));
+  const runner = opts.runner ?? createClaudeCodeRunner();
+  logger.info(`  model=${model} timeout=${TASKIFY_TIMEOUT_MS / 1e3}s`);
+  const result = await runner.run("taskify", prompt, model, TASKIFY_TIMEOUT_MS, taskDir, {
+    cwd: projectDir,
+    mcpConfigJson,
+    env: opts.runnerEnv
+  });
+  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");
+    }
+    process.exit(1);
+  }
+  const resultPath = path10.join(taskDir, RESULT_FILE);
+  if (!fs11.existsSync(resultPath)) {
+    const errMsg = `Claude did not write ${RESULT_FILE}. Output:
+
+${result.output?.slice(0, 500) ?? "(none)"}`;
+    logger.error(`[taskify] ${errMsg}`);
+    if (issueNumber && !local) {
+      postComment(issueNumber, `Kody taskify failed: result file not found.
+
+${errMsg}`);
+      setLifecycleLabel(issueNumber, "failed");
+    }
+    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");
+    }
+    process.exit(1);
+  }
+  const sourceLabel = ticketId ?? (prdFile ? path10.basename(prdFile) : "spec");
+  if (parsed.status === "questions") {
+    handleQuestions(parsed, sourceLabel, issueNumber, local ?? false);
+  } else if (parsed.status === "ready") {
+    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");
+    }
+    process.exit(1);
+  }
+}
+function handleQuestions(parsed, ticketId, issueNumber, local) {
+  const questions = parsed.questions ?? [];
+  const numbered = questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
+  const comment = `Kody has questions before decomposing **${ticketId}**:
+
+${numbered}
+
+Reply with \`@kody approve\` and your answers to proceed.`;
+  logger.info(`[taskify] posting ${questions.length} question(s)`);
+  if (issueNumber && !local) {
+    postComment(issueNumber, comment);
+    setLifecycleLabel(issueNumber, "waiting");
+  } else {
+    logger.info(`[taskify] questions:
+${comment}`);
+  }
+}
+async function handleTasks(parsed, ticketId, issueNumber, local) {
+  const tasks = topoSort(parsed.tasks ?? []);
+  if (tasks.length === 0) {
+    logger.warn("[taskify] no tasks in result \u2014 nothing to file");
+    if (issueNumber && !local) {
+      postComment(issueNumber, `Kody taskify completed but found no tasks to file for **${ticketId}**.`);
+      setLifecycleLabel(issueNumber, "done");
+    }
+    return;
+  }
+  const tooMany = tasks.length > MAX_TASKS_GUARD;
+  if (tooMany) {
+    logger.warn(`[taskify] ${tasks.length} tasks exceeds MAX_TASKS_GUARD (${MAX_TASKS_GUARD}) \u2014 filing issues but skipping auto-trigger`);
+  }
+  logger.info(`[taskify] filing ${tasks.length} issue(s)`);
+  const filed = [];
+  for (const task of tasks) {
+    if (local) {
+      logger.info(`  [local] would create issue: ${task.title}`);
+      filed.push({ number: 0, url: "#", title: task.title });
+      continue;
+    }
+    const allLabels = [...task.labels ?? [], ...task.priority ? [`priority:${task.priority}`] : []];
+    const issue = createIssue(task.title, task.body, allLabels);
+    if (issue) {
+      filed.push({ number: issue.number, url: issue.url, title: task.title });
+    } else {
+      logger.warn(`  failed to create issue: ${task.title}`);
+    }
+  }
+  const autoTrigger = !tooMany && filed.length <= AUTO_TRIGGER_THRESHOLD;
+  if (autoTrigger && !local) {
+    for (const issue of filed) {
+      if (issue.number > 0) {
+        postComment(issue.number, "@kody");
+        logger.info(`  auto-triggered @kody on issue #${issue.number}`);
+      }
+    }
+  }
+  if (issueNumber && !local) {
+    const links = filed.map((i) => `- [#${i.number}](${i.url}) \u2014 ${i.title}`).join("\n");
+    const triggerNote = tooMany ? `
+
+> **${tasks.length} tasks filed** \u2014 auto-trigger is disabled for large epics. Comment \`@kody\` on each issue to start the pipeline.` : autoTrigger ? `
+
+> Auto-triggered \`@kody\` on each issue.` : `
+
+> Comment \`@kody\` on each issue to start the pipeline.`;
+    postComment(
+      issueNumber,
+      `Kody decomposed **${ticketId}** into ${filed.length} task(s):
+
+${links}${triggerNote}`
+    );
+    setLifecycleLabel(issueNumber, "done");
+  } else if (local) {
+    logger.info(`[taskify] local mode \u2014 would file ${filed.length} issue(s)`);
+  }
+}
+function buildPrompt(opts) {
+  const { ticketId, fileContent, taskDir, feedback, projectContext } = opts;
+  const scriptDir = new URL(".", import.meta.url).pathname;
+  const candidates = [
+    path10.resolve(scriptDir, "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(scriptDir, "..", "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(__dirname, "..", "..", "prompts", "taskify-ticket.md"),
+    path10.resolve(__dirname, "..", "prompts", "taskify-ticket.md")
+  ];
+  let template = "";
+  for (const candidate of candidates) {
+    if (fs11.existsSync(candidate)) {
+      template = fs11.readFileSync(candidate, "utf-8");
+      break;
+    }
+  }
+  if (!template) {
+    throw new Error(`Could not find prompts/taskify-ticket.md. Searched: ${candidates.join(", ")}`);
+  }
+  const resolveBlock = (name, value) => {
+    if (value) {
+      template = template.replace(new RegExp(`\\{\\{#if ${name}\\}\\}\\n?([\\s\\S]*?)\\{\\{\\/if\\}\\}`, "g"), "$1");
+      template = template.replace(new RegExp(`\\{\\{${name}\\}\\}`, "g"), value);
+    } else {
+      template = template.replace(new RegExp(`\\{\\{#if ${name}\\}\\}\\n?[\\s\\S]*?\\{\\{\\/if\\}\\}\\n?`, "g"), "");
+    }
+  };
+  resolveBlock("PROJECT_CONTEXT", projectContext);
+  resolveBlock("TICKET_ID", ticketId);
+  resolveBlock("FILE_CONTENT", fileContent);
+  resolveBlock("FEEDBACK", feedback);
+  template = template.replace(/\{\{TASK_DIR\}\}/g, taskDir);
+  return template;
+}
+function isTaskifyRun(taskDir) {
+  return fs11.existsSync(path10.join(taskDir, MARKER_FILE));
+}
+function readTaskifyMarker(taskDir) {
+  const markerPath = path10.join(taskDir, MARKER_FILE);
+  if (!fs11.existsSync(markerPath)) return null;
+  try {
+    return JSON.parse(fs11.readFileSync(markerPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+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";
+    init_config();
+    init_agent_runner();
+    init_mcp_config();
+    init_github_api();
+    init_logger();
+    init_task_resolution();
+    init_litellm();
+    __dirname = path10.dirname(fileURLToPath(import.meta.url));
+    AUTO_TRIGGER_THRESHOLD = 5;
+    MAX_TASKS_GUARD = 20;
+    TASKIFY_TIMEOUT_MS = 5 * 60 * 1e3;
+    MARKER_FILE = "taskify.marker";
+    RESULT_FILE = "taskify-result.json";
+  }
+});
+
+// src/ci/parse-inputs.ts
+var parse_inputs_exports = {};
+__export(parse_inputs_exports, {
+  parseCommentInputs: () => parseCommentInputs,
+  runCiParse: () => runCiParse,
+  writeOutputs: () => writeOutputs
+});
+import * as fs12 from "fs";
+function generateTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const y = String(now.getFullYear()).slice(2);
+  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() {
+  const triggerType = process.env.TRIGGER_TYPE ?? "dispatch";
+  if (triggerType === "dispatch") {
+    const taskId2 = process.env.INPUT_TASK_ID ?? "";
+    return {
+      task_id: taskId2,
+      mode: process.env.INPUT_MODE ?? "full",
+      from_stage: process.env.INPUT_FROM_STAGE ?? "",
+      issue_number: process.env.INPUT_ISSUE_NUMBER ?? "",
+      pr_number: "",
+      feedback: process.env.INPUT_FEEDBACK ?? "",
+      complexity: "",
+      ci_run_id: "",
+      ticket_id: "",
+      prd_file: "",
+      dry_run: false,
+      valid: !!taskId2,
+      trigger_type: "dispatch"
+    };
+  }
+  const commentBody = (process.env.COMMENT_BODY ?? "").replace(/\r/g, "");
+  const issueNumber = process.env.ISSUE_NUMBER ?? "";
+  const isPR = !!process.env.ISSUE_IS_PR;
+  const kodyMatch = commentBody.match(/(?:@kody|\/kody)\s*(.*)/i);
+  if (!kodyMatch) {
+    return {
+      task_id: "",
+      mode: "full",
+      from_stage: "",
+      issue_number: issueNumber,
+      pr_number: "",
+      feedback: "",
+      complexity: "",
+      ci_run_id: "",
+      ticket_id: "",
+      prd_file: "",
+      dry_run: false,
+      valid: false,
+      trigger_type: "comment"
+    };
+  }
+  const argsLine = kodyMatch[1].trim();
+  let fromStage = "";
+  let feedback = "";
+  let complexity = "";
+  let dryRun = false;
+  let ciRunId = "";
+  let ticketId = "";
+  let prdFile = "";
+  const fromMatch = argsLine.match(/--from\s+(\S+)/);
+  if (fromMatch) fromStage = fromMatch[1];
+  const feedbackMatch = argsLine.match(/--feedback\s+"([^"]*)"/);
+  if (feedbackMatch) feedback = feedbackMatch[1];
+  const complexityMatch = argsLine.match(/--complexity\s+(\S+)/);
+  if (complexityMatch) complexity = complexityMatch[1];
+  if (/--dry-run/.test(argsLine)) dryRun = true;
+  const ciRunIdMatch = argsLine.match(/--ci-run-id\s+(\S+)/);
+  if (ciRunIdMatch) ciRunId = ciRunIdMatch[1];
+  const ticketMatch = argsLine.match(/--ticket\s+(\S+)/);
+  if (ticketMatch) ticketId = ticketMatch[1];
+  const fileMatch = argsLine.match(/--file\s+(\S+)/);
+  if (fileMatch) prdFile = fileMatch[1];
+  const positional = argsLine.replace(/--from\s+\S+/g, "").replace(/--feedback\s+"[^"]*"/g, "").replace(/--complexity\s+\S+/g, "").replace(/--dry-run/g, "").replace(/--ci-run-id\s+\S+/g, "").replace(/--ticket\s+\S+/g, "").replace(/--file\s+\S+/g, "").replace(/\s+/g, " ").trim();
+  const parts = positional ? positional.split(/\s+/) : [];
+  let mode = "full";
+  let taskId = "";
+  let idx = 0;
+  if (parts[idx] && VALID_MODES.includes(parts[idx])) {
+    mode = parts[idx];
+    idx++;
+  }
+  if (parts[idx] && !parts[idx].startsWith("--")) {
+    taskId = parts[idx];
+    idx++;
+  } else if (parts[0] && !VALID_MODES.includes(parts[0]) && !parts[0].startsWith("--")) {
+    taskId = parts[0];
+  }
+  const kodyLineIdx = commentBody.search(/(?:@kody|\/kody)/i);
+  const afterKodyLine = commentBody.slice(kodyLineIdx);
+  const newlineIdx = afterKodyLine.indexOf("\n");
+  const bodyAfterCommand = newlineIdx !== -1 ? afterKodyLine.slice(newlineIdx + 1) : "";
+  if (mode === "approve") {
+    mode = "rerun";
+    if (bodyAfterCommand) {
+      feedback = bodyAfterCommand;
+    }
+  }
+  if (mode === "fix") {
+    if (bodyAfterCommand) {
+      feedback = bodyAfterCommand;
+    }
+  }
+  if (mode === "fix-ci") {
+    if (bodyAfterCommand) {
+      feedback = bodyAfterCommand;
+      const runIdFromBody = bodyAfterCommand.match(/Run ID:\s*(\d+)/);
+      if (runIdFromBody) {
+        ciRunId = runIdFromBody[1];
+      }
+    }
+  }
+  if (mode === "bootstrap") {
+    taskId = `bootstrap-${generateTimestamp()}`;
+  }
+  if (mode === "taskify") {
+    taskId = `taskify-${issueNumber}-${generateTimestamp()}`;
+  }
+  const prNumber = isPR ? issueNumber : "";
+  if (mode === "review" && prNumber) {
+    taskId = `review-pr-${prNumber}-${generateTimestamp()}`;
+  }
+  if (!taskId && mode === "full") {
+    taskId = `${issueNumber}-${generateTimestamp()}`;
+  }
+  const modesWithoutTaskId = ["fix", "fix-ci", "status", "review", "resolve", "rerun"];
+  const valid = !!taskId || modesWithoutTaskId.includes(mode);
+  if (mode === "taskify" && !ticketId && !prdFile) {
+    return {
+      task_id: taskId,
+      mode,
+      from_stage: fromStage,
+      issue_number: issueNumber,
+      pr_number: "",
+      feedback,
+      complexity,
+      ci_run_id: ciRunId,
+      ticket_id: "",
+      prd_file: "",
+      dry_run: dryRun,
+      valid: false,
+      trigger_type: "comment"
+    };
+  }
+  return {
+    task_id: taskId,
+    mode,
+    from_stage: fromStage,
+    issue_number: issueNumber,
+    pr_number: prNumber,
+    feedback,
+    complexity,
+    ci_run_id: ciRunId,
+    ticket_id: ticketId,
+    prd_file: prdFile,
+    dry_run: dryRun,
+    valid,
+    trigger_type: "comment"
+  };
+}
+function writeOutputs(result) {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  function output(key, value) {
+    if (outputFile) {
+      if (value.includes("\n")) {
+        fs12.appendFileSync(outputFile, `${key}<<KODY_EOF
+${value}
+KODY_EOF
+`);
+      } else {
+        fs12.appendFileSync(outputFile, `${key}=${value}
+`);
+      }
+    }
+    const display = value.includes("\n") ? value.split("\n")[0] + "..." : value;
+    console.log(`${key}=${display}`);
+  }
+  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 result = parseCommentInputs();
+  writeOutputs(result);
+}
+var VALID_MODES;
+var init_parse_inputs = __esm({
+  "src/ci/parse-inputs.ts"() {
+    "use strict";
+    VALID_MODES = [
+      "full",
+      "rerun",
+      "fix",
+      "fix-ci",
+      "status",
+      "approve",
+      "review",
+      "resolve",
+      "bootstrap",
+      "taskify"
+    ];
+  }
+});
+
+// src/definitions.ts
+var definitions_exports = {};
+__export(definitions_exports, {
+  STAGES: () => STAGES,
+  applyTimeoutOverrides: () => applyTimeoutOverrides,
+  getStage: () => getStage
+});
+function getStage(name) {
+  return STAGES.find((s) => s.name === name);
+}
+function applyTimeoutOverrides(overrides) {
+  for (const stage of STAGES) {
+    if (overrides[stage.name] != null) {
+      stage.timeout = overrides[stage.name] * 1e3;
+    }
+  }
+}
+var STAGES;
+var init_definitions = __esm({
+  "src/definitions.ts"() {
+    "use strict";
+    STAGES = [
+      {
+        name: "taskify",
+        type: "agent",
+        modelTier: "cheap",
+        timeout: 6e5,
+        maxRetries: 1,
+        outputFile: "task.json"
+      },
+      {
+        name: "plan",
+        type: "agent",
+        modelTier: "strong",
+        timeout: 6e5,
+        maxRetries: 1,
+        outputFile: "plan.md"
+      },
+      {
+        name: "build",
+        type: "agent",
+        modelTier: "mid",
+        timeout: 24e5,
+        maxRetries: 1
+      },
+      {
+        name: "verify",
+        type: "gate",
+        modelTier: "cheap",
+        timeout: 3e5,
+        maxRetries: 2,
+        retryWithAgent: "autofix"
+      },
+      {
+        name: "review",
+        type: "agent",
+        modelTier: "strong",
+        timeout: 6e5,
+        maxRetries: 1,
+        outputFile: "review.md"
+      },
+      {
+        name: "review-fix",
+        type: "agent",
+        modelTier: "mid",
+        timeout: 12e5,
+        maxRetries: 1
+      },
+      {
+        name: "ship",
+        type: "deterministic",
+        modelTier: "cheap",
+        timeout: 24e4,
+        maxRetries: 1,
+        outputFile: "ship.md"
+      }
+    ];
+  }
+});
+
+// src/git-utils.ts
+import { execFileSync as execFileSync10 } from "child_process";
+function getHookSafeEnv() {
+  if (!_hookSafeEnv) {
+    _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
+  }
+  return _hookSafeEnv;
+}
+function git(args2, options) {
+  return execFileSync10("git", args2, {
+    encoding: "utf-8",
+    timeout: options?.timeout ?? 3e4,
+    cwd: options?.cwd,
+    env: options?.env ?? getHookSafeEnv(),
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function deriveBranchName(issueNumber, title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50).replace(/-$/, "");
+  return `${issueNumber}-${slug}`;
+}
+function getDefaultBranch(cwd) {
+  try {
+    const config = getProjectConfig();
+    if (config.git?.defaultBranch) {
+      return config.git.defaultBranch;
+    }
+  } catch {
   }
-}
-function createPR(head, base, title, body) {
   try {
-    const output = gh(
-      [
-        "pr",
-        "create",
-        "--head",
-        head,
-        "--base",
-        base,
-        "--title",
-        title,
-        "--body-file",
-        "-"
-      ],
-      { input: body }
-    );
-    const url = output.trim();
-    const match = url.match(/\/pull\/(\d+)$/);
-    const number = match ? parseInt(match[1], 10) : 0;
-    logger.info(`  PR created: ${url}`);
-    return { number, url };
-  } catch (err) {
-    const reason = ghErrorMessage(err);
-    logger.error(`  Failed to create PR: ${reason}`);
-    return null;
+    const ref = git(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd });
+    return ref.replace("refs/remotes/origin/", "");
+  } catch {
+  }
+  try {
+    const output = git(["remote", "show", "origin"], { cwd, timeout: 1e4 });
+    const match = output.match(/HEAD branch:\s*(\S+)/);
+    if (match) return match[1];
+  } catch {
   }
+  return "dev";
 }
-function setLifecycleLabel(issueNumber, phase) {
-  if (!LIFECYCLE_LABELS.includes(phase)) {
-    logger.warn(`  Invalid lifecycle phase: ${phase}`);
-    return;
+function getCurrentBranch(cwd) {
+  return git(["branch", "--show-current"], { cwd });
+}
+function ensureFeatureBranch(issueNumber, title, cwd) {
+  const current = getCurrentBranch(cwd);
+  const branchName = deriveBranchName(issueNumber, title);
+  if (current === branchName || current.startsWith(`${issueNumber}-`)) {
+    logger.info(`  Already on feature branch: ${current}`);
+    return current;
   }
-  const othersToRemove = LIFECYCLE_LABELS.filter((l) => l !== phase).map((l) => `kody:${l}`).join(",");
-  if (othersToRemove) {
+  if (!BASE_BRANCHES.includes(current) && current !== "") {
+    const defaultBranch2 = getDefaultBranch(cwd);
+    logger.info(`  Switching from ${current} to ${defaultBranch2} before creating ${branchName}`);
     try {
-      gh(["issue", "edit", String(issueNumber), "--remove-label", othersToRemove]);
+      git(["checkout", defaultBranch2], { cwd });
     } catch {
+      logger.warn(`  Failed to checkout ${defaultBranch2}, aborting branch creation`);
+      return current;
     }
   }
-  setLabel(issueNumber, `kody:${phase}`);
-}
-function getPRsForIssue(issueNumber) {
   try {
-    const output = gh([
-      "pr",
-      "list",
-      "--search",
-      `${issueNumber} in:body`,
-      "--json",
-      "number,title,url,headRefName",
-      "--state",
-      "open"
-    ]);
-    const prs = JSON.parse(output);
-    const branchPrs = (() => {
-      try {
-        const branchOutput = gh([
-          "pr",
-          "list",
-          "--json",
-          "number,title,url,headRefName",
-          "--state",
-          "open"
-        ]);
-        return JSON.parse(branchOutput).filter((pr) => pr.headRefName.startsWith(`${issueNumber}-`));
-      } catch {
-        return [];
-      }
-    })();
-    const seen = /* @__PURE__ */ new Set();
-    const merged = [];
-    for (const pr of [...prs, ...branchPrs]) {
-      if (!seen.has(pr.number)) {
-        seen.add(pr.number);
-        merged.push({ number: pr.number, title: pr.title, url: pr.url, headBranch: pr.headRefName });
-      }
-    }
-    return merged;
+    git(["fetch", "origin"], { cwd, timeout: 3e4 });
   } catch (err) {
-    logger.error(`  Failed to get PRs for issue #${issueNumber}: ${err}`);
-    return [];
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`  Failed to fetch origin: ${msg}`);
+  }
+  try {
+    git(["rev-parse", "--verify", `origin/${branchName}`], { cwd });
+    git(["checkout", branchName], { cwd });
+    git(["pull", "origin", branchName], { cwd, timeout: 3e4 });
+    logger.info(`  Checked out existing remote branch: ${branchName}`);
+    return branchName;
+  } catch {
+  }
+  try {
+    git(["rev-parse", "--verify", branchName], { cwd });
+    git(["checkout", branchName], { cwd });
+    logger.info(`  Checked out existing local branch: ${branchName}`);
+    return branchName;
+  } catch {
+  }
+  const defaultBranch = getDefaultBranch(cwd);
+  try {
+    git(["checkout", "-b", branchName, `origin/${defaultBranch}`], { cwd });
+  } catch {
+    git(["checkout", "-b", branchName], { cwd });
   }
+  logger.info(`  Created new branch: ${branchName}`);
+  return branchName;
 }
-function getPRDetails(prNumber) {
+function syncWithDefault(cwd, branch) {
+  const defaultBranch = branch ?? getDefaultBranch(cwd);
+  const current = getCurrentBranch(cwd);
+  if (current === defaultBranch) return;
   try {
-    const output = gh([
-      "pr",
-      "view",
-      String(prNumber),
-      "--json",
-      "title,body,headRefName,baseRefName"
-    ]);
-    const data = JSON.parse(output);
-    if (typeof data.title !== "string" || typeof data.headRefName !== "string") {
-      logger.warn(`  PR #${prNumber}: unexpected response shape`);
-      return null;
-    }
-    return {
-      title: data.title,
-      body: data.body ?? "",
-      headBranch: data.headRefName,
-      baseBranch: data.baseRefName ?? "main"
-    };
+    git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
   } catch (err) {
-    if (isNotFoundError(err)) {
-      logger.info(`  PR #${prNumber} not found`);
-    } else {
-      logger.error(`  Failed to get PR #${prNumber}: ${ghErrorMessage(err)}`);
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`  Failed to fetch latest from origin: ${msg}`);
+    return;
+  }
+  try {
+    git(["merge", `origin/${defaultBranch}`, "--no-edit"], { cwd, timeout: 3e4 });
+    logger.info(`  Synced with origin/${defaultBranch}`);
+  } catch {
+    try {
+      git(["merge", "--abort"], { cwd });
+    } catch (abortErr) {
+      logger.warn(`  Failed to abort merge: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}`);
     }
-    return null;
+    logger.warn(`  Merge conflict with origin/${defaultBranch} \u2014 skipping sync`);
   }
 }
-function postPRComment(prNumber, body) {
+function mergeDefault(cwd) {
+  const defaultBranch = getDefaultBranch(cwd);
+  const current = getCurrentBranch(cwd);
+  if (current === defaultBranch) return "clean";
   try {
-    gh(
-      ["pr", "comment", String(prNumber), "--body-file", "-"],
-      { input: body }
-    );
-    logger.info(`  Comment posted on PR #${prNumber}`);
+    git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
   } catch (err) {
-    logger.warn(`  Failed to post PR comment: ${err}`);
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`  Failed to fetch latest from origin: ${msg}`);
+    return "error";
   }
-}
-function submitPRReview(prNumber, body, event) {
-  const flag = event === "approve" ? "--approve" : "--request-changes";
   try {
-    gh(
-      ["pr", "review", String(prNumber), flag, "--body-file", "-"],
-      { input: body }
-    );
-    logger.info(`  PR review submitted on #${prNumber}: ${event}`);
-    return true;
-  } catch (err) {
-    logger.warn(`  Failed to submit PR review: ${err}`);
-    return false;
+    git(["merge", `origin/${defaultBranch}`, "--no-edit"], { cwd, timeout: 3e4 });
+    logger.info(`  Merged origin/${defaultBranch} cleanly`);
+    return "clean";
+  } catch {
+    try {
+      const unmerged = git(["diff", "--name-only", "--diff-filter=U"], { cwd });
+      if (unmerged.trim()) return "conflict";
+    } catch {
+    }
+    try {
+      git(["merge", "--abort"], { cwd });
+    } catch (abortErr) {
+      logger.warn(`  Failed to abort merge: ${abortErr instanceof Error ? abortErr.message : String(abortErr)}`);
+    }
+    return "error";
   }
 }
-function getCIFailureLogs(runId, maxLength = 8e3) {
+function getConflictedFiles(cwd) {
   try {
-    const logsOutput = gh([
-      "run",
-      "view",
-      String(runId),
-      "--log-failed"
-    ]);
-    if (!logsOutput) return null;
-    const truncated = logsOutput.slice(-maxLength);
-    const prefix = logsOutput.length > maxLength ? "...(earlier output truncated)\n" : "";
-    return `${prefix}${truncated}`;
-  } catch (err) {
-    logger.warn(`  Failed to get CI failure logs for run ${runId}: ${ghErrorMessage(err)}`);
-    return null;
+    const output = git(["diff", "--name-only", "--diff-filter=U"], { cwd });
+    return output ? output.split("\n") : [];
+  } catch {
+    return [];
   }
 }
-function getLatestFailedRunForBranch(branch) {
-  try {
-    const output = gh([
-      "run",
-      "list",
-      "--branch",
-      branch,
-      "--status",
-      "failure",
-      "--limit",
-      "1",
-      "--json",
-      "databaseId",
-      "--jq",
-      ".[0].databaseId"
-    ]);
-    return output.trim() || null;
-  } catch (err) {
-    logger.warn(`  Failed to get latest failed run for branch ${branch}: ${ghErrorMessage(err)}`);
-    return null;
+function commitAll(message, cwd) {
+  const status = git(["status", "--porcelain"], { cwd });
+  if (!status) {
+    return { success: false, hash: "", message: "No changes to commit" };
   }
+  git(["add", "."], { cwd });
+  git(["commit", "--no-gpg-sign", "-m", message], { cwd });
+  const hash = git(["rev-parse", "HEAD"], { cwd }).slice(0, 7);
+  logger.info(`  Committed: ${hash} ${message}`);
+  return { success: true, hash, message };
 }
-function getLatestKodyReviewComment(prNumber) {
+function getDiffFiles(baseBranch, cwd) {
   try {
-    const output = gh([
-      "api",
-      `repos/{owner}/{repo}/issues/${prNumber}/comments`,
-      "--jq",
-      '[.[] | select(.body | test("Kody Review"))] | last | .body'
-    ]);
-    return output.trim() || null;
+    const output = git(["diff", "--name-only", `origin/${baseBranch}...HEAD`], { cwd });
+    if (!output) return [];
+    return output.split("\n").filter((f) => f && !f.startsWith(".kody/"));
   } catch (err) {
-    logger.warn(`  Failed to get review comments for PR #${prNumber}: ${err}`);
-    return null;
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`  Failed to get diff files: ${msg}`);
+    return [];
   }
 }
-function getPRFeedbackSinceLastKodyAction(prNumber) {
+function pushBranch(cwd) {
   try {
-    const issueCommentsRaw = gh([
-      "api",
-      `repos/{owner}/{repo}/issues/${prNumber}/comments`,
-      "--jq",
-      "[.[] | {body, created_at, user_login: .user.login, user_type: .user.type}]"
-    ]);
-    const issueComments = issueCommentsRaw ? JSON.parse(issueCommentsRaw) : [];
-    const reviewCommentsRaw = gh([
-      "api",
-      `repos/{owner}/{repo}/pulls/${prNumber}/comments`,
-      "--jq",
-      "[.[] | {body, created_at, user_login: .user.login, user_type: .user.type, path, line}]"
-    ]);
-    const reviewComments = reviewCommentsRaw ? JSON.parse(reviewCommentsRaw) : [];
-    const kodyTimestamp = findLastKodyActionTimestamp(issueComments);
-    const humanIssueComments = issueComments.filter(
-      (c) => !isKodyComment(c) && (!kodyTimestamp || c.created_at > kodyTimestamp)
-    );
-    const humanReviewComments = reviewComments.filter(
-      (c) => !isKodyComment(c) && (!kodyTimestamp || c.created_at > kodyTimestamp)
-    );
-    if (humanIssueComments.length === 0 && humanReviewComments.length === 0) {
-      return null;
-    }
-    const parts = [];
-    if (humanIssueComments.length > 0) {
-      parts.push("### PR Comments");
-      for (const c of humanIssueComments) {
-        parts.push(`**@${c.user_login}:**
-${c.body}`);
-      }
-    }
-    if (humanReviewComments.length > 0) {
-      parts.push("### Code Review Comments");
-      for (const c of humanReviewComments) {
-        const location = c.path ? `\`${c.path}${c.line ? `:${c.line}` : ""}\`` : "";
-        parts.push(`**@${c.user_login}** ${location}:
-${c.body}`);
-      }
-    }
-    return parts.join("\n\n");
-  } catch (err) {
-    logger.warn(`  Failed to get PR feedback for #${prNumber}: ${err}`);
-    return null;
+    git(["push", "-u", "origin", "HEAD"], { cwd, timeout: 12e4 });
+  } catch {
+    logger.info("  Push rejected (non-fast-forward), retrying with --force-with-lease");
+    git(["push", "--force-with-lease", "-u", "origin", "HEAD"], { cwd, timeout: 12e4 });
   }
+  logger.info("  Pushed to origin");
 }
-function isKodyComment(comment) {
-  if (comment.user_type === "Bot") return true;
-  return KODY_MARKERS.some((marker) => comment.body.includes(marker));
-}
-function findLastKodyActionTimestamp(comments) {
-  const kodyComments = comments.filter(isKodyComment);
-  if (kodyComments.length === 0) return null;
-  return kodyComments[kodyComments.length - 1].created_at;
-}
-var API_TIMEOUT_MS, LIFECYCLE_LABELS, _ghCwd, KODY_MARKERS;
-var init_github_api = __esm({
-  "src/github-api.ts"() {
+var BASE_BRANCHES, _hookSafeEnv;
+var init_git_utils = __esm({
+  "src/git-utils.ts"() {
     "use strict";
     init_logger();
-    API_TIMEOUT_MS = 3e4;
-    LIFECYCLE_LABELS = ["planning", "building", "review", "shipping", "done", "failed", "waiting", "low", "medium", "high"];
-    KODY_MARKERS = [
-      "Kody Review",
-      "\u{1F916} Generated by Kody",
-      "Kody pipeline started",
-      "Fix pushed to PR",
-      "PR created:",
-      "Pipeline failed at",
-      "Pipeline already running",
-      "already completed"
-    ];
+    init_config();
+    BASE_BRANCHES = ["dev", "main", "master"];
+    _hookSafeEnv = null;
   }
 });
 
 // src/pipeline/state.ts
-import * as fs10 from "fs";
-import * as path8 from "path";
+import * as fs13 from "fs";
+import * as path11 from "path";
 function loadState(taskId, taskDir) {
-  const p = path8.join(taskDir, "status.json");
-  if (!fs10.existsSync(p)) return null;
+  const p = path11.join(taskDir, "status.json");
+  if (!fs13.existsSync(p)) return null;
   try {
     const result = parseJsonSafe(
-      fs10.readFileSync(p, "utf-8"),
+      fs13.readFileSync(p, "utf-8"),
       ["taskId", "state", "stages", "createdAt", "updatedAt"]
     );
     if (!result.ok) {
@@ -1320,10 +2052,10 @@ function writeState(state, taskDir) {
     ...state,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const target = path8.join(taskDir, "status.json");
+  const target = path11.join(taskDir, "status.json");
   const tmp = target + ".tmp";
-  fs10.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-  fs10.renameSync(tmp, target);
+  fs13.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs13.renameSync(tmp, target);
   return updated;
 }
 function initState(taskId) {
@@ -1364,16 +2096,16 @@ var init_complexity = __esm({
 });
 
 // src/memory.ts
-import * as fs11 from "fs";
-import * as path9 from "path";
+import * as fs14 from "fs";
+import * as path12 from "path";
 function readProjectMemory(projectDir) {
-  const memoryDir = path9.join(projectDir, ".kody", "memory");
-  if (!fs11.existsSync(memoryDir)) return "";
-  const files = fs11.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 = fs11.readFileSync(path9.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}`);
@@ -1392,8 +2124,8 @@ var init_memory = __esm({
 });
 
 // src/context-tiers.ts
-import * as fs12 from "fs";
-import * as path10 from "path";
+import * as fs15 from "fs";
+import * as path13 from "path";
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
@@ -1484,7 +2216,7 @@ function generateL1Json(content) {
   }
 }
 function getTieredContent(filePath, content) {
-  const key = path10.basename(filePath);
+  const key = path13.basename(filePath);
   return {
     source: filePath,
     L0: generateL0(content, key),
@@ -1496,15 +2228,15 @@ function selectTier(tiered, tier) {
   return tiered[tier];
 }
 function readProjectMemoryTiered(projectDir, tier) {
-  const memoryDir = path10.join(projectDir, ".kody", "memory");
-  if (!fs12.existsSync(memoryDir)) return "";
-  const files = fs12.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 = path10.join(memoryDir, file);
-    const content = fs12.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);
@@ -1527,9 +2259,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path10.join(taskDir, "task.md");
-  if (fs12.existsSync(taskMdPath)) {
-    const content = fs12.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 += `
@@ -1537,9 +2269,9 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
 ${selected}
 `;
   }
-  const taskJsonPath = path10.join(taskDir, "task.json");
-  if (fs12.existsSync(taskJsonPath)) {
-    const content = fs12.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, ""));
@@ -1565,9 +2297,9 @@ ${selected}
       }
     }
   }
-  const specPath = path10.join(taskDir, "spec.md");
-  if (fs12.existsSync(specPath)) {
-    const content = fs12.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 += `
@@ -1575,9 +2307,9 @@ ${selected}
 ${selected}
 `;
   }
-  const planPath = path10.join(taskDir, "plan.md");
-  if (fs12.existsSync(planPath)) {
-    const content = fs12.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 += `
@@ -1585,9 +2317,9 @@ ${selected}
 ${selected}
 `;
   }
-  const contextMdPath = path10.join(taskDir, "context.md");
-  if (fs12.existsSync(contextMdPath)) {
-    const content = fs12.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 += `
@@ -1672,71 +2404,25 @@ var init_context_tiers = __esm({
   }
 });
 
-// src/mcp-config.ts
-function withPlaywrightIfNeeded(mcpConfig, hasUI) {
-  if (!mcpConfig?.enabled || !hasUI) return mcpConfig;
-  const hasPlaywright = Object.keys(mcpConfig.servers).some(
-    (name) => name.toLowerCase().includes("playwright")
-  );
-  if (hasPlaywright) return mcpConfig;
-  return {
-    ...mcpConfig,
-    servers: {
-      ...mcpConfig.servers,
-      playwright: PLAYWRIGHT_SERVER
-    }
-  };
-}
-function buildMcpConfigJson(mcpConfig) {
-  if (!mcpConfig?.enabled) return void 0;
-  if (Object.keys(mcpConfig.servers).length === 0) return void 0;
-  const config = { mcpServers: {} };
-  const mcpServers = config.mcpServers;
-  for (const [name, server] of Object.entries(mcpConfig.servers)) {
-    mcpServers[name] = {
-      command: server.command,
-      args: server.args ?? [],
-      ...server.env ? { env: server.env } : {}
-    };
-  }
-  return JSON.stringify(config);
-}
-function isMcpEnabledForStage(stageName, mcpConfig) {
-  if (!mcpConfig?.enabled) return false;
-  const allowedStages = mcpConfig.stages ?? DEFAULT_MCP_STAGES;
-  return allowedStages.includes(stageName);
-}
-var DEFAULT_MCP_STAGES, PLAYWRIGHT_SERVER;
-var init_mcp_config = __esm({
-  "src/mcp-config.ts"() {
-    "use strict";
-    DEFAULT_MCP_STAGES = ["build", "verify", "review", "review-fix"];
-    PLAYWRIGHT_SERVER = {
-      command: "npx",
-      args: ["-y", "@anthropic-ai/mcp-playwright"]
-    };
-  }
-});
-
 // src/context.ts
-import * as fs13 from "fs";
-import * as path11 from "path";
+import * as fs16 from "fs";
+import * as path14 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
-    const stepFile = path11.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs13.existsSync(stepFile)) {
-      return fs13.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 = [
-    path11.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path11.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+    path14.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path14.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs13.existsSync(candidate)) {
-      return fs13.readFileSync(candidate, "utf-8");
+    if (fs16.existsSync(candidate)) {
+      return fs16.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -1748,18 +2434,18 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
 `;
   context += `Task Directory: ${taskDir}
 `;
-  const taskMdPath = path11.join(taskDir, "task.md");
-  if (fs13.existsSync(taskMdPath)) {
-    const taskMd = fs13.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 = path11.join(taskDir, "task.json");
-  if (fs13.existsSync(taskJsonPath)) {
+  const taskJsonPath = path14.join(taskDir, "task.json");
+  if (fs16.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs13.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs16.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -1772,27 +2458,27 @@ ${taskMd}
     } catch {
     }
   }
-  const specPath = path11.join(taskDir, "spec.md");
-  if (fs13.existsSync(specPath)) {
-    const spec = fs13.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 = path11.join(taskDir, "plan.md");
-  if (fs13.existsSync(planPath)) {
-    const plan = fs13.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 = path11.join(taskDir, "context.md");
-  if (fs13.existsSync(contextMdPath)) {
-    const accumulated = fs13.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 += `
@@ -1810,17 +2496,17 @@ ${feedback}
 }
 function inferHasUIFromScope(scope) {
   return scope.some((filePath) => {
-    const ext = path11.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 = path11.join(taskDir, "task.json");
-  if (!fs13.existsSync(taskJsonPath)) return true;
+  const taskJsonPath = path14.join(taskDir, "task.json");
+  if (!fs16.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs13.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);
@@ -1942,9 +2628,9 @@ ${prompt}` : prompt;
   }
   if (isMcpEnabledForStage(stageName, config.mcp) && taskHasUI(taskDir)) {
     assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
-    const qaGuidePath = path11.join(projectDir, ".kody", "qa-guide.md");
-    if (fs13.existsSync(qaGuidePath)) {
-      const qaGuide = fs13.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;
     }
   }
@@ -1977,7 +2663,7 @@ function resolveModel(modelTier, stageName) {
   if (mapped) return mapped;
   return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
 }
-var DEFAULT_MODEL_MAP, 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";
@@ -1985,11 +2671,6 @@ var init_context = __esm({
     init_config();
     init_context_tiers();
     init_mcp_config();
-    DEFAULT_MODEL_MAP = {
-      cheap: "haiku",
-      mid: "sonnet",
-      strong: "opus"
-    };
     MAX_TASK_CONTEXT_PLAN = 1500;
     MAX_TASK_CONTEXT_SPEC = 2e3;
     MAX_ACCUMULATED_CONTEXT = 4e3;
@@ -2016,6 +2697,11 @@ var init_context = __esm({
       mid: "strong",
       strong: "strong"
     };
+    DEFAULT_MODEL_MAP = {
+      cheap: "haiku",
+      mid: "sonnet",
+      strong: "opus"
+    };
   }
 });
 
@@ -2039,8 +2725,8 @@ var init_runner_selection = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs14 from "fs";
-import * as path12 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;
@@ -2127,27 +2813,27 @@ async function executeAgentStage(ctx, def) {
   }
   const result = lastResult;
   if (def.outputFile && result.output) {
-    fs14.writeFileSync(path12.join(ctx.taskDir, def.outputFile), result.output);
+    fs17.writeFileSync(path15.join(ctx.taskDir, def.outputFile), result.output);
   }
   if (def.outputFile) {
-    const outputPath = path12.join(ctx.taskDir, def.outputFile);
-    if (!fs14.existsSync(outputPath)) {
-      const ext = path12.extname(def.outputFile);
-      const base = path12.basename(def.outputFile, ext);
-      const files = fs14.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) {
-        fs14.renameSync(path12.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 = path12.join(ctx.taskDir, def.outputFile);
-    if (fs14.existsSync(outputPath)) {
-      const content = fs14.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") {
@@ -2161,7 +2847,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs14.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}`);
@@ -2174,7 +2860,7 @@ async function executeAgentStage(ctx, def) {
                 risk_level: "low",
                 questions: []
               }, null, 2);
-              fs14.writeFileSync(outputPath, fallback);
+              fs17.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -2188,7 +2874,7 @@ async function executeAgentStage(ctx, def) {
   return { outcome: "completed", outputFile: def.outputFile, retries };
 }
 function appendStageContext(taskDir, stageName, output) {
-  const contextPath = path12.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()) {
@@ -2201,7 +2887,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs14.appendFileSync(contextPath, entry);
+  fs17.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -2224,7 +2910,7 @@ var init_agent = __esm({
 });
 
 // src/verify-runner.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 function isExecError(err) {
   return typeof err === "object" && err !== null;
 }
@@ -2260,7 +2946,7 @@ function runCommand(cmd, cwd, timeout) {
     return { success: true, output: "", timedOut: false };
   }
   try {
-    const output = execFileSync9(parts[0], parts.slice(1), {
+    const output = execFileSync11(parts[0], parts.slice(1), {
       cwd,
       timeout,
       encoding: "utf-8",
@@ -2331,7 +3017,7 @@ var init_verify_runner = __esm({
 });
 
 // src/observer.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, model, options) {
   const context = [
     `Stage: ${stageName}`,
@@ -2391,13 +3077,13 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
 }
 function getModifiedFiles(projectDir) {
   try {
-    const staged = execFileSync10("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 = execFileSync10("git", ["diff", "--name-only"], {
+    const unstaged = execFileSync12("git", ["diff", "--name-only"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -2440,8 +3126,8 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs15 from "fs";
-import * as path13 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}`);
@@ -2484,7 +3170,7 @@ ${output}
 `);
     }
   }
-  fs15.writeFileSync(path13.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
@@ -2499,9 +3185,9 @@ var init_gate = __esm({
 });
 
 // src/stages/verify.ts
-import * as fs16 from "fs";
-import * as path14 from "path";
-import { execFileSync as execFileSync11 } 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++) {
@@ -2511,8 +3197,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      const verifyPath = path14.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs16.existsSync(verifyPath) ? fs16.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();
@@ -2555,7 +3241,7 @@ ${diagnosis.resolution}`);
         const parts = parseCommand(cmd);
         if (parts.length === 0) return;
         try {
-          execFileSync11(parts[0], parts.slice(1), {
+          execFileSync13(parts[0], parts.slice(1), {
             stdio: "pipe",
             timeout: FIX_COMMAND_TIMEOUT_MS
           });
@@ -2580,100 +3266,36 @@ ${ctx.input.feedback ?? ""}`.trim()
           name: def.retryWithAgent,
           type: "agent",
           modelTier: "mid",
-          timeout: 3e5,
-          outputFile: void 0
-        });
-      }
-    }
-  }
-  return {
-    outcome: "failed",
-    retries: maxAttempts,
-    error: "Verification failed after autofix attempts"
-  };
-}
-var init_verify = __esm({
-  "src/stages/verify.ts"() {
-    "use strict";
-    init_context();
-    init_config();
-    init_verify_runner();
-    init_runner_selection();
-    init_github_api();
-    init_observer();
-    init_logger();
-    init_agent();
-    init_gate();
-  }
-});
-
-// src/cli/task-resolution.ts
-import * as fs17 from "fs";
-import * as path15 from "path";
-import { execFileSync as execFileSync12 } from "child_process";
-function findLatestTaskForIssue(issueNumber, projectDir) {
-  const tasksDir = path15.join(projectDir, ".kody", "tasks");
-  if (!fs17.existsSync(tasksDir)) return null;
-  const allDirs = fs17.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
-  const prefix = `${issueNumber}-`;
-  const direct = allDirs.find((d) => d.startsWith(prefix));
-  if (direct) return direct;
-  try {
-    const branch = execFileSync12("git", ["branch", "--show-current"], {
-      encoding: "utf-8",
-      cwd: projectDir,
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const branchIssueMatch = branch.match(/^(\d+)-/);
-    if (branchIssueMatch) {
-      const branchIssueNum = branchIssueMatch[1];
-      const branchPrefix = `${branchIssueNum}-`;
-      const fromBranch = allDirs.find((d) => d.startsWith(branchPrefix));
-      if (fromBranch) return fromBranch;
-    }
-  } catch {
-  }
-  return null;
-}
-function generateTaskId() {
-  const now = /* @__PURE__ */ new Date();
-  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 {
-    const comments = getIssueComments(issueNumber);
-    const pattern = /pipeline started: `([^`]+)`/;
-    let latestTaskId = null;
-    for (const comment of comments) {
-      const match = comment.body.match(pattern);
-      if (match) {
-        latestTaskId = match[1];
+          timeout: 3e5,
+          outputFile: void 0
+        });
       }
     }
-    return latestTaskId;
-  } catch {
-    return null;
   }
+  return {
+    outcome: "failed",
+    retries: maxAttempts,
+    error: "Verification failed after autofix attempts"
+  };
 }
-function resolveTaskIdForCommand(issueNumber, projectDir) {
-  const fromTasks = findLatestTaskForIssue(issueNumber, projectDir);
-  if (fromTasks) return fromTasks;
-  const fromComments = resolveTaskIdFromComments(issueNumber);
-  if (fromComments) return fromComments;
-  return null;
-}
-var init_task_resolution = __esm({
-  "src/cli/task-resolution.ts"() {
+var init_verify = __esm({
+  "src/stages/verify.ts"() {
     "use strict";
+    init_context();
+    init_config();
+    init_verify_runner();
+    init_runner_selection();
     init_github_api();
+    init_observer();
+    init_logger();
+    init_agent();
+    init_gate();
   }
 });
 
 // src/review-standalone.ts
-import * as fs18 from "fs";
-import * as path16 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
     return {
@@ -2697,8 +3319,8 @@ Or comment on the specific PR: \`@kody review\``
 }
 async function runStandaloneReview(input) {
   const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path16.join(input.projectDir, ".kody", "tasks", taskId);
-  fs18.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) {
@@ -2725,7 +3347,7 @@ ${fileList}`;
   const taskContent = `# ${input.prTitle}
 
 ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
-  fs18.writeFileSync(path16.join(taskDir, "task.md"), taskContent);
+  fs20.writeFileSync(path18.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -2747,10 +3369,10 @@ ${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
       error: result.error ?? "Review stage failed"
     };
   }
-  const reviewPath = path16.join(taskDir, "review.md");
+  const reviewPath = path18.join(taskDir, "review.md");
   let reviewContent;
-  if (fs18.existsSync(reviewPath)) {
-    reviewContent = fs18.readFileSync(reviewPath, "utf-8");
+  if (fs20.existsSync(reviewPath)) {
+    reviewContent = fs20.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -2790,8 +3412,8 @@ var init_review_standalone = __esm({
 });
 
 // src/stages/review.ts
-import * as fs19 from "fs";
-import * as path17 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 };
@@ -2805,11 +3427,11 @@ async function executeReviewWithFix(ctx, def) {
     if (reviewResult.outcome !== "completed") {
       return reviewResult;
     }
-    const reviewFile = path17.join(ctx.taskDir, "review.md");
-    if (!fs19.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 = fs19.readFileSync(reviewFile, "utf-8");
+    const content = fs21.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -2838,15 +3460,15 @@ var init_review = __esm({
 });
 
 // src/stages/ship.ts
-import * as fs20 from "fs";
-import * as path18 from "path";
-import { execFileSync as execFileSync13 } from "child_process";
+import * as fs22 from "fs";
+import * as path20 from "path";
+import { execFileSync as execFileSync14 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path18.join(ctx.taskDir, "task.json");
-  if (fs20.existsSync(taskJsonPath)) {
+  const taskJsonPath = path20.join(ctx.taskDir, "task.json");
+  if (fs22.existsSync(taskJsonPath)) {
     try {
-      const raw = fs20.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) {
@@ -2865,9 +3487,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path18.join(ctx.taskDir, "review.md");
-  if (fs20.existsSync(reviewPath)) {
-    const review = fs20.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();
@@ -2884,14 +3506,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path18.join(ctx.taskDir, "verify.md");
-  if (fs20.existsSync(verifyPath)) {
-    const verify = fs20.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 = path18.join(ctx.taskDir, "plan.md");
-  if (fs20.existsSync(planPath)) {
-    const plan = fs20.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(`
@@ -2911,25 +3533,25 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path18.join(ctx.taskDir, "ship.md");
+  const shipPath = path20.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs20.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) {
-    fs20.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs22.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   try {
     const head = getCurrentBranch(ctx.projectDir);
     const base = getDefaultBranch(ctx.projectDir);
     try {
-      execFileSync13("git", ["add", ctx.taskDir], {
+      execFileSync14("git", ["add", ctx.taskDir], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
       });
-      execFileSync13("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
+      execFileSync14("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
@@ -2943,7 +3565,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync13("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync14("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -2964,28 +3586,28 @@ function executeShipStage(ctx, _def) {
       chore: "chore"
     };
     let prefix = "chore";
-    const taskJsonPath = path18.join(ctx.taskDir, "task.json");
-    if (fs20.existsSync(taskJsonPath)) {
+    const taskJsonPath = path20.join(ctx.taskDir, "task.json");
+    if (fs22.existsSync(taskJsonPath)) {
       try {
-        const raw = fs20.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 = path18.join(ctx.taskDir, "task.md");
-    if (fs20.existsSync(taskMdPath)) {
-      const content = fs20.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 (fs20.existsSync(taskJsonPath)) {
+      if (fs22.existsSync(taskJsonPath)) {
         try {
-          const raw = fs20.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);
@@ -3008,7 +3630,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs20.writeFileSync(shipPath, `# Ship
+      fs22.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -3029,20 +3651,20 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs20.writeFileSync(shipPath, `# Ship
+        fs22.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs20.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 {
-      fs20.writeFileSync(shipPath, `# Ship
+      fs22.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
@@ -3091,15 +3713,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs21 from "fs";
-import * as path19 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 = path19.join(ctx.taskDir, "task.json");
-      if (!fs21.existsSync(taskJsonPath)) return false;
-      const raw = fs21.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) {
@@ -3114,9 +3736,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path19.join(ctx.taskDir, "plan.md");
-      if (!fs21.existsSync(planPath)) return false;
-      const plan = fs21.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();
@@ -3145,8 +3767,8 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs22 from "fs";
-import * as path20 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");
@@ -3184,9 +3806,9 @@ function autoDetectComplexity(ctx, def) {
     return { complexity, activeStages };
   }
   try {
-    const taskJsonPath = path20.join(ctx.taskDir, "task.json");
-    if (!fs22.existsSync(taskJsonPath)) return null;
-    const raw = fs22.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;
@@ -3216,8 +3838,8 @@ function checkRiskGate(ctx, def, state, complexity) {
   if (ctx.input.dryRun || ctx.input.local) return null;
   if (ctx.input.mode === "rerun") return null;
   if (!ctx.input.issueNumber) return null;
-  const planPath = path20.join(ctx.taskDir, "plan.md");
-  const plan = fs22.existsSync(planPath) ? fs22.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,
@@ -3284,22 +3906,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs23 from "fs";
-import * as path21 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 = path21.join(ctx.projectDir, ".kody", "memory");
-    if (!fs23.existsSync(memoryDir)) {
-      fs23.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 = path21.join(ctx.taskDir, "verify.md");
-    if (fs23.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs23.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");
@@ -3308,18 +3930,18 @@ function autoLearn(ctx) {
       if (/jsdom/i.test(verify)) learnings.push("- Test environment: jsdom");
       if (/node/i.test(verify) && /environment/i.test(verify)) learnings.push("- Test environment: node");
     }
-    const reviewPath = path21.join(ctx.taskDir, "review.md");
-    if (fs23.existsSync(reviewPath)) {
-      const review = fs23.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 = path21.join(ctx.taskDir, "task.json");
-    if (fs23.existsSync(taskJsonPath)) {
+    const taskJsonPath = path23.join(ctx.taskDir, "task.json");
+    if (fs25.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs23.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)) {
@@ -3330,12 +3952,12 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path21.join(memoryDir, "conventions.md");
+      const conventionsPath = path23.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs23.appendFileSync(conventionsPath, entry);
+      fs25.appendFileSync(conventionsPath, entry);
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
@@ -3343,8 +3965,8 @@ ${learnings.join("\n")}
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path21.join(memoryDir, "architecture.md");
-  if (fs23.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})
@@ -3352,7 +3974,7 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs23.writeFileSync(archPath, content);
+    fs25.writeFileSync(archPath, content);
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
@@ -3365,13 +3987,13 @@ var init_auto_learn = __esm({
 });
 
 // src/retrospective.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path22.join(taskDir, filename);
-  if (!fs24.existsSync(p)) return null;
+  const p = path24.join(taskDir, filename);
+  if (!fs26.existsSync(p)) return null;
   try {
-    const content = fs24.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;
@@ -3424,13 +4046,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path22.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 (!fs24.existsSync(logPath)) return [];
+  if (!fs26.existsSync(logPath)) return [];
   try {
-    const content = fs24.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);
@@ -3457,11 +4079,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path22.dirname(logPath);
-  if (!fs24.existsSync(dir)) {
-    fs24.mkdirSync(dir, { recursive: true });
+  const dir = path24.dirname(logPath);
+  if (!fs26.existsSync(dir)) {
+    fs26.mkdirSync(dir, { recursive: true });
   }
-  fs24.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs26.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -3629,8 +4251,8 @@ var init_summary = __esm({
 });
 
 // src/pipeline.ts
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
   if (ctx.input.prNumber) {
@@ -3643,8 +4265,8 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
   if (!ctx.input.issueNumber) return;
   try {
-    const taskMdPath = path23.join(ctx.taskDir, "task.md");
-    const title = fs25.existsSync(taskMdPath) ? fs25.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) {
@@ -3658,10 +4280,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path23.join(taskDir, ".lock");
-  if (fs25.existsSync(lockPath)) {
+  const lockPath = path25.join(taskDir, ".lock");
+  if (fs27.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs25.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs27.readFileSync(lockPath, "utf-8").trim(), 10);
       if (!isNaN(pid)) {
         try {
           process.kill(pid, 0);
@@ -3678,14 +4300,14 @@ function acquireLock(taskDir) {
       logger.warn(`  Corrupt lock file \u2014 overwriting`);
     }
     try {
-      fs25.unlinkSync(lockPath);
+      fs27.unlinkSync(lockPath);
     } catch {
     }
   }
   try {
-    const fd = fs25.openSync(lockPath, fs25.constants.O_WRONLY | fs25.constants.O_CREAT | fs25.constants.O_EXCL);
-    fs25.writeSync(fd, String(process.pid));
-    fs25.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)");
@@ -3695,7 +4317,7 @@ function acquireLock(taskDir) {
 }
 function releaseLock(taskDir) {
   try {
-    fs25.unlinkSync(path23.join(taskDir, ".lock"));
+    fs27.unlinkSync(path25.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -3903,8 +4525,8 @@ var init_pipeline = __esm({
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync14 } from "child_process";
-import * as fs26 from "fs";
+import { execFileSync as execFileSync15 } from "child_process";
+import * as fs28 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -3916,7 +4538,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync14("claude", ["--version"], {
+      const v = execFileSync15("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3924,14 +4546,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync14("git", ["rev-parse", "--is-inside-work-tree"], {
+      execFileSync15("git", ["rev-parse", "--is-inside-work-tree"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
     }),
     check("pnpm", () => {
-      const v = execFileSync14("pnpm", ["--version"], {
+      const v = execFileSync15("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3939,7 +4561,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync14("node", ["--version"], {
+      const v = execFileSync15("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3949,7 +4571,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync14("gh", ["--version"], {
+      const v = execFileSync15("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3957,7 +4579,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs26.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);
@@ -3978,19 +4600,19 @@ var init_preflight = __esm({
 });
 
 // src/cli/args.ts
-function getArg(args2, flag) {
+function getArg2(args2, flag) {
   const idx = args2.indexOf(flag);
   if (idx !== -1 && args2[idx + 1] && !args2[idx + 1].startsWith("--")) {
     return args2[idx + 1];
   }
   return void 0;
 }
-function hasFlag(args2, flag) {
+function hasFlag2(args2, flag) {
   return args2.includes(flag);
 }
 function parseArgs() {
   const args2 = process.argv.slice(2);
-  if (hasFlag(args2, "--help") || hasFlag(args2, "-h") || args2.length === 0) {
+  if (hasFlag2(args2, "--help") || hasFlag2(args2, "-h") || args2.length === 0) {
     console.log(`Usage:
   kody run    --task-id <id> [--task "<desc>"] [--cwd <path>] [--issue-number <n>] [--complexity low|medium|high] [--feedback "<text>"] [--local] [--dry-run]
   kody rerun  --task-id <id> --from <stage> [--cwd <path>] [--issue-number <n>]
@@ -4007,22 +4629,22 @@ function parseArgs() {
     console.error(`Unknown command: ${command2}`);
     process.exit(1);
   }
-  const issueStr = getArg(args2, "--issue-number") ?? process.env.ISSUE_NUMBER;
-  const prStr = getArg(args2, "--pr-number") ?? process.env.PR_NUMBER;
-  const localFlag = hasFlag(args2, "--local");
+  const issueStr = getArg2(args2, "--issue-number") ?? process.env.ISSUE_NUMBER;
+  const prStr = getArg2(args2, "--pr-number") ?? process.env.PR_NUMBER;
+  const localFlag = hasFlag2(args2, "--local");
   return {
     command: command2,
-    taskId: getArg(args2, "--task-id") ?? process.env.TASK_ID,
-    task: getArg(args2, "--task"),
-    fromStage: getArg(args2, "--from") ?? process.env.FROM_STAGE,
-    dryRun: hasFlag(args2, "--dry-run") || process.env.DRY_RUN === "true",
-    cwd: getArg(args2, "--cwd"),
+    taskId: getArg2(args2, "--task-id") ?? process.env.TASK_ID,
+    task: getArg2(args2, "--task"),
+    fromStage: getArg2(args2, "--from") ?? process.env.FROM_STAGE,
+    dryRun: hasFlag2(args2, "--dry-run") || process.env.DRY_RUN === "true",
+    cwd: getArg2(args2, "--cwd"),
     issueNumber: issueStr ? parseInt(issueStr, 10) : void 0,
     prNumber: prStr ? parseInt(prStr, 10) : void 0,
-    feedback: getArg(args2, "--feedback") ?? process.env.FEEDBACK,
-    local: localFlag || !isCI2 && !hasFlag(args2, "--no-local"),
-    complexity: getArg(args2, "--complexity") ?? process.env.COMPLEXITY,
-    ciRunId: getArg(args2, "--ci-run-id") ?? process.env.CI_RUN_ID
+    feedback: getArg2(args2, "--feedback") ?? process.env.FEEDBACK,
+    local: localFlag || !isCI2 && !hasFlag2(args2, "--no-local"),
+    complexity: getArg2(args2, "--complexity") ?? process.env.COMPLEXITY,
+    ciRunId: getArg2(args2, "--ci-run-id") ?? process.env.CI_RUN_ID
   };
 }
 var isCI2;
@@ -4033,183 +4655,9 @@ var init_args = __esm({
   }
 });
 
-// src/cli/litellm.ts
-import * as fs27 from "fs";
-import * as os from "os";
-import * as path24 from "path";
-import { execFileSync as execFileSync15 } from "child_process";
-async function checkLitellmHealth(url) {
-  try {
-    const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-async function checkModelHealth(baseUrl, apiKey, model = "claude-haiku-4-5") {
-  try {
-    const res = await fetch(`${baseUrl}/v1/messages`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model,
-        max_tokens: 4,
-        messages: [{ role: "user", content: "Reply with: ok" }]
-      }),
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!res.ok) {
-      const body2 = await res.text().catch(() => "");
-      return { ok: false, error: `HTTP ${res.status}: ${body2.slice(0, 200)}` };
-    }
-    const body = await res.json();
-    const hasAnthropicContent = Array.isArray(body.content) && body.content.some((b) => b.type === "text");
-    const hasThinkingContent = Array.isArray(body.content) && body.content.some((b) => b.type === "thinking");
-    const hasOpenAIContent = !!body.choices?.[0]?.message?.content;
-    if (!hasAnthropicContent && !hasThinkingContent && !hasOpenAIContent) {
-      return { ok: false, error: `Unexpected response format: ${JSON.stringify(body).slice(0, 200)}` };
-    }
-    return { ok: true };
-  } catch (err) {
-    return { ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-function generateLitellmConfig(provider, modelMap) {
-  const apiKeyVar = providerApiKeyEnvVar(provider);
-  const entries = ["model_list:"];
-  const seen = /* @__PURE__ */ new Set();
-  for (const providerModel of Object.values(modelMap)) {
-    if (seen.has(providerModel)) continue;
-    seen.add(providerModel);
-    entries.push(`  - model_name: ${providerModel}`);
-    entries.push(`    litellm_params:`);
-    entries.push(`      model: ${provider}/${providerModel}`);
-    entries.push(`      api_key: os.environ/${apiKeyVar}`);
-  }
-  return entries.join("\n") + "\n";
-}
-function generateLitellmConfigFromStages(defaultConfig, stages) {
-  const proxyModels = [];
-  if (defaultConfig && defaultConfig.provider !== "claude" && defaultConfig.provider !== "anthropic") {
-    proxyModels.push(defaultConfig);
-  }
-  if (stages) {
-    for (const sc of Object.values(stages)) {
-      if (sc.provider !== "claude" && sc.provider !== "anthropic") {
-        proxyModels.push(sc);
-      }
-    }
-  }
-  if (proxyModels.length === 0) return void 0;
-  const entries = ["model_list:"];
-  const seen = /* @__PURE__ */ new Set();
-  for (const { provider, model } of proxyModels) {
-    const key = `${provider}/${model}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    const apiKeyVar = providerApiKeyEnvVar(provider);
-    entries.push(`  - model_name: ${model}`);
-    entries.push(`    litellm_params:`);
-    entries.push(`      model: ${provider}/${model}`);
-    entries.push(`      api_key: os.environ/${apiKeyVar}`);
-  }
-  return entries.join("\n") + "\n";
-}
-async function tryStartLitellm(url, projectDir, generatedConfig) {
-  if (!generatedConfig) {
-    logger.warn("No provider configured in kody.config.json \u2014 cannot start LiteLLM proxy");
-    return null;
-  }
-  const configPath = path24.join(os.tmpdir(), "kody-litellm-config.yaml");
-  fs27.writeFileSync(configPath, generatedConfig);
-  const portMatch = url.match(/:(\d+)/);
-  const port = portMatch ? portMatch[1] : "4000";
-  let litellmFound = false;
-  try {
-    execFileSync15("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
-    litellmFound = true;
-  } catch {
-    try {
-      execFileSync15("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
-      litellmFound = true;
-    } catch {
-    }
-  }
-  if (!litellmFound) {
-    logger.warn("litellm not installed (pip install 'litellm[proxy]')");
-    return null;
-  }
-  logger.info(`Starting LiteLLM proxy on port ${port}...`);
-  let cmd;
-  let args2;
-  try {
-    execFileSync15("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
-    cmd = "litellm";
-    args2 = ["--config", configPath, "--port", port];
-  } catch {
-    cmd = "python3";
-    args2 = ["-m", "litellm", "--config", configPath, "--port", port];
-  }
-  const dotenvPath = path24.join(projectDir, ".env");
-  const dotenvVars = {};
-  if (fs27.existsSync(dotenvPath)) {
-    for (const rawLine of fs27.readFileSync(dotenvPath, "utf-8").split("\n")) {
-      const line = rawLine.trim();
-      if (!line || line.startsWith("#")) continue;
-      const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
-      if (match) {
-        let value = match[2].trim();
-        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-          value = value.slice(1, -1);
-        }
-        const commentIdx = value.indexOf(" #");
-        if (commentIdx !== -1) value = value.slice(0, commentIdx).trim();
-        if (value) dotenvVars[match[1]] = value;
-      }
-    }
-    if (Object.keys(dotenvVars).length > 0) {
-      logger.info(`  Loaded API keys: ${Object.keys(dotenvVars).join(", ")}`);
-    }
-  }
-  const { spawn: spawn2 } = await import("child_process");
-  const child = spawn2(cmd, args2, {
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: true,
-    env: { ...process.env, ...dotenvVars }
-  });
-  let proxyStderr = "";
-  child.stderr?.on("data", (chunk) => {
-    proxyStderr += chunk.toString();
-  });
-  for (let i = 0; i < 30; i++) {
-    await new Promise((r) => setTimeout(r, 2e3));
-    if (await checkLitellmHealth(url)) {
-      logger.info(`LiteLLM proxy ready at ${url}`);
-      return child;
-    }
-  }
-  if (proxyStderr) {
-    logger.warn(`LiteLLM stderr: ${proxyStderr.slice(-1e3)}`);
-  }
-  logger.warn("LiteLLM proxy failed to start within 60s");
-  child.kill();
-  return null;
-}
-var init_litellm = __esm({
-  "src/cli/litellm.ts"() {
-    "use strict";
-    init_logger();
-    init_config();
-  }
-});
-
 // src/cli/task-state.ts
-import * as fs28 from "fs";
-import * as path25 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()}` };
@@ -4241,11 +4689,11 @@ function resolveTaskAction(issueNumber, existingTaskId, existingState) {
 function resolveForIssue(issueNumber, projectDir) {
   const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
   if (existingTaskId) {
-    const statusPath = path25.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
+    const statusPath = path26.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs28.existsSync(statusPath)) {
+    if (fs29.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs28.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs29.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -4402,8 +4850,8 @@ var init_resolve = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs29 from "fs";
-import * as path26 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();
@@ -4458,9 +4906,9 @@ async function runModelHealthCheck(config) {
 }
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path26.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path27.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs29.existsSync(projectDir)) {
+    if (!fs30.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -4526,8 +4974,24 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path26.join(projectDir, ".kody", "tasks", taskId);
-  fs29.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) {
+      logger.info(`Resuming taskify run for ${marker.ticketId ?? marker.prdFile} with PM feedback`);
+      await taskifyCommand({
+        ticketId: marker.ticketId,
+        prdFile: marker.prdFile,
+        issueNumber: marker.issueNumber ?? input.issueNumber,
+        feedback: input.feedback,
+        local: input.local,
+        projectDir,
+        taskId
+      });
+      return;
+    }
+  }
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
@@ -4643,31 +5107,31 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs29.writeFileSync(path26.join(taskDir, "task.md"), input.task);
+    fs30.writeFileSync(path27.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path26.join(taskDir, "task.md");
-  if (!fs29.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 ?? ""}`;
-      fs29.writeFileSync(taskMdPath, taskContent);
+      fs30.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs29.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 ?? ""}`;
-      fs29.writeFileSync(taskMdPath, taskContent);
+      fs30.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs29.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);
   }
@@ -4805,7 +5269,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs29.readdirSync(taskDir);
+  const files = fs30.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -4851,6 +5315,7 @@ var init_entry = __esm({
     init_litellm();
     init_task_resolution();
     init_task_state();
+    init_taskify_command();
     init_config();
     main().catch(async (err) => {
       const msg = err instanceof Error ? err.message : String(err);
@@ -4869,9 +5334,9 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs30 from "fs";
-import * as path27 from "path";
-import { fileURLToPath } from "url";
+import * as fs31 from "fs";
+import * as path28 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/bin/commands/init.ts
 import * as fs3 from "fs";
@@ -5705,7 +6170,7 @@ ${repoContext}`;
     const output = execFileSync5("claude", [
       "--print",
       "--model",
-      "haiku",
+      "claude-haiku-4-5-20251001",
       "--dangerously-skip-permissions",
       memoryPrompt
     ], {
@@ -5808,7 +6273,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       const output = execFileSync5("claude", [
         "--print",
         "--model",
-        "haiku",
+        "claude-haiku-4-5-20251001",
         "--dangerously-skip-permissions",
         customizationPrompt
       ], {
@@ -6041,11 +6506,11 @@ Create it manually.`, cwd);
 
 // src/bin/cli.ts
 init_architecture_detection();
-var __dirname = path27.dirname(fileURLToPath(import.meta.url));
-var PKG_ROOT = path27.resolve(__dirname, "..", "..");
+var __dirname2 = path28.dirname(fileURLToPath2(import.meta.url));
+var PKG_ROOT = path28.resolve(__dirname2, "..", "..");
 function getVersion() {
-  const pkgPath = path27.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs30.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);
@@ -6054,6 +6519,8 @@ if (command === "init") {
   initCommand({ force: args.includes("--force") }, PKG_ROOT);
 } else if (command === "bootstrap") {
   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 === "ci-parse") {
   Promise.resolve().then(() => (init_parse_inputs(), parse_inputs_exports)).then(({ runCiParse: runCiParse2 }) => runCiParse2());
 } else if (command === "version" || command === "--version" || command === "-v") {