@kody-ade/kody-engine-lite 0.1.0

package/dist/bin/cli.js

@@ -0,0 +1,1800 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/agent-runner.ts
+import { spawn, execFileSync } from "child_process";
+function writeStdin(child, prompt) {
+  return new Promise((resolve4, reject) => {
+    if (!child.stdin) {
+      resolve4();
+      return;
+    }
+    child.stdin.write(prompt, (err) => {
+      if (err) reject(err);
+      else {
+        child.stdin.end();
+        resolve4();
+      }
+    });
+  });
+}
+function waitForProcess(child, timeout) {
+  return new Promise((resolve4) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) child.kill("SIGKILL");
+      }, SIGKILL_GRACE_MS);
+    }, timeout);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve4({
+        code,
+        stdout: Buffer.concat(stdoutChunks).toString(),
+        stderr: Buffer.concat(stderrChunks).toString()
+      });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve4({ code: -1, stdout: "", stderr: err.message });
+    });
+  });
+}
+function createClaudeCodeRunner() {
+  return {
+    async run(stageName, prompt, model, timeout, _taskDir, options) {
+      const child = spawn(
+        "claude",
+        [
+          "--print",
+          "--model",
+          model,
+          "--dangerously-skip-permissions",
+          "--allowedTools",
+          "Bash,Edit,Read,Write,Glob,Grep"
+        ],
+        {
+          cwd: options?.cwd ?? process.cwd(),
+          env: {
+            ...process.env,
+            SKIP_BUILD: "1",
+            SKIP_HOOKS: "1",
+            ...options?.env
+          },
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      try {
+        await writeStdin(child, prompt);
+      } catch (err) {
+        return {
+          outcome: "failed",
+          error: `Failed to send prompt: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+      const { code, stdout, stderr } = await waitForProcess(child, timeout);
+      if (code === 0) {
+        return { outcome: "completed", output: stdout };
+      }
+      return {
+        outcome: code === null ? "timed_out" : "failed",
+        error: `Exit code ${code}
+${stderr.slice(-STDERR_TAIL_CHARS)}`
+      };
+    },
+    async healthCheck() {
+      try {
+        execFileSync("claude", ["--version"], { timeout: 1e4, stdio: "pipe" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+var SIGKILL_GRACE_MS, STDERR_TAIL_CHARS;
+var init_agent_runner = __esm({
+  "src/agent-runner.ts"() {
+    "use strict";
+    SIGKILL_GRACE_MS = 5e3;
+    STDERR_TAIL_CHARS = 500;
+  }
+});
+
+// src/definitions.ts
+var STAGES;
+var init_definitions = __esm({
+  "src/definitions.ts"() {
+    "use strict";
+    STAGES = [
+      {
+        name: "taskify",
+        type: "agent",
+        modelTier: "cheap",
+        timeout: 18e4,
+        maxRetries: 1,
+        outputFile: "task.json"
+      },
+      {
+        name: "plan",
+        type: "agent",
+        modelTier: "mid",
+        timeout: 3e5,
+        maxRetries: 1,
+        outputFile: "plan.md"
+      },
+      {
+        name: "build",
+        type: "agent",
+        modelTier: "strong",
+        timeout: 12e5,
+        maxRetries: 1
+      },
+      {
+        name: "verify",
+        type: "gate",
+        modelTier: "cheap",
+        timeout: 3e5,
+        maxRetries: 2,
+        retryWithAgent: "autofix"
+      },
+      {
+        name: "review",
+        type: "agent",
+        modelTier: "mid",
+        timeout: 3e5,
+        maxRetries: 1,
+        outputFile: "review.md"
+      },
+      {
+        name: "review-fix",
+        type: "agent",
+        modelTier: "strong",
+        timeout: 6e5,
+        maxRetries: 1
+      },
+      {
+        name: "ship",
+        type: "deterministic",
+        modelTier: "cheap",
+        timeout: 12e4,
+        maxRetries: 1,
+        outputFile: "ship.md"
+      }
+    ];
+  }
+});
+
+// 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",
+        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 promptPath = path3.resolve(
+    new URL(".", import.meta.url).pathname,
+    "..",
+    "prompts",
+    `${stageName}.md`
+  );
+  if (!fs3.existsSync(promptPath)) {
+    throw new Error(`Prompt file not found: ${promptPath}`);
+  }
+  return fs3.readFileSync(promptPath, "utf-8");
+}
+function injectTaskContext(prompt, taskId, taskDir) {
+  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..." : ""}
+`;
+  }
+  return prompt.replace("{{TASK_CONTEXT}}", context);
+}
+function buildFullPrompt(stageName, taskId, taskDir, projectDir) {
+  const memory = readProjectMemory(projectDir);
+  const promptTemplate = readPromptFile(stageName);
+  const prompt = injectTaskContext(promptTemplate, taskId, taskDir);
+  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;
+  return LEVELS[env ?? "info"] ?? LEVELS.info;
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+}
+function log(level, msg) {
+  if (LEVELS[level] < getLevel()) return;
+  const prefix = `[${timestamp()}] ${level.toUpperCase().padEnd(5)}`;
+  if (level === "error") {
+    console.error(`${prefix} ${msg}`);
+  } else if (level === "warn") {
+    console.warn(`${prefix} ${msg}`);
+  } else {
+    console.log(`${prefix} ${msg}`);
+  }
+}
+function ciGroup(title) {
+  if (isCI) process.stdout.write(`::group::${title}
+`);
+}
+function ciGroupEnd() {
+  if (isCI) process.stdout.write(`::endgroup::
+`);
+}
+var isCI, LEVELS, logger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    isCI = !!process.env.GITHUB_ACTIONS;
+    LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    logger = {
+      debug: (msg) => log("debug", msg),
+      info: (msg) => log("info", msg),
+      warn: (msg) => log("warn", msg),
+      error: (msg) => log("error", msg)
+    };
+  }
+});
+
+// src/git-utils.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function getHookSafeEnv() {
+  if (!_hookSafeEnv) {
+    _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
+  }
+  return _hookSafeEnv;
+}
+function git(args2, options) {
+  return execFileSync2("git", args2, {
+    encoding: "utf-8",
+    timeout: options?.timeout ?? 3e4,
+    cwd: options?.cwd,
+    env: options?.env ?? getHookSafeEnv(),
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function deriveBranchName(issueNumber, title) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50).replace(/-$/, "");
+  return `${issueNumber}-${slug}`;
+}
+function getDefaultBranch(cwd) {
+  try {
+    const ref = git(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd });
+    return ref.replace("refs/remotes/origin/", "");
+  } catch {
+  }
+  try {
+    const output = git(["remote", "show", "origin"], { cwd, timeout: 1e4 });
+    const match = output.match(/HEAD branch:\s*(\S+)/);
+    if (match) return match[1];
+  } catch {
+  }
+  return "dev";
+}
+function getCurrentBranch(cwd) {
+  return git(["branch", "--show-current"], { cwd });
+}
+function ensureFeatureBranch(issueNumber, title, cwd) {
+  const current = getCurrentBranch(cwd);
+  if (!BASE_BRANCHES.includes(current) && current !== "") {
+    logger.info(`  Already on feature branch: ${current}`);
+    return current;
+  }
+  const branchName = deriveBranchName(issueNumber, title);
+  try {
+    git(["fetch", "origin"], { cwd, timeout: 3e4 });
+  } catch {
+    logger.warn("  Failed to fetch origin");
+  }
+  try {
+    git(["rev-parse", "--verify", `origin/${branchName}`], { cwd });
+    git(["checkout", branchName], { cwd });
+    git(["pull", "origin", branchName], { cwd, timeout: 3e4 });
+    logger.info(`  Checked out existing remote branch: ${branchName}`);
+    return branchName;
+  } catch {
+  }
+  try {
+    git(["rev-parse", "--verify", branchName], { cwd });
+    git(["checkout", branchName], { cwd });
+    logger.info(`  Checked out existing local branch: ${branchName}`);
+    return branchName;
+  } catch {
+  }
+  const defaultBranch = getDefaultBranch(cwd);
+  try {
+    git(["checkout", "-b", branchName, `origin/${defaultBranch}`], { cwd });
+  } catch {
+    git(["checkout", "-b", branchName], { cwd });
+  }
+  logger.info(`  Created new branch: ${branchName}`);
+  return branchName;
+}
+function commitAll(message, cwd) {
+  const status = git(["status", "--porcelain"], { cwd });
+  if (!status) {
+    return { success: false, hash: "", message: "No changes to commit" };
+  }
+  git(["add", "-A"], { cwd });
+  git(["commit", "--no-gpg-sign", "-m", message], { cwd });
+  const hash = git(["rev-parse", "HEAD"], { cwd }).slice(0, 7);
+  logger.info(`  Committed: ${hash} ${message}`);
+  return { success: true, hash, message };
+}
+function pushBranch(cwd) {
+  git(["push", "-u", "origin", "HEAD"], { cwd, timeout: 12e4 });
+  logger.info("  Pushed to origin");
+}
+var BASE_BRANCHES, _hookSafeEnv;
+var init_git_utils = __esm({
+  "src/git-utils.ts"() {
+    "use strict";
+    init_logger();
+    BASE_BRANCHES = ["dev", "main", "master"];
+    _hookSafeEnv = null;
+  }
+});
+
+// src/github-api.ts
+import { execFileSync as execFileSync3 } from "child_process";
+function setGhCwd(cwd) {
+  _ghCwd = cwd;
+}
+function ghToken() {
+  return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
+}
+function gh(args2, options) {
+  const token = ghToken();
+  const env = token ? { ...process.env, GH_TOKEN: token } : { ...process.env };
+  return execFileSync3("gh", args2, {
+    encoding: "utf-8",
+    timeout: API_TIMEOUT_MS,
+    cwd: _ghCwd,
+    env,
+    input: options?.input,
+    stdio: options?.input ? ["pipe", "pipe", "pipe"] : ["inherit", "pipe", "pipe"]
+  }).trim();
+}
+function setLabel(issueNumber, label) {
+  try {
+    gh(["issue", "edit", String(issueNumber), "--add-label", label]);
+    logger.info(`  Label added: ${label}`);
+  } catch (err) {
+    logger.warn(`  Failed to set label ${label}: ${err}`);
+  }
+}
+function postComment(issueNumber, body) {
+  try {
+    gh(
+      ["issue", "comment", String(issueNumber), "--body-file", "-"],
+      { input: body }
+    );
+    logger.info(`  Comment posted on #${issueNumber}`);
+  } catch (err) {
+    logger.warn(`  Failed to post comment: ${err}`);
+  }
+}
+function createPR(head, base, title, body) {
+  try {
+    const output = gh(
+      [
+        "pr",
+        "create",
+        "--head",
+        head,
+        "--base",
+        base,
+        "--title",
+        title,
+        "--body-file",
+        "-"
+      ],
+      { input: body }
+    );
+    const url = output.trim();
+    const match = url.match(/\/pull\/(\d+)$/);
+    const number = match ? parseInt(match[1], 10) : 0;
+    logger.info(`  PR created: ${url}`);
+    return { number, url };
+  } catch (err) {
+    logger.error(`  Failed to create PR: ${err}`);
+    return null;
+  }
+}
+function setLifecycleLabel(issueNumber, phase) {
+  if (!LIFECYCLE_LABELS.includes(phase)) {
+    logger.warn(`  Invalid lifecycle phase: ${phase}`);
+    return;
+  }
+  const othersToRemove = LIFECYCLE_LABELS.filter((l) => l !== phase).map((l) => `kody:${l}`).join(",");
+  if (othersToRemove) {
+    try {
+      gh(["issue", "edit", String(issueNumber), "--remove-label", othersToRemove]);
+    } catch {
+    }
+  }
+  setLabel(issueNumber, `kody:${phase}`);
+}
+var API_TIMEOUT_MS, LIFECYCLE_LABELS, _ghCwd;
+var init_github_api = __esm({
+  "src/github-api.ts"() {
+    "use strict";
+    init_logger();
+    API_TIMEOUT_MS = 3e4;
+    LIFECYCLE_LABELS = ["planning", "building", "review", "done", "failed"];
+  }
+});
+
+// src/verify-runner.ts
+import { execFileSync as execFileSync4 } from "child_process";
+function runCommand(cmd, cwd, timeout) {
+  const parts = cmd.split(/\s+/);
+  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 };
+  }
+}
+function parseErrors(output) {
+  const errors = [];
+  for (const line of output.split("\n")) {
+    if (/error|Error|ERROR|failed|Failed|FAIL|warning:|Warning:|WARN/i.test(line)) {
+      errors.push(line.slice(0, 500));
+    }
+  }
+  return errors;
+}
+function extractSummary(output, cmdName) {
+  const summaryPatterns = /Test Suites|Tests|Coverage|ERRORS|FAILURES|success|completed/i;
+  const lines = output.split("\n").filter((l) => summaryPatterns.test(l));
+  return lines.slice(-3).map((l) => `[${cmdName}] ${l.trim()}`);
+}
+function runQualityGates(taskDir, projectRoot) {
+  const config = getProjectConfig();
+  const cwd = projectRoot ?? process.cwd();
+  const allErrors = [];
+  const allSummary = [];
+  let allPass = true;
+  const commands = [
+    { name: "typecheck", cmd: config.quality.typecheck },
+    { name: "test", cmd: config.quality.testUnit }
+  ];
+  if (config.quality.lint) {
+    commands.push({ name: "lint", cmd: config.quality.lint });
+  }
+  for (const { name, cmd } of commands) {
+    if (!cmd) continue;
+    logger.info(`  Running ${name}: ${cmd}`);
+    const result = runCommand(cmd, cwd, VERIFY_COMMAND_TIMEOUT_MS);
+    if (result.timedOut) {
+      allErrors.push(`${name}: timed out after ${VERIFY_COMMAND_TIMEOUT_MS / 1e3}s`);
+      allPass = false;
+      continue;
+    }
+    if (!result.success) {
+      allPass = false;
+      const errors = parseErrors(result.output);
+      allErrors.push(...errors.map((e) => `[${name}] ${e}`));
+    }
+    allSummary.push(...extractSummary(result.output, name));
+  }
+  return { pass: allPass, errors: allErrors, summary: allSummary };
+}
+var init_verify_runner = __esm({
+  "src/verify-runner.ts"() {
+    "use strict";
+    init_config();
+    init_logger();
+  }
+});
+
+// src/state-machine.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { execFileSync as execFileSync5 } from "child_process";
+function loadState(taskId, taskDir) {
+  const p = path4.join(taskDir, "status.json");
+  if (!fs4.existsSync(p)) return null;
+  try {
+    const raw = JSON.parse(fs4.readFileSync(p, "utf-8"));
+    if (raw.taskId === taskId) return raw;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeState(state, taskDir) {
+  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  fs4.writeFileSync(
+    path4.join(taskDir, "status.json"),
+    JSON.stringify(state, null, 2)
+  );
+}
+function initState(taskId) {
+  const stages = {};
+  for (const stage of STAGES) {
+    stages[stage.name] = { state: "pending", retries: 0 };
+  }
+  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 };
+  }
+}
+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);
+  const model = resolveModel(def.modelTier, def.name);
+  logger.info(`  model=${model} timeout=${def.timeout / 1e3}s`);
+  const config = getProjectConfig();
+  const extraEnv = {};
+  if (config.agent.litellmUrl) {
+    extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
+  }
+  const result = await ctx.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) {
+    fs4.writeFileSync(path4.join(ctx.taskDir, def.outputFile), result.output);
+  }
+  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}`);
+      }
+    }
+  }
+  return { outcome: "completed", outputFile: def.outputFile, retries: 0 };
+}
+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}
+`);
+    }
+  }
+  fs4.writeFileSync(path4.join(ctx.taskDir, "verify.md"), lines.join(""));
+  return {
+    outcome: verifyResult.pass ? "completed" : "failed",
+    retries: 0
+  };
+}
+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+/);
+        try {
+          execFileSync5(parts[0], parts.slice(1), {
+            stdio: "pipe",
+            timeout: FIX_COMMAND_TIMEOUT_MS
+          });
+        } 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 {
+    outcome: "failed",
+    retries: maxAttempts,
+    error: "Verification failed after autofix attempts"
+  };
+}
+async function executeReviewWithFix(ctx, def) {
+  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 = path4.join(ctx.taskDir, "review.md");
+  if (!fs4.existsSync(reviewFile)) {
+    return { outcome: "failed", retries: 0, error: "review.md not found" };
+  }
+  const content = fs4.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);
+}
+function executeShipStage(ctx, _def) {
+  const shipPath = path4.join(ctx.taskDir, "ship.md");
+  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 };
+  }
+  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 {
+      }
+    }
+    const taskMdPath = path4.join(ctx.taskDir, "task.md");
+    let title = "Update";
+    if (fs4.existsSync(taskMdPath)) {
+      const content = fs4.readFileSync(taskMdPath, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+      title = (lines[0] ?? "Update").slice(0, 72);
+    }
+    const body = "Generated by Kody pipeline\n\n---\n\u{1F916} Generated by Kody";
+    const pr = createPR(head, base, title, body);
+    if (pr) {
+      if (ctx.input.issueNumber && !ctx.input.local) {
+        try {
+          postComment(ctx.input.issueNumber, `\u{1F389} PR created: ${pr.url}`);
+        } catch {
+        }
+      }
+      fs4.writeFileSync(shipPath, `# Ship
+
+PR created: ${pr.url}
+PR #${pr.number}
+`);
+    } else {
+      fs4.writeFileSync(shipPath, "# Ship\n\nPushed branch but failed to create PR.\n");
+    }
+    return { outcome: "completed", outputFile: "ship.md", retries: 0 };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    fs4.writeFileSync(shipPath, `# Ship
+
+Failed: ${msg}
+`);
+    return { outcome: "failed", retries: 0, error: msg };
+  }
+}
+async function runPipeline(ctx) {
+  let state = loadState(ctx.taskId, ctx.taskDir);
+  if (!state) {
+    state = initState(ctx.taskId);
+    writeState(state, ctx.taskDir);
+  }
+  if (state.state !== "running") {
+    state.state = "running";
+    for (const stage of STAGES) {
+      const s = state.stages[stage.name];
+      if (s.state === "running" || s.state === "failed" || s.state === "timeout") {
+        state.stages[stage.name] = { ...s, state: "pending" };
+      }
+    }
+    writeState(state, ctx.taskDir);
+  }
+  const fromStage = ctx.input.fromStage;
+  let startExecution = !fromStage;
+  logger.info(`Pipeline started: ${ctx.taskId}`);
+  logger.info(`Stages: ${STAGES.map((s) => s.name).join(" \u2192 ")}`);
+  if (fromStage) logger.info(`Resuming from: ${fromStage}`);
+  if (ctx.input.issueNumber && !ctx.input.local) {
+    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);
+    } catch (err) {
+      logger.warn(`  Failed to create feature branch: ${err}`);
+    }
+  }
+  for (const def of STAGES) {
+    if (!startExecution) {
+      if (def.name === fromStage) {
+        startExecution = true;
+      } else {
+        continue;
+      }
+    }
+    if (state.stages[def.name].state === "completed") {
+      logger.info(`[${def.name}] already completed, skipping`);
+      continue;
+    }
+    ciGroup(`Stage: ${def.name}`);
+    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");
+    }
+    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}` };
+      }
+    } catch (error) {
+      result = {
+        outcome: "failed",
+        retries: 0,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+    ciGroupEnd();
+    if (result.outcome === "completed") {
+      state.stages[def.name] = {
+        state: "completed",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        retries: result.retries,
+        outputFile: result.outputFile
+      };
+      logger.info(`[${def.name}] \u2713 completed`);
+      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");
+      }
+      break;
+    } else {
+      state.stages[def.name] = {
+        state: "failed",
+        retries: result.retries,
+        error: result.error ?? "Stage failed"
+      };
+      state.state = "failed";
+      writeState(state, ctx.taskDir);
+      logger.error(`[${def.name}] \u2717 failed: ${result.error}`);
+      if (ctx.input.issueNumber && !ctx.input.local) {
+        setLifecycleLabel(ctx.input.issueNumber, "failed");
+      }
+      break;
+    }
+    writeState(state, ctx.taskDir);
+  }
+  const allCompleted = STAGES.every(
+    (s) => state.stages[s.name].state === "completed"
+  );
+  if (allCompleted) {
+    state.state = "completed";
+    writeState(state, ctx.taskDir);
+    logger.info(`Pipeline completed: ${ctx.taskId}`);
+    if (ctx.input.issueNumber && !ctx.input.local) {
+      setLifecycleLabel(ctx.input.issueNumber, "done");
+    }
+    autoLearn(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) {
+    console.log(`No status found for task ${taskId}`);
+    return;
+  }
+  console.log(`
+Task: ${state.taskId}`);
+  console.log(`State: ${state.state}`);
+  console.log(`Created: ${state.createdAt}`);
+  console.log(`Updated: ${state.updatedAt}
+`);
+  for (const stage of STAGES) {
+    const s = state.stages[stage.name];
+    const icon = s.state === "completed" ? "\u2713" : s.state === "failed" ? "\u2717" : s.state === "running" ? "\u25B6" : s.state === "timeout" ? "\u23F1" : "\u25CB";
+    const extra = s.error ? ` \u2014 ${s.error}` : "";
+    console.log(`  ${icon} ${stage.name}: ${s.state}${extra}`);
+  }
+}
+var init_state_machine = __esm({
+  "src/state-machine.ts"() {
+    "use strict";
+    init_definitions();
+    init_context();
+    init_validators();
+    init_git_utils();
+    init_github_api();
+    init_verify_runner();
+    init_config();
+    init_logger();
+  }
+});
+
+// src/preflight.ts
+import { execFileSync as execFileSync6 } from "child_process";
+import * as fs5 from "fs";
+function check(name, fn) {
+  try {
+    const detail = fn() ?? void 0;
+    return { name, ok: true, detail };
+  } catch {
+    return { name, ok: false };
+  }
+}
+function runPreflight() {
+  const checks = [
+    check("claude CLI", () => {
+      const v = execFileSync6("claude", ["--version"], {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      return v;
+    }),
+    check("git repo", () => {
+      execFileSync6("git", ["rev-parse", "--is-inside-work-tree"], {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }),
+    check("pnpm", () => {
+      const v = execFileSync6("pnpm", ["--version"], {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      return v;
+    }),
+    check("node >= 18", () => {
+      const v = execFileSync6("node", ["--version"], {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const major = parseInt(v.replace("v", "").split(".")[0], 10);
+      if (major < 18) throw new Error(`Node ${v} < 18`);
+      return v;
+    }),
+    check("gh CLI", () => {
+      const v = execFileSync6("gh", ["--version"], {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim().split("\n")[0];
+      return v;
+    }),
+    check("package.json", () => {
+      if (!fs5.existsSync("package.json")) throw new Error("not found");
+    })
+  ];
+  const failed = checks.filter((c) => !c.ok);
+  for (const c of checks) {
+    logger.info(`  ${c.ok ? "\u2713" : "\u2717"} ${c.name}${c.detail ? ` (${c.detail})` : ""}`);
+  }
+  if (failed.length > 0) {
+    throw new Error(
+      `Preflight failed: ${failed.map((c) => c.name).join(", ")}`
+    );
+  }
+}
+var init_preflight = __esm({
+  "src/preflight.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/entry.ts
+var entry_exports = {};
+import * as fs6 from "fs";
+import * as path5 from "path";
+function getArg(args2, flag) {
+  const idx = args2.indexOf(flag);
+  if (idx !== -1 && args2[idx + 1] && !args2[idx + 1].startsWith("--")) {
+    return args2[idx + 1];
+  }
+  return void 0;
+}
+function hasFlag(args2, flag) {
+  return args2.includes(flag);
+}
+function parseArgs() {
+  const args2 = process.argv.slice(2);
+  if (hasFlag(args2, "--help") || hasFlag(args2, "-h") || args2.length === 0) {
+    console.log(`Usage:
+  kody run    --task-id <id> [--task "<desc>"] [--cwd <path>] [--issue-number <n>] [--feedback "<text>"] [--local] [--dry-run]
+  kody rerun  --task-id <id> --from <stage> [--cwd <path>] [--issue-number <n>]
+  kody status --task-id <id> [--cwd <path>]
+  kody --help`);
+    process.exit(0);
+  }
+  const command2 = args2[0];
+  if (!["run", "rerun", "status"].includes(command2)) {
+    console.error(`Unknown command: ${command2}`);
+    process.exit(1);
+  }
+  const issueStr = getArg(args2, "--issue-number") ?? process.env.ISSUE_NUMBER;
+  const localFlag = hasFlag(args2, "--local");
+  return {
+    command: command2,
+    taskId: getArg(args2, "--task-id") ?? process.env.TASK_ID,
+    task: getArg(args2, "--task"),
+    fromStage: getArg(args2, "--from") ?? process.env.FROM_STAGE,
+    dryRun: hasFlag(args2, "--dry-run") || process.env.DRY_RUN === "true",
+    cwd: getArg(args2, "--cwd"),
+    issueNumber: issueStr ? parseInt(issueStr, 10) : void 0,
+    feedback: getArg(args2, "--feedback") ?? process.env.FEEDBACK,
+    local: localFlag || !isCI2 && !hasFlag(args2, "--no-local")
+  };
+}
+function generateTaskId() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${String(now.getFullYear()).slice(2)}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+async function main() {
+  const input = parseArgs();
+  let taskId = input.taskId;
+  if (!taskId) {
+    if (input.command === "run" && input.task) {
+      taskId = generateTaskId();
+    } else {
+      console.error("--task-id is required");
+      process.exit(1);
+    }
+  }
+  const projectDir = input.cwd ? path5.resolve(input.cwd) : process.cwd();
+  if (input.cwd) {
+    if (!fs6.existsSync(projectDir)) {
+      console.error(`--cwd path does not exist: ${projectDir}`);
+      process.exit(1);
+    }
+    setConfigDir(projectDir);
+    setGhCwd(projectDir);
+    logger.info(`Working directory: ${projectDir}`);
+  }
+  const taskDir = path5.join(projectDir, ".tasks", taskId);
+  fs6.mkdirSync(taskDir, { recursive: true });
+  if (input.command === "status") {
+    printStatus(taskId, taskDir);
+    return;
+  }
+  logger.info("Preflight checks:");
+  runPreflight();
+  if (input.task) {
+    fs6.writeFileSync(path5.join(taskDir, "task.md"), input.task);
+  }
+  if (input.command === "run") {
+    const taskMdPath = path5.join(taskDir, "task.md");
+    if (!fs6.existsSync(taskMdPath)) {
+      console.error("No task.md found. Provide --task or ensure .tasks/<id>/task.md exists.");
+      process.exit(1);
+    }
+  }
+  if (input.command === "rerun" && !input.fromStage) {
+    console.error("--from <stage> is required for rerun");
+    process.exit(1);
+  }
+  const runner = createClaudeCodeRunner();
+  const healthy = await runner.healthCheck();
+  if (!healthy) {
+    console.error("Claude Code CLI not available. Install: npm i -g @anthropic-ai/claude-code");
+    process.exit(1);
+  }
+  const ctx = {
+    taskId,
+    taskDir,
+    projectDir,
+    runner,
+    input: {
+      mode: input.command === "rerun" ? "rerun" : "full",
+      fromStage: input.fromStage,
+      dryRun: input.dryRun,
+      issueNumber: input.issueNumber,
+      feedback: input.feedback,
+      local: input.local
+    }
+  };
+  logger.info(`Mode: ${ctx.input.mode}${ctx.input.local ? " (local)" : " (CI)"}`);
+  if (ctx.input.issueNumber) logger.info(`Issue: #${ctx.input.issueNumber}`);
+  const state = await runPipeline(ctx);
+  const files = fs6.readdirSync(taskDir);
+  console.log(`
+Artifacts in ${taskDir}:`);
+  for (const f of files) {
+    console.log(`  ${f}`);
+  }
+  if (state.state === "failed") {
+    process.exit(1);
+  }
+}
+var isCI2;
+var init_entry = __esm({
+  "src/entry.ts"() {
+    "use strict";
+    init_agent_runner();
+    init_state_machine();
+    init_preflight();
+    init_config();
+    init_github_api();
+    init_logger();
+    isCI2 = !!process.env.GITHUB_ACTIONS;
+    main().catch((err) => {
+      console.error(err instanceof Error ? err.message : err);
+      process.exit(1);
+    });
+  }
+});
+
+// src/bin/cli.ts
+import * as fs7 from "fs";
+import * as path6 from "path";
+import { execFileSync as execFileSync7 } from "child_process";
+import { fileURLToPath } from "url";
+var __dirname = path6.dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = path6.resolve(__dirname, "..", "..");
+function getVersion() {
+  const pkgPath = path6.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+  return pkg.version;
+}
+function checkCommand(name, args2, fix) {
+  try {
+    const output = execFileSync7(name, args2, {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return { name: `${name} CLI`, ok: true, detail: output.split("\n")[0] };
+  } catch {
+    return { name: `${name} CLI`, ok: false, fix };
+  }
+}
+function checkFile(filePath, description, fix) {
+  if (fs7.existsSync(filePath)) {
+    return { name: description, ok: true, detail: filePath };
+  }
+  return { name: description, ok: false, fix };
+}
+function checkGhAuth(cwd) {
+  try {
+    const output = execFileSync7("gh", ["auth", "status"], {
+      encoding: "utf-8",
+      timeout: 1e4,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    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 ?? "";
+    if (stderr.includes("not logged")) {
+      return { name: "gh auth", ok: false, fix: "Run: gh auth login" };
+    }
+    return { name: "gh auth", ok: true, detail: "authenticated (partial check)" };
+  }
+}
+function checkGhRepoAccess(cwd) {
+  try {
+    const remote = execFileSync7("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = remote.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+    if (!match) {
+      return { name: "GitHub repo", ok: false, fix: "Set git remote origin to a GitHub URL" };
+    }
+    const repoSlug = `${match[1]}/${match[2]}`;
+    execFileSync7("gh", ["repo", "view", repoSlug, "--json", "name"], {
+      encoding: "utf-8",
+      timeout: 1e4,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { name: "GitHub repo access", ok: true, detail: repoSlug };
+  } catch {
+    return { name: "GitHub repo access", ok: false, fix: "Verify gh auth and repo permissions" };
+  }
+}
+function checkGhSecret(repoSlug, secretName) {
+  try {
+    const output = execFileSync7("gh", ["secret", "list", "--repo", repoSlug], {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (output.includes(secretName)) {
+      return { name: `Secret: ${secretName}`, ok: true, detail: "configured" };
+    }
+    return {
+      name: `Secret: ${secretName}`,
+      ok: false,
+      fix: `Run: gh secret set ${secretName} --repo ${repoSlug}`
+    };
+  } catch {
+    return {
+      name: `Secret: ${secretName}`,
+      ok: false,
+      fix: `Run: gh secret set ${secretName} --repo ${repoSlug} (or check permissions)`
+    };
+  }
+}
+function detectArchitecture(cwd) {
+  const detected = [];
+  const pkgPath = path6.join(cwd, "package.json");
+  if (fs7.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs7.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}`);
+      else if (allDeps.hono) detected.push(`- Framework: Hono ${allDeps.hono}`);
+      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}`);
+      else if (allDeps.mocha) detected.push(`- Testing: mocha ${allDeps.mocha}`);
+      if (allDeps.eslint) detected.push(`- Linting: eslint ${allDeps.eslint}`);
+      if (allDeps.prettier) detected.push(`- Formatting: prettier ${allDeps.prettier}`);
+      if (allDeps.biome || allDeps["@biomejs/biome"]) detected.push("- Formatting: biome");
+      if (allDeps.prisma || allDeps["@prisma/client"]) detected.push("- ORM: Prisma");
+      if (allDeps["drizzle-orm"]) detected.push("- ORM: Drizzle");
+      if (allDeps.pg || allDeps.postgres) detected.push("- Database: PostgreSQL");
+      if (allDeps.mongodb || allDeps.mongoose) detected.push("- Database: MongoDB");
+      if (allDeps.redis || allDeps.ioredis) detected.push("- Cache: Redis");
+      if (allDeps.payload || allDeps["@payloadcms/next"]) detected.push("- CMS: Payload CMS");
+      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");
+    } catch {
+    }
+  }
+  try {
+    const entries = fs7.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)) {
+    try {
+      const srcEntries = fs7.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 (configs.length > 0) detected.push(`- Config files: ${configs.join(", ")}`);
+  return detected;
+}
+function initCommand(opts) {
+  const cwd = process.cwd();
+  console.log(`
+\u{1F527} Kody Engine Lite \u2014 Init
+`);
+  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)) {
+    console.error("  \u2717 Template kody.yml not found in package");
+    process.exit(1);
+  }
+  if (fs7.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);
+    console.log("  \u2713 .github/workflows/kody.yml");
+  }
+  const configDest = path6.join(cwd, "kody.config.json");
+  if (!fs7.existsSync(configDest)) {
+    const defaultConfig = {
+      quality: {
+        typecheck: "pnpm tsc --noEmit",
+        lint: "",
+        lintFix: "",
+        format: "",
+        formatFix: "",
+        testUnit: "pnpm test"
+      },
+      git: { defaultBranch: "main" },
+      github: { owner: "", repo: "" },
+      paths: { taskDir: ".tasks" },
+      agent: {
+        runner: "claude-code",
+        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+      }
+    };
+    fs7.writeFileSync(configDest, JSON.stringify(defaultConfig, null, 2) + "\n");
+    console.log("  \u2713 kody.config.json (created \u2014 edit github.owner and github.repo)");
+  } 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");
+    if (!content.includes(".tasks/")) {
+      fs7.appendFileSync(gitignorePath, "\n.tasks/\n");
+      console.log("  \u2713 .gitignore (added .tasks/)");
+    } else {
+      console.log("  \u25CB .gitignore (.tasks/ already present)");
+    }
+  }
+  console.log("\n\u2500\u2500 Prerequisites \u2500\u2500");
+  const checks = [
+    checkCommand("claude", ["--version"], "Install: npm i -g @anthropic-ai/claude-code"),
+    checkCommand("gh", ["--version"], "Install: https://cli.github.com"),
+    checkCommand("git", ["--version"], "Install git"),
+    checkCommand("node", ["--version"], "Install Node.js >= 22"),
+    checkCommand("pnpm", ["--version"], "Install: npm i -g pnpm"),
+    checkFile(path6.join(cwd, "package.json"), "package.json", "Run: pnpm init")
+  ];
+  for (const c of checks) {
+    if (c.ok) {
+      console.log(`  \u2713 ${c.name}${c.detail ? ` (${c.detail})` : ""}`);
+    } else {
+      console.log(`  \u2717 ${c.name} \u2014 ${c.fix}`);
+    }
+  }
+  console.log("\n\u2500\u2500 GitHub \u2500\u2500");
+  const ghAuth = checkGhAuth(cwd);
+  console.log(ghAuth.ok ? `  \u2713 ${ghAuth.name} (${ghAuth.detail})` : `  \u2717 ${ghAuth.name} \u2014 ${ghAuth.fix}`);
+  const ghRepo = checkGhRepoAccess(cwd);
+  console.log(ghRepo.ok ? `  \u2713 ${ghRepo.name} (${ghRepo.detail})` : `  \u2717 ${ghRepo.name} \u2014 ${ghRepo.fix}`);
+  if (ghRepo.ok && ghRepo.detail) {
+    const repoSlug = ghRepo.detail;
+    const secretChecks = [
+      checkGhSecret(repoSlug, "ANTHROPIC_API_KEY")
+    ];
+    for (const c of secretChecks) {
+      if (c.ok) {
+        console.log(`  \u2713 ${c.name}`);
+      } else {
+        console.log(`  \u2717 ${c.name} \u2014 ${c.fix}`);
+      }
+    }
+  }
+  console.log("\n\u2500\u2500 Config \u2500\u2500");
+  if (fs7.existsSync(configDest)) {
+    try {
+      const config = JSON.parse(fs7.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}` });
+      } else {
+        configChecks.push({ name: "github.owner/repo", ok: false, fix: "Edit kody.config.json: set github.owner and github.repo" });
+      }
+      if (config.git?.defaultBranch) {
+        configChecks.push({ name: "git.defaultBranch", ok: true, detail: config.git.defaultBranch });
+      }
+      if (config.quality?.testUnit) {
+        configChecks.push({ name: "quality.testUnit", ok: true, detail: config.quality.testUnit });
+      } else {
+        configChecks.push({ name: "quality.testUnit", ok: false, fix: "Edit kody.config.json: set quality.testUnit command" });
+      }
+      for (const c of configChecks) {
+        if (c.ok) {
+          console.log(`  \u2713 ${c.name}${c.detail ? `: ${c.detail}` : ""}`);
+        } else {
+          console.log(`  \u2717 ${c.name} \u2014 ${c.fix}`);
+        }
+      }
+    } catch {
+      console.log("  \u2717 kody.config.json \u2014 invalid JSON");
+    }
+  }
+  console.log("\n\u2500\u2500 Architecture Detection \u2500\u2500");
+  const memoryDir = path6.join(cwd, ".kody", "memory");
+  const archPath = path6.join(memoryDir, "architecture.md");
+  if (fs7.existsSync(archPath)) {
+    console.log("  \u25CB .kody/memory/architecture.md (exists, not overwriting)");
+  } else {
+    const archItems = detectArchitecture(cwd);
+    if (archItems.length > 0) {
+      fs7.mkdirSync(memoryDir, { recursive: true });
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const content = `# Architecture (auto-detected ${timestamp2})
+
+## Overview
+${archItems.join("\n")}
+`;
+      fs7.writeFileSync(archPath, content);
+      console.log(`  \u2713 .kody/memory/architecture.md (${archItems.length} items detected)`);
+      for (const item of archItems) {
+        console.log(`    ${item}`);
+      }
+    } else {
+      console.log("  \u25CB No architecture detected");
+    }
+  }
+  const conventionsPath = path6.join(memoryDir, "conventions.md");
+  if (!fs7.existsSync(conventionsPath)) {
+    fs7.mkdirSync(memoryDir, { recursive: true });
+    fs7.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];
+  const failed = allChecks.filter((c) => !c.ok);
+  console.log("\n\u2500\u2500 Summary \u2500\u2500");
+  if (failed.length === 0) {
+    console.log("  \u2713 All checks passed! Ready to use.");
+    console.log("\n  Next: Comment '@kody full <task-id>' on a GitHub issue");
+  } else {
+    console.log(`  \u26A0 ${failed.length} issue(s) to fix:`);
+    for (const c of failed) {
+      console.log(`    \u2022 ${c.name}: ${c.fix}`);
+    }
+  }
+  console.log("");
+}
+var args = process.argv.slice(2);
+var command = args[0];
+if (command === "init") {
+  initCommand({ force: args.includes("--force") });
+} else if (command === "version" || command === "--version" || command === "-v") {
+  console.log(getVersion());
+} else {
+  Promise.resolve().then(() => init_entry());
+}