@kody-ade/kody-engine-lite 0.1.20 → 0.1.22

package/dist/bin/cli.js

@@ -107,26 +107,6 @@ function createClaudeCodeRunner() {
     }
   };
 }
-function createOpenCodeRunner() {
-  return {
-    async run(stageName, prompt, model, timeout, _taskDir, options) {
-      const args2 = ["run", "--agent", "build"];
-      if (model) {
-        args2.push("--model", model);
-      }
-      return runSubprocess(
-        "opencode",
-        args2,
-        prompt,
-        timeout,
-        options
-      );
-    },
-    async healthCheck() {
-      return checkCommand("opencode", ["--version"]);
-    }
-  };
-}
 function createRunners(config) {
   if (config.agent.runners && Object.keys(config.agent.runners).length > 0) {
     const runners = {};
@@ -150,8 +130,7 @@ var init_agent_runner = __esm({
     SIGKILL_GRACE_MS = 5e3;
     STDERR_TAIL_CHARS = 500;
     RUNNER_FACTORIES = {
-      "claude-code": createClaudeCodeRunner,
-      "opencode": createOpenCodeRunner
+      "claude-code": createClaudeCodeRunner
     };
   }
 });
@@ -220,251 +199,6 @@ var init_definitions = __esm({
   }
 });
 
-// src/memory.ts
-import * as fs from "fs";
-import * as path from "path";
-function readProjectMemory(projectDir) {
-  const memoryDir = path.join(projectDir, ".kody", "memory");
-  if (!fs.existsSync(memoryDir)) return "";
-  const files = fs.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
-  if (files.length === 0) return "";
-  const sections = [];
-  for (const file of files) {
-    const content = fs.readFileSync(path.join(memoryDir, file), "utf-8").trim();
-    if (content) {
-      sections.push(`## ${file.replace(".md", "")}
-${content}`);
-    }
-  }
-  if (sections.length === 0) return "";
-  return `# Project Memory
-
-${sections.join("\n\n")}
-`;
-}
-var init_memory = __esm({
-  "src/memory.ts"() {
-    "use strict";
-  }
-});
-
-// src/config.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-function setConfigDir(dir) {
-  _configDir = dir;
-  _config = null;
-}
-function getProjectConfig() {
-  if (_config) return _config;
-  const configPath = path2.join(_configDir ?? process.cwd(), "kody.config.json");
-  if (fs2.existsSync(configPath)) {
-    try {
-      const raw = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
-      _config = {
-        quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
-        git: { ...DEFAULT_CONFIG.git, ...raw.git },
-        github: { ...DEFAULT_CONFIG.github, ...raw.github },
-        paths: { ...DEFAULT_CONFIG.paths, ...raw.paths },
-        agent: { ...DEFAULT_CONFIG.agent, ...raw.agent }
-      };
-    } catch {
-      _config = { ...DEFAULT_CONFIG };
-    }
-  } else {
-    _config = { ...DEFAULT_CONFIG };
-  }
-  return _config;
-}
-var DEFAULT_CONFIG, VERIFY_COMMAND_TIMEOUT_MS, FIX_COMMAND_TIMEOUT_MS, _config, _configDir;
-var init_config = __esm({
-  "src/config.ts"() {
-    "use strict";
-    DEFAULT_CONFIG = {
-      quality: {
-        typecheck: "pnpm -s tsc --noEmit",
-        lint: "pnpm -s lint",
-        lintFix: "pnpm lint:fix",
-        format: "pnpm -s format:check",
-        formatFix: "pnpm format:fix",
-        testUnit: "pnpm -s test"
-      },
-      git: {
-        defaultBranch: "dev"
-      },
-      github: {
-        owner: "",
-        repo: ""
-      },
-      paths: {
-        taskDir: ".tasks"
-      },
-      agent: {
-        runner: "claude-code",
-        defaultRunner: "claude",
-        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
-      }
-    };
-    VERIFY_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
-    FIX_COMMAND_TIMEOUT_MS = 2 * 60 * 1e3;
-    _config = null;
-    _configDir = null;
-  }
-});
-
-// src/context.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-function readPromptFile(stageName) {
-  const scriptDir = new URL(".", import.meta.url).pathname;
-  const candidates = [
-    path3.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
-    path3.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
-  ];
-  for (const candidate of candidates) {
-    if (fs3.existsSync(candidate)) {
-      return fs3.readFileSync(candidate, "utf-8");
-    }
-  }
-  throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
-}
-function injectTaskContext(prompt, taskId, taskDir, feedback) {
-  let context = `## Task Context
-`;
-  context += `Task ID: ${taskId}
-`;
-  context += `Task Directory: ${taskDir}
-`;
-  const taskMdPath = path3.join(taskDir, "task.md");
-  if (fs3.existsSync(taskMdPath)) {
-    const taskMd = fs3.readFileSync(taskMdPath, "utf-8");
-    context += `
-## Task Description
-${taskMd}
-`;
-  }
-  const taskJsonPath = path3.join(taskDir, "task.json");
-  if (fs3.existsSync(taskJsonPath)) {
-    try {
-      const taskDef = JSON.parse(fs3.readFileSync(taskJsonPath, "utf-8"));
-      context += `
-## Task Classification
-`;
-      context += `Type: ${taskDef.task_type ?? "unknown"}
-`;
-      context += `Title: ${taskDef.title ?? "unknown"}
-`;
-      context += `Risk: ${taskDef.risk_level ?? "unknown"}
-`;
-    } catch {
-    }
-  }
-  const specPath = path3.join(taskDir, "spec.md");
-  if (fs3.existsSync(specPath)) {
-    const spec = fs3.readFileSync(specPath, "utf-8");
-    const truncated = spec.slice(0, MAX_TASK_CONTEXT_SPEC);
-    context += `
-## Spec Summary
-${truncated}${spec.length > MAX_TASK_CONTEXT_SPEC ? "\n..." : ""}
-`;
-  }
-  const planPath = path3.join(taskDir, "plan.md");
-  if (fs3.existsSync(planPath)) {
-    const plan = fs3.readFileSync(planPath, "utf-8");
-    const truncated = plan.slice(0, MAX_TASK_CONTEXT_PLAN);
-    context += `
-## Plan Summary
-${truncated}${plan.length > MAX_TASK_CONTEXT_PLAN ? "\n..." : ""}
-`;
-  }
-  if (feedback) {
-    context += `
-## Human Feedback
-${feedback}
-`;
-  }
-  return prompt.replace("{{TASK_CONTEXT}}", context);
-}
-function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback) {
-  const memory = readProjectMemory(projectDir);
-  const promptTemplate = readPromptFile(stageName);
-  const prompt = injectTaskContext(promptTemplate, taskId, taskDir, feedback);
-  return memory ? `${memory}
----
-
-${prompt}` : prompt;
-}
-function resolveModel(modelTier, stageName) {
-  const config = getProjectConfig();
-  if (config.agent.usePerStageRouting && stageName) {
-    return stageName;
-  }
-  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;
-var init_context = __esm({
-  "src/context.ts"() {
-    "use strict";
-    init_memory();
-    init_config();
-    DEFAULT_MODEL_MAP = {
-      cheap: "haiku",
-      mid: "sonnet",
-      strong: "opus"
-    };
-    MAX_TASK_CONTEXT_PLAN = 1500;
-    MAX_TASK_CONTEXT_SPEC = 2e3;
-  }
-});
-
-// src/validators.ts
-function validateTaskJson(content) {
-  try {
-    const parsed = JSON.parse(content);
-    for (const field of REQUIRED_TASK_FIELDS) {
-      if (!(field in parsed)) {
-        return { valid: false, error: `Missing field: ${field}` };
-      }
-    }
-    return { valid: true };
-  } catch (err) {
-    return {
-      valid: false,
-      error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-}
-function validatePlanMd(content) {
-  if (content.length < 10) {
-    return { valid: false, error: "Plan is too short (< 10 chars)" };
-  }
-  if (!/^##\s+\w+/m.test(content)) {
-    return { valid: false, error: "Plan has no markdown h2 sections" };
-  }
-  return { valid: true };
-}
-function validateReviewMd(content) {
-  if (/pass/i.test(content) || /fail/i.test(content)) {
-    return { valid: true };
-  }
-  return { valid: false, error: "Review must contain 'pass' or 'fail'" };
-}
-var REQUIRED_TASK_FIELDS;
-var init_validators = __esm({
-  "src/validators.ts"() {
-    "use strict";
-    REQUIRED_TASK_FIELDS = [
-      "task_type",
-      "title",
-      "description",
-      "scope",
-      "risk_level"
-    ];
-  }
-});
-
 // src/logger.ts
 function getLevel() {
   const env = process.env.LOG_LEVEL;
@@ -552,11 +286,21 @@ function getCurrentBranch(cwd) {
 }
 function ensureFeatureBranch(issueNumber, title, cwd) {
   const current = getCurrentBranch(cwd);
-  if (!BASE_BRANCHES.includes(current) && current !== "") {
+  const branchName = deriveBranchName(issueNumber, title);
+  if (current === branchName || current.startsWith(`${issueNumber}-`)) {
     logger.info(`  Already on feature branch: ${current}`);
     return current;
   }
-  const branchName = deriveBranchName(issueNumber, title);
+  if (!BASE_BRANCHES.includes(current) && current !== "") {
+    const defaultBranch2 = getDefaultBranch(cwd);
+    logger.info(`  Switching from ${current} to ${defaultBranch2} before creating ${branchName}`);
+    try {
+      git(["checkout", defaultBranch2], { cwd });
+    } catch {
+      logger.warn(`  Failed to checkout ${defaultBranch2}, aborting branch creation`);
+      return current;
+    }
+  }
   try {
     git(["fetch", "origin"], { cwd, timeout: 3e4 });
   } catch {
@@ -612,7 +356,7 @@ function commitAll(message, cwd) {
   if (!status) {
     return { success: false, hash: "", message: "No changes to commit" };
   }
-  git(["add", "-A"], { cwd });
+  git(["add", "."], { cwd });
   git(["commit", "--no-gpg-sign", "-m", message], { cwd });
   const hash = git(["rev-parse", "HEAD"], { cwd }).slice(0, 7);
   logger.info(`  Committed: ${hash} ${message}`);
@@ -737,130 +481,314 @@ var init_github_api = __esm({
   }
 });
 
-// src/verify-runner.ts
-import { execFileSync as execFileSync4 } from "child_process";
-function runCommand(cmd, cwd, timeout) {
-  const parts = cmd.split(/\s+/);
+// src/pipeline/state.ts
+import * as fs from "fs";
+import * as path from "path";
+function loadState(taskId, taskDir) {
+  const p = path.join(taskDir, "status.json");
+  if (!fs.existsSync(p)) return null;
   try {
-    const output = execFileSync4(parts[0], parts.slice(1), {
-      cwd,
-      timeout,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env, FORCE_COLOR: "0" }
-    });
-    return { success: true, output: output ?? "", timedOut: false };
-  } catch (err) {
-    const e = err;
-    const output = `${e.stdout ?? ""}${e.stderr ?? ""}`;
-    return { success: false, output, timedOut: !!e.killed };
+    const raw = JSON.parse(fs.readFileSync(p, "utf-8"));
+    if (raw.taskId === taskId) return raw;
+    return null;
+  } catch {
+    return null;
   }
 }
-function parseErrors(output) {
-  const errors = [];
-  for (const line of output.split("\n")) {
-    if (/error|Error|ERROR|failed|Failed|FAIL|warning:|Warning:|WARN/i.test(line)) {
-      errors.push(line.slice(0, 500));
-    }
+function writeState(state, taskDir) {
+  const updated = {
+    ...state,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const target = path.join(taskDir, "status.json");
+  const tmp = target + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify(updated, null, 2));
+  fs.renameSync(tmp, target);
+  state.updatedAt = updated.updatedAt;
+}
+function initState(taskId) {
+  const stages = {};
+  for (const stage of STAGES) {
+    stages[stage.name] = { state: "pending", retries: 0 };
   }
-  return errors;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return { taskId, state: "running", stages, createdAt: now, updatedAt: now };
 }
-function extractSummary(output, cmdName) {
-  const summaryPatterns = /Test Suites|Tests|Coverage|ERRORS|FAILURES|success|completed/i;
-  const lines = output.split("\n").filter((l) => summaryPatterns.test(l));
-  return lines.slice(-3).map((l) => `[${cmdName}] ${l.trim()}`);
+var init_state = __esm({
+  "src/pipeline/state.ts"() {
+    "use strict";
+    init_definitions();
+  }
+});
+
+// src/pipeline/complexity.ts
+function filterByComplexity(stages, complexity) {
+  const skip = COMPLEXITY_SKIP[complexity] ?? [];
+  return stages.filter((s) => !skip.includes(s.name));
 }
-function runQualityGates(taskDir, projectRoot) {
-  const config = getProjectConfig();
-  const cwd = projectRoot ?? process.cwd();
-  const allErrors = [];
-  const allSummary = [];
-  let allPass = true;
-  const commands = [
-    { name: "typecheck", cmd: config.quality.typecheck },
-    { name: "test", cmd: config.quality.testUnit }
-  ];
-  if (config.quality.lint) {
-    commands.push({ name: "lint", cmd: config.quality.lint });
+function isValidComplexity(value) {
+  return value in COMPLEXITY_SKIP;
+}
+var COMPLEXITY_SKIP;
+var init_complexity = __esm({
+  "src/pipeline/complexity.ts"() {
+    "use strict";
+    COMPLEXITY_SKIP = {
+      low: ["plan", "review", "review-fix"],
+      medium: ["review-fix"],
+      high: []
+    };
   }
-  for (const { name, cmd } of commands) {
-    if (!cmd) continue;
-    logger.info(`  Running ${name}: ${cmd}`);
-    const result = runCommand(cmd, cwd, VERIFY_COMMAND_TIMEOUT_MS);
-    if (result.timedOut) {
-      allErrors.push(`${name}: timed out after ${VERIFY_COMMAND_TIMEOUT_MS / 1e3}s`);
-      allPass = false;
-      continue;
+});
+
+// src/memory.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function readProjectMemory(projectDir) {
+  const memoryDir = path2.join(projectDir, ".kody", "memory");
+  if (!fs2.existsSync(memoryDir)) return "";
+  const files = fs2.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+  if (files.length === 0) return "";
+  const sections = [];
+  for (const file of files) {
+    const content = fs2.readFileSync(path2.join(memoryDir, file), "utf-8").trim();
+    if (content) {
+      sections.push(`## ${file.replace(".md", "")}
+${content}`);
     }
-    if (!result.success) {
-      allPass = false;
-      const errors = parseErrors(result.output);
-      allErrors.push(...errors.map((e) => `[${name}] ${e}`));
+  }
+  if (sections.length === 0) return "";
+  return `# Project Memory
+
+${sections.join("\n\n")}
+`;
+}
+var init_memory = __esm({
+  "src/memory.ts"() {
+    "use strict";
+  }
+});
+
+// src/config.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+function setConfigDir(dir) {
+  _configDir = dir;
+  _config = null;
+}
+function getProjectConfig() {
+  if (_config) return _config;
+  const configPath = path3.join(_configDir ?? process.cwd(), "kody.config.json");
+  if (fs3.existsSync(configPath)) {
+    try {
+      const raw = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+      _config = {
+        quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
+        git: { ...DEFAULT_CONFIG.git, ...raw.git },
+        github: { ...DEFAULT_CONFIG.github, ...raw.github },
+        paths: { ...DEFAULT_CONFIG.paths, ...raw.paths },
+        agent: { ...DEFAULT_CONFIG.agent, ...raw.agent }
+      };
+    } catch {
+      logger.warn("kody.config.json is invalid JSON \u2014 using defaults");
+      _config = { ...DEFAULT_CONFIG };
     }
-    allSummary.push(...extractSummary(result.output, name));
+  } else {
+    _config = { ...DEFAULT_CONFIG };
   }
-  return { pass: allPass, errors: allErrors, summary: allSummary };
+  return _config;
 }
-var init_verify_runner = __esm({
-  "src/verify-runner.ts"() {
+var DEFAULT_CONFIG, VERIFY_COMMAND_TIMEOUT_MS, FIX_COMMAND_TIMEOUT_MS, _config, _configDir;
+var init_config = __esm({
+  "src/config.ts"() {
     "use strict";
-    init_config();
     init_logger();
+    DEFAULT_CONFIG = {
+      quality: {
+        typecheck: "pnpm -s tsc --noEmit",
+        lint: "pnpm -s lint",
+        lintFix: "pnpm lint:fix",
+        format: "pnpm -s format:check",
+        formatFix: "pnpm format:fix",
+        testUnit: "pnpm -s test"
+      },
+      git: {
+        defaultBranch: "dev"
+      },
+      github: {
+        owner: "",
+        repo: ""
+      },
+      paths: {
+        taskDir: ".tasks"
+      },
+      agent: {
+        runner: "claude-code",
+        defaultRunner: "claude",
+        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+      }
+    };
+    VERIFY_COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
+    FIX_COMMAND_TIMEOUT_MS = 2 * 60 * 1e3;
+    _config = null;
+    _configDir = null;
   }
 });
 
-// src/state-machine.ts
+// src/context.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { execFileSync as execFileSync5 } from "child_process";
-function filterByComplexity(stages, complexity) {
-  const skip = COMPLEXITY_SKIP[complexity] ?? [];
-  return stages.filter((s) => !skip.includes(s.name));
+function readPromptFile(stageName) {
+  const scriptDir = new URL(".", import.meta.url).pathname;
+  const candidates = [
+    path4.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+    path4.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`)
+  ];
+  for (const candidate of candidates) {
+    if (fs4.existsSync(candidate)) {
+      return fs4.readFileSync(candidate, "utf-8");
+    }
+  }
+  throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
 }
-function checkForQuestions(ctx, stageName) {
-  if (ctx.input.local || !ctx.input.issueNumber) return false;
-  try {
-    if (stageName === "taskify") {
-      const taskJsonPath = path4.join(ctx.taskDir, "task.json");
-      if (!fs4.existsSync(taskJsonPath)) return false;
-      const raw = fs4.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) {
-        const body = `\u{1F914} **Kody has questions before proceeding:**
-
-${taskJson.questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}
-
-Reply with \`@kody approve\` and your answers in the comment body.`;
-        postComment(ctx.input.issueNumber, body);
-        setLifecycleLabel(ctx.input.issueNumber, "waiting");
-        return true;
-      }
+function injectTaskContext(prompt, taskId, taskDir, feedback) {
+  let context = `## Task Context
+`;
+  context += `Task ID: ${taskId}
+`;
+  context += `Task Directory: ${taskDir}
+`;
+  const taskMdPath = path4.join(taskDir, "task.md");
+  if (fs4.existsSync(taskMdPath)) {
+    const taskMd = fs4.readFileSync(taskMdPath, "utf-8");
+    context += `
+## Task Description
+${taskMd}
+`;
+  }
+  const taskJsonPath = path4.join(taskDir, "task.json");
+  if (fs4.existsSync(taskJsonPath)) {
+    try {
+      const taskDef = JSON.parse(fs4.readFileSync(taskJsonPath, "utf-8"));
+      context += `
+## Task Classification
+`;
+      context += `Type: ${taskDef.task_type ?? "unknown"}
+`;
+      context += `Title: ${taskDef.title ?? "unknown"}
+`;
+      context += `Risk: ${taskDef.risk_level ?? "unknown"}
+`;
+    } catch {
     }
-    if (stageName === "plan") {
-      const planPath = path4.join(ctx.taskDir, "plan.md");
-      if (!fs4.existsSync(planPath)) return false;
-      const plan = fs4.readFileSync(planPath, "utf-8");
-      const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
-      if (questionsMatch) {
-        const questionsText = questionsMatch[1].trim();
-        const questions = questionsText.split("\n").filter((l) => l.startsWith("- ")).map((l) => l.slice(2));
-        if (questions.length > 0) {
-          const body = `\u{1F3D7}\uFE0F **Kody has architecture questions:**
+  }
+  const specPath = path4.join(taskDir, "spec.md");
+  if (fs4.existsSync(specPath)) {
+    const spec = fs4.readFileSync(specPath, "utf-8");
+    const truncated = spec.slice(0, MAX_TASK_CONTEXT_SPEC);
+    context += `
+## Spec Summary
+${truncated}${spec.length > MAX_TASK_CONTEXT_SPEC ? "\n..." : ""}
+`;
+  }
+  const planPath = path4.join(taskDir, "plan.md");
+  if (fs4.existsSync(planPath)) {
+    const plan = fs4.readFileSync(planPath, "utf-8");
+    const truncated = plan.slice(0, MAX_TASK_CONTEXT_PLAN);
+    context += `
+## Plan Summary
+${truncated}${plan.length > MAX_TASK_CONTEXT_PLAN ? "\n..." : ""}
+`;
+  }
+  if (feedback) {
+    context += `
+## Human Feedback
+${feedback}
+`;
+  }
+  return prompt.replace("{{TASK_CONTEXT}}", context);
+}
+function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback) {
+  const memory = readProjectMemory(projectDir);
+  const promptTemplate = readPromptFile(stageName);
+  const prompt = injectTaskContext(promptTemplate, taskId, taskDir, feedback);
+  return memory ? `${memory}
+---
 
-${questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}
+${prompt}` : prompt;
+}
+function resolveModel(modelTier, stageName) {
+  const config = getProjectConfig();
+  if (config.agent.usePerStageRouting && stageName) {
+    return stageName;
+  }
+  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;
+var init_context = __esm({
+  "src/context.ts"() {
+    "use strict";
+    init_memory();
+    init_config();
+    DEFAULT_MODEL_MAP = {
+      cheap: "haiku",
+      mid: "sonnet",
+      strong: "opus"
+    };
+    MAX_TASK_CONTEXT_PLAN = 1500;
+    MAX_TASK_CONTEXT_SPEC = 2e3;
+  }
+});
 
-Reply with \`@kody approve\` and your answers in the comment body.`;
-          postComment(ctx.input.issueNumber, body);
-          setLifecycleLabel(ctx.input.issueNumber, "waiting");
-          return true;
-        }
+// src/validators.ts
+function validateTaskJson(content) {
+  try {
+    const parsed = JSON.parse(content);
+    for (const field of REQUIRED_TASK_FIELDS) {
+      if (!(field in parsed)) {
+        return { valid: false, error: `Missing field: ${field}` };
       }
     }
-  } catch {
+    return { valid: true };
+  } catch (err) {
+    return {
+      valid: false,
+      error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
-  return false;
 }
+function validatePlanMd(content) {
+  if (content.length < 10) {
+    return { valid: false, error: "Plan is too short (< 10 chars)" };
+  }
+  if (!/^##\s+\w+/m.test(content)) {
+    return { valid: false, error: "Plan has no markdown h2 sections" };
+  }
+  return { valid: true };
+}
+function validateReviewMd(content) {
+  if (/pass/i.test(content) || /fail/i.test(content)) {
+    return { valid: true };
+  }
+  return { valid: false, error: "Review must contain 'pass' or 'fail'" };
+}
+var REQUIRED_TASK_FIELDS;
+var init_validators = __esm({
+  "src/validators.ts"() {
+    "use strict";
+    REQUIRED_TASK_FIELDS = [
+      "task_type",
+      "title",
+      "description",
+      "scope",
+      "risk_level"
+    ];
+  }
+});
+
+// src/pipeline/runner-selection.ts
 function getRunnerForStage(ctx, stageName) {
   const config = getProjectConfig();
   const runnerName = config.agent.stageRunners?.[stageName] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
@@ -872,32 +800,16 @@ function getRunnerForStage(ctx, stageName) {
   }
   return runner;
 }
-function loadState(taskId, taskDir) {
-  const p = path4.join(taskDir, "status.json");
-  if (!fs4.existsSync(p)) return null;
-  try {
-    const raw = JSON.parse(fs4.readFileSync(p, "utf-8"));
-    if (raw.taskId === taskId) return raw;
-    return null;
-  } catch {
-    return null;
-  }
-}
-function writeState(state, taskDir) {
-  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  fs4.writeFileSync(
-    path4.join(taskDir, "status.json"),
-    JSON.stringify(state, null, 2)
-  );
-}
-function initState(taskId) {
-  const stages = {};
-  for (const stage of STAGES) {
-    stages[stage.name] = { state: "pending", retries: 0 };
+var init_runner_selection = __esm({
+  "src/pipeline/runner-selection.ts"() {
+    "use strict";
+    init_config();
   }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return { taskId, state: "running", stages, createdAt: now, updatedAt: now };
-}
+});
+
+// src/stages/agent.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
 function validateStageOutput(stageName, content) {
   switch (stageName) {
     case "taskify":
@@ -933,35 +845,246 @@ async function executeAgentStage(ctx, def) {
     return { outcome: result.outcome, error: result.error, retries: 0 };
   }
   if (def.outputFile && result.output) {
-    fs4.writeFileSync(path4.join(ctx.taskDir, def.outputFile), result.output);
+    fs5.writeFileSync(path5.join(ctx.taskDir, def.outputFile), result.output);
   }
   if (def.outputFile) {
-    const outputPath = path4.join(ctx.taskDir, def.outputFile);
-    if (!fs4.existsSync(outputPath)) {
-      const ext = path4.extname(def.outputFile);
-      const base = path4.basename(def.outputFile, ext);
-      const files = fs4.readdirSync(ctx.taskDir);
+    const outputPath = path5.join(ctx.taskDir, def.outputFile);
+    if (!fs5.existsSync(outputPath)) {
+      const ext = path5.extname(def.outputFile);
+      const base = path5.basename(def.outputFile, ext);
+      const files = fs5.readdirSync(ctx.taskDir);
       const variant = files.find(
         (f) => f.startsWith(base + "-") && f.endsWith(ext)
       );
       if (variant) {
-        fs4.renameSync(path4.join(ctx.taskDir, variant), outputPath);
+        fs5.renameSync(path5.join(ctx.taskDir, variant), outputPath);
         logger.info(`  Renamed variant ${variant} \u2192 ${def.outputFile}`);
       }
     }
   }
   if (def.outputFile) {
-    const outputPath = path4.join(ctx.taskDir, def.outputFile);
-    if (fs4.existsSync(outputPath)) {
-      const content = fs4.readFileSync(outputPath, "utf-8");
+    const outputPath = path5.join(ctx.taskDir, def.outputFile);
+    if (fs5.existsSync(outputPath)) {
+      const content = fs5.readFileSync(outputPath, "utf-8");
       const validation = validateStageOutput(def.name, content);
       if (!validation.valid) {
         logger.warn(`  validation warning: ${validation.error}`);
       }
     }
   }
-  return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
+  return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
+}
+var init_agent = __esm({
+  "src/stages/agent.ts"() {
+    "use strict";
+    init_context();
+    init_validators();
+    init_config();
+    init_runner_selection();
+    init_logger();
+  }
+});
+
+// src/verify-runner.ts
+import { execFileSync as execFileSync4 } from "child_process";
+function isExecError(err) {
+  return typeof err === "object" && err !== null;
+}
+function parseCommand(cmd) {
+  const parts = [];
+  let current = "";
+  let inQuote = null;
+  for (const ch of cmd) {
+    if (inQuote) {
+      if (ch === inQuote) {
+        inQuote = null;
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' || ch === "'") {
+      inQuote = ch;
+    } else if (/\s/.test(ch)) {
+      if (current) {
+        parts.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) parts.push(current);
+  if (inQuote) logger.warn(`Unclosed quote in command: ${cmd}`);
+  return parts;
+}
+function runCommand(cmd, cwd, timeout) {
+  const parts = parseCommand(cmd);
+  if (parts.length === 0) {
+    return { success: true, output: "", timedOut: false };
+  }
+  try {
+    const output = execFileSync4(parts[0], parts.slice(1), {
+      cwd,
+      timeout,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, FORCE_COLOR: "0" }
+    });
+    return { success: true, output: output ?? "", timedOut: false };
+  } catch (err) {
+    const stdout = isExecError(err) ? err.stdout ?? "" : "";
+    const stderr = isExecError(err) ? err.stderr ?? "" : "";
+    const killed = isExecError(err) ? !!err.killed : false;
+    return { success: false, output: `${stdout}${stderr}`, timedOut: killed };
+  }
+}
+function parseErrors(output) {
+  const errors = [];
+  for (const line of output.split("\n")) {
+    if (/error|Error|ERROR|failed|Failed|FAIL|warning:|Warning:|WARN/i.test(line)) {
+      errors.push(line.slice(0, 500));
+    }
+  }
+  return errors;
+}
+function extractSummary(output, cmdName) {
+  const summaryPatterns = /Test Suites|Tests|Coverage|ERRORS|FAILURES|success|completed/i;
+  const lines = output.split("\n").filter((l) => summaryPatterns.test(l));
+  return lines.slice(-3).map((l) => `[${cmdName}] ${l.trim()}`);
+}
+function runQualityGates(taskDir, projectRoot) {
+  const config = getProjectConfig();
+  const cwd = projectRoot ?? process.cwd();
+  const allErrors = [];
+  const allSummary = [];
+  let allPass = true;
+  const commands = [
+    { name: "typecheck", cmd: config.quality.typecheck },
+    { name: "test", cmd: config.quality.testUnit }
+  ];
+  if (config.quality.lint) {
+    commands.push({ name: "lint", cmd: config.quality.lint });
+  }
+  for (const { name, cmd } of commands) {
+    if (!cmd) continue;
+    logger.info(`  Running ${name}: ${cmd}`);
+    const result = runCommand(cmd, cwd, VERIFY_COMMAND_TIMEOUT_MS);
+    if (result.timedOut) {
+      allErrors.push(`${name}: timed out after ${VERIFY_COMMAND_TIMEOUT_MS / 1e3}s`);
+      allPass = false;
+      continue;
+    }
+    if (!result.success) {
+      allPass = false;
+      const errors = parseErrors(result.output);
+      allErrors.push(...errors.map((e) => `[${name}] ${e}`));
+    }
+    allSummary.push(...extractSummary(result.output, name));
+  }
+  return { pass: allPass, errors: allErrors, summary: allSummary };
+}
+var init_verify_runner = __esm({
+  "src/verify-runner.ts"() {
+    "use strict";
+    init_config();
+    init_logger();
+  }
+});
+
+// src/observer.ts
+import { execFileSync as execFileSync5 } from "child_process";
+async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, model) {
+  const context = [
+    `Stage: ${stageName}`,
+    ``,
+    `Error output:`,
+    errorOutput.slice(-2e3),
+    // Last 2000 chars of error
+    ``,
+    modifiedFiles.length > 0 ? `Files modified by build stage:
+${modifiedFiles.map((f) => `- ${f}`).join("\n")}` : "No files were modified (build may not have run yet)."
+  ].join("\n");
+  const prompt = DIAGNOSIS_PROMPT + context;
+  try {
+    const result = await runner.run(
+      "diagnosis",
+      prompt,
+      model,
+      3e4,
+      // 30s timeout — this should be fast
+      ""
+    );
+    if (result.outcome === "completed" && result.output) {
+      const cleaned = result.output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "").trim();
+      const parsed = JSON.parse(cleaned);
+      const validClassifications = [
+        "fixable",
+        "infrastructure",
+        "pre-existing",
+        "retry",
+        "abort"
+      ];
+      if (validClassifications.includes(parsed.classification)) {
+        logger.info(`  Diagnosis: ${parsed.classification} \u2014 ${parsed.reason}`);
+        return {
+          classification: parsed.classification,
+          reason: parsed.reason ?? "Unknown reason",
+          resolution: parsed.resolution ?? ""
+        };
+      }
+    }
+  } catch (err) {
+    logger.warn(`  Diagnosis error: ${err instanceof Error ? err.message : err}`);
+  }
+  logger.warn("  Diagnosis failed \u2014 defaulting to fixable");
+  return {
+    classification: "fixable",
+    reason: "Could not diagnose failure",
+    resolution: errorOutput.slice(-500)
+  };
+}
+function getModifiedFiles(projectDir) {
+  try {
+    const output = execFileSync5("git", ["diff", "--name-only", "HEAD~1"], {
+      encoding: "utf-8",
+      cwd: projectDir,
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return output ? output.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+var DIAGNOSIS_PROMPT;
+var init_observer = __esm({
+  "src/observer.ts"() {
+    "use strict";
+    init_logger();
+    DIAGNOSIS_PROMPT = `You are a pipeline failure diagnosis agent. Analyze the error and classify it.
+
+Output ONLY valid JSON. No markdown fences. No explanation.
+
+{
+  "classification": "fixable | infrastructure | pre-existing | retry | abort",
+  "reason": "One sentence explaining what went wrong",
+  "resolution": "Specific instructions for fixing (if fixable) or what the user needs to do (if infrastructure)"
 }
+
+Classification rules:
+- fixable: Error is in code that was just written/modified. The resolution should describe exactly what to change.
+- infrastructure: External dependency not available (database, API, service). The resolution should say what the user needs to set up.
+- pre-existing: Error exists in code that was NOT modified. Safe to skip. The resolution should note which files.
+- retry: Transient error (network timeout, rate limit, flaky test). Worth retrying once.
+- abort: Unrecoverable error (permission denied, corrupted state, out of disk). Pipeline should stop.
+
+Error context:
+`;
+  }
+});
+
+// src/stages/gate.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
 function executeGateStage(ctx, def) {
   if (ctx.input.dryRun) {
     logger.info(`  [dry-run] skipping ${def.name}`);
@@ -992,12 +1115,24 @@ function executeGateStage(ctx, def) {
 `);
     }
   }
-  fs4.writeFileSync(path4.join(ctx.taskDir, "verify.md"), lines.join(""));
+  fs6.writeFileSync(path6.join(ctx.taskDir, "verify.md"), lines.join(""));
   return {
     outcome: verifyResult.pass ? "completed" : "failed",
     retries: 0
   };
 }
+var init_gate = __esm({
+  "src/stages/gate.ts"() {
+    "use strict";
+    init_verify_runner();
+    init_logger();
+  }
+});
+
+// src/stages/verify.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+import { execFileSync as execFileSync6 } from "child_process";
 async function executeVerifyWithAutofix(ctx, def) {
   const maxAttempts = def.maxRetries ?? 2;
   for (let attempt = 0; attempt <= maxAttempts; attempt++) {
@@ -1007,13 +1142,45 @@ async function executeVerifyWithAutofix(ctx, def) {
       return { ...gateResult, retries: attempt };
     }
     if (attempt < maxAttempts) {
-      logger.info(`  verification failed, running fixes...`);
+      const verifyPath = path7.join(ctx.taskDir, "verify.md");
+      const errorOutput = fs7.existsSync(verifyPath) ? fs7.readFileSync(verifyPath, "utf-8") : "Unknown error";
+      const modifiedFiles = getModifiedFiles(ctx.projectDir);
+      const defaultRunner = getRunnerForStage(ctx, "taskify");
+      const diagnosis = await diagnoseFailure(
+        "verify",
+        errorOutput,
+        modifiedFiles,
+        defaultRunner,
+        resolveModel("cheap")
+      );
+      if (diagnosis.classification === "infrastructure") {
+        logger.warn(`  Infrastructure issue: ${diagnosis.reason}`);
+        if (ctx.input.issueNumber && !ctx.input.local) {
+          try {
+            postComment(ctx.input.issueNumber, `\u26A0\uFE0F **Infrastructure issue detected:** ${diagnosis.reason}
+
+${diagnosis.resolution}`);
+          } catch {
+          }
+        }
+        return { outcome: "completed", retries: attempt, error: `Skipped: ${diagnosis.reason}` };
+      }
+      if (diagnosis.classification === "pre-existing") {
+        logger.warn(`  Pre-existing issue: ${diagnosis.reason}`);
+        return { outcome: "completed", retries: attempt, error: `Skipped: ${diagnosis.reason}` };
+      }
+      if (diagnosis.classification === "abort") {
+        logger.error(`  Unrecoverable: ${diagnosis.reason}`);
+        return { outcome: "failed", retries: attempt, error: diagnosis.reason };
+      }
+      logger.info(`  Diagnosis: ${diagnosis.classification} \u2014 ${diagnosis.reason}`);
       const config = getProjectConfig();
       const runFix = (cmd) => {
         if (!cmd) return;
-        const parts = cmd.split(/\s+/);
+        const parts = parseCommand(cmd);
+        if (parts.length === 0) return;
         try {
-          execFileSync5(parts[0], parts.slice(1), {
+          execFileSync6(parts[0], parts.slice(1), {
             stdio: "pipe",
             timeout: FIX_COMMAND_TIMEOUT_MS
           });
@@ -1023,8 +1190,17 @@ async function executeVerifyWithAutofix(ctx, def) {
       runFix(config.quality.lintFix);
       runFix(config.quality.formatFix);
       if (def.retryWithAgent) {
-        logger.info(`  running ${def.retryWithAgent} agent...`);
-        await executeAgentStage(ctx, {
+        const autofixCtx = {
+          ...ctx,
+          input: {
+            ...ctx.input,
+            feedback: `${diagnosis.resolution}
+
+${ctx.input.feedback ?? ""}`.trim()
+          }
+        };
+        logger.info(`  running ${def.retryWithAgent} agent with diagnosis guidance...`);
+        await executeAgentStage(autofixCtx, {
           ...def,
           name: def.retryWithAgent,
           type: "agent",
@@ -1041,6 +1217,24 @@ async function executeVerifyWithAutofix(ctx, def) {
     error: "Verification failed after autofix attempts"
   };
 }
+var init_verify = __esm({
+  "src/stages/verify.ts"() {
+    "use strict";
+    init_context();
+    init_config();
+    init_verify_runner();
+    init_runner_selection();
+    init_github_api();
+    init_observer();
+    init_logger();
+    init_agent();
+    init_gate();
+  }
+});
+
+// src/stages/review.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
 async function executeReviewWithFix(ctx, def) {
   if (ctx.input.dryRun) {
     return { outcome: "completed", retries: 0 };
@@ -1051,11 +1245,11 @@ async function executeReviewWithFix(ctx, def) {
   if (reviewResult.outcome !== "completed") {
     return reviewResult;
   }
-  const reviewFile = path4.join(ctx.taskDir, "review.md");
-  if (!fs4.existsSync(reviewFile)) {
+  const reviewFile = path8.join(ctx.taskDir, "review.md");
+  if (!fs8.existsSync(reviewFile)) {
     return { outcome: "failed", retries: 0, error: "review.md not found" };
   }
-  const content = fs4.readFileSync(reviewFile, "utf-8");
+  const content = fs8.readFileSync(reviewFile, "utf-8");
   const hasIssues = /\bfail\b/i.test(content) && !/pass/i.test(content);
   if (!hasIssues) {
     return reviewResult;
@@ -1068,12 +1262,25 @@ async function executeReviewWithFix(ctx, def) {
   logger.info(`  re-running review after fix...`);
   return executeAgentStage(ctx, reviewDef);
 }
+var init_review = __esm({
+  "src/stages/review.ts"() {
+    "use strict";
+    init_definitions();
+    init_logger();
+    init_agent();
+  }
+});
+
+// src/stages/ship.ts
+import * as fs9 from "fs";
+import * as path9 from "path";
+import { execFileSync as execFileSync7 } from "child_process";
 function buildPrBody(ctx) {
   const sections = [];
-  const taskJsonPath = path4.join(ctx.taskDir, "task.json");
-  if (fs4.existsSync(taskJsonPath)) {
+  const taskJsonPath = path9.join(ctx.taskDir, "task.json");
+  if (fs9.existsSync(taskJsonPath)) {
     try {
-      const raw = fs4.readFileSync(taskJsonPath, "utf-8");
+      const raw = fs9.readFileSync(taskJsonPath, "utf-8");
       const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
       const task = JSON.parse(cleaned);
       if (task.description) {
@@ -1092,9 +1299,9 @@ ${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
     } catch {
     }
   }
-  const reviewPath = path4.join(ctx.taskDir, "review.md");
-  if (fs4.existsSync(reviewPath)) {
-    const review = fs4.readFileSync(reviewPath, "utf-8");
+  const reviewPath = path9.join(ctx.taskDir, "review.md");
+  if (fs9.existsSync(reviewPath)) {
+    const review = fs9.readFileSync(reviewPath, "utf-8");
     const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
     if (summaryMatch) {
       const summary = summaryMatch[1].trim();
@@ -1111,14 +1318,14 @@ ${summary}`);
 **Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
     }
   }
-  const verifyPath = path4.join(ctx.taskDir, "verify.md");
-  if (fs4.existsSync(verifyPath)) {
-    const verify = fs4.readFileSync(verifyPath, "utf-8");
+  const verifyPath = path9.join(ctx.taskDir, "verify.md");
+  if (fs9.existsSync(verifyPath)) {
+    const verify = fs9.readFileSync(verifyPath, "utf-8");
     if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
   }
-  const planPath = path4.join(ctx.taskDir, "plan.md");
-  if (fs4.existsSync(planPath)) {
-    const plan = fs4.readFileSync(planPath, "utf-8").trim();
+  const planPath = path9.join(ctx.taskDir, "plan.md");
+  if (fs9.existsSync(planPath)) {
+    const plan = fs9.readFileSync(planPath, "utf-8").trim();
     if (plan) {
       const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
       sections.push(`
@@ -1138,13 +1345,13 @@ Closes #${ctx.input.issueNumber}`);
   return sections.join("\n");
 }
 function executeShipStage(ctx, _def) {
-  const shipPath = path4.join(ctx.taskDir, "ship.md");
+  const shipPath = path9.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    fs4.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    fs9.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) {
-    fs4.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    fs9.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
     return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
   try {
@@ -1156,7 +1363,7 @@ function executeShipStage(ctx, _def) {
     let repo = config.github?.repo;
     if (!owner || !repo) {
       try {
-        const remoteUrl = execFileSync5("git", ["remote", "get-url", "origin"], {
+        const remoteUrl = execFileSync7("git", ["remote", "get-url", "origin"], {
           encoding: "utf-8",
           cwd: ctx.projectDir
         }).trim();
@@ -1176,10 +1383,10 @@ function executeShipStage(ctx, _def) {
       docs: "docs",
       chore: "chore"
     };
-    const taskJsonPath = path4.join(ctx.taskDir, "task.json");
-    if (fs4.existsSync(taskJsonPath)) {
+    const taskJsonPath = path9.join(ctx.taskDir, "task.json");
+    if (fs9.existsSync(taskJsonPath)) {
       try {
-        const raw = fs4.readFileSync(taskJsonPath, "utf-8");
+        const raw = fs9.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";
@@ -1188,42 +1395,396 @@ function executeShipStage(ctx, _def) {
       } catch {
       }
     }
-    if (title === "Update") {
-      const taskMdPath = path4.join(ctx.taskDir, "task.md");
-      if (fs4.existsSync(taskMdPath)) {
-        const content = fs4.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);
-      }
+    if (title === "Update") {
+      const taskMdPath = path9.join(ctx.taskDir, "task.md");
+      if (fs9.existsSync(taskMdPath)) {
+        const content = fs9.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);
+      }
+    }
+    const body = buildPrBody(ctx);
+    const pr = createPR(head, base, title, body);
+    if (pr) {
+      if (ctx.input.issueNumber && !ctx.input.local) {
+        try {
+          postComment(ctx.input.issueNumber, `\u{1F389} PR created: ${pr.url}`);
+        } catch {
+        }
+      }
+      fs9.writeFileSync(shipPath, `# Ship
+
+PR created: ${pr.url}
+PR #${pr.number}
+`);
+    } else {
+      fs9.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);
+    fs9.writeFileSync(shipPath, `# Ship
+
+Failed: ${msg}
+`);
+    return { outcome: "failed", retries: 0, error: msg };
+  }
+}
+var init_ship = __esm({
+  "src/stages/ship.ts"() {
+    "use strict";
+    init_git_utils();
+    init_github_api();
+    init_config();
+  }
+});
+
+// src/pipeline/executor-registry.ts
+function getExecutor(name) {
+  const executor = EXECUTOR_REGISTRY[name];
+  if (!executor) {
+    throw new Error(`No executor registered for stage: ${name}`);
+  }
+  return executor;
+}
+var EXECUTOR_REGISTRY;
+var init_executor_registry = __esm({
+  "src/pipeline/executor-registry.ts"() {
+    "use strict";
+    init_agent();
+    init_verify();
+    init_review();
+    init_ship();
+    EXECUTOR_REGISTRY = {
+      taskify: executeAgentStage,
+      plan: executeAgentStage,
+      build: executeAgentStage,
+      verify: executeVerifyWithAutofix,
+      review: executeReviewWithFix,
+      "review-fix": executeAgentStage,
+      ship: executeShipStage
+    };
+  }
+});
+
+// src/pipeline/questions.ts
+import * as fs10 from "fs";
+import * as path10 from "path";
+function checkForQuestions(ctx, stageName) {
+  if (ctx.input.local || !ctx.input.issueNumber) return false;
+  try {
+    if (stageName === "taskify") {
+      const taskJsonPath = path10.join(ctx.taskDir, "task.json");
+      if (!fs10.existsSync(taskJsonPath)) return false;
+      const raw = fs10.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) {
+        const body = `\u{1F914} **Kody has questions before proceeding:**
+
+${taskJson.questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}
+
+Reply with \`@kody approve\` and your answers in the comment body.`;
+        postComment(ctx.input.issueNumber, body);
+        setLifecycleLabel(ctx.input.issueNumber, "waiting");
+        return true;
+      }
+    }
+    if (stageName === "plan") {
+      const planPath = path10.join(ctx.taskDir, "plan.md");
+      if (!fs10.existsSync(planPath)) return false;
+      const plan = fs10.readFileSync(planPath, "utf-8");
+      const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
+      if (questionsMatch) {
+        const questionsText = questionsMatch[1].trim();
+        const questions = questionsText.split("\n").filter((l) => l.startsWith("- ")).map((l) => l.slice(2));
+        if (questions.length > 0) {
+          const body = `\u{1F3D7}\uFE0F **Kody has architecture questions:**
+
+${questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}
+
+Reply with \`@kody approve\` and your answers in the comment body.`;
+          postComment(ctx.input.issueNumber, body);
+          setLifecycleLabel(ctx.input.issueNumber, "waiting");
+          return true;
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+var init_questions = __esm({
+  "src/pipeline/questions.ts"() {
+    "use strict";
+    init_github_api();
+  }
+});
+
+// src/pipeline/hooks.ts
+import * as fs11 from "fs";
+import * as path11 from "path";
+function applyPreStageLabel(ctx, def) {
+  if (!ctx.input.issueNumber || ctx.input.local) return;
+  if (def.name === "build") setLifecycleLabel(ctx.input.issueNumber, "building");
+  if (def.name === "review") setLifecycleLabel(ctx.input.issueNumber, "review");
+}
+function checkQuestionsAfterStage(ctx, def, state) {
+  if (def.name !== "taskify" && def.name !== "plan") return null;
+  if (ctx.input.dryRun) return null;
+  const paused = checkForQuestions(ctx, def.name);
+  if (!paused) return null;
+  state.state = "failed";
+  state.stages[def.name] = {
+    ...state.stages[def.name],
+    state: "completed",
+    error: "paused: waiting for answers"
+  };
+  writeState(state, ctx.taskDir);
+  logger.info(`  Pipeline paused \u2014 questions posted on issue`);
+  return state;
+}
+function autoDetectComplexity(ctx, def) {
+  if (def.name !== "taskify") return null;
+  if (ctx.input.complexity) return null;
+  try {
+    const taskJsonPath = path11.join(ctx.taskDir, "task.json");
+    if (!fs11.existsSync(taskJsonPath)) return null;
+    const raw = fs11.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;
+    const complexity = taskJson.risk_level;
+    const activeStages = filterByComplexity(STAGES, complexity);
+    logger.info(`  Complexity auto-detected: ${complexity} (${activeStages.map((s) => s.name).join(" \u2192 ")})`);
+    if (ctx.input.issueNumber && !ctx.input.local) {
+      try {
+        setLifecycleLabel(ctx.input.issueNumber, complexity);
+      } catch {
+      }
+      if (taskJson.task_type) {
+        try {
+          setLabel(ctx.input.issueNumber, `kody:${taskJson.task_type}`);
+        } catch {
+        }
+      }
+    }
+    return { complexity, activeStages };
+  } catch {
+    return null;
+  }
+}
+function commitAfterStage(ctx, def) {
+  if (ctx.input.dryRun || !ctx.input.issueNumber) return;
+  if (def.name === "build") {
+    try {
+      commitAll(`feat(${ctx.taskId}): implement task`, ctx.projectDir);
+    } catch {
+    }
+  }
+  if (def.name === "review-fix") {
+    try {
+      commitAll(`fix(${ctx.taskId}): address review`, ctx.projectDir);
+    } catch {
+    }
+  }
+}
+function postSkippedStagesComment(ctx, complexity, activeStages) {
+  if (!ctx.input.issueNumber || ctx.input.local || ctx.input.dryRun) return;
+  const skipped = STAGES.filter((s) => !activeStages.find((a) => a.name === s.name)).map((s) => s.name);
+  if (skipped.length === 0) return;
+  try {
+    postComment(
+      ctx.input.issueNumber,
+      `\u26A1 **Complexity: ${complexity}** \u2014 skipping ${skipped.join(", ")} (not needed for ${complexity}-risk tasks)`
+    );
+  } catch {
+  }
+}
+var init_hooks = __esm({
+  "src/pipeline/hooks.ts"() {
+    "use strict";
+    init_definitions();
+    init_github_api();
+    init_git_utils();
+    init_questions();
+    init_complexity();
+    init_state();
+    init_logger();
+  }
+});
+
+// src/learning/auto-learn.ts
+import * as fs12 from "fs";
+import * as path12 from "path";
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function autoLearn(ctx) {
+  try {
+    const memoryDir = path12.join(ctx.projectDir, ".kody", "memory");
+    if (!fs12.existsSync(memoryDir)) {
+      fs12.mkdirSync(memoryDir, { recursive: true });
+    }
+    const learnings = [];
+    const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const verifyPath = path12.join(ctx.taskDir, "verify.md");
+    if (fs12.existsSync(verifyPath)) {
+      const verify = stripAnsi(fs12.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");
+      if (/prettier/i.test(verify)) learnings.push("- Uses prettier for formatting");
+      if (/tsc\b/i.test(verify)) learnings.push("- Uses TypeScript (tsc)");
+      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 = path12.join(ctx.taskDir, "review.md");
+    if (fs12.existsSync(reviewPath)) {
+      const review = fs12.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 = path12.join(ctx.taskDir, "task.json");
+    if (fs12.existsSync(taskJsonPath)) {
+      try {
+        const raw = stripAnsi(fs12.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)) {
+          const dirs = [...new Set(task.scope.map((s) => s.split("/").slice(0, -1).join("/")).filter(Boolean))];
+          if (dirs.length > 0) learnings.push(`- Active directories: ${dirs.join(", ")}`);
+        }
+      } catch {
+      }
+    }
+    if (learnings.length > 0) {
+      const conventionsPath = path12.join(memoryDir, "conventions.md");
+      const entry = `
+## Learned ${timestamp2} (task: ${ctx.taskId})
+${learnings.join("\n")}
+`;
+      fs12.appendFileSync(conventionsPath, entry);
+      logger.info(`Auto-learned ${learnings.length} convention(s)`);
+    }
+    autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
+  } catch {
+  }
+}
+function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
+  const archPath = path12.join(memoryDir, "architecture.md");
+  if (fs12.existsSync(archPath)) return;
+  const detected = [];
+  const pkgPath = path12.join(projectDir, "package.json");
+  if (fs12.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs12.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}`);
+      else if (allDeps.express) detected.push(`- Framework: Express ${allDeps.express}`);
+      else if (allDeps.fastify) detected.push(`- Framework: Fastify ${allDeps.fastify}`);
+      if (allDeps.typescript) detected.push(`- Language: TypeScript ${allDeps.typescript}`);
+      if (allDeps.vitest) detected.push(`- Testing: vitest ${allDeps.vitest}`);
+      else if (allDeps.jest) detected.push(`- Testing: jest ${allDeps.jest}`);
+      if (allDeps.eslint) detected.push(`- Linting: eslint ${allDeps.eslint}`);
+      if (allDeps.prisma || allDeps["@prisma/client"]) detected.push("- Database: Prisma ORM");
+      if (allDeps.drizzle || allDeps["drizzle-orm"]) detected.push("- Database: Drizzle ORM");
+      if (allDeps.pg || allDeps.postgres) detected.push("- Database: PostgreSQL");
+      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 (fs12.existsSync(path12.join(projectDir, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
+      else if (fs12.existsSync(path12.join(projectDir, "yarn.lock"))) detected.push("- Package manager: yarn");
+      else if (fs12.existsSync(path12.join(projectDir, "package-lock.json"))) detected.push("- Package manager: npm");
+    } catch {
+    }
+  }
+  const topDirs = [];
+  try {
+    const entries = fs12.readdirSync(projectDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        topDirs.push(entry.name);
+      }
+    }
+    if (topDirs.length > 0) detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
+  } catch {
+  }
+  const srcDir = path12.join(projectDir, "src");
+  if (fs12.existsSync(srcDir)) {
+    try {
+      const srcEntries = fs12.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 {
     }
-    const body = buildPrBody(ctx);
-    const pr = createPR(head, base, title, body);
-    if (pr) {
-      if (ctx.input.issueNumber && !ctx.input.local) {
-        try {
-          postComment(ctx.input.issueNumber, `\u{1F389} PR created: ${pr.url}`);
-        } catch {
-        }
-      }
-      fs4.writeFileSync(shipPath, `# Ship
+  }
+  if (detected.length > 0) {
+    const content = `# Architecture (auto-detected ${timestamp2})
 
-PR created: ${pr.url}
-PR #${pr.number}
-`);
-    } else {
-      fs4.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);
-    fs4.writeFileSync(shipPath, `# Ship
+## Overview
+${detected.join("\n")}
+`;
+    fs12.writeFileSync(archPath, content);
+    logger.info(`Auto-detected architecture (${detected.length} items)`);
+  }
+}
+var init_auto_learn = __esm({
+  "src/learning/auto-learn.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
 
-Failed: ${msg}
-`);
-    return { outcome: "failed", retries: 0, error: msg };
+// src/pipeline.ts
+import * as fs13 from "fs";
+import * as path13 from "path";
+function ensureFeatureBranchIfNeeded(ctx) {
+  if (!ctx.input.issueNumber || ctx.input.dryRun) return;
+  try {
+    const taskMdPath = path13.join(ctx.taskDir, "task.md");
+    const title = fs13.existsSync(taskMdPath) ? fs13.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
+    ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
+    syncWithDefault(ctx.projectDir);
+  } catch (err) {
+    logger.warn(`  Failed to create/sync feature branch: ${err}`);
+  }
+}
+function acquireLock(taskDir) {
+  const lockPath = path13.join(taskDir, ".lock");
+  if (fs13.existsSync(lockPath)) {
+    try {
+      const pid = parseInt(fs13.readFileSync(lockPath, "utf-8").trim(), 10);
+      try {
+        process.kill(pid, 0);
+        throw new Error(`Pipeline already running (PID ${pid})`);
+      } catch (e) {
+        if (e.code !== "ESRCH") throw e;
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith("Pipeline already")) throw e;
+    }
+  }
+  fs13.writeFileSync(lockPath, String(process.pid));
+}
+function releaseLock(taskDir) {
+  try {
+    fs13.unlinkSync(path13.join(taskDir, ".lock"));
+  } catch {
   }
 }
 async function runPipeline(ctx) {
+  acquireLock(ctx.taskDir);
+  try {
+    return await runPipelineInner(ctx);
+  } finally {
+    releaseLock(ctx.taskDir);
+  }
+}
+async function runPipelineInner(ctx) {
   let state = loadState(ctx.taskId, ctx.taskDir);
   if (!state) {
     state = initState(ctx.taskId);
@@ -1248,16 +1809,7 @@ async function runPipeline(ctx) {
     const initialPhase = ctx.input.mode === "rerun" ? "building" : "planning";
     setLifecycleLabel(ctx.input.issueNumber, initialPhase);
   }
-  if (ctx.input.issueNumber && !ctx.input.dryRun) {
-    try {
-      const taskMdPath = path4.join(ctx.taskDir, "task.md");
-      const title = fs4.existsSync(taskMdPath) ? fs4.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50) : ctx.taskId;
-      ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
-      syncWithDefault(ctx.projectDir);
-    } catch (err) {
-      logger.warn(`  Failed to create/sync feature branch: ${err}`);
-    }
-  }
+  ensureFeatureBranchIfNeeded(ctx);
   let complexity = ctx.input.complexity ?? "high";
   let activeStages = filterByComplexity(STAGES, complexity);
   let skippedStagesCommentPosted = false;
@@ -1277,50 +1829,20 @@ async function runPipeline(ctx) {
       logger.info(`[${def.name}] skipped (complexity: ${complexity})`);
       state.stages[def.name] = { state: "completed", retries: 0, outputFile: void 0 };
       writeState(state, ctx.taskDir);
-      if (!skippedStagesCommentPosted && ctx.input.issueNumber && !ctx.input.local && !ctx.input.dryRun) {
-        const skipped = STAGES.filter((s) => !activeStages.find((a) => a.name === s.name)).map((s) => s.name);
-        try {
-          postComment(
-            ctx.input.issueNumber,
-            `\u26A1 **Complexity: ${complexity}** \u2014 skipping ${skipped.join(", ")} (not needed for ${complexity}-risk tasks)`
-          );
-        } catch {
-        }
+      if (!skippedStagesCommentPosted) {
+        postSkippedStagesComment(ctx, complexity, activeStages);
         skippedStagesCommentPosted = true;
       }
       continue;
     }
     ciGroup(`Stage: ${def.name}`);
-    state.stages[def.name] = {
-      state: "running",
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      retries: 0
-    };
+    state.stages[def.name] = { state: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString(), retries: 0 };
     writeState(state, ctx.taskDir);
     logger.info(`[${def.name}] starting...`);
-    if (ctx.input.issueNumber && !ctx.input.local) {
-      if (def.name === "build") setLifecycleLabel(ctx.input.issueNumber, "building");
-      if (def.name === "review") setLifecycleLabel(ctx.input.issueNumber, "review");
-    }
+    applyPreStageLabel(ctx, def);
     let result;
     try {
-      if (def.type === "agent") {
-        if (def.name === "review") {
-          result = await executeReviewWithFix(ctx, def);
-        } else {
-          result = await executeAgentStage(ctx, def);
-        }
-      } else if (def.type === "gate") {
-        if (def.name === "verify") {
-          result = await executeVerifyWithAutofix(ctx, def);
-        } else {
-          result = executeGateStage(ctx, def);
-        }
-      } else if (def.type === "deterministic") {
-        result = executeShipStage(ctx, def);
-      } else {
-        result = { outcome: "failed", retries: 0, error: `Unknown stage type: ${def.type}` };
-      }
+      result = await getExecutor(def.name)(ctx, def);
     } catch (error) {
       result = {
         outcome: "failed",
@@ -1337,84 +1859,24 @@ async function runPipeline(ctx) {
         outputFile: result.outputFile
       };
       logger.info(`[${def.name}] \u2713 completed`);
-      if ((def.name === "taskify" || def.name === "plan") && !ctx.input.dryRun) {
-        const paused = checkForQuestions(ctx, def.name);
-        if (paused) {
-          state.state = "failed";
-          state.stages[def.name] = {
-            ...state.stages[def.name],
-            state: "completed",
-            error: "paused: waiting for answers"
-          };
-          writeState(state, ctx.taskDir);
-          logger.info(`  Pipeline paused \u2014 questions posted on issue`);
-          return state;
-        }
-      }
-      if (def.name === "taskify" && !ctx.input.complexity) {
-        try {
-          const taskJsonPath = path4.join(ctx.taskDir, "task.json");
-          if (fs4.existsSync(taskJsonPath)) {
-            const raw = fs4.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 && COMPLEXITY_SKIP[taskJson.risk_level]) {
-              complexity = taskJson.risk_level;
-              activeStages = filterByComplexity(STAGES, complexity);
-              logger.info(`  Complexity auto-detected: ${complexity} (${activeStages.map((s) => s.name).join(" \u2192 ")})`);
-              if (ctx.input.issueNumber && !ctx.input.local) {
-                try {
-                  setLifecycleLabel(ctx.input.issueNumber, complexity);
-                } catch {
-                }
-                if (taskJson.task_type) {
-                  try {
-                    setLabel(ctx.input.issueNumber, `kody:${taskJson.task_type}`);
-                  } catch {
-                  }
-                }
-              }
-            }
-          }
-        } catch {
-        }
-      }
-      if (!ctx.input.dryRun && ctx.input.issueNumber) {
-        if (def.name === "build") {
-          try {
-            commitAll(`feat(${ctx.taskId}): implement task`, ctx.projectDir);
-          } catch {
-          }
-        }
-        if (def.name === "review-fix") {
-          try {
-            commitAll(`fix(${ctx.taskId}): address review`, ctx.projectDir);
-          } catch {
-          }
-        }
-      }
-    } else if (result.outcome === "timed_out") {
-      state.stages[def.name] = {
-        state: "timeout",
-        retries: result.retries,
-        error: "Stage timed out"
-      };
-      state.state = "failed";
-      writeState(state, ctx.taskDir);
-      logger.error(`[${def.name}] \u23F1 timed out`);
-      if (ctx.input.issueNumber && !ctx.input.local) {
-        setLifecycleLabel(ctx.input.issueNumber, "failed");
+      const paused = checkQuestionsAfterStage(ctx, def, state);
+      if (paused) return paused;
+      const detected = autoDetectComplexity(ctx, def);
+      if (detected) {
+        complexity = detected.complexity;
+        activeStages = detected.activeStages;
       }
-      break;
+      commitAfterStage(ctx, def);
     } else {
+      const isTimeout = result.outcome === "timed_out";
       state.stages[def.name] = {
-        state: "failed",
+        state: isTimeout ? "timeout" : "failed",
         retries: result.retries,
-        error: result.error ?? "Stage failed"
+        error: isTimeout ? "Stage timed out" : result.error ?? "Stage failed"
       };
       state.state = "failed";
       writeState(state, ctx.taskDir);
-      logger.error(`[${def.name}] \u2717 failed: ${result.error}`);
+      logger.error(`[${def.name}] ${isTimeout ? "\u23F1 timed out" : `\u2717 failed: ${result.error}`}`);
       if (ctx.input.issueNumber && !ctx.input.local) {
         setLifecycleLabel(ctx.input.issueNumber, "failed");
       }
@@ -1422,9 +1884,7 @@ async function runPipeline(ctx) {
     }
     writeState(state, ctx.taskDir);
   }
-  const allCompleted = STAGES.every(
-    (s) => state.stages[s.name].state === "completed"
-  );
+  const allCompleted = STAGES.every((s) => state.stages[s.name].state === "completed");
   if (allCompleted) {
     state.state = "completed";
     writeState(state, ctx.taskDir);
@@ -1436,121 +1896,6 @@ async function runPipeline(ctx) {
   }
   return state;
 }
-function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*m/g, "");
-}
-function autoLearn(ctx) {
-  try {
-    const memoryDir = path4.join(ctx.projectDir, ".kody", "memory");
-    if (!fs4.existsSync(memoryDir)) {
-      fs4.mkdirSync(memoryDir, { recursive: true });
-    }
-    const learnings = [];
-    const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const verifyPath = path4.join(ctx.taskDir, "verify.md");
-    if (fs4.existsSync(verifyPath)) {
-      const verify = stripAnsi(fs4.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");
-      if (/prettier/i.test(verify)) learnings.push("- Uses prettier for formatting");
-      if (/tsc\b/i.test(verify)) learnings.push("- Uses TypeScript (tsc)");
-      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 = path4.join(ctx.taskDir, "review.md");
-    if (fs4.existsSync(reviewPath)) {
-      const review = fs4.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 = path4.join(ctx.taskDir, "task.json");
-    if (fs4.existsSync(taskJsonPath)) {
-      try {
-        const raw = stripAnsi(fs4.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)) {
-          const dirs = [...new Set(task.scope.map((s) => s.split("/").slice(0, -1).join("/")).filter(Boolean))];
-          if (dirs.length > 0) learnings.push(`- Active directories: ${dirs.join(", ")}`);
-        }
-      } catch {
-      }
-    }
-    if (learnings.length > 0) {
-      const conventionsPath = path4.join(memoryDir, "conventions.md");
-      const entry = `
-## Learned ${timestamp2} (task: ${ctx.taskId})
-${learnings.join("\n")}
-`;
-      fs4.appendFileSync(conventionsPath, entry);
-      logger.info(`Auto-learned ${learnings.length} convention(s)`);
-    }
-    autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
-  } catch {
-  }
-}
-function autoLearnArchitecture(projectDir, memoryDir, timestamp2) {
-  const archPath = path4.join(memoryDir, "architecture.md");
-  if (fs4.existsSync(archPath)) return;
-  const detected = [];
-  const pkgPath = path4.join(projectDir, "package.json");
-  if (fs4.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs4.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}`);
-      else if (allDeps.express) detected.push(`- Framework: Express ${allDeps.express}`);
-      else if (allDeps.fastify) detected.push(`- Framework: Fastify ${allDeps.fastify}`);
-      if (allDeps.typescript) detected.push(`- Language: TypeScript ${allDeps.typescript}`);
-      if (allDeps.vitest) detected.push(`- Testing: vitest ${allDeps.vitest}`);
-      else if (allDeps.jest) detected.push(`- Testing: jest ${allDeps.jest}`);
-      if (allDeps.eslint) detected.push(`- Linting: eslint ${allDeps.eslint}`);
-      if (allDeps.prisma || allDeps["@prisma/client"]) detected.push("- Database: Prisma ORM");
-      if (allDeps.drizzle || allDeps["drizzle-orm"]) detected.push("- Database: Drizzle ORM");
-      if (allDeps.pg || allDeps.postgres) detected.push("- Database: PostgreSQL");
-      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 (fs4.existsSync(path4.join(projectDir, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs4.existsSync(path4.join(projectDir, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs4.existsSync(path4.join(projectDir, "package-lock.json"))) detected.push("- Package manager: npm");
-    } catch {
-    }
-  }
-  const topDirs = [];
-  try {
-    const entries = fs4.readdirSync(projectDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        topDirs.push(entry.name);
-      }
-    }
-    if (topDirs.length > 0) detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
-  } catch {
-  }
-  const srcDir = path4.join(projectDir, "src");
-  if (fs4.existsSync(srcDir)) {
-    try {
-      const srcEntries = fs4.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 {
-    }
-  }
-  if (detected.length > 0) {
-    const content = `# Architecture (auto-detected ${timestamp2})
-
-## Overview
-${detected.join("\n")}
-`;
-    fs4.writeFileSync(archPath, content);
-    logger.info(`Auto-detected architecture (${detected.length} items)`);
-  }
-}
 function printStatus(taskId, taskDir) {
   const state = loadState(taskId, taskDir);
   if (!state) {
@@ -1570,29 +1915,24 @@ Task: ${state.taskId}`);
     console.log(`  ${icon} ${stage.name}: ${s.state}${extra}`);
   }
 }
-var COMPLEXITY_SKIP;
-var init_state_machine = __esm({
-  "src/state-machine.ts"() {
+var init_pipeline = __esm({
+  "src/pipeline.ts"() {
     "use strict";
     init_definitions();
-    init_context();
-    init_validators();
     init_git_utils();
     init_github_api();
-    init_verify_runner();
-    init_config();
     init_logger();
-    COMPLEXITY_SKIP = {
-      low: ["plan", "review", "review-fix"],
-      medium: ["review-fix"],
-      high: []
-    };
+    init_state();
+    init_complexity();
+    init_executor_registry();
+    init_hooks();
+    init_auto_learn();
   }
 });
 
 // src/preflight.ts
-import { execFileSync as execFileSync6 } from "child_process";
-import * as fs5 from "fs";
+import { execFileSync as execFileSync8 } from "child_process";
+import * as fs14 from "fs";
 function check(name, fn) {
   try {
     const detail = fn() ?? void 0;
@@ -1604,7 +1944,7 @@ function check(name, fn) {
 function runPreflight() {
   const checks = [
     check("claude CLI", () => {
-      const v = execFileSync6("claude", ["--version"], {
+      const v = execFileSync8("claude", ["--version"], {
         encoding: "utf-8",
         timeout: 1e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -1612,14 +1952,14 @@ function runPreflight() {
       return v;
     }),
     check("git repo", () => {
-      execFileSync6("git", ["rev-parse", "--is-inside-work-tree"], {
+      execFileSync8("git", ["rev-parse", "--is-inside-work-tree"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
     }),
     check("pnpm", () => {
-      const v = execFileSync6("pnpm", ["--version"], {
+      const v = execFileSync8("pnpm", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -1627,7 +1967,7 @@ function runPreflight() {
       return v;
     }),
     check("node >= 18", () => {
-      const v = execFileSync6("node", ["--version"], {
+      const v = execFileSync8("node", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -1637,7 +1977,7 @@ function runPreflight() {
       return v;
     }),
     check("gh CLI", () => {
-      const v = execFileSync6("gh", ["--version"], {
+      const v = execFileSync8("gh", ["--version"], {
         encoding: "utf-8",
         timeout: 5e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -1645,7 +1985,7 @@ function runPreflight() {
       return v;
     }),
     check("package.json", () => {
-      if (!fs5.existsSync("package.json")) throw new Error("not found");
+      if (!fs14.existsSync("package.json")) throw new Error("not found");
     })
   ];
   const failed = checks.filter((c) => !c.ok);
@@ -1665,11 +2005,7 @@ var init_preflight = __esm({
   }
 });
 
-// src/entry.ts
-var entry_exports = {};
-import * as fs6 from "fs";
-import * as path5 from "path";
-import { execFileSync as execFileSync7 } from "child_process";
+// src/cli/args.ts
 function getArg(args2, flag) {
   const idx = args2.indexOf(flag);
   if (idx !== -1 && args2[idx + 1] && !args2[idx + 1].startsWith("--")) {
@@ -1711,15 +2047,92 @@ function parseArgs() {
     complexity: getArg(args2, "--complexity") ?? process.env.COMPLEXITY
   };
 }
+var isCI2;
+var init_args = __esm({
+  "src/cli/args.ts"() {
+    "use strict";
+    isCI2 = !!process.env.GITHUB_ACTIONS;
+  }
+});
+
+// src/cli/litellm.ts
+import * as fs15 from "fs";
+import * as path14 from "path";
+import { execFileSync as execFileSync9 } from "child_process";
+async function checkLitellmHealth(url) {
+  try {
+    const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function tryStartLitellm(url, projectDir) {
+  const configPath = path14.join(projectDir, "litellm-config.yaml");
+  if (!fs15.existsSync(configPath)) {
+    logger.warn("litellm-config.yaml not found \u2014 cannot start proxy");
+    return null;
+  }
+  const portMatch = url.match(/:(\d+)/);
+  const port = portMatch ? portMatch[1] : "4000";
+  try {
+    execFileSync9("litellm", ["--version"], { timeout: 5e3, stdio: "pipe" });
+  } catch {
+    try {
+      execFileSync9("python3", ["-m", "litellm", "--version"], { timeout: 5e3, stdio: "pipe" });
+    } catch {
+      logger.warn("litellm not installed (pip install 'litellm[proxy]')");
+      return null;
+    }
+  }
+  logger.info(`Starting LiteLLM proxy on port ${port}...`);
+  let cmd;
+  let args2;
+  try {
+    execFileSync9("litellm", ["--version"], { timeout: 5e3, stdio: "pipe" });
+    cmd = "litellm";
+    args2 = ["--config", configPath, "--port", port];
+  } catch {
+    cmd = "python3";
+    args2 = ["-m", "litellm", "--config", configPath, "--port", port];
+  }
+  const { spawn: spawn2 } = await import("child_process");
+  const child = spawn2(cmd, args2, {
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    env: process.env
+  });
+  for (let i = 0; i < 30; i++) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    if (await checkLitellmHealth(url)) {
+      logger.info(`LiteLLM proxy ready at ${url}`);
+      return child;
+    }
+  }
+  logger.warn("LiteLLM proxy failed to start within 60s");
+  child.kill();
+  return null;
+}
+var init_litellm = __esm({
+  "src/cli/litellm.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/cli/task-resolution.ts
+import * as fs16 from "fs";
+import * as path15 from "path";
+import { execFileSync as execFileSync10 } from "child_process";
 function findLatestTaskForIssue(issueNumber, projectDir) {
-  const tasksDir = path5.join(projectDir, ".tasks");
-  if (!fs6.existsSync(tasksDir)) return null;
-  const allDirs = fs6.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  const tasksDir = path15.join(projectDir, ".tasks");
+  if (!fs16.existsSync(tasksDir)) return null;
+  const allDirs = fs16.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"], {
+    const branch = execFileSync10("git", ["branch", "--show-current"], {
       encoding: "utf-8",
       cwd: projectDir,
       timeout: 5e3,
@@ -1741,11 +2154,21 @@ 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())}`;
 }
+var init_task_resolution = __esm({
+  "src/cli/task-resolution.ts"() {
+    "use strict";
+  }
+});
+
+// src/entry.ts
+var entry_exports = {};
+import * as fs17 from "fs";
+import * as path16 from "path";
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path5.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path16.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs6.existsSync(projectDir)) {
+    if (!fs17.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -1772,8 +2195,8 @@ async function main() {
       process.exit(1);
     }
   }
-  const taskDir = path5.join(projectDir, ".tasks", taskId);
-  fs6.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path16.join(projectDir, ".tasks", taskId);
+  fs17.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
@@ -1781,22 +2204,22 @@ async function main() {
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs6.writeFileSync(path5.join(taskDir, "task.md"), input.task);
+    fs17.writeFileSync(path16.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path5.join(taskDir, "task.md");
-  if (!fs6.existsSync(taskMdPath) && input.issueNumber) {
+  const taskMdPath = path16.join(taskDir, "task.md");
+  if (!fs17.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 ?? ""}`;
-      fs6.writeFileSync(taskMdPath, taskContent);
+      fs17.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
   if (input.command === "run") {
-    if (!fs6.existsSync(taskMdPath)) {
+    if (!fs17.existsSync(taskMdPath)) {
       console.error("No task.md found. Provide --task, --issue-number, or ensure .tasks/<id>/task.md exists.");
       process.exit(1);
     }
@@ -1805,10 +2228,10 @@ ${issue.body ?? ""}`;
     input.fromStage = "build";
   }
   if (input.command === "rerun" && !input.fromStage) {
-    const statusPath = path5.join(taskDir, "status.json");
-    if (fs6.existsSync(statusPath)) {
+    const statusPath = path16.join(taskDir, "status.json");
+    if (fs17.existsSync(statusPath)) {
       try {
-        const status = JSON.parse(fs6.readFileSync(statusPath, "utf-8"));
+        const status = JSON.parse(fs17.readFileSync(statusPath, "utf-8"));
         const stageNames = ["taskify", "plan", "build", "verify", "review", "review-fix", "ship"];
         let foundPaused = false;
         for (const name of stageNames) {
@@ -1843,6 +2266,34 @@ ${issue.body ?? ""}`;
     }
   }
   const config = getProjectConfig();
+  let litellmProcess = null;
+  const cleanupLitellm = () => {
+    if (litellmProcess) {
+      litellmProcess.kill();
+      litellmProcess = null;
+    }
+  };
+  process.on("exit", cleanupLitellm);
+  process.on("SIGINT", () => {
+    cleanupLitellm();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanupLitellm();
+    process.exit(143);
+  });
+  if (config.agent.litellmUrl) {
+    const proxyRunning = await checkLitellmHealth(config.agent.litellmUrl);
+    if (!proxyRunning) {
+      litellmProcess = await tryStartLitellm(config.agent.litellmUrl, projectDir);
+      if (!litellmProcess) {
+        logger.warn("LiteLLM not available \u2014 falling back to Anthropic models");
+        config.agent.litellmUrl = void 0;
+      }
+    } else {
+      logger.info(`LiteLLM proxy already running at ${config.agent.litellmUrl}`);
+    }
+  }
   const runners = createRunners(config);
   const defaultRunnerName = config.agent.defaultRunner ?? Object.keys(runners)[0] ?? "claude";
   const defaultRunner = runners[defaultRunnerName];
@@ -1887,7 +2338,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs6.readdirSync(taskDir);
+  const files = fs17.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -1895,7 +2346,7 @@ Artifacts in ${taskDir}:`);
   }
   if (state.state === "failed") {
     const isPaused = Object.values(state.stages).some(
-      (s) => typeof s === "object" && s !== null && "error" in s && typeof s.error === "string" && s.error.includes("paused")
+      (s) => s.error?.includes("paused") ?? false
     );
     if (isPaused) {
       process.exit(0);
@@ -1917,17 +2368,18 @@ Artifacts in ${taskDir}:`);
     process.exit(1);
   }
 }
-var isCI2;
 var init_entry = __esm({
   "src/entry.ts"() {
     "use strict";
     init_agent_runner();
-    init_state_machine();
+    init_pipeline();
     init_preflight();
     init_config();
     init_github_api();
     init_logger();
-    isCI2 = !!process.env.GITHUB_ACTIONS;
+    init_args();
+    init_litellm();
+    init_task_resolution();
     main().catch(async (err) => {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(msg);
@@ -1945,20 +2397,20 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
-import { execFileSync as execFileSync8 } from "child_process";
+import * as fs18 from "fs";
+import * as path17 from "path";
+import { execFileSync as execFileSync11 } from "child_process";
 import { fileURLToPath } from "url";
-var __dirname = path6.dirname(fileURLToPath(import.meta.url));
-var PKG_ROOT = path6.resolve(__dirname, "..", "..");
+var __dirname = path17.dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = path17.resolve(__dirname, "..", "..");
 function getVersion() {
-  const pkgPath = path6.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path17.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs18.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 function checkCommand2(name, args2, fix) {
   try {
-    const output = execFileSync8(name, args2, {
+    const output = execFileSync11(name, args2, {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -1969,14 +2421,14 @@ function checkCommand2(name, args2, fix) {
   }
 }
 function checkFile(filePath, description, fix) {
-  if (fs7.existsSync(filePath)) {
+  if (fs18.existsSync(filePath)) {
     return { name: description, ok: true, detail: filePath };
   }
   return { name: description, ok: false, fix };
 }
 function checkGhAuth(cwd) {
   try {
-    const output = execFileSync8("gh", ["auth", "status"], {
+    const output = execFileSync11("gh", ["auth", "status"], {
       encoding: "utf-8",
       timeout: 1e4,
       cwd,
@@ -1985,7 +2437,7 @@ function checkGhAuth(cwd) {
     const account = output.match(/Logged in to .* account (\S+)/)?.[1];
     return { name: "gh auth", ok: true, detail: account ?? "authenticated" };
   } catch (err) {
-    const stderr = err.stderr ?? "";
+    const stderr = err instanceof Error && "stderr" in err ? String(err.stderr ?? "") : "";
     if (stderr.includes("not logged")) {
       return { name: "gh auth", ok: false, fix: "Run: gh auth login" };
     }
@@ -1994,7 +2446,7 @@ function checkGhAuth(cwd) {
 }
 function checkGhRepoAccess(cwd) {
   try {
-    const remote = execFileSync8("git", ["remote", "get-url", "origin"], {
+    const remote = execFileSync11("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -2005,7 +2457,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]}`;
-    execFileSync8("gh", ["repo", "view", repoSlug, "--json", "name"], {
+    execFileSync11("gh", ["repo", "view", repoSlug, "--json", "name"], {
       encoding: "utf-8",
       timeout: 1e4,
       cwd,
@@ -2018,7 +2470,7 @@ function checkGhRepoAccess(cwd) {
 }
 function checkGhSecret(repoSlug, secretName) {
   try {
-    const output = execFileSync8("gh", ["secret", "list", "--repo", repoSlug], {
+    const output = execFileSync11("gh", ["secret", "list", "--repo", repoSlug], {
       encoding: "utf-8",
       timeout: 1e4,
       stdio: ["pipe", "pipe", "pipe"]
@@ -2041,10 +2493,10 @@ function checkGhSecret(repoSlug, secretName) {
 }
 function detectArchitecture(cwd) {
   const detected = [];
-  const pkgPath = path6.join(cwd, "package.json");
-  if (fs7.existsSync(pkgPath)) {
+  const pkgPath = path17.join(cwd, "package.json");
+  if (fs18.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs18.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}`);
@@ -2067,44 +2519,44 @@ function detectArchitecture(cwd) {
       if (allDeps.tailwindcss) detected.push(`- CSS: Tailwind CSS ${allDeps.tailwindcss}`);
       if (pkg.type === "module") detected.push("- Module system: ESM");
       else detected.push("- Module system: CommonJS");
-      if (fs7.existsSync(path6.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs7.existsSync(path6.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs7.existsSync(path6.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
-      else if (fs7.existsSync(path6.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
+      if (fs18.existsSync(path17.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
+      else if (fs18.existsSync(path17.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
+      else if (fs18.existsSync(path17.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
+      else if (fs18.existsSync(path17.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
     } catch {
     }
   }
   try {
-    const entries = fs7.readdirSync(cwd, { withFileTypes: true });
+    const entries = fs18.readdirSync(cwd, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
     if (dirs.length > 0) detected.push(`- Top-level directories: ${dirs.join(", ")}`);
   } catch {
   }
-  const srcDir = path6.join(cwd, "src");
-  if (fs7.existsSync(srcDir)) {
+  const srcDir = path17.join(cwd, "src");
+  if (fs18.existsSync(srcDir)) {
     try {
-      const srcEntries = fs7.readdirSync(srcDir, { withFileTypes: true });
+      const srcEntries = fs18.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 {
     }
   }
   const configs = [];
-  if (fs7.existsSync(path6.join(cwd, "tsconfig.json"))) configs.push("tsconfig.json");
-  if (fs7.existsSync(path6.join(cwd, "docker-compose.yml")) || fs7.existsSync(path6.join(cwd, "docker-compose.yaml"))) configs.push("docker-compose");
-  if (fs7.existsSync(path6.join(cwd, "Dockerfile"))) configs.push("Dockerfile");
-  if (fs7.existsSync(path6.join(cwd, ".env")) || fs7.existsSync(path6.join(cwd, ".env.local"))) configs.push(".env");
+  if (fs18.existsSync(path17.join(cwd, "tsconfig.json"))) configs.push("tsconfig.json");
+  if (fs18.existsSync(path17.join(cwd, "docker-compose.yml")) || fs18.existsSync(path17.join(cwd, "docker-compose.yaml"))) configs.push("docker-compose");
+  if (fs18.existsSync(path17.join(cwd, "Dockerfile"))) configs.push("Dockerfile");
+  if (fs18.existsSync(path17.join(cwd, ".env")) || fs18.existsSync(path17.join(cwd, ".env.local"))) configs.push(".env");
   if (configs.length > 0) detected.push(`- Config files: ${configs.join(", ")}`);
   return detected;
 }
 function detectBasicConfig(cwd) {
   let pm = "pnpm";
-  if (fs7.existsSync(path6.join(cwd, "yarn.lock"))) pm = "yarn";
-  else if (fs7.existsSync(path6.join(cwd, "bun.lockb"))) pm = "bun";
-  else if (!fs7.existsSync(path6.join(cwd, "pnpm-lock.yaml")) && fs7.existsSync(path6.join(cwd, "package-lock.json"))) pm = "npm";
+  if (fs18.existsSync(path17.join(cwd, "yarn.lock"))) pm = "yarn";
+  else if (fs18.existsSync(path17.join(cwd, "bun.lockb"))) pm = "bun";
+  else if (!fs18.existsSync(path17.join(cwd, "pnpm-lock.yaml")) && fs18.existsSync(path17.join(cwd, "package-lock.json"))) pm = "npm";
   let defaultBranch = "main";
   try {
-    const ref = execFileSync8("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync11("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -2113,7 +2565,7 @@ function detectBasicConfig(cwd) {
     defaultBranch = ref.replace("refs/remotes/origin/", "");
   } catch {
     try {
-      execFileSync8("git", ["rev-parse", "--verify", "origin/dev"], {
+      execFileSync11("git", ["rev-parse", "--verify", "origin/dev"], {
         encoding: "utf-8",
         timeout: 5e3,
         cwd,
@@ -2126,7 +2578,7 @@ function detectBasicConfig(cwd) {
   let owner = "";
   let repo = "";
   try {
-    const remote = execFileSync8("git", ["remote", "get-url", "origin"], {
+    const remote = execFileSync11("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       timeout: 5e3,
       cwd,
@@ -2139,16 +2591,15 @@ function detectBasicConfig(cwd) {
     }
   } catch {
   }
-  const hasOpenCode = fs7.existsSync(path6.join(cwd, "opencode.json"));
-  return { defaultBranch, owner, repo, pm, hasOpenCode };
+  return { defaultBranch, owner, repo, pm };
 }
 function smartInit(cwd) {
   const basic = detectBasicConfig(cwd);
   let context = "";
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path6.join(cwd, rel);
-    if (fs7.existsSync(p)) {
-      const content = fs7.readFileSync(p, "utf-8");
+    const p = path17.join(cwd, rel);
+    if (fs18.existsSync(p)) {
+      const content = fs18.readFileSync(p, "utf-8");
       return content.slice(0, maxChars);
     }
     return null;
@@ -2174,14 +2625,14 @@ ${claudeMd}
 
 `;
   try {
-    const topDirs = fs7.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs18.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
     context += `## Top-level directories
 ${topDirs.join(", ")}
 
 `;
-    const srcDir = path6.join(cwd, "src");
-    if (fs7.existsSync(srcDir)) {
-      const srcDirs = fs7.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const srcDir = path17.join(cwd, "src");
+    if (fs18.existsSync(srcDir)) {
+      const srcDirs = fs18.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       context += `## src/ subdirectories
 ${srcDirs.join(", ")}
 
@@ -2190,14 +2641,14 @@ ${srcDirs.join(", ")}
   } catch {
   }
   const existingFiles = [];
-  for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "opencode.json", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
-    if (fs7.existsSync(path6.join(cwd, f))) existingFiles.push(f);
+  for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
+    if (fs18.existsSync(path17.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) context += `## Config files present
 ${existingFiles.join(", ")}
 
 `;
-  context += `## Detected: package manager=${basic.pm}, default branch=${basic.defaultBranch}, github=${basic.owner}/${basic.repo}, opencode=${basic.hasOpenCode}
+  context += `## Detected: package manager=${basic.pm}, default branch=${basic.defaultBranch}, github=${basic.owner}/${basic.repo}
 `;
   const prompt = `You are analyzing a project to configure Kody (an autonomous SDLC pipeline).
 
@@ -2217,8 +2668,8 @@ Given this project context, output ONLY a JSON object with EXACTLY this structur
     "github": { "owner": "${basic.owner}", "repo": "${basic.repo}" },
     "paths": { "taskDir": ".tasks" },
     "agent": {
-      "runner": "${basic.hasOpenCode ? "opencode" : "claude-code"}",
-      "defaultRunner": "${basic.hasOpenCode ? "opencode" : "claude"}",
+      "runner": "${"claude-code"}",
+      "defaultRunner": "${"claude"}",
       "modelMap": { "cheap": "haiku", "mid": "sonnet", "strong": "opus" }
     }
   },
@@ -2250,7 +2701,7 @@ Output ONLY valid JSON. No markdown fences. No explanation before or after.
 ${context}`;
   console.log("  \u23F3 Analyzing project with Claude Code...");
   try {
-    const output = execFileSync8("claude", [
+    const output = execFileSync11("claude", [
       "--print",
       "--model",
       "haiku",
@@ -2269,12 +2720,13 @@ ${context}`;
     if (!config.github) config.github = {};
     if (!config.paths) config.paths = {};
     if (!config.agent) config.agent = {};
+    config["$schema"] = "https://raw.githubusercontent.com/aharonyaircohen/Kody-Engine-Lite/main/kody.config.schema.json";
     config.git.defaultBranch = config.git.defaultBranch || basic.defaultBranch;
     config.github.owner = config.github.owner || basic.owner;
     config.github.repo = config.github.repo || basic.repo;
     config.paths.taskDir = config.paths.taskDir || ".tasks";
-    config.agent.runner = config.agent.runner || (basic.hasOpenCode ? "opencode" : "claude-code");
-    config.agent.defaultRunner = config.agent.defaultRunner || (basic.hasOpenCode ? "opencode" : "claude");
+    config.agent.runner = config.agent.runner || "claude-code";
+    config.agent.defaultRunner = config.agent.defaultRunner || "claude";
     if (!config.agent.modelMap) {
       config.agent.modelMap = { cheap: "haiku", mid: "sonnet", strong: "opus" };
     }
@@ -2296,7 +2748,7 @@ ${context}`;
 function validateQualityCommands(cwd, config, pm) {
   let scripts = {};
   try {
-    const pkg = JSON.parse(fs7.readFileSync(path6.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs18.readFileSync(path17.join(cwd, "package.json"), "utf-8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return;
@@ -2330,7 +2782,7 @@ function validateQualityCommands(cwd, config, pm) {
 function buildFallbackConfig(cwd, basic) {
   const pkg = (() => {
     try {
-      return JSON.parse(fs7.readFileSync(path6.join(cwd, "package.json"), "utf-8"));
+      return JSON.parse(fs18.readFileSync(path17.join(cwd, "package.json"), "utf-8"));
     } catch {
       return {};
     }
@@ -2343,6 +2795,7 @@ function buildFallbackConfig(cwd, basic) {
     return "";
   };
   return {
+    "$schema": "https://raw.githubusercontent.com/aharonyaircohen/Kody-Engine-Lite/main/kody.config.schema.json",
     quality: {
       typecheck: find("typecheck", "type-check") || (pkg.devDependencies?.typescript ? `${basic.pm} tsc --noEmit` : ""),
       lint: find("lint"),
@@ -2355,8 +2808,8 @@ function buildFallbackConfig(cwd, basic) {
     github: { owner: basic.owner, repo: basic.repo },
     paths: { taskDir: ".tasks" },
     agent: {
-      runner: basic.hasOpenCode ? "opencode" : "claude-code",
-      defaultRunner: basic.hasOpenCode ? "opencode" : "claude",
+      runner: "claude-code",
+      defaultRunner: "claude",
       modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
     }
   };
@@ -2369,34 +2822,34 @@ function initCommand(opts) {
   console.log(`Project: ${cwd}
 `);
   console.log("\u2500\u2500 Files \u2500\u2500");
-  const templatesDir = path6.join(PKG_ROOT, "templates");
-  const workflowSrc = path6.join(templatesDir, "kody.yml");
-  const workflowDest = path6.join(cwd, ".github", "workflows", "kody.yml");
-  if (!fs7.existsSync(workflowSrc)) {
+  const templatesDir = path17.join(PKG_ROOT, "templates");
+  const workflowSrc = path17.join(templatesDir, "kody.yml");
+  const workflowDest = path17.join(cwd, ".github", "workflows", "kody.yml");
+  if (!fs18.existsSync(workflowSrc)) {
     console.error("  \u2717 Template kody.yml not found in package");
     process.exit(1);
   }
-  if (fs7.existsSync(workflowDest) && !opts.force) {
+  if (fs18.existsSync(workflowDest) && !opts.force) {
     console.log("  \u25CB .github/workflows/kody.yml (exists, use --force to overwrite)");
   } else {
-    fs7.mkdirSync(path6.dirname(workflowDest), { recursive: true });
-    fs7.copyFileSync(workflowSrc, workflowDest);
+    fs18.mkdirSync(path17.dirname(workflowDest), { recursive: true });
+    fs18.copyFileSync(workflowSrc, workflowDest);
     console.log("  \u2713 .github/workflows/kody.yml");
   }
-  const configDest = path6.join(cwd, "kody.config.json");
+  const configDest = path17.join(cwd, "kody.config.json");
   let smartResult = null;
-  if (!fs7.existsSync(configDest) || opts.force) {
+  if (!fs18.existsSync(configDest) || opts.force) {
     smartResult = smartInit(cwd);
-    fs7.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
+    fs18.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
     console.log("  \u2713 kody.config.json (auto-configured)");
   } else {
     console.log("  \u25CB kody.config.json (exists)");
   }
-  const gitignorePath = path6.join(cwd, ".gitignore");
-  if (fs7.existsSync(gitignorePath)) {
-    const content = fs7.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path17.join(cwd, ".gitignore");
+  if (fs18.existsSync(gitignorePath)) {
+    const content = fs18.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".tasks/")) {
-      fs7.appendFileSync(gitignorePath, "\n.tasks/\n");
+      fs18.appendFileSync(gitignorePath, "\n.tasks/\n");
       console.log("  \u2713 .gitignore (added .tasks/)");
     } else {
       console.log("  \u25CB .gitignore (.tasks/ already present)");
@@ -2409,7 +2862,7 @@ function initCommand(opts) {
     checkCommand2("git", ["--version"], "Install git"),
     checkCommand2("node", ["--version"], "Install Node.js >= 22"),
     checkCommand2("pnpm", ["--version"], "Install: npm i -g pnpm"),
-    checkFile(path6.join(cwd, "package.json"), "package.json", "Run: pnpm init")
+    checkFile(path17.join(cwd, "package.json"), "package.json", "Run: pnpm init")
   ];
   for (const c of checks) {
     if (c.ok) {
@@ -2454,7 +2907,7 @@ function initCommand(opts) {
     console.log("\n\u2500\u2500 Labels \u2500\u2500");
     for (const label of labels) {
       try {
-        execFileSync8("gh", [
+        execFileSync11("gh", [
           "label",
           "create",
           label.name,
@@ -2473,7 +2926,7 @@ function initCommand(opts) {
         console.log(`  \u2713 ${label.name}`);
       } catch {
         try {
-          execFileSync8("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
+          execFileSync11("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
             encoding: "utf-8",
             timeout: 1e4,
             stdio: ["pipe", "pipe", "pipe"]
@@ -2486,9 +2939,9 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Config \u2500\u2500");
-  if (fs7.existsSync(configDest)) {
+  if (fs18.existsSync(configDest)) {
     try {
-      const config = JSON.parse(fs7.readFileSync(configDest, "utf-8"));
+      const config = JSON.parse(fs18.readFileSync(configDest, "utf-8"));
       const configChecks = [];
       if (config.github?.owner && config.github?.repo) {
         configChecks.push({ name: "github.owner/repo", ok: true, detail: `${config.github.owner}/${config.github.repo}` });
@@ -2515,21 +2968,21 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Project Memory \u2500\u2500");
-  const memoryDir = path6.join(cwd, ".kody", "memory");
-  fs7.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path6.join(memoryDir, "architecture.md");
-  const conventionsPath = path6.join(memoryDir, "conventions.md");
-  if (fs7.existsSync(archPath) && !opts.force) {
+  const memoryDir = path17.join(cwd, ".kody", "memory");
+  fs18.mkdirSync(memoryDir, { recursive: true });
+  const archPath = path17.join(memoryDir, "architecture.md");
+  const conventionsPath = path17.join(memoryDir, "conventions.md");
+  if (fs18.existsSync(archPath) && !opts.force) {
     console.log("  \u25CB .kody/memory/architecture.md (exists, use --force to regenerate)");
   } else if (smartResult?.architecture) {
-    fs7.writeFileSync(archPath, smartResult.architecture);
+    fs18.writeFileSync(archPath, smartResult.architecture);
     const lineCount = smartResult.architecture.split("\n").length;
     console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines, LLM-generated)`);
   } else {
     const archItems = detectArchitecture(cwd);
     if (archItems.length > 0) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs7.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs18.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${archItems.join("\n")}
@@ -2539,14 +2992,14 @@ ${archItems.join("\n")}
       console.log("  \u25CB No architecture detected");
     }
   }
-  if (fs7.existsSync(conventionsPath) && !opts.force) {
+  if (fs18.existsSync(conventionsPath) && !opts.force) {
     console.log("  \u25CB .kody/memory/conventions.md (exists, use --force to regenerate)");
   } else if (smartResult?.conventions) {
-    fs7.writeFileSync(conventionsPath, smartResult.conventions);
+    fs18.writeFileSync(conventionsPath, smartResult.conventions);
     const lineCount = smartResult.conventions.split("\n").length;
     console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines, LLM-generated)`);
   } else {
-    fs7.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs18.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }
   const allChecks = [...checks, ghAuth, ghRepo];