@kody-ade/kody-engine-lite 0.1.104 → 0.1.106

package/dist/bin/cli.js

@@ -64,6 +64,193 @@ 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}`;
+}
+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"
+    };
+  }
+  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"
+    };
+  }
+  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];
+  }
+  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()}`;
+  }
+  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);
+  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"
+  };
+}
+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}`);
+  }
+  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);
+}
+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"
+    ];
+  }
+});
+
 // src/agent-runner.ts
 import { spawn, execFileSync as execFileSync6 } from "child_process";
 function writeStdin(child, prompt) {
@@ -395,11 +582,36 @@ var init_validators = __esm({
 });
 
 // src/config.ts
-import * as fs8 from "fs";
+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`);
+  }
+  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;
 }
@@ -414,9 +626,9 @@ function setConfigDir(dir) {
 function getProjectConfig() {
   if (_config) return _config;
   const configPath = path7.join(_configDir ?? process.cwd(), "kody.config.json");
-  if (fs8.existsSync(configPath)) {
+  if (fs9.existsSync(configPath)) {
     try {
-      const result = parseJsonSafe(fs8.readFileSync(configPath, "utf-8"));
+      const result = parseJsonSafe(fs9.readFileSync(configPath, "utf-8"));
       if (!result.ok) {
         logger.warn(`kody.config.json: ${result.error} \u2014 using defaults`);
         _config = { ...DEFAULT_CONFIG };
@@ -652,6 +864,17 @@ function commitAll(message, cwd) {
   logger.info(`  Committed: ${hash} ${message}`);
   return { success: true, hash, message };
 }
+function getDiffFiles(baseBranch, cwd) {
+  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 [];
+  }
+}
 function pushBranch(cwd) {
   try {
     git(["push", "-u", "origin", "HEAD"], { cwd, timeout: 12e4 });
@@ -730,6 +953,19 @@ function getIssue(issueNumber) {
     return null;
   }
 }
+function getIssueComments(issueNumber) {
+  try {
+    const output = gh([
+      "api",
+      `repos/{owner}/{repo}/issues/${issueNumber}/comments`,
+      "--jq",
+      "[.[] | {body, created_at}]"
+    ]);
+    return output ? JSON.parse(output) : [];
+  } catch {
+    return [];
+  }
+}
 function getIssueLabels(issueNumber) {
   try {
     const output = gh(["issue", "view", String(issueNumber), "--json", "labels", "--jq", ".labels[].name"]);
@@ -1059,14 +1295,14 @@ var init_github_api = __esm({
 });
 
 // src/pipeline/state.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path8 from "path";
 function loadState(taskId, taskDir) {
   const p = path8.join(taskDir, "status.json");
-  if (!fs9.existsSync(p)) return null;
+  if (!fs10.existsSync(p)) return null;
   try {
     const result = parseJsonSafe(
-      fs9.readFileSync(p, "utf-8"),
+      fs10.readFileSync(p, "utf-8"),
       ["taskId", "state", "stages", "createdAt", "updatedAt"]
     );
     if (!result.ok) {
@@ -1086,8 +1322,8 @@ function writeState(state, taskDir) {
   };
   const target = path8.join(taskDir, "status.json");
   const tmp = target + ".tmp";
-  fs9.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-  fs9.renameSync(tmp, target);
+  fs10.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs10.renameSync(tmp, target);
   return updated;
 }
 function initState(taskId) {
@@ -1128,16 +1364,16 @@ var init_complexity = __esm({
 });
 
 // src/memory.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path9 from "path";
 function readProjectMemory(projectDir) {
   const memoryDir = path9.join(projectDir, ".kody", "memory");
-  if (!fs10.existsSync(memoryDir)) return "";
-  const files = fs10.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  if (!fs11.existsSync(memoryDir)) return "";
+  const files = fs11.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
   if (files.length === 0) return "";
   const sections = [];
   for (const file of files) {
-    const content = fs10.readFileSync(path9.join(memoryDir, file), "utf-8").trim();
+    const content = fs11.readFileSync(path9.join(memoryDir, file), "utf-8").trim();
     if (content) {
       sections.push(`## ${file.replace(".md", "")}
 ${content}`);
@@ -1156,7 +1392,7 @@ var init_memory = __esm({
 });
 
 // src/context-tiers.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path10 from "path";
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
@@ -1261,14 +1497,14 @@ function selectTier(tiered, tier) {
 }
 function readProjectMemoryTiered(projectDir, tier) {
   const memoryDir = path10.join(projectDir, ".kody", "memory");
-  if (!fs11.existsSync(memoryDir)) return "";
-  const files = fs11.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  if (!fs12.existsSync(memoryDir)) return "";
+  const files = fs12.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 = fs11.readFileSync(filePath, "utf-8").trim();
+    const content = fs12.readFileSync(filePath, "utf-8").trim();
     if (!content) continue;
     const tiered = getTieredContent(filePath, content);
     const selected = selectTier(tiered, tier);
@@ -1292,8 +1528,8 @@ function injectTaskContextTiered(prompt, taskId, taskDir, policy, feedback) {
   context += `Task Directory: ${taskDir}
 `;
   const taskMdPath = path10.join(taskDir, "task.md");
-  if (fs11.existsSync(taskMdPath)) {
-    const content = fs11.readFileSync(taskMdPath, "utf-8");
+  if (fs12.existsSync(taskMdPath)) {
+    const content = fs12.readFileSync(taskMdPath, "utf-8");
     const selected = selectContent(taskMdPath, content, policy.taskDescription);
     const label = tierLabel("Task Description", policy.taskDescription);
     context += `
@@ -1302,8 +1538,8 @@ ${selected}
 `;
   }
   const taskJsonPath = path10.join(taskDir, "task.json");
-  if (fs11.existsSync(taskJsonPath)) {
-    const content = fs11.readFileSync(taskJsonPath, "utf-8");
+  if (fs12.existsSync(taskJsonPath)) {
+    const content = fs12.readFileSync(taskJsonPath, "utf-8");
     if (policy.taskClassification === "L2") {
       try {
         const taskDef = JSON.parse(content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, ""));
@@ -1330,8 +1566,8 @@ ${selected}
     }
   }
   const specPath = path10.join(taskDir, "spec.md");
-  if (fs11.existsSync(specPath)) {
-    const content = fs11.readFileSync(specPath, "utf-8");
+  if (fs12.existsSync(specPath)) {
+    const content = fs12.readFileSync(specPath, "utf-8");
     const selected = selectContent(specPath, content, policy.spec);
     const label = tierLabel("Spec", policy.spec);
     context += `
@@ -1340,8 +1576,8 @@ ${selected}
 `;
   }
   const planPath = path10.join(taskDir, "plan.md");
-  if (fs11.existsSync(planPath)) {
-    const content = fs11.readFileSync(planPath, "utf-8");
+  if (fs12.existsSync(planPath)) {
+    const content = fs12.readFileSync(planPath, "utf-8");
     const selected = selectContent(planPath, content, policy.plan);
     const label = tierLabel("Plan", policy.plan);
     context += `
@@ -1350,8 +1586,8 @@ ${selected}
 `;
   }
   const contextMdPath = path10.join(taskDir, "context.md");
-  if (fs11.existsSync(contextMdPath)) {
-    const content = fs11.readFileSync(contextMdPath, "utf-8");
+  if (fs12.existsSync(contextMdPath)) {
+    const content = fs12.readFileSync(contextMdPath, "utf-8");
     const selected = selectContent(contextMdPath, content, policy.accumulatedContext);
     const label = tierLabel("Previous Stage Context", policy.accumulatedContext);
     context += `
@@ -1483,13 +1719,13 @@ var init_mcp_config = __esm({
 });
 
 // src/context.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path11 from "path";
 function readPromptFile(stageName, projectDir) {
   if (projectDir) {
     const stepFile = path11.join(projectDir, ".kody", "steps", `${stageName}.md`);
-    if (fs12.existsSync(stepFile)) {
-      return fs12.readFileSync(stepFile, "utf-8");
+    if (fs13.existsSync(stepFile)) {
+      return fs13.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.`);
   }
@@ -1499,8 +1735,8 @@ function readPromptFile(stageName, projectDir) {
     path11.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
   ];
   for (const candidate of candidates) {
-    if (fs12.existsSync(candidate)) {
-      return fs12.readFileSync(candidate, "utf-8");
+    if (fs13.existsSync(candidate)) {
+      return fs13.readFileSync(candidate, "utf-8");
     }
   }
   throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
@@ -1513,17 +1749,17 @@ function injectTaskContext(prompt, taskId, taskDir, feedback) {
   context += `Task Directory: ${taskDir}
 `;
   const taskMdPath = path11.join(taskDir, "task.md");
-  if (fs12.existsSync(taskMdPath)) {
-    const taskMd = fs12.readFileSync(taskMdPath, "utf-8");
+  if (fs13.existsSync(taskMdPath)) {
+    const taskMd = fs13.readFileSync(taskMdPath, "utf-8");
     context += `
 ## Task Description
 ${taskMd}
 `;
   }
   const taskJsonPath = path11.join(taskDir, "task.json");
-  if (fs12.existsSync(taskJsonPath)) {
+  if (fs13.existsSync(taskJsonPath)) {
     try {
-      const taskDef = JSON.parse(fs12.readFileSync(taskJsonPath, "utf-8"));
+      const taskDef = JSON.parse(fs13.readFileSync(taskJsonPath, "utf-8"));
       context += `
 ## Task Classification
 `;
@@ -1537,8 +1773,8 @@ ${taskMd}
     }
   }
   const specPath = path11.join(taskDir, "spec.md");
-  if (fs12.existsSync(specPath)) {
-    const spec = fs12.readFileSync(specPath, "utf-8");
+  if (fs13.existsSync(specPath)) {
+    const spec = fs13.readFileSync(specPath, "utf-8");
     const truncated = spec.slice(0, MAX_TASK_CONTEXT_SPEC);
     context += `
 ## Spec Summary
@@ -1546,8 +1782,8 @@ ${truncated}${spec.length > MAX_TASK_CONTEXT_SPEC ? "\n..." : ""}
 `;
   }
   const planPath = path11.join(taskDir, "plan.md");
-  if (fs12.existsSync(planPath)) {
-    const plan = fs12.readFileSync(planPath, "utf-8");
+  if (fs13.existsSync(planPath)) {
+    const plan = fs13.readFileSync(planPath, "utf-8");
     const truncated = plan.slice(0, MAX_TASK_CONTEXT_PLAN);
     context += `
 ## Plan Summary
@@ -1555,8 +1791,8 @@ ${truncated}${plan.length > MAX_TASK_CONTEXT_PLAN ? "\n..." : ""}
 `;
   }
   const contextMdPath = path11.join(taskDir, "context.md");
-  if (fs12.existsSync(contextMdPath)) {
-    const accumulated = fs12.readFileSync(contextMdPath, "utf-8");
+  if (fs13.existsSync(contextMdPath)) {
+    const accumulated = fs13.readFileSync(contextMdPath, "utf-8");
     const truncated = accumulated.slice(-MAX_ACCUMULATED_CONTEXT);
     const prefix = accumulated.length > MAX_ACCUMULATED_CONTEXT ? "...(earlier context truncated)\n" : "";
     context += `
@@ -1572,12 +1808,22 @@ ${feedback}
   }
   return prompt.replace("{{TASK_CONTEXT}}", context);
 }
+function inferHasUIFromScope(scope) {
+  return scope.some((filePath) => {
+    const ext = path11.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 (!fs12.existsSync(taskJsonPath)) return true;
+  if (!fs13.existsSync(taskJsonPath)) return true;
   try {
-    const taskDef = JSON.parse(fs12.readFileSync(taskJsonPath, "utf-8"));
-    return taskDef.hasUI !== false;
+    const taskDef = JSON.parse(fs13.readFileSync(taskJsonPath, "utf-8"));
+    const scope = Array.isArray(taskDef.scope) ? taskDef.scope : [];
+    if (scope.length === 0) return true;
+    return inferHasUIFromScope(scope);
   } catch {
     return true;
   }
@@ -1697,8 +1943,8 @@ ${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 (fs12.existsSync(qaGuidePath)) {
-      const qaGuide = fs12.readFileSync(qaGuidePath, "utf-8").trim();
+    if (fs13.existsSync(qaGuidePath)) {
+      const qaGuide = fs13.readFileSync(qaGuidePath, "utf-8").trim();
       assembled = assembled + "\n\n" + qaGuide;
     }
   }
@@ -1722,13 +1968,16 @@ ${prompt}` : prompt;
   }
   return assembled;
 }
+function escalateModelTier(currentTier) {
+  return TIER_ESCALATION[currentTier] ?? "strong";
+}
 function resolveModel(modelTier, stageName) {
   const config = getProjectConfig();
   const mapped = config.agent.modelMap[modelTier];
   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;
+var DEFAULT_MODEL_MAP, MAX_TASK_CONTEXT_PLAN, MAX_TASK_CONTEXT_SPEC, MAX_ACCUMULATED_CONTEXT, UI_EXTENSIONS, UI_PATH_SEGMENTS, TIER_ESCALATION;
 var init_context = __esm({
   "src/context.ts"() {
     "use strict";
@@ -1744,6 +1993,29 @@ var init_context = __esm({
     MAX_TASK_CONTEXT_PLAN = 1500;
     MAX_TASK_CONTEXT_SPEC = 2e3;
     MAX_ACCUMULATED_CONTEXT = 4e3;
+    UI_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".tsx",
+      ".jsx",
+      ".vue",
+      ".svelte",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+      ".html"
+    ]);
+    UI_PATH_SEGMENTS = [
+      "/components/",
+      "/pages/",
+      "/layouts/",
+      "/styles/",
+      "/views/"
+    ];
+    TIER_ESCALATION = {
+      cheap: "mid",
+      mid: "strong",
+      strong: "strong"
+    };
   }
 });
 
@@ -1767,7 +2039,7 @@ var init_runner_selection = __esm({
 });
 
 // src/stages/agent.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path12 from "path";
 function getSessionInfo(stageName, sessions) {
   const group = SESSION_GROUP[stageName];
@@ -1798,15 +2070,19 @@ async function executeAgentStage(ctx, def) {
     return { outcome: "completed", retries: 0 };
   }
   const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
-  const model = resolveModel(def.modelTier, def.name);
+  let currentModelTier = def.modelTier;
   if (ctx.input.feedback && def.name === "build") {
     logger.info(`  feedback: ${ctx.input.feedback.slice(0, 200)}${ctx.input.feedback.length > 200 ? "..." : ""}`);
   }
   const config = getProjectConfig();
+  const sc = resolveStageConfig(config, def.name, def.modelTier);
+  let model = sc.model;
+  const useProxy = stageNeedsProxy(sc);
+  const escalateEnabled = config.agent.escalateOnTimeout !== false;
   const runnerName = config.agent.stageRunners?.[def.name] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
-  logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1e3}s`);
+  logger.info(`  runner=${runnerName} provider=${sc.provider} model=${model} timeout=${def.timeout / 1e3}s`);
   const extraEnv = {};
-  if (needsLitellmProxy(config)) {
+  if (useProxy) {
     extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
   }
   const sessions = ctx.sessions ?? {};
@@ -1820,37 +2096,58 @@ async function executeAgentStage(ctx, def) {
     logger.info(`  MCP servers enabled for ${def.name}`);
   }
   const runner = getRunnerForStage(ctx, def.name);
-  const result = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
+  const maxRetries = def.maxRetries ?? 0;
+  let lastResult = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
     cwd: ctx.projectDir,
     env: extraEnv,
     ...sessionInfo,
     mcpConfigJson
   });
-  if (result.outcome !== "completed") {
-    return { outcome: result.outcome, error: result.error, retries: 0 };
+  let retries = 0;
+  while (lastResult.outcome !== "completed" && retries < maxRetries) {
+    retries++;
+    const isTimeout = lastResult.outcome === "timed_out";
+    if (isTimeout && escalateEnabled) {
+      const nextTier = escalateModelTier(currentModelTier);
+      if (nextTier !== currentModelTier) {
+        logger.info(`  Escalating model from ${currentModelTier} to ${nextTier} after timeout`);
+        currentModelTier = nextTier;
+        model = resolveModel(currentModelTier, def.name);
+      }
+    }
+    logger.info(`  retry ${retries}/${maxRetries} with model=${model}`);
+    lastResult = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
+      cwd: ctx.projectDir,
+      env: extraEnv,
+      mcpConfigJson
+    });
+  }
+  if (lastResult.outcome !== "completed") {
+    return { outcome: lastResult.outcome, error: lastResult.error, retries };
   }
+  const result = lastResult;
   if (def.outputFile && result.output) {
-    fs13.writeFileSync(path12.join(ctx.taskDir, def.outputFile), result.output);
+    fs14.writeFileSync(path12.join(ctx.taskDir, def.outputFile), result.output);
   }
   if (def.outputFile) {
     const outputPath = path12.join(ctx.taskDir, def.outputFile);
-    if (!fs13.existsSync(outputPath)) {
+    if (!fs14.existsSync(outputPath)) {
       const ext = path12.extname(def.outputFile);
       const base = path12.basename(def.outputFile, ext);
-      const files = fs13.readdirSync(ctx.taskDir);
+      const files = fs14.readdirSync(ctx.taskDir);
       const variant = files.find(
         (f) => f.startsWith(base + "-") && f.endsWith(ext)
       );
       if (variant) {
-        fs13.renameSync(path12.join(ctx.taskDir, variant), outputPath);
+        fs14.renameSync(path12.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 (fs13.existsSync(outputPath)) {
-      const content = fs13.readFileSync(outputPath, "utf-8");
+    if (fs14.existsSync(outputPath)) {
+      const content = fs14.readFileSync(outputPath, "utf-8");
       const validation = validateStageOutput(def.name, content);
       if (!validation.valid) {
         if (def.name === "taskify") {
@@ -1864,7 +2161,7 @@ async function executeAgentStage(ctx, def) {
             const stripped = stripFences(retryResult.output);
             const retryValidation = validateTaskJson(stripped);
             if (retryValidation.valid) {
-              fs13.writeFileSync(outputPath, retryResult.output);
+              fs14.writeFileSync(outputPath, retryResult.output);
               logger.info(`  taskify retry produced valid JSON`);
             } else {
               logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
@@ -1875,10 +2172,9 @@ async function executeAgentStage(ctx, def) {
                 description: plainText.slice(0, 500),
                 scope: [],
                 risk_level: "low",
-                hasUI: true,
                 questions: []
               }, null, 2);
-              fs13.writeFileSync(outputPath, fallback);
+              fs14.writeFileSync(outputPath, fallback);
               logger.info(`  taskify fallback: generated minimal task.json (risk_level=low)`);
             }
           }
@@ -1889,7 +2185,7 @@ async function executeAgentStage(ctx, def) {
     }
   }
   appendStageContext(ctx.taskDir, def.name, result.output);
-  return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
+  return { outcome: "completed", outputFile: def.outputFile, retries };
 }
 function appendStageContext(taskDir, stageName, output) {
   const contextPath = path12.join(taskDir, "context.md");
@@ -1905,7 +2201,7 @@ function appendStageContext(taskDir, stageName, output) {
 ### ${stageName} (${timestamp2})
 ${summary}
 `;
-  fs13.appendFileSync(contextPath, entry);
+  fs14.appendFileSync(contextPath, entry);
 }
 var SESSION_GROUP;
 var init_agent = __esm({
@@ -2144,7 +2440,7 @@ Error context:
 });
 
 // src/stages/gate.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as path13 from "path";
 function executeGateStage(ctx, def) {
   if (ctx.input.dryRun) {
@@ -2188,7 +2484,7 @@ ${output}
 `);
     }
   }
-  fs14.writeFileSync(path13.join(ctx.taskDir, "verify.md"), lines.join(""));
+  fs15.writeFileSync(path13.join(ctx.taskDir, "verify.md"), lines.join(""));
   return {
     outcome: verifyResult.pass ? "completed" : "failed",
     retries: 0
@@ -2203,7 +2499,7 @@ var init_gate = __esm({
 });
 
 // src/stages/verify.ts
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as path14 from "path";
 import { execFileSync as execFileSync11 } from "child_process";
 async function executeVerifyWithAutofix(ctx, def) {
@@ -2216,7 +2512,7 @@ async function executeVerifyWithAutofix(ctx, def) {
     }
     if (attempt < maxAttempts) {
       const verifyPath = path14.join(ctx.taskDir, "verify.md");
-      const errorOutput = fs15.existsSync(verifyPath) ? fs15.readFileSync(verifyPath, "utf-8") : "Unknown error";
+      const errorOutput = fs16.existsSync(verifyPath) ? fs16.readFileSync(verifyPath, "utf-8") : "Unknown error";
       const modifiedFiles = getModifiedFiles(ctx.projectDir);
       const defaultRunner = getRunnerForStage(ctx, "taskify");
       const diagConfig = getProjectConfig();
@@ -2312,13 +2608,13 @@ var init_verify = __esm({
 });
 
 // src/cli/task-resolution.ts
-import * as fs16 from "fs";
+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 (!fs16.existsSync(tasksDir)) return null;
-  const allDirs = fs16.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  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;
@@ -2345,14 +2641,38 @@ function generateTaskId() {
   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];
+      }
+    }
+    return latestTaskId;
+  } catch {
+    return null;
+  }
+}
+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_github_api();
   }
 });
 
 // src/review-standalone.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as path16 from "path";
 function resolveReviewTarget(input) {
   if (input.prs.length === 0) {
@@ -2378,16 +2698,34 @@ 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);
-  fs17.mkdirSync(taskDir, { recursive: true });
-  const diffInstruction = input.baseBranch ? `
+  fs18.mkdirSync(taskDir, { recursive: true });
+  let diffInstruction = "";
+  let filesChangedSection = "";
+  if (input.baseBranch) {
+    diffInstruction = `
 
 ## Diff Command
 Run: \`git diff origin/${input.baseBranch}...HEAD\` to see the PR changes.
-Do NOT use bare \`git diff\` \u2014 it shows only uncommitted working tree changes, not the PR diff.` : "";
+Do NOT use bare \`git diff\` \u2014 it shows only uncommitted working tree changes, not the PR diff.`;
+    const diffFiles = getDiffFiles(input.baseBranch, input.projectDir);
+    if (diffFiles.length > 0) {
+      logger.info(`[review] Review scope: git diff origin/${input.baseBranch}...HEAD (${diffFiles.length} files)`);
+      const fileList = diffFiles.map((f) => `- ${f}`).join("\n");
+      filesChangedSection = `
+
+## Files Changed
+Only review the following ${diffFiles.length} files (these are the files changed in this PR):
+${fileList}`;
+    } else {
+      logger.info(`[review] Review scope: git diff origin/${input.baseBranch}...HEAD (0 files)`);
+    }
+  } else {
+    logger.warn(`[review] No baseBranch provided \u2014 reviewing all files (no diff scope)`);
+  }
   const taskContent = `# ${input.prTitle}
 
-${input.prBody ?? ""}${diffInstruction}`;
-  fs17.writeFileSync(path16.join(taskDir, "task.md"), taskContent);
+${input.prBody ?? ""}${diffInstruction}${filesChangedSection}`;
+  fs18.writeFileSync(path16.join(taskDir, "task.md"), taskContent);
   const reviewDef = STAGES.find((s) => s.name === "review");
   const ctx = {
     taskId,
@@ -2411,8 +2749,8 @@ ${input.prBody ?? ""}${diffInstruction}`;
   }
   const reviewPath = path16.join(taskDir, "review.md");
   let reviewContent;
-  if (fs17.existsSync(reviewPath)) {
-    reviewContent = fs17.readFileSync(reviewPath, "utf-8");
+  if (fs18.existsSync(reviewPath)) {
+    reviewContent = fs18.readFileSync(reviewPath, "utf-8");
   }
   return {
     outcome: "completed",
@@ -2447,11 +2785,12 @@ var init_review_standalone = __esm({
     init_agent();
     init_task_resolution();
     init_logger();
+    init_git_utils();
   }
 });
 
 // src/stages/review.ts
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import * as path17 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
@@ -2467,10 +2806,10 @@ async function executeReviewWithFix(ctx, def) {
       return reviewResult;
     }
     const reviewFile = path17.join(ctx.taskDir, "review.md");
-    if (!fs18.existsSync(reviewFile)) {
+    if (!fs19.existsSync(reviewFile)) {
       return { outcome: "failed", retries: iteration, error: "review.md not found" };
     }
-    const content = fs18.readFileSync(reviewFile, "utf-8");
+    const content = fs19.readFileSync(reviewFile, "utf-8");
     if (detectReviewVerdict(content) !== "fail") {
       return { ...reviewResult, retries: iteration };
     }
@@ -2499,15 +2838,15 @@ var init_review = __esm({
 });
 
 // src/stages/ship.ts
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 import * as path18 from "path";
 import { execFileSync as execFileSync13 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
   const taskJsonPath = path18.join(ctx.taskDir, "task.json");
-  if (fs19.existsSync(taskJsonPath)) {
+  if (fs20.existsSync(taskJsonPath)) {
     try {
-      const raw = fs19.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs20.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -2527,8 +2866,8 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     }
   }
   const reviewPath = path18.join(ctx.taskDir, "review.md");
-  if (fs19.existsSync(reviewPath)) {
-    const review = fs19.readFileSync(reviewPath, "utf-8");
+  if (fs20.existsSync(reviewPath)) {
+    const review = fs20.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -2546,13 +2885,13 @@ ${summary}`);
     }
   }
   const verifyPath = path18.join(ctx.taskDir, "verify.md");
-  if (fs19.existsSync(verifyPath)) {
-    const verify = fs19.readFileSync(verifyPath, "utf-8");
+  if (fs20.existsSync(verifyPath)) {
+    const verify = fs20.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 (fs19.existsSync(planPath)) {
-    const plan = fs19.readFileSync(planPath, "utf-8").trim();
+  if (fs20.existsSync(planPath)) {
+    const plan = fs20.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -2574,11 +2913,11 @@ Closes #${ctx.input.issueNumber}`);
 function executeShipStage(ctx, _def) {
   const shipPath = path18.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs19.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs20.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) {
-    fs19.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs20.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   try {
@@ -2626,9 +2965,9 @@ function executeShipStage(ctx, _def) {
     };
     let prefix = "chore";
     const taskJsonPath = path18.join(ctx.taskDir, "task.json");
-    if (fs19.existsSync(taskJsonPath)) {
+    if (fs20.existsSync(taskJsonPath)) {
       try {
-        const raw = fs19.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs20.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";
@@ -2636,17 +2975,17 @@ function executeShipStage(ctx, _def) {
       }
     }
     const taskMdPath = path18.join(ctx.taskDir, "task.md");
-    if (fs19.existsSync(taskMdPath)) {
-      const content = fs19.readFileSync(taskMdPath, "utf-8");
+    if (fs20.existsSync(taskMdPath)) {
+      const content = fs20.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 (fs19.existsSync(taskJsonPath)) {
+      if (fs20.existsSync(taskJsonPath)) {
         try {
-          const raw = fs19.readFileSync(taskJsonPath, "utf-8");
+          const raw = fs20.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);
@@ -2669,7 +3008,7 @@ function executeShipStage(ctx, _def) {
         } catch {
         }
       }
-      fs19.writeFileSync(shipPath, `# Ship
+      fs20.writeFileSync(shipPath, `# Ship
 
 Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
@@ -2690,20 +3029,20 @@ PR #${existingPr.number}
           } catch {
           }
         }
-        fs19.writeFileSync(shipPath, `# Ship
+        fs20.writeFileSync(shipPath, `# Ship
 
 PR created: ${pr.url}
 PR #${pr.number}
 `);
       } else {
-        fs19.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+        fs20.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 {
-      fs19.writeFileSync(shipPath, `# Ship
+      fs20.writeFileSync(shipPath, `# Ship
 
 Failed: ${msg}
 `);
@@ -2752,15 +3091,15 @@ var init_executor_registry = __esm({
 });
 
 // src/pipeline/questions.ts
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as path19 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 (!fs20.existsSync(taskJsonPath)) return false;
-      const raw = fs20.readFileSync(taskJsonPath, "utf-8");
+      if (!fs21.existsSync(taskJsonPath)) return false;
+      const raw = fs21.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) {
@@ -2776,8 +3115,8 @@ Reply with \`@kody approve\` and your answers in the comment body.`;
     }
     if (stageName === "plan") {
       const planPath = path19.join(ctx.taskDir, "plan.md");
-      if (!fs20.existsSync(planPath)) return false;
-      const plan = fs20.readFileSync(planPath, "utf-8");
+      if (!fs21.existsSync(planPath)) return false;
+      const plan = fs21.readFileSync(planPath, "utf-8");
       const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
       if (questionsMatch) {
         const questionsText = questionsMatch[1].trim();
@@ -2806,7 +3145,7 @@ var init_questions = __esm({
 });
 
 // src/pipeline/hooks.ts
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as path20 from "path";
 function applyPreStageLabel(ctx, def) {
   if (!ctx.input.issueNumber || ctx.input.local) return;
@@ -2846,8 +3185,8 @@ function autoDetectComplexity(ctx, def) {
   }
   try {
     const taskJsonPath = path20.join(ctx.taskDir, "task.json");
-    if (!fs21.existsSync(taskJsonPath)) return null;
-    const raw = fs21.readFileSync(taskJsonPath, "utf-8");
+    if (!fs22.existsSync(taskJsonPath)) return null;
+    const raw = fs22.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;
@@ -2878,7 +3217,7 @@ function checkRiskGate(ctx, def, state, complexity) {
   if (ctx.input.mode === "rerun") return null;
   if (!ctx.input.issueNumber) return null;
   const planPath = path20.join(ctx.taskDir, "plan.md");
-  const plan = fs21.existsSync(planPath) ? fs21.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
+  const plan = fs22.existsSync(planPath) ? fs22.readFileSync(planPath, "utf-8").slice(0, 1500) : "(plan not available)";
   try {
     postComment(
       ctx.input.issueNumber,
@@ -2945,7 +3284,7 @@ var init_hooks = __esm({
 });
 
 // src/learning/auto-learn.ts
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import * as path21 from "path";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
@@ -2953,14 +3292,14 @@ function stripAnsi(str) {
 function autoLearn(ctx) {
   try {
     const memoryDir = path21.join(ctx.projectDir, ".kody", "memory");
-    if (!fs22.existsSync(memoryDir)) {
-      fs22.mkdirSync(memoryDir, { recursive: true });
+    if (!fs23.existsSync(memoryDir)) {
+      fs23.mkdirSync(memoryDir, { recursive: true });
     }
     const learnings = [];
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const verifyPath = path21.join(ctx.taskDir, "verify.md");
-    if (fs22.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs22.readFileSync(verifyPath, "utf-8"));
+    if (fs23.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs23.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");
@@ -2970,17 +3309,17 @@ function autoLearn(ctx) {
       if (/node/i.test(verify) && /environment/i.test(verify)) learnings.push("- Test environment: node");
     }
     const reviewPath = path21.join(ctx.taskDir, "review.md");
-    if (fs22.existsSync(reviewPath)) {
-      const review = fs22.readFileSync(reviewPath, "utf-8");
+    if (fs23.existsSync(reviewPath)) {
+      const review = fs23.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 (fs22.existsSync(taskJsonPath)) {
+    if (fs23.existsSync(taskJsonPath)) {
       try {
-        const raw = stripAnsi(fs22.readFileSync(taskJsonPath, "utf-8"));
+        const raw = stripAnsi(fs23.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)) {
@@ -2996,7 +3335,7 @@ function autoLearn(ctx) {
 ## Learned ${timestamp2} (task: ${ctx.taskId})
 ${learnings.join("\n")}
 `;
-      fs22.appendFileSync(conventionsPath, entry);
+      fs23.appendFileSync(conventionsPath, entry);
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
@@ -3005,7 +3344,7 @@ ${learnings.join("\n")}
 }
 function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
   const archPath = path21.join(memoryDir, "architecture.md");
-  if (fs22.existsSync(archPath)) return;
+  if (fs23.existsSync(archPath)) return;
   const detected = detectArchitectureBasic(projectDir);
   if (detected.length > 0) {
     const content = `# Architecture (auto-detected ${timestamp2})
@@ -3013,7 +3352,7 @@ function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
 ## Overview
 ${detected.join("\n")}
 `;
-    fs22.writeFileSync(archPath, content);
+    fs23.writeFileSync(archPath, content);
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
@@ -3026,13 +3365,13 @@ var init_auto_learn = __esm({
 });
 
 // src/retrospective.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as path22 from "path";
 function readArtifact(taskDir, filename, maxChars) {
   const p = path22.join(taskDir, filename);
-  if (!fs23.existsSync(p)) return null;
+  if (!fs24.existsSync(p)) return null;
   try {
-    const content = fs23.readFileSync(p, "utf-8");
+    const content = fs24.readFileSync(p, "utf-8");
     return content.length > maxChars ? content.slice(0, maxChars) + "\n...(truncated)" : content;
   } catch {
     return null;
@@ -3089,9 +3428,9 @@ function getLogPath(projectDir) {
 }
 function readPreviousRetrospectives(projectDir, limit = 10) {
   const logPath = getLogPath(projectDir);
-  if (!fs23.existsSync(logPath)) return [];
+  if (!fs24.existsSync(logPath)) return [];
   try {
-    const content = fs23.readFileSync(logPath, "utf-8");
+    const content = fs24.readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const entries = [];
     const start = Math.max(0, lines.length - limit);
@@ -3119,10 +3458,10 @@ function formatPreviousEntries(entries) {
 function appendRetrospectiveEntry(projectDir, entry) {
   const logPath = getLogPath(projectDir);
   const dir = path22.dirname(logPath);
-  if (!fs23.existsSync(dir)) {
-    fs23.mkdirSync(dir, { recursive: true });
+  if (!fs24.existsSync(dir)) {
+    fs24.mkdirSync(dir, { recursive: true });
   }
-  fs23.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  fs24.appendFileSync(logPath, JSON.stringify(entry) + "\n");
 }
 async function runRetrospective(ctx, state, pipelineStartTime) {
   if (ctx.input.dryRun) return;
@@ -3232,8 +3571,65 @@ If no pipeline flaw is detected, set "pipelineFlaw" to null.
   }
 });
 
+// src/pipeline/summary.ts
+function formatDuration(ms) {
+  const totalSec = Math.round(ms / 1e3);
+  if (totalSec < 60) return `${totalSec}s`;
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  return `${min}m ${sec}s`;
+}
+function stageDuration(stage) {
+  if (!stage.startedAt) return "-";
+  const start = new Date(stage.startedAt).getTime();
+  const end = stage.completedAt ? new Date(stage.completedAt).getTime() : Date.now();
+  if (isNaN(start) || isNaN(end)) return "-";
+  return formatDuration(end - start);
+}
+function formatPipelineSummary(state, options) {
+  const lines = [];
+  lines.push(`## Pipeline Summary: \`${state.taskId}\``);
+  lines.push("");
+  lines.push("| Stage | Status | Duration | Retries |");
+  lines.push("|-------|--------|----------|---------|");
+  for (const def of STAGES) {
+    const s = state.stages[def.name];
+    if (!s) continue;
+    const status = STATUS_ICONS[s.state] ?? s.state;
+    const duration = stageDuration(s);
+    const retries = s.retries ?? 0;
+    lines.push(`| ${def.name} | ${status} | ${duration} | ${retries} |`);
+  }
+  const totalMs = new Date(state.updatedAt).getTime() - new Date(state.createdAt).getTime();
+  const totalStr = isNaN(totalMs) || totalMs < 0 ? "-" : formatDuration(totalMs);
+  lines.push("");
+  const footerParts = [`**Total:** ${totalStr}`];
+  if (options?.complexity) {
+    footerParts.push(`**Complexity:** ${options.complexity}`);
+  }
+  if (options?.model) {
+    footerParts.push(`**Model:** ${options.model}`);
+  }
+  lines.push(footerParts.join(" | "));
+  return lines.join("\n");
+}
+var STATUS_ICONS;
+var init_summary = __esm({
+  "src/pipeline/summary.ts"() {
+    "use strict";
+    init_definitions();
+    STATUS_ICONS = {
+      completed: "completed",
+      failed: "failed",
+      timeout: "timeout",
+      running: "running",
+      pending: "pending"
+    };
+  }
+});
+
 // src/pipeline.ts
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 import * as path23 from "path";
 function ensureFeatureBranchIfNeeded(ctx) {
   if (ctx.input.dryRun) return;
@@ -3248,7 +3644,7 @@ function ensureFeatureBranchIfNeeded(ctx) {
   if (!ctx.input.issueNumber) return;
   try {
     const taskMdPath = path23.join(ctx.taskDir, "task.md");
-    const title = fs24.existsSync(taskMdPath) ? fs24.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    const title = fs25.existsSync(taskMdPath) ? fs25.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
     ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
     syncWithDefault(ctx.projectDir);
   } catch (err) {
@@ -3263,9 +3659,9 @@ function ensureFeatureBranchIfNeeded(ctx) {
 }
 function acquireLock(taskDir) {
   const lockPath = path23.join(taskDir, ".lock");
-  if (fs24.existsSync(lockPath)) {
+  if (fs25.existsSync(lockPath)) {
     try {
-      const pid = parseInt(fs24.readFileSync(lockPath, "utf-8").trim(), 10);
+      const pid = parseInt(fs25.readFileSync(lockPath, "utf-8").trim(), 10);
       if (!isNaN(pid)) {
         try {
           process.kill(pid, 0);
@@ -3282,14 +3678,14 @@ function acquireLock(taskDir) {
       logger.warn(`  Corrupt lock file \u2014 overwriting`);
     }
     try {
-      fs24.unlinkSync(lockPath);
+      fs25.unlinkSync(lockPath);
     } catch {
     }
   }
   try {
-    const fd = fs24.openSync(lockPath, fs24.constants.O_WRONLY | fs24.constants.O_CREAT | fs24.constants.O_EXCL);
-    fs24.writeSync(fd, String(process.pid));
-    fs24.closeSync(fd);
+    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);
   } catch (err) {
     if (err.code === "EEXIST") {
       throw new Error("Pipeline already running (lock acquired by another process)");
@@ -3299,7 +3695,7 @@ function acquireLock(taskDir) {
 }
 function releaseLock(taskDir) {
   try {
-    fs24.unlinkSync(path23.join(taskDir, ".lock"));
+    fs25.unlinkSync(path23.join(taskDir, ".lock"));
   } catch {
   }
 }
@@ -3449,6 +3845,24 @@ async function runPipelineInner(ctx) {
   await runRetrospective(ctx, state, pipelineStartTime).catch((err) => {
     logger.warn(`  Retrospective failed: ${err instanceof Error ? err.message : String(err)}`);
   });
+  if (ctx.input.issueNumber && !ctx.input.dryRun) {
+    const config = getProjectConfig();
+    const isCI3 = !!process.env.GITHUB_ACTIONS;
+    const shouldPost = config.github.postSummary ?? (isCI3 ? true : false);
+    if (shouldPost) {
+      try {
+        const summaryOpts = {};
+        if (complexity) summaryOpts.complexity = complexity;
+        const modelMap = config.agent?.modelMap;
+        if (modelMap?.mid) summaryOpts.model = modelMap.mid;
+        const summary = formatPipelineSummary(state, summaryOpts);
+        postComment(ctx.input.issueNumber, summary);
+        logger.info("Pipeline summary posted on issue");
+      } catch (err) {
+        logger.warn(`  Failed to post pipeline summary: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
   return state;
 }
 function printStatus(taskId, taskDir) {
@@ -3483,12 +3897,14 @@ var init_pipeline = __esm({
     init_hooks();
     init_auto_learn();
     init_retrospective();
+    init_summary();
+    init_config();
   }
 });
 
 // src/preflight.ts
 import { execFileSync as execFileSync14 } from "child_process";
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -3541,7 +3957,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs25.existsSync("package.json")) throw new Error("not found");
+      if (!fs26.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -3618,7 +4034,7 @@ var init_args = __esm({
 });
 
 // src/cli/litellm.ts
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 import * as os from "os";
 import * as path24 from "path";
 import { execFileSync as execFileSync15 } from "child_process";
@@ -3676,13 +4092,40 @@ function generateLitellmConfig(provider, modelMap) {
   }
   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");
-  fs26.writeFileSync(configPath, generatedConfig);
+  fs27.writeFileSync(configPath, generatedConfig);
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   let litellmFound = false;
@@ -3706,15 +4149,15 @@ async function tryStartLitellm(url, projectDir, generatedConfig) {
   try {
     execFileSync15("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     cmd = "litellm";
-    args2 = ["--config", configPath, "--port", port];
+    args2 = ["--config", configPath, "--port", port, "--no_db"];
   } catch {
     cmd = "python3";
-    args2 = ["-m", "litellm", "--config", configPath, "--port", port];
+    args2 = ["-m", "litellm", "--config", configPath, "--port", port, "--no_db"];
   }
   const dotenvPath = path24.join(projectDir, ".env");
   const dotenvVars = {};
-  if (fs26.existsSync(dotenvPath)) {
-    for (const rawLine of fs26.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  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)=(.*)$/);
@@ -3765,7 +4208,7 @@ var init_litellm = __esm({
 });
 
 // src/cli/task-state.ts
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 import * as path25 from "path";
 function resolveTaskAction(issueNumber, existingTaskId, existingState) {
   if (!existingTaskId || !existingState) {
@@ -3800,9 +4243,9 @@ function resolveForIssue(issueNumber, projectDir) {
   if (existingTaskId) {
     const statusPath = path25.join(projectDir, ".kody", "tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs27.existsSync(statusPath)) {
+    if (fs28.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs27.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs28.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -3959,10 +4402,10 @@ var init_resolve = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 import * as path26 from "path";
 async function ensureLitellmProxy(config, projectDir) {
-  if (!needsLitellmProxy(config)) return null;
+  if (!anyStageNeedsProxy(config)) return null;
   const litellmUrl = getLitellmUrl();
   const proxyRunning = await checkLitellmHealth(litellmUrl);
   let litellmProcess = null;
@@ -3975,7 +4418,9 @@ async function ensureLitellmProxy(config, projectDir) {
       }
     }
     let generatedConfig;
-    if (config.agent.provider && config.agent.provider !== "anthropic") {
+    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);
@@ -3986,9 +4431,8 @@ async function ensureLitellmProxy(config, projectDir) {
   } else {
     logger.info(`LiteLLM proxy already running at ${litellmUrl}`);
   }
-  process.env.ANTHROPIC_BASE_URL = litellmUrl;
-  logger.info(`ANTHROPIC_BASE_URL set to ${litellmUrl}`);
-  if (!process.env.ANTHROPIC_API_KEY || !process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
+  logger.info(`LiteLLM proxy available at ${litellmUrl}`);
+  if (!process.env.ANTHROPIC_API_KEY) {
     process.env.ANTHROPIC_API_KEY = `sk-ant-api03-${"0".repeat(64)}`;
   }
   return litellmProcess;
@@ -4016,7 +4460,7 @@ async function main() {
   const input = parseArgs();
   const projectDir = input.cwd ? path26.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs28.existsSync(projectDir)) {
+    if (!fs29.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -4060,7 +4504,16 @@ async function main() {
   }
   let taskId = input.taskId;
   if (!taskId) {
-    if (isPRFix) {
+    if ((input.command === "rerun" || input.command === "status") && input.issueNumber) {
+      const resolved = resolveTaskIdForCommand(input.issueNumber, projectDir);
+      if (resolved) {
+        taskId = resolved;
+        logger.info(`Auto-resolved task-id: ${taskId} (from issue #${input.issueNumber})`);
+      } else {
+        console.error(`No task found for issue #${input.issueNumber}. Provide --task-id explicitly.`);
+        process.exit(1);
+      }
+    } else if (isPRFix) {
       taskId = `${input.command === "fix-ci" ? "fixci" : "fix"}-pr-${input.prNumber}-${generateTaskId()}`;
     } else if (input.issueNumber) {
       taskId = `${input.issueNumber}-${generateTaskId()}`;
@@ -4074,7 +4527,7 @@ async function main() {
     }
   }
   const taskDir = path26.join(projectDir, ".kody", "tasks", taskId);
-  fs28.mkdirSync(taskDir, { recursive: true });
+  fs29.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
@@ -4190,31 +4643,31 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs28.writeFileSync(path26.join(taskDir, "task.md"), input.task);
+    fs29.writeFileSync(path26.join(taskDir, "task.md"), input.task);
   }
   const taskMdPath = path26.join(taskDir, "task.md");
-  if (!fs28.existsSync(taskMdPath) && isPRFix && input.prNumber) {
+  if (!fs29.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 ?? ""}`;
-      fs28.writeFileSync(taskMdPath, taskContent);
+      fs29.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from PR #${input.prNumber}: ${prDetails.title}`);
     }
-  } else if (!fs28.existsSync(taskMdPath) && input.issueNumber) {
+  } else if (!fs29.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 ?? ""}`;
-      fs28.writeFileSync(taskMdPath, taskContent);
+      fs29.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs28.existsSync(taskMdPath)) {
+  if (!fs29.existsSync(taskMdPath)) {
     console.error("No task.md found. Provide --task, --issue-number, or ensure .kody/tasks/<id>/task.md exists.");
     process.exit(1);
   }
@@ -4352,7 +4805,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs28.readdirSync(taskDir);
+  const files = fs29.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -4416,7 +4869,7 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as path27 from "path";
 import { fileURLToPath } from "url";
 
@@ -5592,7 +6045,7 @@ var __dirname = path27.dirname(fileURLToPath(import.meta.url));
 var PKG_ROOT = path27.resolve(__dirname, "..", "..");
 function getVersion() {
   const pkgPath = path27.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs29.readFileSync(pkgPath, "utf-8"));
+  const pkg = JSON.parse(fs30.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 var args = process.argv.slice(2);
@@ -5601,6 +6054,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 === "ci-parse") {
+  Promise.resolve().then(() => (init_parse_inputs(), parse_inputs_exports)).then(({ runCiParse: runCiParse2 }) => runCiParse2());
 } else if (command === "version" || command === "--version" || command === "-v") {
   console.log(getVersion());
 } else {