@kody-ade/kody-engine-lite 0.1.21 → 0.1.23

package/dist/bin/cli.js

@@ -199,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;
@@ -542,7 +297,8 @@ function ensureFeatureBranch(issueNumber, title, cwd) {
     try {
       git(["checkout", defaultBranch2], { cwd });
     } catch {
-      logger.warn(`  Failed to checkout ${defaultBranch2}`);
+      logger.warn(`  Failed to checkout ${defaultBranch2}, aborting branch creation`);
+      return current;
     }
   }
   try {
@@ -600,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}`);
@@ -725,33 +481,492 @@ 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 };
+}
+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 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: []
+    };
+  }
+});
+
+// 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 (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 };
+    }
+  } 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";
+    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/context.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+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 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 {
+    }
+  }
+  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}
+---
+
+${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 stripFences(content) {
+  return content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+}
+function validateTaskJson(content) {
+  try {
+    const parsed = JSON.parse(stripFences(content));
+    for (const field of REQUIRED_TASK_FIELDS) {
+      if (!(field in parsed)) {
+        return { valid: false, error: `Missing field: ${field}` };
+      }
+    }
+    return { valid: true };
+  } catch (err) {
+    return {
+      valid: false,
+      error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+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";
+  const runner = ctx.runners[runnerName];
+  if (!runner) {
+    throw new Error(
+      `Runner "${runnerName}" not found for stage ${stageName}. Available: ${Object.keys(ctx.runners).join(", ")}`
+    );
+  }
+  return runner;
+}
+var init_runner_selection = __esm({
+  "src/pipeline/runner-selection.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/stages/agent.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function validateStageOutput(stageName, content) {
+  switch (stageName) {
+    case "taskify":
+      return validateTaskJson(content);
+    case "plan":
+      return validatePlanMd(content);
+    case "review":
+      return validateReviewMd(content);
+    default:
+      return { valid: true };
+  }
+}
+async function executeAgentStage(ctx, def) {
+  if (ctx.input.dryRun) {
+    logger.info(`  [dry-run] skipping ${def.name}`);
+    return { outcome: "completed", retries: 0 };
+  }
+  const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
+  const model = resolveModel(def.modelTier, def.name);
+  const config = getProjectConfig();
+  const runnerName = config.agent.stageRunners?.[def.name] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
+  logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1e3}s`);
+  const extraEnv = {};
+  if (config.agent.litellmUrl) {
+    extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
+  }
+  const runner = getRunnerForStage(ctx, def.name);
+  const result = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
+    cwd: ctx.projectDir,
+    env: extraEnv
+  });
+  if (result.outcome !== "completed") {
+    return { outcome: result.outcome, error: result.error, retries: 0 };
+  }
+  if (def.outputFile && result.output) {
+    fs5.writeFileSync(path5.join(ctx.taskDir, def.outputFile), result.output);
+  }
+  if (def.outputFile) {
+    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) {
+        fs5.renameSync(path5.join(ctx.taskDir, variant), outputPath);
+        logger.info(`  Renamed variant ${variant} \u2192 ${def.outputFile}`);
+      }
+    }
+  }
+  if (def.outputFile) {
+    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) {
+        if (def.name === "taskify") {
+          logger.warn(`  taskify output invalid (${validation.error}), retrying...`);
+          const retryPrompt = prompt + "\n\nIMPORTANT: Your previous output was not valid JSON. Output ONLY the raw JSON object. No markdown, no fences, no explanation.";
+          const retryResult = await runner.run(def.name, retryPrompt, model, def.timeout, ctx.taskDir, {
+            cwd: ctx.projectDir,
+            env: extraEnv
+          });
+          if (retryResult.outcome === "completed" && retryResult.output) {
+            const stripped = stripFences(retryResult.output);
+            const retryValidation = validateTaskJson(stripped);
+            if (retryValidation.valid) {
+              fs5.writeFileSync(outputPath, retryResult.output);
+              logger.info(`  taskify retry produced valid JSON`);
+            } else {
+              logger.warn(`  taskify retry still invalid: ${retryValidation.error}`);
+            }
+          }
+        } else {
+          logger.warn(`  validation warning: ${validation.error}`);
+        }
+      }
+    }
+  }
+  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;
@@ -787,431 +1002,811 @@ function runQualityGates(taskDir, projectRoot) {
     }
     allSummary.push(...extractSummary(result.output, name));
   }
-  return { pass: allPass, errors: allErrors, summary: allSummary };
+  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}`);
+    return { outcome: "completed", retries: 0 };
+  }
+  const verifyResult = runQualityGates(ctx.taskDir, ctx.projectDir);
+  const lines = [
+    `# Verification Report
+`,
+    `## Result: ${verifyResult.pass ? "PASS" : "FAIL"}
+`
+  ];
+  if (verifyResult.errors.length > 0) {
+    lines.push(`
+## Errors
+`);
+    for (const e of verifyResult.errors) {
+      lines.push(`- ${e}
+`);
+    }
+  }
+  if (verifyResult.summary.length > 0) {
+    lines.push(`
+## Summary
+`);
+    for (const s of verifyResult.summary) {
+      lines.push(`- ${s}
+`);
+    }
+  }
+  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++) {
+    logger.info(`  verification attempt ${attempt + 1}/${maxAttempts + 1}`);
+    const gateResult = executeGateStage(ctx, def);
+    if (gateResult.outcome === "completed") {
+      return { ...gateResult, retries: attempt };
+    }
+    if (attempt < maxAttempts) {
+      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 = parseCommand(cmd);
+        if (parts.length === 0) return;
+        try {
+          execFileSync6(parts[0], parts.slice(1), {
+            stdio: "pipe",
+            timeout: FIX_COMMAND_TIMEOUT_MS
+          });
+        } catch {
+        }
+      };
+      runFix(config.quality.lintFix);
+      runFix(config.quality.formatFix);
+      if (def.retryWithAgent) {
+        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",
+          modelTier: "mid",
+          timeout: 3e5,
+          outputFile: void 0
+        });
+      }
+    }
+  }
+  return {
+    outcome: "failed",
+    retries: maxAttempts,
+    error: "Verification failed after autofix attempts"
+  };
+}
+var init_verify = __esm({
+  "src/stages/verify.ts"() {
+    "use strict";
+    init_context();
+    init_config();
+    init_verify_runner();
+    init_runner_selection();
+    init_github_api();
+    init_observer();
+    init_logger();
+    init_agent();
+    init_gate();
+  }
+});
+
+// src/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 };
+  }
+  const reviewDef = STAGES.find((s) => s.name === "review");
+  const reviewFixDef = STAGES.find((s) => s.name === "review-fix");
+  const reviewResult = await executeAgentStage(ctx, reviewDef);
+  if (reviewResult.outcome !== "completed") {
+    return reviewResult;
+  }
+  const reviewFile = path8.join(ctx.taskDir, "review.md");
+  if (!fs8.existsSync(reviewFile)) {
+    return { outcome: "failed", retries: 0, error: "review.md not found" };
+  }
+  const content = fs8.readFileSync(reviewFile, "utf-8");
+  const hasIssues = /\bfail\b/i.test(content) && !/pass/i.test(content);
+  if (!hasIssues) {
+    return reviewResult;
+  }
+  logger.info(`  review found issues, running review-fix...`);
+  const fixResult = await executeAgentStage(ctx, reviewFixDef);
+  if (fixResult.outcome !== "completed") {
+    return fixResult;
+  }
+  logger.info(`  re-running review after fix...`);
+  return executeAgentStage(ctx, reviewDef);
 }
-var init_verify_runner = __esm({
-  "src/verify-runner.ts"() {
+var init_review = __esm({
+  "src/stages/review.ts"() {
     "use strict";
-    init_config();
+    init_definitions();
     init_logger();
+    init_agent();
   }
 });
 
-// src/state-machine.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 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");
+// 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 = path9.join(ctx.taskDir, "task.json");
+  if (fs9.existsSync(taskJsonPath)) {
+    try {
+      const raw = fs9.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:**
+      const task = JSON.parse(cleaned);
+      if (task.description) {
+        sections.push(`## What
 
-${taskJson.questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}
+${task.description}`);
+      }
+      if (task.scope?.length) {
+        sections.push(`
+## Scope
 
-Reply with \`@kody approve\` and your answers in the comment body.`;
-        postComment(ctx.input.issueNumber, body);
-        setLifecycleLabel(ctx.input.issueNumber, "waiting");
-        return true;
+${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
       }
+      sections.push(`
+**Type:** ${task.task_type ?? "unknown"} | **Risk:** ${task.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:**
-
-${questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}
+  }
+  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();
+      if (summary) {
+        sections.push(`
+## Changes
 
-Reply with \`@kody approve\` and your answers in the comment body.`;
-          postComment(ctx.input.issueNumber, body);
-          setLifecycleLabel(ctx.input.issueNumber, "waiting");
-          return true;
-        }
+${summary}`);
       }
     }
-  } catch {
-  }
-  return false;
-}
-function getRunnerForStage(ctx, stageName) {
-  const config = getProjectConfig();
-  const runnerName = config.agent.stageRunners?.[stageName] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
-  const runner = ctx.runners[runnerName];
-  if (!runner) {
-    throw new Error(
-      `Runner "${runnerName}" not found for stage ${stageName}. Available: ${Object.keys(ctx.runners).join(", ")}`
-    );
+    const verdictMatch = review.match(/## Verdict:\s*(PASS|FAIL)/i);
+    if (verdictMatch) {
+      sections.push(`
+**Review:** ${verdictMatch[1].toUpperCase() === "PASS" ? "\u2705 PASS" : "\u274C FAIL"}`);
+    }
   }
-  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;
+  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`);
   }
-}
-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 };
+  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(`
+<details><summary>\u{1F4CB} Implementation plan</summary>
+
+${truncated}
+</details>`);
+    }
   }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return { taskId, state: "running", stages, createdAt: now, updatedAt: now };
-}
-function validateStageOutput(stageName, content) {
-  switch (stageName) {
-    case "taskify":
-      return validateTaskJson(content);
-    case "plan":
-      return validatePlanMd(content);
-    case "review":
-      return validateReviewMd(content);
-    default:
-      return { valid: true };
+  if (ctx.input.issueNumber) {
+    sections.push(`
+Closes #${ctx.input.issueNumber}`);
   }
+  sections.push(`
+---
+\u{1F916} Generated by Kody`);
+  return sections.join("\n");
 }
-async function executeAgentStage(ctx, def) {
+function executeShipStage(ctx, _def) {
+  const shipPath = path9.join(ctx.taskDir, "ship.md");
   if (ctx.input.dryRun) {
-    logger.info(`  [dry-run] skipping ${def.name}`);
-    return { outcome: "completed", retries: 0 };
+    fs9.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 dry run.\n");
+    return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
-  const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
-  const model = resolveModel(def.modelTier, def.name);
-  const config = getProjectConfig();
-  const runnerName = config.agent.stageRunners?.[def.name] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
-  logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1e3}s`);
-  const extraEnv = {};
-  if (config.agent.litellmUrl) {
-    extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
+  if (ctx.input.local && !ctx.input.issueNumber) {
+    fs9.writeFileSync(shipPath, "# Ship\n\nShip stage skipped \u2014 local mode, no issue number.\n");
+    return { outcome: "completed", outputFile: "ship.md", retries: 0 };
   }
-  const runner = getRunnerForStage(ctx, def.name);
-  const result = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
-    cwd: ctx.projectDir,
-    env: extraEnv
-  });
-  if (result.outcome !== "completed") {
-    return { outcome: result.outcome, error: result.error, retries: 0 };
+  try {
+    const head = getCurrentBranch(ctx.projectDir);
+    const base = getDefaultBranch(ctx.projectDir);
+    pushBranch(ctx.projectDir);
+    const config = getProjectConfig();
+    let owner = config.github?.owner;
+    let repo = config.github?.repo;
+    if (!owner || !repo) {
+      try {
+        const remoteUrl = execFileSync7("git", ["remote", "get-url", "origin"], {
+          encoding: "utf-8",
+          cwd: ctx.projectDir
+        }).trim();
+        const match = remoteUrl.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+        if (match) {
+          owner = match[1];
+          repo = match[2];
+        }
+      } catch {
+      }
+    }
+    let title = "Update";
+    const TYPE_PREFIX = {
+      feature: "feat",
+      bugfix: "fix",
+      refactor: "refactor",
+      docs: "docs",
+      chore: "chore"
+    };
+    const taskJsonPath = path9.join(ctx.taskDir, "task.json");
+    if (fs9.existsSync(taskJsonPath)) {
+      try {
+        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";
+        const taskTitle = task.title ?? "Update";
+        title = `${prefix}: ${taskTitle}`.slice(0, 72);
+      } catch {
+      }
+    }
+    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 };
   }
-  if (def.outputFile && result.output) {
-    fs4.writeFileSync(path4.join(ctx.taskDir, def.outputFile), result.output);
+}
+var init_ship = __esm({
+  "src/stages/ship.ts"() {
+    "use strict";
+    init_git_utils();
+    init_github_api();
+    init_config();
   }
-  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 variant = files.find(
-        (f) => f.startsWith(base + "-") && f.endsWith(ext)
-      );
-      if (variant) {
-        fs4.renameSync(path4.join(ctx.taskDir, variant), outputPath);
-        logger.info(`  Renamed variant ${variant} \u2192 ${def.outputFile}`);
+});
+
+// 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 (def.outputFile) {
-    const outputPath = path4.join(ctx.taskDir, def.outputFile);
-    if (fs4.existsSync(outputPath)) {
-      const content = fs4.readFileSync(outputPath, "utf-8");
-      const validation = validateStageOutput(def.name, content);
-      if (!validation.valid) {
-        logger.warn(`  validation warning: ${validation.error}`);
+    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 { outcome: "completed", outputFile: def.outputFile, retries: 0 };
+  return false;
 }
-function executeGateStage(ctx, def) {
-  if (ctx.input.dryRun) {
-    logger.info(`  [dry-run] skipping ${def.name}`);
-    return { outcome: "completed", retries: 0 };
-  }
-  const verifyResult = runQualityGates(ctx.taskDir, ctx.projectDir);
-  const lines = [
-    `# Verification Report
-`,
-    `## Result: ${verifyResult.pass ? "PASS" : "FAIL"}
-`
-  ];
-  if (verifyResult.errors.length > 0) {
-    lines.push(`
-## Errors
-`);
-    for (const e of verifyResult.errors) {
-      lines.push(`- ${e}
-`);
-    }
-  }
-  if (verifyResult.summary.length > 0) {
-    lines.push(`
-## Summary
-`);
-    for (const s of verifyResult.summary) {
-      lines.push(`- ${s}
-`);
-    }
+var init_questions = __esm({
+  "src/pipeline/questions.ts"() {
+    "use strict";
+    init_github_api();
   }
-  fs4.writeFileSync(path4.join(ctx.taskDir, "verify.md"), lines.join(""));
-  return {
-    outcome: verifyResult.pass ? "completed" : "failed",
-    retries: 0
+});
+
+// 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;
 }
-async function executeVerifyWithAutofix(ctx, def) {
-  const maxAttempts = def.maxRetries ?? 2;
-  for (let attempt = 0; attempt <= maxAttempts; attempt++) {
-    logger.info(`  verification attempt ${attempt + 1}/${maxAttempts + 1}`);
-    const gateResult = executeGateStage(ctx, def);
-    if (gateResult.outcome === "completed") {
-      return { ...gateResult, retries: attempt };
-    }
-    if (attempt < maxAttempts) {
-      logger.info(`  verification failed, running fixes...`);
-      const config = getProjectConfig();
-      const runFix = (cmd) => {
-        if (!cmd) return;
-        const parts = cmd.split(/\s+/);
+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 {
-          execFileSync5(parts[0], parts.slice(1), {
-            stdio: "pipe",
-            timeout: FIX_COMMAND_TIMEOUT_MS
-          });
+          setLabel(ctx.input.issueNumber, `kody:${taskJson.task_type}`);
         } catch {
         }
-      };
-      runFix(config.quality.lintFix);
-      runFix(config.quality.formatFix);
-      if (def.retryWithAgent) {
-        logger.info(`  running ${def.retryWithAgent} agent...`);
-        await executeAgentStage(ctx, {
-          ...def,
-          name: def.retryWithAgent,
-          type: "agent",
-          modelTier: "mid",
-          timeout: 3e5,
-          outputFile: void 0
-        });
       }
     }
+    return { complexity, activeStages };
+  } catch {
+    return null;
   }
-  return {
-    outcome: "failed",
-    retries: maxAttempts,
-    error: "Verification failed after autofix attempts"
-  };
 }
-async function executeReviewWithFix(ctx, def) {
-  if (ctx.input.dryRun) {
-    return { outcome: "completed", retries: 0 };
+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 {
+    }
   }
-  const reviewDef = STAGES.find((s) => s.name === "review");
-  const reviewFixDef = STAGES.find((s) => s.name === "review-fix");
-  const reviewResult = await executeAgentStage(ctx, reviewDef);
-  if (reviewResult.outcome !== "completed") {
-    return reviewResult;
+  if (def.name === "review-fix") {
+    try {
+      commitAll(`fix(${ctx.taskId}): address review`, ctx.projectDir);
+    } catch {
+    }
   }
-  const reviewFile = path4.join(ctx.taskDir, "review.md");
-  if (!fs4.existsSync(reviewFile)) {
-    return { outcome: "failed", retries: 0, error: "review.md not found" };
+}
+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 {
   }
-  const content = fs4.readFileSync(reviewFile, "utf-8");
-  const hasIssues = /\bfail\b/i.test(content) && !/pass/i.test(content);
-  if (!hasIssues) {
-    return reviewResult;
+}
+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();
   }
-  logger.info(`  review found issues, running review-fix...`);
-  const fixResult = await executeAgentStage(ctx, reviewFixDef);
-  if (fixResult.outcome !== "completed") {
-    return fixResult;
+});
+
+// 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 {
   }
-  logger.info(`  re-running review after fix...`);
-  return executeAgentStage(ctx, reviewDef);
 }
-function buildPrBody(ctx) {
-  const sections = [];
-  const taskJsonPath = path4.join(ctx.taskDir, "task.json");
-  if (fs4.existsSync(taskJsonPath)) {
+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 raw = fs4.readFileSync(taskJsonPath, "utf-8");
-      const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
-      const task = JSON.parse(cleaned);
-      if (task.description) {
-        sections.push(`## What
-
-${task.description}`);
-      }
-      if (task.scope?.length) {
-        sections.push(`
-## Scope
-
-${task.scope.map((s) => `- \`${s}\``).join("\n")}`);
-      }
-      sections.push(`
-**Type:** ${task.task_type ?? "unknown"} | **Risk:** ${task.risk_level ?? "unknown"}`);
+      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 reviewPath = path4.join(ctx.taskDir, "review.md");
-  if (fs4.existsSync(reviewPath)) {
-    const review = fs4.readFileSync(reviewPath, "utf-8");
-    const summaryMatch = review.match(/## Summary\s*\n([\s\S]*?)(?=\n## |\n*$)/);
-    if (summaryMatch) {
-      const summary = summaryMatch[1].trim();
-      if (summary) {
-        sections.push(`
-## Changes
-
-${summary}`);
+  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);
       }
     }
-    const verdictMatch = review.match(/## Verdict:\s*(PASS|FAIL)/i);
-    if (verdictMatch) {
-      sections.push(`
-**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");
-    if (/PASS/i.test(verify)) sections.push(`**Verify:** \u2705 typecheck + tests + lint passed`);
+    if (topDirs.length > 0) detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
+  } catch {
   }
-  const planPath = path4.join(ctx.taskDir, "plan.md");
-  if (fs4.existsSync(planPath)) {
-    const plan = fs4.readFileSync(planPath, "utf-8").trim();
-    if (plan) {
-      const truncated = plan.length > 800 ? plan.slice(0, 800) + "\n..." : plan;
-      sections.push(`
-<details><summary>\u{1F4CB} Implementation plan</summary>
-
-${truncated}
-</details>`);
+  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 {
     }
   }
-  if (ctx.input.issueNumber) {
-    sections.push(`
-Closes #${ctx.input.issueNumber}`);
+  if (detected.length > 0) {
+    const content = `# Architecture (auto-detected ${timestamp2})
+
+## Overview
+${detected.join("\n")}
+`;
+    fs12.writeFileSync(archPath, content);
+    logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
-  sections.push(`
----
-\u{1F916} Generated by Kody`);
-  return sections.join("\n");
 }
-function executeShipStage(ctx, _def) {
-  const shipPath = path4.join(ctx.taskDir, "ship.md");
-  if (ctx.input.dryRun) {
-    fs4.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");
-    return { outcome: "completed", outputFile: "ship.md", retries: 0 };
+var init_auto_learn = __esm({
+  "src/learning/auto-learn.ts"() {
+    "use strict";
+    init_logger();
   }
+});
+
+// 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 head = getCurrentBranch(ctx.projectDir);
-    const base = getDefaultBranch(ctx.projectDir);
-    pushBranch(ctx.projectDir);
-    const config = getProjectConfig();
-    let owner = config.github?.owner;
-    let repo = config.github?.repo;
-    if (!owner || !repo) {
-      try {
-        const remoteUrl = execFileSync5("git", ["remote", "get-url", "origin"], {
-          encoding: "utf-8",
-          cwd: ctx.projectDir
-        }).trim();
-        const match = remoteUrl.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
-        if (match) {
-          owner = match[1];
-          repo = match[2];
-        }
-      } catch {
-      }
-    }
-    let title = "Update";
-    const TYPE_PREFIX = {
-      feature: "feat",
-      bugfix: "fix",
-      refactor: "refactor",
-      docs: "docs",
-      chore: "chore"
-    };
-    const taskJsonPath = path4.join(ctx.taskDir, "task.json");
-    if (fs4.existsSync(taskJsonPath)) {
+    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 {
-        const raw = fs4.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";
-        const taskTitle = task.title ?? "Update";
-        title = `${prefix}: ${taskTitle}`.slice(0, 72);
-      } 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);
-      }
-    }
-    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 {
-        }
+        process.kill(pid, 0);
+        throw new Error(`Pipeline already running (PID ${pid})`);
+      } catch (e) {
+        if (e.code !== "ESRCH") throw e;
       }
-      fs4.writeFileSync(shipPath, `# Ship
-
-PR created: ${pr.url}
-PR #${pr.number}
-`);
-    } else {
-      fs4.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith("Pipeline already")) throw e;
     }
-    return { outcome: "completed", outputFile: "ship.md", retries: 0 };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    fs4.writeFileSync(shipPath, `# Ship
-
-Failed: ${msg}
-`);
-    return { outcome: "failed", retries: 0, error: msg };
+  }
+  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);
@@ -1236,16 +1831,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;
@@ -1265,50 +1851,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",
@@ -1325,84 +1881,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");
       }
@@ -1410,9 +1906,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);
@@ -1424,121 +1918,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) {
@@ -1558,29 +1937,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;
@@ -1592,7 +1966,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"]
@@ -1600,14 +1974,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"]
@@ -1615,7 +1989,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"]
@@ -1625,7 +1999,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"]
@@ -1633,7 +2007,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);
@@ -1653,11 +2027,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("--")) {
@@ -1699,6 +2069,18 @@ 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) });
@@ -1708,18 +2090,18 @@ async function checkLitellmHealth(url) {
   }
 }
 async function tryStartLitellm(url, projectDir) {
-  const configPath = path5.join(projectDir, "litellm-config.yaml");
-  if (!fs6.existsSync(configPath)) {
+  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 {
-    execFileSync7("litellm", ["--version"], { timeout: 5e3, stdio: "pipe" });
+    execFileSync9("litellm", ["--version"], { timeout: 5e3, stdio: "pipe" });
   } catch {
     try {
-      execFileSync7("python3", ["-m", "litellm", "--version"], { timeout: 5e3, stdio: "pipe" });
+      execFileSync9("python3", ["-m", "litellm", "--version"], { timeout: 5e3, stdio: "pipe" });
     } catch {
       logger.warn("litellm not installed (pip install 'litellm[proxy]')");
       return null;
@@ -1729,7 +2111,7 @@ async function tryStartLitellm(url, projectDir) {
   let cmd;
   let args2;
   try {
-    execFileSync7("litellm", ["--version"], { timeout: 5e3, stdio: "pipe" });
+    execFileSync9("litellm", ["--version"], { timeout: 5e3, stdio: "pipe" });
     cmd = "litellm";
     args2 = ["--config", configPath, "--port", port];
   } catch {
@@ -1753,15 +2135,26 @@ async function tryStartLitellm(url, projectDir) {
   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,
@@ -1783,11 +2176,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);
     }
@@ -1814,8 +2217,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;
@@ -1823,22 +2226,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);
     }
@@ -1847,10 +2250,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) {
@@ -1893,6 +2296,14 @@ ${issue.body ?? ""}`;
     }
   };
   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) {
@@ -1949,7 +2360,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) {
@@ -1957,7 +2368,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);
@@ -1979,17 +2390,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);
@@ -2007,20 +2419,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"]
@@ -2031,14 +2443,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,
@@ -2047,7 +2459,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" };
     }
@@ -2056,7 +2468,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,
@@ -2067,7 +2479,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,
@@ -2080,7 +2492,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"]
@@ -2103,10 +2515,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}`);
@@ -2129,44 +2541,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,
@@ -2175,7 +2587,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,
@@ -2188,7 +2600,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,
@@ -2207,9 +2619,9 @@ 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;
@@ -2235,14 +2647,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(", ")}
 
@@ -2252,7 +2664,7 @@ ${srcDirs.join(", ")}
   }
   const existingFiles = [];
   for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
-    if (fs7.existsSync(path6.join(cwd, f))) existingFiles.push(f);
+    if (fs18.existsSync(path17.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) context += `## Config files present
 ${existingFiles.join(", ")}
@@ -2311,7 +2723,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",
@@ -2358,7 +2770,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;
@@ -2392,7 +2804,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 {};
     }
@@ -2432,34 +2844,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)");
@@ -2472,7 +2884,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) {
@@ -2517,7 +2929,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,
@@ -2536,7 +2948,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"]
@@ -2549,9 +2961,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}` });
@@ -2578,21 +2990,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")}
@@ -2602,14 +3014,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];