@kody-ade/kody-engine-lite 0.1.80 → 0.1.82

package/dist/bin/cli.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/agent-runner.ts
 import { spawn, execFileSync } from "child_process";
@@ -132,7 +137,7 @@ var init_agent_runner = __esm({
   "src/agent-runner.ts"() {
     "use strict";
     SIGKILL_GRACE_MS = 5e3;
-    STDERR_TAIL_CHARS = 500;
+    STDERR_TAIL_CHARS = 2e3;
     RUNNER_FACTORIES = {
       "claude-code": createClaudeCodeRunner
     };
@@ -277,7 +282,11 @@ function getProjectConfig() {
         quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
         git: { ...DEFAULT_CONFIG.git, ...raw.git },
         github: { ...DEFAULT_CONFIG.github, ...raw.github },
-        agent: { ...DEFAULT_CONFIG.agent, ...raw.agent },
+        agent: {
+          ...DEFAULT_CONFIG.agent,
+          ...raw.agent,
+          modelMap: { ...DEFAULT_CONFIG.agent.modelMap, ...raw.agent?.modelMap }
+        },
         contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers,
         mcp: raw.mcp ? { enabled: false, servers: {}, stages: ["build", "verify", "review", "review-fix"], ...raw.mcp } : void 0
       };
@@ -290,7 +299,7 @@ function getProjectConfig() {
   }
   return _config;
 }
-var DEFAULT_CONFIG, LITELLM_DEFAULT_PORT, LITELLM_DEFAULT_URL, TIER_TO_ANTHROPIC_IDS, VERIFY_COMMAND_TIMEOUT_MS, FIX_COMMAND_TIMEOUT_MS, _config, _configDir;
+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";
@@ -320,11 +329,6 @@ var init_config = __esm({
     };
     LITELLM_DEFAULT_PORT = 4e3;
     LITELLM_DEFAULT_URL = `http://localhost:${LITELLM_DEFAULT_PORT}`;
-    TIER_TO_ANTHROPIC_IDS = {
-      cheap: ["claude-haiku-4-5-20251001", "claude-haiku-4-5", "haiku"],
-      mid: ["claude-sonnet-4-6-20250514", "claude-sonnet-4-6", "sonnet"],
-      strong: ["claude-opus-4-6-20250514", "claude-opus-4-6", "opus"]
-    };
     VERIFY_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
     FIX_COMMAND_TIMEOUT_MS = 2 * 60 * 1e3;
     _config = null;
@@ -444,6 +448,41 @@ function syncWithDefault(cwd) {
     logger.warn(`  Merge conflict with origin/${defaultBranch} \u2014 skipping sync`);
   }
 }
+function mergeDefault(cwd) {
+  const defaultBranch = getDefaultBranch(cwd);
+  const current = getCurrentBranch(cwd);
+  if (current === defaultBranch) return "clean";
+  try {
+    git(["fetch", "origin", defaultBranch], { cwd, timeout: 3e4 });
+  } catch {
+    logger.warn("  Failed to fetch latest from origin");
+    return "error";
+  }
+  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 {
+    }
+    try {
+      git(["merge", "--abort"], { cwd });
+    } catch {
+    }
+    return "error";
+  }
+}
+function getConflictedFiles(cwd) {
+  try {
+    const output = git(["diff", "--name-only", "--diff-filter=U"], { cwd });
+    return output ? output.split("\n") : [];
+  } catch {
+    return [];
+  }
+}
 function commitAll(message, cwd) {
   const status = git(["status", "--porcelain"], { cwd });
   if (!status) {
@@ -1483,9 +1522,6 @@ ${prompt}` : prompt;
 }
 function resolveModel(modelTier, stageName) {
   const config = getProjectConfig();
-  if (config.agent.provider && config.agent.provider !== "anthropic") {
-    return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
-  }
   const mapped = config.agent.modelMap[modelTier];
   if (mapped) return mapped;
   return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
@@ -1836,8 +1872,8 @@ async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, mo
     `Stage: ${stageName}`,
     ``,
     `Error output:`,
-    errorOutput.slice(-2e3),
-    // Last 2000 chars of error
+    errorOutput.slice(-5e3),
+    // Last 5000 chars of error for accurate diagnosis
     ``,
     modifiedFiles.length > 0 ? `Files modified by build stage:
 ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (build may not have run yet)."
@@ -1884,13 +1920,21 @@ ${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (bui
 }
 function getModifiedFiles(projectDir) {
   try {
-    const output = execFileSync5("git", ["diff", "--name-only", "HEAD~1"], {
+    const staged = execFileSync5("git", ["diff", "--name-only", "--cached"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return output ? output.split("\n").filter(Boolean) : [];
+    const unstaged = execFileSync5("git", ["diff", "--name-only"], {
+      encoding: "utf-8",
+      cwd: projectDir,
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const all = `${staged}
+${unstaged}`.split("\n").filter(Boolean);
+    return [...new Set(all)];
   } catch {
     return [];
   }
@@ -2090,55 +2134,198 @@ var init_verify = __esm({
   }
 });
 
-// src/stages/review.ts
+// src/cli/task-resolution.ts
 import * as fs9 from "fs";
 import * as path9 from "path";
+import { execFileSync as execFileSync7 } from "child_process";
+function findLatestTaskForIssue(issueNumber, projectDir) {
+  const tasksDir = path9.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 branch = execFileSync7("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())}`;
+}
+var init_task_resolution = __esm({
+  "src/cli/task-resolution.ts"() {
+    "use strict";
+  }
+});
+
+// src/review-standalone.ts
+import * as fs10 from "fs";
+import * as path10 from "path";
+function resolveReviewTarget(input) {
+  if (input.prs.length === 0) {
+    return {
+      action: "none",
+      message: `Issue #${input.issueNumber} has no open PRs. Nothing to review.`
+    };
+  }
+  if (input.prs.length === 1) {
+    return { action: "review", prNumber: input.prs[0].number };
+  }
+  const prList = input.prs.map((pr) => `  - #${pr.number}: ${pr.title}`).join("\n");
+  return {
+    action: "pick",
+    prs: input.prs,
+    message: `\u26A0\uFE0F Issue #${input.issueNumber} has ${input.prs.length} open PRs:
+${prList}
+
+Run: \`pnpm kody review --pr-number <n>\`
+Or comment on the specific PR: \`@kody review\``
+  };
+}
+async function runStandaloneReview(input) {
+  const taskId = input.taskId ?? `review-${generateTaskId()}`;
+  const taskDir = path10.join(input.projectDir, ".kody", "tasks", taskId);
+  fs10.mkdirSync(taskDir, { recursive: true });
+  const taskContent = `# ${input.prTitle}
+
+${input.prBody ?? ""}`;
+  fs10.writeFileSync(path10.join(taskDir, "task.md"), taskContent);
+  const reviewDef = STAGES.find((s) => s.name === "review");
+  const ctx = {
+    taskId,
+    taskDir,
+    projectDir: input.projectDir,
+    runners: input.runners,
+    sessions: {},
+    input: {
+      mode: "full",
+      local: input.local
+    }
+  };
+  logger.info(`[review] standalone review for: ${input.prTitle}`);
+  const result = await executeAgentStage(ctx, reviewDef);
+  if (result.outcome !== "completed") {
+    return {
+      outcome: "failed",
+      taskDir,
+      error: result.error ?? "Review stage failed"
+    };
+  }
+  const reviewPath = path10.join(taskDir, "review.md");
+  let reviewContent;
+  if (fs10.existsSync(reviewPath)) {
+    reviewContent = fs10.readFileSync(reviewPath, "utf-8");
+  }
+  return {
+    outcome: "completed",
+    reviewContent,
+    taskDir
+  };
+}
+function detectReviewVerdict(reviewContent) {
+  const verdictMatch = reviewContent.match(/##\s*Verdict:\s*(PASS|FAIL)/i);
+  if (verdictMatch) {
+    return verdictMatch[1].toLowerCase();
+  }
+  const hasCritical = /###\s*Critical\s*\n(?!None\.)/i.test(reviewContent);
+  const hasMajor = /###\s*Major\s*\n(?!None\.)/i.test(reviewContent);
+  if (hasCritical || hasMajor) return "fail";
+  return "pass";
+}
+function formatReviewComment(reviewContent, taskId) {
+  const verdict = detectReviewVerdict(reviewContent);
+  const cta = verdict === "fail" ? "\n\n> To fix these issues, comment: `@kody fix`\n> The review findings will be used automatically as context." : "";
+  return `## \u{1F50D} Kody Review (\`${taskId}\`)
+
+${reviewContent}${cta}
+
+---
+\u{1F916} Generated by Kody`;
+}
+var init_review_standalone = __esm({
+  "src/review-standalone.ts"() {
+    "use strict";
+    init_definitions();
+    init_agent();
+    init_task_resolution();
+    init_logger();
+  }
+});
+
+// src/stages/review.ts
+import * as fs11 from "fs";
+import * as path11 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
   }
   const reviewDef = STAGES.find((s) => s.name === "review");
   const reviewFixDef = STAGES.find((s) => s.name === "review-fix");
-  const reviewResult = await executeAgentStage(ctx, reviewDef);
-  if (reviewResult.outcome !== "completed") {
-    return reviewResult;
-  }
-  const reviewFile = path9.join(ctx.taskDir, "review.md");
-  if (!fs9.existsSync(reviewFile)) {
-    return { outcome: "failed", retries: 0, error: "review.md not found" };
-  }
-  const content = fs9.readFileSync(reviewFile, "utf-8");
-  const hasIssues = /\bfail\b/i.test(content) && !/pass/i.test(content);
-  if (!hasIssues) {
-    return reviewResult;
-  }
-  logger.info(`  review found issues, running review-fix...`);
-  const fixResult = await executeAgentStage(ctx, reviewFixDef);
-  if (fixResult.outcome !== "completed") {
-    return fixResult;
+  for (let iteration = 0; iteration <= MAX_REVIEW_FIX_ITERATIONS; iteration++) {
+    const label = iteration === 0 ? "initial review" : `review after fix #${iteration}`;
+    logger.info(`  running ${label}...`);
+    const reviewResult = await executeAgentStage(ctx, reviewDef);
+    if (reviewResult.outcome !== "completed") {
+      return reviewResult;
+    }
+    const reviewFile = path11.join(ctx.taskDir, "review.md");
+    if (!fs11.existsSync(reviewFile)) {
+      return { outcome: "failed", retries: iteration, error: "review.md not found" };
+    }
+    const content = fs11.readFileSync(reviewFile, "utf-8");
+    if (detectReviewVerdict(content) !== "fail") {
+      return { ...reviewResult, retries: iteration };
+    }
+    if (iteration === MAX_REVIEW_FIX_ITERATIONS) {
+      logger.warn(`  review still failing after ${MAX_REVIEW_FIX_ITERATIONS} fix attempts`);
+      return { ...reviewResult, retries: iteration };
+    }
+    logger.info(`  review found issues (iteration ${iteration + 1}/${MAX_REVIEW_FIX_ITERATIONS}), running review-fix...`);
+    const fixResult = await executeAgentStage(ctx, reviewFixDef);
+    if (fixResult.outcome !== "completed") {
+      return fixResult;
+    }
   }
-  logger.info(`  re-running review after fix...`);
-  return executeAgentStage(ctx, reviewDef);
+  return { outcome: "failed", retries: MAX_REVIEW_FIX_ITERATIONS, error: "Unexpected review-fix loop exit" };
 }
+var MAX_REVIEW_FIX_ITERATIONS;
 var init_review = __esm({
   "src/stages/review.ts"() {
     "use strict";
     init_definitions();
     init_logger();
     init_agent();
+    init_review_standalone();
+    MAX_REVIEW_FIX_ITERATIONS = 2;
   }
 });
 
 // src/stages/ship.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
-import { execFileSync as execFileSync7 } from "child_process";
+import * as fs12 from "fs";
+import * as path12 from "path";
+import { execFileSync as execFileSync8 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path10.join(ctx.taskDir, "task.json");
-  if (fs10.existsSync(taskJsonPath)) {
+  const taskJsonPath = path12.join(ctx.taskDir, "task.json");
+  if (fs12.existsSync(taskJsonPath)) {
     try {
-      const raw = fs10.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs12.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -2157,9 +2344,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path10.join(ctx.taskDir, "review.md");
-  if (fs10.existsSync(reviewPath)) {
-    const review = fs10.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path12.join(ctx.taskDir, "review.md");
+  if (fs12.existsSync(reviewPath)) {
+    const review = fs12.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -2176,14 +2363,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path10.join(ctx.taskDir, "verify.md");
-  if (fs10.existsSync(verifyPath)) {
-    const verify = fs10.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path12.join(ctx.taskDir, "verify.md");
+  if (fs12.existsSync(verifyPath)) {
+    const verify = fs12.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path10.join(ctx.taskDir, "plan.md");
-  if (fs10.existsSync(planPath)) {
-    const plan = fs10.readFileSync(planPath, "utf-8").trim();
+  const planPath = path12.join(ctx.taskDir, "plan.md");
+  if (fs12.existsSync(planPath)) {
+    const plan = fs12.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -2203,25 +2390,25 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path10.join(ctx.taskDir, "ship.md");
+  const shipPath = path12.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs10.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs12.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) {
-    fs10.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs12.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 {
-      execFileSync7("git", ["add", ctx.taskDir], {
+      execFileSync8("git", ["add", ctx.taskDir], {
         cwd: ctx.projectDir,
         env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
         stdio: "pipe"
       });
-      execFileSync7("git", ["commit", "--no-gpg-sign", "-m", `chore: add kody task artifacts [skip ci]`], {
+      execFileSync8("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"
@@ -2235,7 +2422,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync7("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync8("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -2255,10 +2442,10 @@ function executeShipStage(ctx, _def) {
       docs: "docs",
       chore: "chore"
     };
-    const taskJsonPath = path10.join(ctx.taskDir, "task.json");
-    if (fs10.existsSync(taskJsonPath)) {
+    const taskJsonPath = path12.join(ctx.taskDir, "task.json");
+    if (fs12.existsSync(taskJsonPath)) {
       try {
-        const raw = fs10.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs12.readFileSync(taskJsonPath, "utf-8");
         const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
         const task = JSON.parse(cleaned);
         const prefix = TYPE_PREFIX[task.task_type] ?? "chore";
@@ -2268,9 +2455,9 @@ function executeShipStage(ctx, _def) {
       }
     }
     if (title === "Update") {
-      const taskMdPath = path10.join(ctx.taskDir, "task.md");
-      if (fs10.existsSync(taskMdPath)) {
-        const content = fs10.readFileSync(taskMdPath, "utf-8");
+      const taskMdPath = path12.join(ctx.taskDir, "task.md");
+      if (fs12.existsSync(taskMdPath)) {
+        const content = fs12.readFileSync(taskMdPath, "utf-8");
         const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#") && !l.startsWith("*"));
         if (firstLine) title = `chore: ${firstLine.trim()}`.slice(0, 72);
       }
@@ -2290,7 +2477,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs10.writeFileSync(shipPath, `# Ship
+      fs12.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -2311,19 +2498,19 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs10.writeFileSync(shipPath, `# Ship
+        fs12.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs10.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs12.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);
-    fs10.writeFileSync(shipPath, `# Ship
+    fs12.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
@@ -2369,15 +2556,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 function checkForQuestions(ctx, stageName) {
   if (ctx.input.local || !ctx.input.issueNumber) return false;
   try {
     if (stageName === "taskify") {
-      const taskJsonPath = path11.join(ctx.taskDir, "task.json");
-      if (!fs11.existsSync(taskJsonPath)) return false;
-      const raw = fs11.readFileSync(taskJsonPath, "utf-8");
+      const taskJsonPath = path13.join(ctx.taskDir, "task.json");
+      if (!fs13.existsSync(taskJsonPath)) return false;
+      const raw = fs13.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) {
@@ -2392,9 +2579,9 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
       }
     }
     if (stageName === "plan") {
-      const planPath = path11.join(ctx.taskDir, "plan.md");
-      if (!fs11.existsSync(planPath)) return false;
-      const plan = fs11.readFileSync(planPath, "utf-8");
+      const planPath = path13.join(ctx.taskDir, "plan.md");
+      if (!fs13.existsSync(planPath)) return false;
+      const plan = fs13.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -2423,8 +2610,8 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
   if (def.name === "build") setLifecycleLabel(ctx.input.issueNumber, "building");
@@ -2450,9 +2637,9 @@ function autoDetectComplexity(ctx, def) {
   if (def.name !== "taskify") return null;
   if (ctx.input.complexity) return null;
   try {
-    const taskJsonPath = path12.join(ctx.taskDir, "task.json");
-    if (!fs12.existsSync(taskJsonPath)) return null;
-    const raw = fs12.readFileSync(taskJsonPath, "utf-8");
+    const taskJsonPath = path14.join(ctx.taskDir, "task.json");
+    if (!fs14.existsSync(taskJsonPath)) return null;
+    const raw = fs14.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;
@@ -2482,8 +2669,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 = path12.join(ctx.taskDir, "plan.md");
-  const plan = fs12.existsSync(planPath) ? fs12.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const planPath = path14.join(ctx.taskDir, "plan.md");
+  const plan = fs14.existsSync(planPath) ? fs14.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -2550,22 +2737,22 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function autoLearn(ctx) {
   try {
-    const memoryDir = path13.join(ctx.projectDir, ".kody", "memory");
-    if (!fs13.existsSync(memoryDir)) {
-      fs13.mkdirSync(memoryDir, { recursive: true });
+    const memoryDir = path15.join(ctx.projectDir, ".kody", "memory");
+    if (!fs15.existsSync(memoryDir)) {
+      fs15.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path13.join(ctx.taskDir, "verify.md");
-    if (fs13.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs13.readFileSync(verifyPath, "utf-8"));
+    const verifyPath = path15.join(ctx.taskDir, "verify.md");
+    if (fs15.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs15.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");
@@ -2574,18 +2761,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 = path13.join(ctx.taskDir, "review.md");
-    if (fs13.existsSync(reviewPath)) {
-      const review = fs13.readFileSync(reviewPath, "utf-8");
+    const reviewPath = path15.join(ctx.taskDir, "review.md");
+    if (fs15.existsSync(reviewPath)) {
+      const review = fs15.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 = path13.join(ctx.taskDir, "task.json");
-    if (fs13.existsSync(taskJsonPath)) {
+    const taskJsonPath = path15.join(ctx.taskDir, "task.json");
+    if (fs15.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs13.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs15.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)) {
@@ -2596,13 +2783,13 @@ function autoLearn(ctx) {
       }
     }
     if (learnings.length > 0) {
-      const conventionsPath = path13.join(memoryDir, "conventions.md");
+      const conventionsPath = path15.join(memoryDir, "conventions.md");
       const entry = `
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs13.appendFileSync(conventionsPath, entry);
-      invalidateCache(conventionsPath, path13.join(memoryDir, ".tiers"));
+      fs15.appendFileSync(conventionsPath, entry);
+      invalidateCache(conventionsPath, path15.join(memoryDir, ".tiers"));
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnDecisions(ctx.taskDir, memoryDir, ctx.taskId, timestamp2);
@@ -2611,13 +2798,13 @@ ${learnings.join("\n")}
   }
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path13.join(memoryDir, "architecture.md");
-  if (fs13.existsSync(archPath)) return;
+  const archPath = path15.join(memoryDir, "architecture.md");
+  if (fs15.existsSync(archPath)) return;
   const detected = [];
-  const pkgPath = path13.join(projectDir, "package.json");
-  if (fs13.existsSync(pkgPath)) {
+  const pkgPath = path15.join(projectDir, "package.json");
+  if (fs15.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (allDeps.next) detected.push(`- Framework: Next.js ${allDeps.next}`);
       else if (allDeps.react) detected.push(`- Framework: React ${allDeps.react}`);
@@ -2633,15 +2820,15 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
       if (allDeps.payload || allDeps["@payloadcms/next"]) detected.push(`- CMS: Payload CMS`);
       if (pkg.type === "module") detected.push("- Module system: ESM");
       else detected.push("- Module system: CommonJS");
-      if (fs13.existsSync(path13.join(projectDir, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs13.existsSync(path13.join(projectDir, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs13.existsSync(path13.join(projectDir, "package-lock.json"))) detected.push("- Package manager: npm");
+      if (fs15.existsSync(path15.join(projectDir, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
+      else if (fs15.existsSync(path15.join(projectDir, "yarn.lock"))) detected.push("- Package manager: yarn");
+      else if (fs15.existsSync(path15.join(projectDir, "package-lock.json"))) detected.push("- Package manager: npm");
     } catch {
     }
   }
   const topDirs = [];
   try {
-    const entries = fs13.readdirSync(projectDir, { withFileTypes: true });
+    const entries = fs15.readdirSync(projectDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         topDirs.push(entry.name);
@@ -2650,10 +2837,10 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
     if (topDirs.length > 0) detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
   } catch {
   }
-  const srcDir = path13.join(projectDir, "src");
-  if (fs13.existsSync(srcDir)) {
+  const srcDir = path15.join(projectDir, "src");
+  if (fs15.existsSync(srcDir)) {
     try {
-      const srcEntries = fs13.readdirSync(srcDir, { withFileTypes: true });
+      const srcEntries = fs15.readdirSync(srcDir, { withFileTypes: true });
       const srcDirs = srcEntries.filter((e) => e.isDirectory()).map((e) => e.name);
       if (srcDirs.length > 0) detected.push(`- src/ structure: ${srcDirs.join(", ")}`);
     } catch {
@@ -2665,15 +2852,15 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs13.writeFileSync(archPath, content);
-    invalidateCache(archPath, path13.join(memoryDir, ".tiers"));
+    fs15.writeFileSync(archPath, content);
+    invalidateCache(archPath, path15.join(memoryDir, ".tiers"));
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
 function autoLearnDecisions(taskDir, memoryDir, taskId, timestamp2) {
-  const reviewPath = path13.join(taskDir, "review.md");
-  if (!fs13.existsSync(reviewPath)) return;
-  const review = fs13.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path15.join(taskDir, "review.md");
+  if (!fs15.existsSync(reviewPath)) return;
+  const review = fs15.readFileSync(reviewPath, "utf-8");
   const decisions = [];
   const existingPatternRe = /(?:use|follow|reuse|match|adopt)\s+(?:the\s+)?existing\s+(.+?)(?:\.|$)/gim;
   for (const match of review.matchAll(existingPatternRe)) {
@@ -2692,10 +2879,10 @@ function autoLearnDecisions(taskDir, memoryDir, taskId, timestamp2) {
     decisions.push(`- Avoid ${match[1].trim()} for ${match[2].trim()}`);
   }
   if (decisions.length === 0) return;
-  const decisionsPath = path13.join(memoryDir, "decisions.md");
+  const decisionsPath = path15.join(memoryDir, "decisions.md");
   let existing = "";
-  if (fs13.existsSync(decisionsPath)) {
-    existing = fs13.readFileSync(decisionsPath, "utf-8");
+  if (fs15.existsSync(decisionsPath)) {
+    existing = fs15.readFileSync(decisionsPath, "utf-8");
   } else {
     existing = "# Architectural Decisions\n\nDecisions extracted from code reviews. The planning agent MUST follow these.\n";
   }
@@ -2705,8 +2892,8 @@ function autoLearnDecisions(taskDir, memoryDir, taskId, timestamp2) {
 ## From task ${taskId} (${timestamp2})
 ${newDecisions.join("\n")}
 `;
-  fs13.appendFileSync(decisionsPath, existing ? entry : existing + entry);
-  invalidateCache(decisionsPath, path13.join(memoryDir, ".tiers"));
+  fs15.appendFileSync(decisionsPath, existing ? entry : existing + entry);
+  invalidateCache(decisionsPath, path15.join(memoryDir, ".tiers"));
   logger.info(`Auto-learned ${newDecisions.length} architectural decision(s)`);
 }
 var init_auto_learn = __esm({
@@ -2718,13 +2905,13 @@ var init_auto_learn = __esm({
 });
 
 // src/retrospective.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
 function readArtifact(taskDir, filename, maxChars) {
-  const p = path14.join(taskDir, filename);
-  if (!fs14.existsSync(p)) return null;
+  const p = path16.join(taskDir, filename);
+  if (!fs16.existsSync(p)) return null;
   try {
-    const content = fs14.readFileSync(p, "utf-8");
+    const content = fs16.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -2777,13 +2964,13 @@ function collectRunContext(ctx, state, pipelineStartTime) {
   return lines.join("\n");
 }
 function getLogPath(projectDir) {
-  return path14.join(projectDir, ".kody", "memory", "observer-log.jsonl");
+  return path16.join(projectDir, ".kody", "memory", "observer-log.jsonl");
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs14.existsSync(logPath)) return [];
+  if (!fs16.existsSync(logPath)) return [];
   try {
-    const content = fs14.readFileSync(logPath, "utf-8");
+    const content = fs16.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -2810,11 +2997,11 @@ function formatPreviousEntries(entries) {
 }
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
-  const dir = path14.dirname(logPath);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path16.dirname(logPath);
+  if (!fs16.existsSync(dir)) {
+    fs16.mkdirSync(dir, { recursive: true });
   }
-  fs14.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs16.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -2925,14 +3112,22 @@ If no pipeline flaw is detected, set "pipelineFlaw" to null.
 });
 
 // src/pipeline.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path17 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
-  if (ctx.input.prNumber) return;
-  if (!ctx.input.issueNumber || ctx.input.dryRun) return;
+  if (ctx.input.dryRun) return;
+  if (ctx.input.prNumber) {
+    try {
+      syncWithDefault(ctx.projectDir);
+    } catch (err) {
+      logger.warn(`  Failed to sync with default branch: ${err}`);
+    }
+    return;
+  }
+  if (!ctx.input.issueNumber) return;
   try {
-    const taskMdPath = path15.join(ctx.taskDir, "task.md");
-    const title = fs15.existsSync(taskMdPath) ? fs15.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const taskMdPath = path17.join(ctx.taskDir, "task.md");
+    const title = fs17.existsSync(taskMdPath) ? fs17.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
@@ -2940,10 +3135,10 @@ function ensureFeatureBranchIfNeeded(ctx) {
   }
 }
 function acquireLock(taskDir) {
-  const lockPath = path15.join(taskDir, ".lock");
-  if (fs15.existsSync(lockPath)) {
+  const lockPath = path17.join(taskDir, ".lock");
+  if (fs17.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs15.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs17.readFileSync(lockPath, "utf-8").trim(), 10);
       try {
         process.kill(pid, 0);
         throw new Error(`Pipeline already running (PID ${pid})`);
@@ -2954,11 +3149,11 @@ function acquireLock(taskDir) {
       if (e instanceof Error && e.message.startsWith("Pipeline already")) throw e;
     }
   }
-  fs15.writeFileSync(lockPath, String(process.pid));
+  fs17.writeFileSync(lockPath, String(process.pid));
 }
 function releaseLock(taskDir) {
   try {
-    fs15.unlinkSync(path15.join(taskDir, ".lock"));
+    fs17.unlinkSync(path17.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -3126,8 +3321,8 @@ var init_pipeline = __esm({
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync8 } from "child_process";
-import * as fs16 from "fs";
+import { execFileSync as execFileSync9 } from "child_process";
+import * as fs18 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -3139,7 +3334,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync8("claude", ["--version"], {
+      const v = execFileSync9("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3147,14 +3342,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync8("git", ["rev-parse", "--is-inside-work-tree"], {
+      execFileSync9("git", ["rev-parse", "--is-inside-work-tree"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
     }),
     check("pnpm", () => {
-      const v = execFileSync8("pnpm", ["--version"], {
+      const v = execFileSync9("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3162,7 +3357,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync8("node", ["--version"], {
+      const v = execFileSync9("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3172,7 +3367,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync8("gh", ["--version"], {
+      const v = execFileSync9("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -3180,7 +3375,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs16.existsSync("package.json")) throw new Error("not found");
+      if (!fs18.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -3200,140 +3395,6 @@ var init_preflight = __esm({
   }
 });
 
-// src/cli/task-resolution.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
-import { execFileSync as execFileSync9 } from "child_process";
-function findLatestTaskForIssue(issueNumber, projectDir) {
-  const tasksDir = path16.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 = execFileSync9("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())}`;
-}
-var init_task_resolution = __esm({
-  "src/cli/task-resolution.ts"() {
-    "use strict";
-  }
-});
-
-// src/review-standalone.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
-function resolveReviewTarget(input) {
-  if (input.prs.length === 0) {
-    return {
-      action: "none",
-      message: `Issue #${input.issueNumber} has no open PRs. Nothing to review.`
-    };
-  }
-  if (input.prs.length === 1) {
-    return { action: "review", prNumber: input.prs[0].number };
-  }
-  const prList = input.prs.map((pr) => `  - #${pr.number}: ${pr.title}`).join("\n");
-  return {
-    action: "pick",
-    prs: input.prs,
-    message: `\u26A0\uFE0F Issue #${input.issueNumber} has ${input.prs.length} open PRs:
-${prList}
-
-Run: \`pnpm kody review --pr-number <n>\`
-Or comment on the specific PR: \`@kody review\``
-  };
-}
-async function runStandaloneReview(input) {
-  const taskId = input.taskId ?? `review-${generateTaskId()}`;
-  const taskDir = path17.join(input.projectDir, ".kody", "tasks", taskId);
-  fs18.mkdirSync(taskDir, { recursive: true });
-  const taskContent = `# ${input.prTitle}
-
-${input.prBody ?? ""}`;
-  fs18.writeFileSync(path17.join(taskDir, "task.md"), taskContent);
-  const reviewDef = STAGES.find((s) => s.name === "review");
-  const ctx = {
-    taskId,
-    taskDir,
-    projectDir: input.projectDir,
-    runners: input.runners,
-    sessions: {},
-    input: {
-      mode: "full",
-      local: input.local
-    }
-  };
-  logger.info(`[review] standalone review for: ${input.prTitle}`);
-  const result = await executeAgentStage(ctx, reviewDef);
-  if (result.outcome !== "completed") {
-    return {
-      outcome: "failed",
-      taskDir,
-      error: result.error ?? "Review stage failed"
-    };
-  }
-  const reviewPath = path17.join(taskDir, "review.md");
-  let reviewContent;
-  if (fs18.existsSync(reviewPath)) {
-    reviewContent = fs18.readFileSync(reviewPath, "utf-8");
-  }
-  return {
-    outcome: "completed",
-    reviewContent,
-    taskDir
-  };
-}
-function detectReviewVerdict(reviewContent) {
-  const verdictMatch = reviewContent.match(/##\s*Verdict:\s*(PASS|FAIL)/i);
-  if (verdictMatch) {
-    return verdictMatch[1].toLowerCase();
-  }
-  const hasCritical = /###\s*Critical\s*\n(?!None\.)/i.test(reviewContent);
-  const hasMajor = /###\s*Major\s*\n(?!None\.)/i.test(reviewContent);
-  if (hasCritical || hasMajor) return "fail";
-  return "pass";
-}
-function formatReviewComment(reviewContent, taskId) {
-  const verdict = detectReviewVerdict(reviewContent);
-  const cta = verdict === "fail" ? "\n\n> To fix these issues, comment: `@kody fix`\n> The review findings will be used automatically as context." : "";
-  return `## \u{1F50D} Kody Review (\`${taskId}\`)
-
-${reviewContent}${cta}
-
----
-\u{1F916} Generated by Kody`;
-}
-var init_review_standalone = __esm({
-  "src/review-standalone.ts"() {
-    "use strict";
-    init_definitions();
-    init_agent();
-    init_task_resolution();
-    init_logger();
-  }
-});
-
 // src/cli/args.ts
 function getArg(args2, flag) {
   const idx = args2.indexOf(flag);
@@ -3354,12 +3415,13 @@ function parseArgs() {
   kody fix    --task-id <id> [--cwd <path>] [--issue-number <n>] [--feedback "<text>"]
   kody fix-ci [--pr-number <n>] [--ci-run-id <id>] [--cwd <path>] [--issue-number <n>] [--feedback "<text>"]
   kody review [--pr-number <n>] [--issue-number <n>] [--cwd <path>] [--local]
+  kody resolve --pr-number <n> [--cwd <path>] [--local]
   kody status --task-id <id> [--cwd <path>]
   kody --help`);
     process.exit(0);
   }
   const command2 = args2[0];
-  if (!["run", "rerun", "fix", "fix-ci", "status", "review"].includes(command2)) {
+  if (!["run", "rerun", "fix", "fix-ci", "status", "review", "resolve"].includes(command2)) {
     console.error(`Unknown command: ${command2}`);
     process.exit(1);
   }
@@ -3437,15 +3499,14 @@ async function checkModelHealth(baseUrl, apiKey, model = "claude-haiku-4-5") {
 function generateLitellmConfig(provider, modelMap) {
   const apiKeyVar = providerApiKeyEnvVar(provider);
   const entries = ["model_list:"];
-  for (const [tier, providerModel] of Object.entries(modelMap)) {
-    const anthropicIds = TIER_TO_ANTHROPIC_IDS[tier];
-    if (!anthropicIds) continue;
-    for (const modelName of anthropicIds) {
-      entries.push(`  - model_name: ${modelName}`);
-      entries.push(`    litellm_params:`);
-      entries.push(`      model: ${provider}/${providerModel}`);
-      entries.push(`      api_key: os.environ/${apiKeyVar}`);
-    }
+  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";
 }
@@ -3593,6 +3654,133 @@ var init_task_state = __esm({
   }
 });
 
+// src/resolve.ts
+var resolve_exports = {};
+__export(resolve_exports, {
+  runResolve: () => runResolve
+});
+import { execFileSync as execFileSync11 } from "child_process";
+function getConflictContext(cwd, files) {
+  const parts = [];
+  for (const file of files.slice(0, 10)) {
+    try {
+      const content = execFileSync11("git", ["diff", file], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      parts.push(`### ${file}
+\`\`\`diff
+${content.slice(0, 3e3)}
+\`\`\``);
+    } catch {
+      parts.push(`### ${file}
+(could not read diff)`);
+    }
+  }
+  return parts.join("\n\n");
+}
+async function runResolve(options) {
+  const { prNumber, projectDir, runners, local } = options;
+  const defaultBranch = getDefaultBranch(projectDir);
+  logger.info(`Resolving PR #${prNumber} \u2014 merging ${defaultBranch}...`);
+  const mergeResult = mergeDefault(projectDir);
+  if (mergeResult === "error") {
+    return { outcome: "failed", error: "Failed to merge default branch" };
+  }
+  if (mergeResult === "clean") {
+    logger.info("  Clean merge \u2014 no conflicts");
+    if (!local) {
+      pushBranch(projectDir);
+    }
+    return { outcome: "merged" };
+  }
+  const conflictedFiles = getConflictedFiles(projectDir);
+  if (conflictedFiles.length === 0) {
+    return { outcome: "failed", error: "Merge reported conflict but no conflicted files found" };
+  }
+  logger.info(`  ${conflictedFiles.length} conflicted file(s): ${conflictedFiles.join(", ")}`);
+  const conflictContext = getConflictContext(projectDir, conflictedFiles);
+  const prompt = buildResolvePrompt(conflictedFiles, conflictContext, defaultBranch);
+  const config = getProjectConfig();
+  const runnerName = config.agent.defaultRunner ?? Object.keys(runners)[0] ?? "claude";
+  const runner = runners[runnerName];
+  if (!runner) {
+    return { outcome: "failed", error: `Runner "${runnerName}" not found` };
+  }
+  const model = resolveModel("mid");
+  const extraEnv = {};
+  if (needsLitellmProxy(config)) {
+    extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
+  }
+  logger.info(`  Running agent to resolve conflicts (model=${model})...`);
+  const result = await runner.run("resolve", prompt, model, 3e5, projectDir, {
+    cwd: projectDir,
+    env: extraEnv
+  });
+  if (result.outcome !== "completed") {
+    return { outcome: "failed", error: `Agent failed: ${result.error}` };
+  }
+  logger.info("  Verifying resolution...");
+  const verify = runQualityGates(projectDir, projectDir);
+  if (!verify.pass) {
+    const errorSummary = verify.errors.slice(0, 5).join("\n");
+    logger.error(`  Verification failed:
+${errorSummary}`);
+    return { outcome: "failed", error: `Conflict resolution failed verification:
+${errorSummary}` };
+  }
+  logger.info("  Verification passed");
+  commitAll(`chore: resolve merge conflicts with ${defaultBranch}`, projectDir);
+  if (!local) {
+    pushBranch(projectDir);
+    try {
+      const fileList = conflictedFiles.map((f) => `- \`${f}\``).join("\n");
+      postPRComment(
+        prNumber,
+        `\u2705 **Merge conflicts resolved** with \`${defaultBranch}\`
+
+**Conflicted files:**
+${fileList}
+
+_Verification passed. Please review the resolution._`
+      );
+    } catch {
+    }
+  }
+  return { outcome: "resolved" };
+}
+function buildResolvePrompt(files, conflictContext, defaultBranch) {
+  return `You are resolving merge conflicts between a feature branch and the \`${defaultBranch}\` branch.
+
+## Conflicted files
+${files.map((f) => `- ${f}`).join("\n")}
+
+## Conflict diffs
+${conflictContext}
+
+## Instructions
+1. Read each conflicted file
+2. Resolve the conflict markers (<<<<<<< / ======= / >>>>>>>) by combining both sides correctly:
+   - For feature/business logic: preserve the PR branch's intent
+   - For infrastructure/config/dependencies: prefer the \`${defaultBranch}\` branch
+   - For imports/types: merge both sides
+3. Write the resolved file using the Edit or Write tool
+4. Do NOT add new features or refactor \u2014 only resolve the conflicts
+5. After resolving all files, run \`git add .\` to stage the resolution`;
+}
+var init_resolve = __esm({
+  "src/resolve.ts"() {
+    "use strict";
+    init_git_utils();
+    init_github_api();
+    init_verify_runner();
+    init_logger();
+    init_context();
+    init_config();
+  }
+});
+
 // src/entry.ts
 var entry_exports = {};
 import * as fs21 from "fs";
@@ -3638,7 +3826,7 @@ async function runModelHealthCheck(config) {
     logger.warn(`Skipping model health check \u2014 ${keyName} not set`);
     return;
   }
-  const model = usesProxy ? "claude-haiku-4-5" : config.agent.modelMap.cheap;
+  const model = config.agent.modelMap.cheap;
   logger.info(`Model health check (${model} via ${usesProxy ? "LiteLLM" : "Anthropic"})...`);
   const result = await checkModelHealth(baseUrl, apiKey, model);
   if (result.ok) {
@@ -3771,7 +3959,6 @@ async function main() {
       console.log(result.reviewContent);
       if (!input.local && prNumber) {
         const comment = formatReviewComment(result.reviewContent, taskId);
-        postPRComment(prNumber, comment);
         const verdict = detectReviewVerdict(result.reviewContent);
         if (verdict === "fail") {
           submitPRReview(prNumber, comment, "request-changes");
@@ -3782,6 +3969,42 @@ async function main() {
     }
     process.exit(0);
   }
+  if (input.command === "resolve") {
+    if (!input.prNumber) {
+      console.error("--pr-number is required for resolve command");
+      process.exit(1);
+    }
+    runPreflight();
+    const config2 = getProjectConfig();
+    const litellmProcess2 = await ensureLitellmProxy(config2, projectDir);
+    await runModelHealthCheck(config2);
+    const runners2 = createRunners(config2);
+    const defaultRunnerName2 = config2.agent.defaultRunner ?? Object.keys(runners2)[0] ?? "claude";
+    const defaultRunner2 = runners2[defaultRunnerName2];
+    if (!defaultRunner2) {
+      console.error(`Default runner "${defaultRunnerName2}" not configured`);
+      process.exit(1);
+    }
+    const healthy2 = await defaultRunner2.healthCheck();
+    if (!healthy2) {
+      console.error(`Runner "${defaultRunnerName2}" health check failed`);
+      process.exit(1);
+    }
+    const { runResolve: runResolve2 } = await Promise.resolve().then(() => (init_resolve(), resolve_exports));
+    const result = await runResolve2({
+      prNumber: input.prNumber,
+      projectDir,
+      runners: runners2,
+      local: input.local ?? true
+    });
+    if (litellmProcess2) litellmProcess2.kill?.();
+    if (result.outcome === "failed") {
+      console.error(`Resolve failed: ${result.error}`);
+      process.exit(1);
+    }
+    console.log(`Resolve: ${result.outcome}`);
+    process.exit(0);
+  }
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
@@ -4001,7 +4224,7 @@ var init_entry = __esm({
 // src/bin/cli.ts
 import * as fs22 from "fs";
 import * as path21 from "path";
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 import { fileURLToPath } from "url";
 var __dirname = path21.dirname(fileURLToPath(import.meta.url));
 var PKG_ROOT = path21.resolve(__dirname, "..", "..");
@@ -4012,7 +4235,7 @@ function getVersion() {
 }
 function checkCommand2(name, args2, fix) {
   try {
-    const output = execFileSync11(name, args2, {
+    const output = execFileSync12(name, args2, {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4030,7 +4253,7 @@ function checkFile(filePath, description, fix) {
 }
 function checkGhAuth(cwd) {
   try {
-    const output = execFileSync11("gh", ["auth", "status"], {
+    const output = execFileSync12("gh", ["auth", "status"], {
       encoding: "utf-8",
       timeout: 1e4,
       cwd,
@@ -4048,7 +4271,7 @@ function checkGhAuth(cwd) {
 }
 function checkGhRepoAccess(cwd) {
   try {
-    const remote = execFileSync11("git", ["remote", "get-url", "origin"], {
+    const remote = execFileSync12("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4059,7 +4282,7 @@ function checkGhRepoAccess(cwd) {
       return { name: "GitHub repo", ok: false, fix: "Set git remote origin to a GitHub URL" };
     }
     const repoSlug = `${match[1]}/${match[2]}`;
-    execFileSync11("gh", ["repo", "view", repoSlug, "--json", "name"], {
+    execFileSync12("gh", ["repo", "view", repoSlug, "--json", "name"], {
       encoding: "utf-8",
       timeout: 1e4,
       cwd,
@@ -4072,7 +4295,7 @@ function checkGhRepoAccess(cwd) {
 }
 function checkGhSecret(repoSlug, secretName) {
   try {
-    const output = execFileSync11("gh", ["secret", "list", "--repo", repoSlug], {
+    const output = execFileSync12("gh", ["secret", "list", "--repo", repoSlug], {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4100,7 +4323,7 @@ function detectBasicConfig(cwd) {
   else if (!fs22.existsSync(path21.join(cwd, "pnpm-lock.yaml")) && fs22.existsSync(path21.join(cwd, "package-lock.json"))) pm = "npm";
   let defaultBranch = "main";
   try {
-    const ref = execFileSync11("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync12("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4109,7 +4332,7 @@ function detectBasicConfig(cwd) {
     defaultBranch = ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      execFileSync11("git", ["rev-parse", "--verify", "origin/dev"], {
+      execFileSync12("git", ["rev-parse", "--verify", "origin/dev"], {
         encoding: "utf-8",
         timeout: 5e3,
         cwd,
@@ -4122,7 +4345,7 @@ function detectBasicConfig(cwd) {
   let owner = "";
   let repo = "";
   try {
-    const remote = execFileSync11("git", ["remote", "get-url", "origin"], {
+    const remote = execFileSync12("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -4314,7 +4537,7 @@ function initCommand(opts) {
   if (filesToCommit.length > 0) {
     try {
       const fullPaths = filesToCommit.map((f) => path21.join(cwd, f));
-      execFileSync11("npx", ["prettier", "--write", ...fullPaths], {
+      execFileSync12("npx", ["prettier", "--write", ...fullPaths], {
         cwd,
         encoding: "utf-8",
         timeout: 3e4,
@@ -4325,13 +4548,13 @@ function initCommand(opts) {
   }
   if (filesToCommit.length > 0) {
     try {
-      execFileSync11("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-      const staged = execFileSync11("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+      execFileSync12("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+      const staged = execFileSync12("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
       if (staged) {
-        execFileSync11("git", ["commit", "-m", "chore: Add Kody Engine workflow and config\n\nAdd GitHub Actions workflow and auto-detected configuration for Kody Engine Lite."], { cwd, stdio: "pipe" });
+        execFileSync12("git", ["commit", "-m", "chore: Add Kody Engine workflow and config\n\nAdd GitHub Actions workflow and auto-detected configuration for Kody Engine Lite."], { cwd, stdio: "pipe" });
         console.log(`  \u2713 Committed: ${filesToCommit.join(", ")}`);
         try {
-          execFileSync11("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
+          execFileSync12("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
           console.log("  \u2713 Pushed to origin");
         } catch {
           console.log("  \u25CB Push failed \u2014 run 'git push' manually");
@@ -4425,7 +4648,7 @@ function ghComment(issueNumber, body, cwd) {
     } catch {
     }
     if (!repoSlug) return;
-    execFileSync11("gh", [
+    execFileSync12("gh", [
       "issue",
       "comment",
       String(issueNumber),
@@ -4558,7 +4781,7 @@ Output ONLY valid JSON. No markdown fences. No explanation.
 ${repoContext}`;
   console.log("  \u23F3 Analyzing project...");
   try {
-    const output = execFileSync11("claude", [
+    const output = execFileSync12("claude", [
       "--print",
       "--model",
       "haiku",
@@ -4661,7 +4884,7 @@ ${repoContext}
 
 REMINDER: Output the full prompt template first (unchanged), then your three appended sections. Do NOT include "${contextPlaceholder}".`;
     try {
-      const output = execFileSync11("claude", [
+      const output = execFileSync12("claude", [
         "--print",
         "--model",
         "haiku",
@@ -4718,7 +4941,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       ];
       for (const label of labels) {
         try {
-          execFileSync11("gh", [
+          execFileSync12("gh", [
             "label",
             "create",
             label.name,
@@ -4738,7 +4961,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
           console.log(`  \u2713 ${label.name}`);
         } catch {
           try {
-            execFileSync11("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
+            execFileSync12("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
               cwd,
               encoding: "utf-8",
               timeout: 1e4,
@@ -4777,7 +5000,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
     try {
       const fullPaths = filesToCommit.map((f) => path21.join(cwd, f));
       for (let pass = 0; pass < 2; pass++) {
-        execFileSync11("npx", ["prettier", "--write", ...fullPaths], {
+        execFileSync12("npx", ["prettier", "--write", ...fullPaths], {
           cwd,
           encoding: "utf-8",
           timeout: 3e4,
@@ -4793,12 +5016,12 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
     try {
       if (isCI3) {
         const branchName = `kody-bootstrap-${Date.now()}`;
-        execFileSync11("git", ["checkout", "-b", branchName], { cwd, stdio: "pipe" });
-        execFileSync11("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-        const staged = execFileSync11("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+        execFileSync12("git", ["checkout", "-b", branchName], { cwd, stdio: "pipe" });
+        execFileSync12("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+        const staged = execFileSync12("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
         if (staged) {
-          execFileSync11("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
-          execFileSync11("git", ["push", "-u", "origin", branchName], { cwd, stdio: "pipe", timeout: 6e4 });
+          execFileSync12("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
+          execFileSync12("git", ["push", "-u", "origin", branchName], { cwd, stdio: "pipe", timeout: 6e4 });
           console.log(`  \u2713 Pushed branch: ${branchName}`);
           let baseBranch = "main";
           try {
@@ -4810,7 +5033,7 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
           } catch {
           }
           try {
-            const prUrl = execFileSync11("gh", [
+            const prUrl = execFileSync12("gh", [
               "pr",
               "create",
               "--title",
@@ -4849,13 +5072,13 @@ Create it manually.`, cwd);
           console.log("  \u25CB No new changes to commit");
         }
       } else {
-        execFileSync11("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
-        const staged = execFileSync11("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
+        execFileSync12("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });
+        const staged = execFileSync12("git", ["diff", "--cached", "--name-only"], { cwd, encoding: "utf-8" }).trim();
         if (staged) {
-          execFileSync11("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
+          execFileSync12("git", ["commit", "-m", "chore: Add Kody project memory and step files\n\nBootstrap Kody Engine with project-specific architecture, conventions, and pipeline step files."], { cwd, stdio: "pipe" });
           console.log(`  \u2713 Committed: ${filesToCommit.join(", ")}`);
           try {
-            execFileSync11("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
+            execFileSync12("git", ["push"], { cwd, stdio: "pipe", timeout: 6e4 });
             console.log("  \u2713 Pushed to origin");
           } catch {
             console.log("  \u25CB Push failed \u2014 run 'git push' manually");
@@ -4976,7 +5199,7 @@ function installSkillsForProject(cwd) {
     }
     try {
       console.log(`  Installing: ${skill.label} (${skill.package})`);
-      execFileSync11("npx", ["skills", "add", skill.package, "--yes"], {
+      execFileSync12("npx", ["skills", "add", skill.package, "--yes"], {
         cwd,
         encoding: "utf-8",
         timeout: 6e4,